Paper Expert Generator logo

Paper Expert Generator

Community
guhaohao0991
paper-expert-generator

Generate a specialized domain-expert research agent modeled on PaperClaw architecture. Use this skill when a user wants to create an AI agent that can automatically search, filter, summarize, and evaluate academic papers in a specific research field. Trigger phrases include help me create a paper tracking agent for my field, I want an agent to monitor latest papers in bioinformatics, build me a paper review agent for computer vision, create a PaperClaw-style agent for my domain, generate a domain-specific paper expert agent. The generated agent is a complete OpenClaw agent with all required skills (arxiv-search, semantic-scholar, paper-review, daily-search, weekly-report) fully adapted for the target domain.

Overview

Publisherguhaohao0991
RepositoryPaperClaw
Skill namepaper-expert-generator
Stars
252
Forks
18
Bundled files
6
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 6 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by guhaohao0991 on GitHub. Read the source before you install it.

Installation

Install the Paper Expert Generator AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/guhaohao0991/PaperClaw/tree/main/skills/paper-expert-generator
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/guhaohao0991/PaperClaw.git /tmp/PaperClaw
mkdir -p .claude/skills
cp -r /tmp/PaperClaw/skills/paper-expert-generator .claude/skills/paper-expert-generator
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Paper Expert Generator in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Paper Expert Generator on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Paper Expert Generator is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Paper Expert Generator

Generate a complete, ready-to-use domain-specific paper expert agent by adapting the PaperClaw architecture for any research field.

Workflow

Step 1: Domain Interview

Collect these details from the user before generating anything. Ask conversationally – do not dump all questions at once. Start with the most critical ones:

Critical (ask first):

  1. Research domain – Primary field (e.g., "bioinformatics", "quantum computing", "computer vision")
  2. Core topics – Specific sub-areas or problems (e.g., "protein folding, drug discovery, single-cell sequencing")
  3. Key methods/techniques – Central methodologies (e.g., "transformers, GNN, diffusion models, RL")

Important (ask second): 4. Evaluation priorities – What dimensions matter most for paper quality in this domain? 5. Exclusion topics – What should be filtered out? (e.g., "finance, social media, NLP") 6. Output location – Where to create the agent? (default: ~/agents/<domain-slug>/)

Optional (ask only if needed): 7. Notification channel – Feishu/Lark webhook URL for push notifications 8. LLM config – API base URL, model name, API key (default: same as PaperClaw models.json) 9. Schedule timezone – Default is Asia/Singapore

Infer reasonable defaults for anything not provided and confirm before proceeding.

Step 2: Build Keyword Library

Construct a structured keyword library from the domain interview. Aim for:

  • Core queries (3–5): Direct topic+method combinations for arXiv ti: searches
  • Method queries (3–5): Method+application combinations
  • Application queries (2–3): Use-case-specific terms
  • Exclusion keywords (3–6): Out-of-scope terms to filter

See references/domain-adaptation-guide.md Section 1 for keyword examples across 8 common domains.

Step 3: Design Evaluation Rubric

Design 4 domain-specific scoring dimensions (each scored 1–10) that replace PaperClaw's SciML dimensions (engineering_value, architecture_innovation, theoretical_contribution, result_reliability).

The scoring formula is unchanged:

final_score = base_score × 0.9 + impact_score × 0.1
base_score = (dim1 + dim2 + dim3 + dim4) / 4
impact_score = date_citation_adjustment(citations, age_months)

See references/domain-adaptation-guide.md Section 2 for rubric examples by domain.

Step 4: Generate Agent Files

Run the scaffolding script to create the directory structure:

bash
python ~/.comate/skills/paper-expert-generator/scripts/init_domain_agent.py \
  --domain "<domain_slug>" \
  --output "<output_dir>" \
  --paperclaw-skills "<paperclaw_skills_path>"

Example:

bash
python ~/.comate/skills/paper-expert-generator/scripts/init_domain_agent.py \
  --domain "bioinfo-ml" \
  --output ~/agents/bioinfo-ml \
  --paperclaw-skills /work/work/PaperClaw/skills

Generated structure:

<output_dir>/
├── agent/
│   ├── AGENT.md          ← write domain content here
│   ├── models.json       ← pre-filled from template
│   └── schedules.json    ← pre-filled from template
├── skills/
│   ├── arxiv-search/     ← copy from PaperClaw (needs keyword update)
│   ├── semantic-scholar/ ← copy from PaperClaw (no changes needed)
│   ├── paper-review/     ← copy from PaperClaw (needs rubric update)
│   ├── daily-search/     ← copy from PaperClaw (minor text update)
│   └── weekly-report/    ← copy from PaperClaw (minor text update)
└── workspace/
    └── evaluated_papers.json  ← initialized empty

Step 5: Write AGENT.md

Use assets/templates/AGENT.md.template as the base. The AGENT.md must include:

  1. Role Definition – Domain expert persona with specific depth. Replace SciML expertise with domain-specific expertise (key algorithms, theoretical foundations, benchmark datasets, top venues/conferences).

  2. Keyword Library – Paste structured keywords from Step 2.

  3. Four Core Tasks (preserve exact structure from PaperClaw):

    • Task 1 (Paper Research): Download PDF → write summary.md answering 10 domain-adapted questions
    • Task 2 (Paper Evaluation): 4-dimension scoring → write scores.md → update metadata.json → update registry
    • Task 3 (Daily Search): Cron trigger → daily_paper_search.py --top 3 → dedup → trigger Task 1+2
    • Task 4 (Weekly Report): Cron trigger → generate_weekly_report_v2.py → push notification
  4. Mandatory <think> Reasoning – Required in Task 2 evaluation.

  5. Dedup Gate – Always check evaluated_papers.json before starting paper review.

See references/agent-template-guide.md for the full AGENT.md authoring guide.

Step 6: Adapt Skill SKILL.md Files

Minimal adaptation needed – Python scripts are domain-agnostic:

SkillRequired changes to SKILL.md
arxiv-searchReplace the keyword list with domain keywords from Step 2
paper-reviewReplace 4 scoring dimensions + update the 10 summary questions
daily-searchUpdate domain name in task description text
weekly-reportUpdate domain name in report title
semantic-scholarNo changes needed

Step 7: Configure models.json and schedules.json

models.json: Edit agent/models.json, fill in:

  • baseUrl: LLM API endpoint
  • apiKey: API key placeholder
  • id and name: Model identifier

schedules.json: Default schedule is pre-filled. Adjust tz field if not in Singapore timezone.

Step 8: Validate and Deliver

Checklist before presenting results:

  • AGENT.md has domain role, keywords, 4 tasks, rubric
  • paper-review/SKILL.md has domain scoring dimensions + 10 adapted questions
  • arxiv-search/SKILL.md has domain keyword list
  • models.json has correct structure (API key placeholder)
  • workspace/evaluated_papers.json initialized as []
  • All 5 skill directories exist

Then present the output summary (see next section).

Output Summary Format

Always deliver this summary after generation:

markdown
## Generated Agent: <Domain Name> Paper Expert

**Domain**: <domain>
**Location**: `<output_dir>`
**Model**: <model_name>

### Keyword Library (<N> total queries)
**Core**: <query1>, <query2>, <query3>
**Methods**: <query1>, <query2>
**Exclusions**: <term1>, <term2>, ...

### Evaluation Rubric
| Dimension | Score Weight | Measures |
|-----------|-------------|---------|
| <dim1>    | 25%         | ...     |
| <dim2>    | 25%         | ...     |
| <dim3>    | 25%         | ...     |
| <dim4>    | 25%         | ...     |

### Schedule
- Daily search: `0 20 * * *` (<timezone>)
- Weekly report: `0 10 * * 0` (<timezone>)

### Quick Start
1. Open OpenClaw → select agent from `<output_dir>/agent/`
2. Set API key in `agent/models.json`
3. Test: "Search for recent papers on <core_topic>"
4. Or wait for first daily trigger at 20:00

References

  • references/domain-adaptation-guide.md – Keyword and rubric examples for 8 common domains
  • references/agent-template-guide.md – Full AGENT.md authoring guide with annotated sections
  • assets/templates/AGENT.md.template – Base template for the generated AGENT.md
  • assets/templates/models.json – Base models config template
  • assets/templates/schedules.json – Base schedules config template

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Paper Expert Generator AI skill do?

Generate a specialized domain-expert research agent modeled on PaperClaw architecture. Use this skill when a user wants to create an AI agent that can automatically search, filter, summarize, and evaluate academic papers in a specific research field. Trigger phrases include help me create a paper tracking agent for my field, I want an agent to monitor latest papers in bioinformatics, build me a paper review agent for computer vision, create a PaperClaw-style agent for my domain, generate a domain-specific paper expert agent. The generated agent is a complete OpenClaw agent with all required...

Why use Paper Expert Generator on TypingMind?

Because you install it once and use it with any model. Paper Expert Generator is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Paper Expert Generator in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/guhaohao0991/PaperClaw/tree/main/skills/paper-expert-generator. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Paper Expert Generator?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Paper Expert Generator?

As many as you like. As long as a model supports skills, you can use Paper Expert Generator with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Paper Expert Generator AI skill free?

It is published on GitHub by guhaohao0991. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇