cb_shared_searchswarm

A filtered view of SearchSwarm/SearchSwarm-SFT (MIT, arXiv 2606.09730) for evaluating non-prefix KV-cache reuse across agents: a report written at the end of a sub-agent's context is read again, verbatim, inside the main agent's context behind a different prefix.

Why this pattern, and why real data

The workload here is the orchestrator and sub-agent pattern: a main agent writes a brief, a sub-agent works in its own context and ends with a report, and the main agent reads that report inside its own context. The report's KV cache was computed in the sub-agent's context, behind the sub-agent's system prompt and tool steps. In the main agent it sits behind a different prefix, at a different position, and usually next to other sub-agents' reports. Prefix caching cannot serve it; position-independent (non-prefix) reuse can. This dataset exists so that claim can be tested on reports that real sub-agents actually wrote, rather than on a contrived layout.

The pattern is the documented default of the production harnesses, not a construction of this dataset or of the SearchSwarm paper:

• Anthropic, multi-agent research system (How we built our multi-agent research system, June 2025; Effective context engineering for AI agents, September 2025). The lead agent gives each sub-agent "an objective, an output format, guidance on the tools and sources to use, and clear task boundaries"; each sub-agent "might explore extensively, using tens of thousands of tokens or more, but returns only a condensed, distilled summary of its work (often 1,000-2,000 tokens)". Sub-agents run in parallel and cannot talk to each other.
• Claude Code sub-agents (docs). A sub-agent "receives only this system prompt plus basic environment details", does its work "in its own context and returns only the summary", which the parent reads as a tool result.
• OpenAI Codex sub-agents (docs): spawn prompt down, summary up ("Return summaries from subagents instead of raw intermediate output").
• OpenAI Agents SDK, agents as tools (tools, multi-agent); LangChain subagents (docs); Google ADK AgentTool (custom agents, collaboration); Gemini CLI sub-agents (docs); OpenHands TaskToolSet (docs); Roo Code orchestrator (docs): in each, the child starts fresh with the task text and only its final message returns to the parent (checked 2026-11-13).

SearchSwarm (arXiv 2606.09730) implements the same design: a main agent with a call_sub_agent tool that dispatches several briefs at once, sub-agents with search and visit tools and no further delegation, and the final report returned as the tool observation. Its report sizes (median about 1,600 tokens here) match the 1,000 to 2,000 tokens Anthropic reports for production. What this dataset adds is the selection of the requests where that reuse is large relative to the request, and the guarantee that every report is present, byte for byte, in both the sub-agent's and the main agent's context.

One row is one measured request:

• subagents[*].messages: each sub-agent's full conversation, system prompt to final message. The final message ends with the report (inside <report> tags, after a <think> block). These are the store requests.
• main_history: the main agent's conversation up to and including the dispatch turn, which is the request the main agent sent before the reports came back. In production that request was served just before the measured one, so its KV is a prefix hit for the measured request; send it first, in every arm, to reproduce that.
• main_messages: main_history plus the user message that carries the sub-agents' reports. This is the measured request. The last message concatenates 2 to 5 reports as A sub-agent dispatched for goal "<goal>" returned the following report:\n\n<report>.
• main_next: the main agent's following assistant turn in the source trajectory, for reference only (teacher output, not gold).
• question, answer: the task and its ground-truth short answer, from the source.

Every subagents[i].report is a byte-identical substring of both main_messages[-1].content and that sub-agent's final message, so the reused span is exactly locatable in both contexts.

Filters

Starting from the 6,732 source tasks and their 28,773 main-agent replies that carry reports:

1. Drop replies in which any report has no sub-agent conversation in the source bundle (the source authors removed some sub-agent runs): 10,308 replies.
2. Keep replies whose non-prefix share is above 0.5, where the share is report tokens divided by all tokens of the measured request (main prefix with earlier main-agent <think> blocks removed, plus the reply), counted with o200k_base: 8,063 dropped.
3. Keep one row per task, the first dispatch round that passes the filters: a later round's conversation contains the earlier round's whole request, so two rounds of one task would reuse each other's KV when both are run: 13 dropped.

Result: 1,596 rows from 1,596 tasks, 4,890 reports. 1,565 rows are the main agent's first dispatch round, 31 the second (their first round was dropped). 1,556 rows come from the redsearcher source, 40 from openseeker.

Sizes

Tokens are o200k_base. The measured request is 8,428 tokens at the median (6,830 at p10, 10,986 at p90) with earlier main-agent thinks stripped; the non-prefix share is 0.60 at the median and 0.52 at p10 (0.57 and 0.49 with those thinks kept). 4,859 of the 4,890 reports are at least 511 tokens. On the store side, one sub-agent context is 34K tokens at the median (13K to 53K, p10 to p90) and a row stores 106K tokens across its sub-agents (59K to 153K). Exact percentiles are in stats.json.

Columns

column	type	meaning
id	string	<task_index>-r<round>
task_index, round	int	source row index; dispatch round within the task (1 = first)
source, question, answer	string	from the source
n_reports	int	reports in the reply, equal to len(subagents)
main_history	list of {role, content}	the main agent's previous request: main_messages without its last message
main_messages	list of {role, content}	the measured request
main_next	string or null	the main agent's next assistant turn in the source
subagents	list of {goal, brief, report, report_tokens, context_tokens, messages}	one per report, in reply order
main_prefix_tokens_think_kept, main_prefix_tokens_think_stripped	int	tokens of main_messages[:-1] with and without earlier <think> blocks
reply_tokens, report_tokens_total	int	tokens of the last main message; sum of report tokens
share_think_kept, share_think_stripped	float	report_tokens_total / (prefix + reply)

Intended protocol

Send each subagents[i].messages as a store request (the sub-agent's whole context, ending in its final message) and main_history as the main agent's previous request (stored on the blend endpoint, plain on the recompute endpoint, so both hold it in the engine's prefix cache), then send main_messages once as the measured request with storing off, and compare the main agent's next turn between a blend endpoint and a recompute endpoint. The measured request then has a prefix hit on its own history and non-prefix hits on the reports, which is the production shape; the two together are the overall hit rate. The main agent's own earlier <think> blocks are kept in the record; drop or keep them consistently across arms (the served model's chat template usually drops them).

Provenance

Built on 2026-11-13 (main_history added and one row per task kept the same day) with a deterministic filter script (searchswarm_shared.py, part of TensorMesh's CacheBlend evaluation suite) from the source revision current on that date. The source trajectories were generated by the SearchSwarm authors' research harness with an unnamed teacher model and kept only when the main agent's final answer was correct. Licence follows the source: MIT.