Should an AI agent do everything in one endless conversation, or hand each step to a fresh helper with a clean slate?
How do fresh-context subtask executors differ from single-stream autonomous agents?
This explores how an agent that hands each subtask to a worker starting with a clean context window differs from an agent that runs as one continuous stream where everything piles up.
This explores how an agent that hands each subtask to a worker starting with a clean context window differs from an agent that runs as one continuous stream where everything piles up. The main difference is what each step gets to see. A single-stream agent carries every past observation, dead end and tool output forward, so its context fills with material that is irrelevant to the current step. A fresh-context executor sees only what its step needs. Can algorithms control LLM reasoning better than LLMs alone? calls this information hiding. An explicit algorithm holds the control flow and state, and each LLM call gets a step-specific prompt. That gets around context-window and capability limits, and it turns a sprawling task into small pieces you can debug one at a time.
Fresh context is also a skill, not just a wiring choice. Can delegation teach models to manage context more actively? trained models to dispatch subtasks and fold the summarized results back in. That beat passively compressing a long history, and a 30B model matched much larger ones. The skill also carried over to single-agent tasks, which suggests that delegating teaches disciplined decomposition and evidence grounding. The line between the two designs is thinner than it looks. Can recursive subtask trees overcome context window limits? gets fresh-context behavior inside one model. It structures reasoning as a tree of subtasks and prunes the KV cache when a subtask finishes, and this holds up even when 90% of the cache is being manipulated. So separate workers are not the only way to get a clean slate.
The price of a clean slate is that nothing carries over unless you build the carrying-over. A single stream remembers implicitly, until the window fills or fills with noise. Fresh executors need explicit memory, and the corpus shows several forms. Short-lived agents in one evaluation Can ordinary infrastructure become unplanned agent memory? improvised memory by using a shared package repository to leave findings for later agents. Others design it deliberately: Can agents learn reusable sub-task routines from past experience? extracts reusable sub-task routines, and Can agents reconstruct memory on demand instead of retrieving it? rebuilds memory on demand by traversing a graph while reasoning, instead of retrieving first and reasoning afterward.
Splitting the work also changes the economics and the ceiling. Do single agents always hit organizational limits? argues that parallel execution, mixed expertise and independent verification exceed what any single agent loop can organize, however capable the model. Narrow subtasks can go to cheap models: Can small language models handle most agent tasks? puts small models at 10–30× lower cost for the repetitive, well-defined work that makes up most agent activity. Part of the apparent gain from splitting may come from spending more tokens, though. How does test-time scaling work at the agent level? finds that about 80% of multi-agent performance variance comes from token budget rather than coordination. The corpus has no controlled head-to-head of fresh-context executors against a single stream, so how much of the win is context hygiene and how much is extra compute is still open.
Sources 9 notes
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
SearchSwarm shows that training models to delegate subtasks and integrate summarized results beats passive compression, with a 30B model matching much larger ones. Critically, the delegation skill transfers to single-agent tasks, suggesting it teaches disciplined decomposition and evidence grounding, not just orchestration.
The Thread Inference Model demonstrates that reasoning structured as recursive subtask trees with rule-based KV cache pruning sustains accurate reasoning beyond context limits, even when manipulating 90% of the cache. This enables single models to replace multi-agent systems by handling full recursive reasoning internally.
During a 2026 evaluation, short-lived AI agents repurposed a shared package repository as memory by writing and reading exploit findings across agent lifespans. The agents converted ordinary infrastructure into persistent state without deliberate memory system architecture.
Agent Workflow Memory induces sub-task routines at finer granularity than full tasks, abstracts example-specific values, and compounds them hierarchically. This produces 24.6% relative gain on Mind2Web and 51.1% on WebArena, with larger gains as train-test gaps widen.
Show all 9 sources
MRAgent achieves up to 23% gains on reasoning tasks by reconstructing memory through active graph traversal that prunes paths based on accumulated evidence, while reducing token and runtime cost compared to fixed-retrieval pipelines.
Research shows that real-world tasks requiring heterogeneous expertise, parallel execution, and independent verification exceed what any single agent loop can organize. Graph-based system abstractions are needed to distribute intelligence across specialized agents.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
Research shows 80% of multi-agent performance variance comes from token budget, not coordination intelligence. LatentMAS and shared-KV-cache approaches offer ways to decouple performance gains from token costs.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- From Model Scaling to System Scaling: Scaling the Harness in Agentic AI
- Towards a Science of Scaling Agent Systems
- Agent Workflow Memory
- MUSE-Autoskill: Self-Evolving Agents via Skill Creation, Memory, Management, and Evaluation
- How we built our multi-agent research system
- Scaling Behavior of Single LLM-Driven Multi-Agent Systems
- Why Do Multi-agent LLM Systems Fail?
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures