CORAL: Teaching Agents to Manage Their Own Context Beats Scaling Up Models for Long Tasks

A Familiar Scenario

You ask an agent to complete a multi-step task: find information on the web, cross-verify, compute, summarize.

The first 10 steps go well. By step 15, it starts repeating searches for the same keyword. By step 20, it forgets facts it already verified and re-verifies them. By step 30, it's stuck in a loop—treating earlier flawed reasoning as fact and building on top of it.

This isn't a model that isn't smart enough. This is cognitive overload.

What would a human do? You'd grab a piece of paper, write down the confirmed facts, clear the messy intermediate work out of your head, and continue from a clean state.

CORAL (COgnitive Resource Self-ALlocation) is that piece of paper for agents.

The paper comes from a research team at The Chinese University of Hong Kong and Tencent, published October 29, 2026.

The Problem: An Agent's "Working Memory" Gets Clogged

LLM agents typically work like this: at every step, they see the complete record of all previous steps—what was searched, what was clicked, what was reasoned. That's their "working memory."

Short tasks are fine. But once tasks get long (30, 50, 100 steps), the working memory fills up with:

• Contents of pages already searched (mostly useless by now)
• Intermediate reasoning steps (many dead ends from trial and error)
• Tool call return values (verbose and repetitive)
• "Contamination" left by early erroneous reasoning

It's like having 50 papers piled on your desk where the information you need is on papers 3 and 47, but you have to flip through all of them every time. Worse, paper 23 has a wrong calculation that distracts you every time you pass it.

Direct consequences of cognitive overload: 1. Diluted attention—important information mixed with noise 2. Error accumulation—early faulty reasoning gets treated as fact by later steps 3. Loops—the agent forgets what it has done and repeats the same operations 4. Cost explosion—each step processes an ever-longer context, with token consumption growing linearly

CORAL's Solution: Checkpoint + Reset

CORAL's core idea is remarkably simple: let the agent decide when to "clear the desk."

Specifically, CORAL provides the agent with a "working memory management toolkit":

1. Checkpoint The agent can proactively save "verified facts" and "current task progress." Like writing yourself a note: "X, Y, Z are confirmed; next step is W."

2. Context Reset The agent can proactively clear its current working memory, keeping only what's saved in checkpoints. Like sweeping all the papers off your desk and keeping only the note with key information.

3. Resume After clearing, the agent continues reasoning from the checkpointed state, starting a new "episode" with a clean working memory.

The key: the agent itself decides when to checkpoint and when to reset. This isn't an externally imposed rule—it's a metacognitive ability the agent learns through training.

Multi-episode Agentic RL: Teaching the Agent to "Clear the Desk"

Giving tools isn't enough—the agent must learn to use them. The researchers used Multi-episode Agentic Reinforced Policy Optimization to train the agent's checkpointing ability.

The training setup:

• Long tasks are split into multiple episodes
• The agent can checkpoint at the end of each episode
• The next episode resumes from the checkpoint, but with clean working memory
• RL rewards are based on final task completion, but the agent must learn "when checkpointing is most valuable"

This mirrors how humans work: when writing code, you commit after finishing a feature. Not because someone told you to "commit now," but because you learned "committing at this point is safest."

Results: An 8B Model Beats Bigger Models

On the GAIA benchmark (a standard evaluation for multi-step agent tasks):

CORAL + 8B model: 42.8% average accuracy

That number alone may not dazzle, but consider:

• CORAL's gains are largest on the hardest Level 2 and Level 3 tasks
• CORAL consumes 1/6 to 1/7 of the input tokens of a ReAct agent

A 6–7x improvement in token efficiency. That's not "slightly better"—it's "same task, done at 1/7 the cost."

More notably: an 8B model equipped with CORAL can outperform larger models without it on long tasks. The bottleneck isn't model capacity—it's context management.

Ablations: Every Component Matters

The researchers ran detailed ablations:

Remove checkpoint: The agent can't save progress, so every reset starts from zero. Long-task accuracy drops sharply.

Remove reset: The agent can only checkpoint, not clear context. Like only being able to add papers to the desk, never sweep them off. Cognitive overload persists.

Remove RL training: Tools provided without training. The agent doesn't know when to checkpoint or reset. Performance falls in between.

All three are indispensable: tools (checkpoint + reset) + policy (RL-trained judgment of checkpoint timing) = CORAL's complete recipe.

Generalization: Not Just GAIA

CORAL isn't only effective on GAIA. The researchers also tested:

• Multi-hop knowledge QA: tasks requiring reasoning across multiple documents. CORAL's checkpointing helps the agent remember "which facts have already been found."
• BrowseComp: tasks requiring extensive web browsing. CORAL's reset helps the agent escape interference from "browsing history."

This shows CORAL addresses not a specific benchmark quirk, but the general cognitive overload problem of long-task agents.

A Concrete Example

The paper's appendix includes a great case study:

Task: A BrowseComp question requiring 36 steps.

• CORAL Agent: Completed in 36 steps, checkpointing 7 times along the way. After each checkpoint it reset the context and continued from a clean state. Answered correctly.
• ReAct Agent: Gave up after 47 steps. Performed 42 searches (heavily duplicated), context grew longer and longer, and it ultimately got lost in the noise.

The key difference: the CORAL agent checkpointed around step 10, saving "the key facts found so far," then reset. From step 11 onward, its working memory contained just 3 key facts instead of 5000 tokens of accumulated noise from the first 10 steps.

My Take: From "Longer Context" to "Better Context Management"

CORAL represents an important paradigm shift: solving long tasks isn't about giving models longer context windows—it's about teaching models to manage their own context.

This aligns with human cognitive science. Human working memory is tiny (roughly 7±2 chunks), yet humans complete extremely complex long tasks. Not with bigger working memory, but through:

• Externalized memory (notes, files, checkpoints)
• Active cleanup ("forgetting" intermediate steps once done)
• Episodic processing (splitting long tasks into short episodes)

CORAL gives agents all three strategies—and crucially, lets the agent decide when to use them.

This is in the same spirit as "judgment-gate decoupling": don't give the model more capabilities—give it the ability to manage its own capabilities. Checkpointing is the judgment (what's worth saving); reset is the gate (what should be cleared); only by learning to coordinate both can an agent stay sharp over long tasks.

A more practical takeaway: if your agent degrades on long tasks, don't rush to swap in a bigger model. Try teaching it to "clear the desk." The bottleneck may not be model capacity—it may be a context stuffed with things that should have been cleared.

---

Paper: arXiv:2610.40350