An AI agent can look simple from the outside: an LLM calling tools in a loop. Give that loop a task lasting an hour and requiring 200 tool calls, though, and two failures arrive with predictable force—context overflow and goal loss.
The answer is not only a smarter model. The real action sits in the harness, the layer that manages everything around the model and turns a shallow loop into a deep agent. Compaction, memory strategy, context budgeting, and todo-state give long-running systems a way to keep the mission alive while the work keeps expanding.
Why Long Tasks Push Models Past Their Limits
A typical task needs around 50 tool calls, and its input-to-output token ratio runs near 100:1. Every observation from those calls lands in context and stays there, creating a growing record that the model must process again and again.
Anthropic describes the pressure through attention. “Attention creates n² pairwise relationships for n tokens, so every added token depletes a finite ‘attention budget.’” As the context grows, recall degrades. Earlier decisions, useful details, and the original objective compete with a flood of new observations.
That is how goal loss emerges. “Goal loss is not only a model bug. It is the expected outcome of an unmanaged context on a long enough task.” The agent may continue producing outputs and calling tools, yet drift away from the task that started the whole process.
The harness tackles that problem with four connected mechanisms: it compresses old history, controls what enters the context, moves oversized information outside the window, and keeps the task state visible.
Four Mechanisms Inside the Harness
1. Compaction turns history into usable state
Compaction summarizes a conversation nearing the window limit, then starts a new context with that summary. The goal is not to preserve every line. It is to preserve what the next stage needs to continue the work.
Claude Code’s compaction keeps architectural decisions, unresolved bugs, and implementation details while discarding redundant tool outputs. That balance matters because a long task needs its reasoning landmarks, not every repeated observation that led there.
The full original transcript is written to the filesystem, so the system can recover facts that the summary left behind. The active context stays focused, but the deeper record remains available when a missing detail matters.
2. Memory strategy moves important information beyond the window
Large tool responses do not need to occupy the model’s context forever. When a tool response exceeds 20,000 tokens, it is written to the filesystem and replaced with a file path plus a preview of its first 10 lines.
That single move changes the agent’s working environment. The context carries a pointer and a small orientation signal, while the full response remains stored outside the active window. The agent can continue without dragging every large result through each later step.
After compaction, any re-read file over 5,000 tokens comes back as a path reference rather than content. This creates another boundary between active reasoning and stored material, helping the model retrieve information without allowing every retrieval to expand the context again.
3. Context budgeting controls what gets loaded
Context budgeting asks a practical question before the first prompt even arrives: what deserves space now? Claude Code applies this approach to preloaded material, capping auto memory at the first 200 lines or 25KB.
That cap prevents background memory from consuming the room needed for the live task. The agent starts with a controlled foundation instead of loading an unlimited archive before it has made its first decision.
The harness also watches the model’s window during execution. When session context crosses 85% of the model’s window, older write and edit tool calls are truncated to a pointer. The system keeps the existence and location of those actions without preserving every token inside the active conversation.
4. Structured todo-state protects the mission
Goal preservation becomes stronger when the task state has a clear structure. Deep Agents made that principle a built-in feature, using summaries as structured documents with dedicated fields for session intent, artifacts created, and next steps.
The LangChain team added structured fields after experiments showed performance improvements. Instead of asking a summary to remember everything in one block of prose, the harness gives important information a place to live.
Session intent tells the agent why the work exists. Artifacts record what the process created. Next steps point the system toward its unfinished work. Together, those fields create a durable map through a task that may span dozens of tools and multiple context resets.
From One Loop to Coordinated Agent Systems
A harness can also divide work instead of forcing one model loop to handle every task in sequence. AWS AgentCore builds a coordinator that spawns 3 browser subagents in parallel, with each subagent running in its own MicroVM and an analyst subagent receiving their findings.
That design turns coordination into part of the system architecture. Parallel browser work can finish in 4 to 6 minutes, while sequential processing could run 3x longer. The coordinator manages the separation, the isolated environments, and the handoff to analysis.
This is the same core idea as compaction and memory strategy: the model does not carry the entire system alone. The harness controls where work happens, what information returns, and how the next decision receives it.
Production agentic AI needs that control because long tasks expose weaknesses that short demonstrations can hide. A loop may look capable for a few tool calls, but durable performance requires boundaries, records, summaries, and state.
The next generation of agents will not win through context size alone. They will win by using context with discipline—storing oversized responses, protecting attention, preserving intent, and making every new step aware of the work that came before it.
Based on
