mit einem Klick
synthesis
// Multi-source research synthesis — aggregate and compare 3+ sources or any source >5KB using sub-agent dispatch and SharedState
// Multi-source research synthesis — aggregate and compare 3+ sources or any source >5KB using sub-agent dispatch and SharedState
| name | synthesis |
| description | Multi-source research synthesis — aggregate and compare 3+ sources or any source >5KB using sub-agent dispatch and SharedState |
| version | 1.0 |
| origin | yoyo |
| core | false |
| status | active |
| score | 0.66 |
| uses | 2 |
| wins | 2 |
| last_used | 2026-05-01T06:18:55Z |
| last_evolved | 2026-05-25 |
| parent_pattern_key | null |
| tools | ["bash","read_file","write_file","search","sub_agent","shared_state"] |
| keywords | ["synthesis","multi-source","aggregate sources","compare sources","multiple sources"] |
You are performing multi-source research synthesis — aggregating, comparing, and composing insights from multiple sources (papers, blog posts, docs, discussions, code) into a coherent answer. The goal is a single composed response that draws on all sources, not a list of summaries.
This skill exists because loading 3+ full web pages or documents into your main context window is wasteful and noisy. The pattern (Recursive Language Model — see the RLM substrate section in CLAUDE.md) is: fetch each source, store it in shared state, dispatch a sub-agent per source to extract key claims, then dispatch a final synthesis sub-agent to compose the answer.
This skill complements the existing research skill. Research handles single small sources (fetch → read → answer). Synthesis handles the cases where multiple sources or large sources make direct reading impractical.
Trigger this skill when ANY of these hold:
research skill's single-source procedure — direct curl and read. Sub-agent overhead exceeds the savings.explore-codebase instead — it's optimized for structural code comprehension, not prose synthesis.Examples of well-framed questions:
A good question names a specific topic and what you want to learn. Don't ask vague questions like "tell me about Rust".
Fetch each source via bash. Typical patterns:
# Web page
curl -sL "https://example.com/article" | sed 's/<[^>]*>//g' | head -500
# GitHub README
curl -sL "https://raw.githubusercontent.com/org/repo/main/README.md"
# Documentation page
curl -sL "https://docs.rs/crate/latest/crate/" | sed 's/<[^>]*>//g' | head -500
# Search results (to find sources)
curl -s "https://lite.duckduckgo.com/lite?q=your+query" | sed 's/<[^>]*>//g' | head -60
Aim for 3-7 sources. More than 7 rarely adds insight — diminishing returns set in fast.
Estimate total content size:
echo "$SOURCE_1" | wc -c
# repeat for each source
Store each source under a namespaced key:
shared_state set key="synthesis.<topic>.source-1" value="<source 1 content>"
shared_state set key="synthesis.<topic>.source-2" value="<source 2 content>"
shared_state set key="synthesis.<topic>.source-3" value="<source 3 content>"
Namespace convention: synthesis.<topic>.source-<N> where <topic> is a short kebab-case slug (e.g., synthesis.rust-json-parsers.source-1).
If any single source exceeds 30KB (~120,000 bytes):
\n\n). Don't split mid-sentence.shared_state set key="synthesis.<topic>.source-<N>.chunk-1" value="<first ~25KB>"
shared_state set key="synthesis.<topic>.source-<N>.chunk-2" value="<next ~25KB>"
key_claims and key_quotes from all chunks of the same source, deduplicate, and store the merged result as the source's summary.For each source, dispatch a sub-agent with a focused extraction question. One source per sub-agent — sources are the natural unit of synthesis.
sub_agent: You are extracting key claims from a research source.
The source is stored in shared state under key "synthesis.<topic>.source-<N>".
Read it with: shared_state get key="synthesis.<topic>.source-<N>"
Research question: <your single-sentence question from step 1>
Extract the source's relevant claims and evidence. Reply with ONLY a JSON object (no markdown fences, no prose):
{
"key_claims": ["claim 1", "claim 2", ...],
"key_quotes": ["exact quote or close paraphrase with attribution", ...],
"relevance": "high|medium|low",
"confidence": 0.0-1.0,
"source_type": "paper|blog|docs|discussion|code|other",
"deeper_question": "a follow-up question if something is unclear, or null"
}
Skills do not chain. Sub-agents don't load this skill or any other; include the full question and shared-state key reference directly in the sub-agent's prompt.
Parse each sub-agent's response as JSON:
synthesis.<topic>.summary-<N>.{"key_claims": ["<first 300 chars of response>"], "key_quotes": [], "relevance": "low", "confidence": 0.2, "source_type": "other", "deeper_question": null}.curl | head -100. Produce a low-confidence summary manually from what you can see.If a sub-agent returns a non-null deeper_question AND confidence < 0.5:
Hard cap: recursion depth = 3. That's: initial dispatch → 1st recursion → 2nd recursion. After depth 3, accept whatever you have. If you find yourself wanting depth 4, your original question was probably too vague — go back to Step 1 and narrow it.
After all per-source summaries are collected, store them together:
shared_state set key="synthesis.<topic>.summaries" value="<JSON array of all summaries>"
Then dispatch a synthesis sub-agent to compose the final answer:
sub_agent: You are synthesizing research from multiple sources into a composed answer.
The per-source summaries are stored in shared state under key "synthesis.<topic>.summaries".
Read them with: shared_state get key="synthesis.<topic>.summaries"
Research question: <your single-sentence question from step 1>
Compose a synthesis that:
1. Identifies areas of AGREEMENT across sources
2. Identifies areas of DISAGREEMENT or tension
3. Notes any gaps — important aspects of the question that no source addressed
4. Weighs claims by source confidence and relevance
Reply with ONLY a JSON object (no markdown fences, no prose):
{
"answer": "3-5 paragraph composed answer to the research question",
"consensus": ["claims that multiple sources agree on"],
"disagreements": ["claims where sources conflict, with attribution"],
"gaps": ["aspects of the question not covered by any source"],
"confidence": 0.0-1.0,
"source_count": <number of sources that contributed>
}
The synthesis sub-agent's answer field is your composed response. Use it to:
memory/learnings.jsonl if the finding is novel and would change future behaviorStore the final synthesis in shared state under synthesis.<topic>.result so it can be referenced later in the session without re-running.
| Scenario | Use |
|---|---|
| 1 source, < 5KB | research — direct curl + read |
| 1 source, ≥ 5KB | synthesis — store in shared state, sub-agent extract |
| 2 sources, both < 5KB | research — direct curl + read both |
| 2 sources, any ≥ 5KB | synthesis — sub-agent dispatch |
| 3+ sources, any size | synthesis — always |
The research skill finds and fetches sources. This skill processes and composes them. They're complementary: research is the scout, synthesis is the analyst.
synthesis.<topic>.result. Read it with shared_state get instead of re-dispatching sub-agents.A synthesis is "good enough" when ALL of:
If the synthesis fails any of these, either add another source to fill the gap, or accept the partial result and note the open question.
research skill's job (search → evaluate → pick). This skill takes sources as input and produces synthesis as output.Find your way home — register with the yoyo family, introduce yourself, and participate in family discussions
Systematically find blind spots in code, architecture, APIs, and deployment — structured critique that catches what familiarity hides
RLM-style large-codebase comprehension — build a mental map of any codebase by dispatching sub-agents to explore regions without bloating main context
Interact with the community through GitHub Discussions — reply, share, learn
Read X (Twitter) via xurl — search posts, fetch threads, read profiles, and read long-form articles
Evaluate readiness and publish to crates.io