What BAAI's AREX teaches us about building agents that know what to forget
AREX uses a recursive self-improvement loop to reach 82.5 on BrowseComp with only 10B active parameters. The key is not training or scale. It is knowing when to compress context and what to keep.
TL;DR: BAAI released AREX, a family of open-weight deep research agents that use a recursive self-improvement loop to reach 82.5 on BrowseComp with only 10B active parameters. The architecture pairs an inner research loop with an outer self-improvement loop. The key innovation is a context-update tool that compresses the agent’s growing history into a structured improvement state. The model decides what to keep and what to drop based on what it still doesn’t know.
Key takeaways:
- AREX uses a bi-level loop: inner research loop gathers evidence, outer self-improvement loop audits constraint-by-constraint and decides Accept/Refine/Restart
- The Autonomous Context-Update Tool (ACU) compresses interaction history into a structured improvement state at a median of 25K tokens, not waiting for a 128K ceiling
- AREX-Base (10B active parameters) outperforms Qwen3.5-397B and achieves the best WideSearch-en score of any model including frontier systems
- Each component adds 10-12 points on BrowseComp. The complete system gains 22.9 points over the no-ACU, no-outer-loop baseline
- The improvement state is per-session only. AREX doesn’t learn across sessions. The architecture persists, not the refinements
What problem does AREX solve?
Deep research means an agent has to find an answer that satisfies multiple constraints at once. Find the paper that first proposed speculative decoding, was published at NeurIPS, and has at least 500 citations from non-US institutions.
The hard part isn’t searching. Each constraint adds a dimension the agent has to check. The agent finds one paper. Does it satisfy all three? No. Then what was useful about that search and what was not? Should it search wider, or should it check which constraints are still open and search more specifically?
Most deep research agents handle this by searching longer. More tool calls. More context. More tokens. They treat the problem as a budget problem.
AREX treats it as a state-maintenance problem. What have I verified? What is still open? What did I reject and why?
What do the two approaches look like?
| Approach | How it works | Problem |
|---|---|---|
| Search-harder | Run more tool calls, use more context, retry when stuck | Wastes budget on already-answered constraints. Rediscover things already found. Cannot tell progress from noise |
| Recursive self-improvement | After each search, audit the answer constraint-by-constraint. Preserve what is verified. Target what is still open | Requires the model to learn when to compress context and what to keep |
The first approach is easier to build. The second is more efficient. AREX is the first open-weight system that makes the second approach work at scale.
How does the bi-level architecture work?
AREX runs two loops, one inside the other.
The inner research loop is the worker. Given a research question, it analyzes what it needs, calls search or visit or python, reads the observations, updates its understanding, and decides whether to search more or produce an answer. It does this in a loop until it either has enough confidence or runs out of budget.
When it is done, it calls finish and produces a structured output with three parts: a provisional answer, the supporting evidence with source identifiers, and a confidence score from 0 to 100.
The outer self-improvement loop is the reviewer. It takes the inner loop output and makes one of three decisions:
- Accept. Confidence is above a threshold. Return the answer.
- Refine. Confidence is low but the trajectory has useful findings. The outer loop preserves the verified evidence, identifies which constraints are still unresolved, and launches a fresh inner loop with a targeted objective.
- Restart. The trajectory is too noisy or misdirected. Discard everything. Start a fresh inner loop from the original problem.
The catch: the confidence threshold is a manual knob. The paper uses a fixed value. A better system would learn when to stop.
The context-update tool is the key mechanism
Here is how it works. The Autonomous Context-Update Tool (ACU) is a tool the model can call during the inner loop. When the model calls it, the tool compresses the accumulated trajectory into a compact improvement state.
The improvement state contains six things:
| What it keeps | What it drops |
|---|---|
| Verified findings with source IDs | Redundant observations |
| Current candidate answers | Superseded conclusions |
| Unresolved constraints | Obsolete plans |
| Validity concerns | |
| Rejected candidates with reasons | |
| Next-step plan |
The model decides when to call ACU. Not a fixed interval. Not a token threshold. The model learns to call it when the research state needs refreshing.
Why it works. The structure is constraint-indexed, not token-position-indexed. Every piece of evidence is tagged to the constraint it addresses. When the outer loop selects Refine, it knows exactly which constraint is still unresolved and can target that specifically. The model doesn’t have to re-read 50K tokens to figure out what is missing.
The data from the paper backs this up. ACU is called in 80.3% of BrowseComp runs. The mean context at call is 25,721 tokens, well below the 128K ceiling. The top trigger is search strategy revision at 66.9% of calls. The model most often refreshes its state when the current direction isn’t working.
The catch: ACU is learned, not principled. The model figures out what to keep through reinforcement learning, not through a structured information-needs analysis. It can make the same compression mistakes a person would, keeping the wrong thing or dropping useful evidence.
Why the confidence score matters
The outer loop uses the confidence score from finish to decide what to do next. The calibration is good.
Correct outputs concentrate in the 90-100 bin. 95.9% of correct answers score 90-100 with ACU enabled. Incorrect outputs concentrate below 60. 55.2% of errors score below 60.
The catch: the confidence score depends on ACU being active. Without ACU, only 89.3% of correct answers reach 90-100. The score is less reliable when the model is drowning in its own context.
This separation supports the outer loop’s decision procedure. Many failures can be identified from the answer-level confidence score without reinterpreting the entire trajectory. The outer loop doesn’t need to read 50K tokens to decide something is wrong. The model flags itself.
What do the ablation numbers tell us?
The ablation study on BrowseComp isolates the contribution of each component.
| Configuration | Accuracy | Gain |
|---|---|---|
| No ACU, no outer loop | 59.6 | baseline |
| Outer loop only (no ACU) | 69.8 | +10.2 |
| ACU only (no outer loop) | 71.4 | +11.8 |
| Both | 82.5 | +22.9 |
The components are additive. ACU provides a refreshed state for the inner loop. The outer loop provides a targeted objective for the next inner round. Together they improve the same session by 22.9 points without changing the model.
The training ablations are also informative. Replacing the progressive multi-stage training with mixed training drops accuracy from 82.5 to 77.5. Replacing key-step supervision with random-step replay drops to 74.1. Replacing step-aware RL with standard GRPO drops to 79.4. The training recipe matters, and the gains from each stage are measurable.
What does the training pipeline look like?
AREX starts from Qwen3.5, a 4B model for AREX-Turbo and a 122B-A10B Mixture-of-Experts model for AREX-Base.
The mid-training has three stages. First, browse-intensive training to establish tool-use and web-navigation capabilities. Second, reasoning-intensive training for long-form thinking and hypothesis verification. Third, mixed consolidation where the model learns verification-driven research transitions.
After mid-training comes reinforcement learning. The key insight from the training analysis is that not all steps in a research trajectory are equally important. Ordinary steps like routine tool calls have an average loss of 0.232 after full-trajectory training. Evidence discovery steps have 0.277, or 19% higher. Path rejection and redirection steps have 0.298, or 28% higher. Key context-update steps have 0.300, or 29% higher.
The model learns routine actions easily. It underfits the decisive steps.
Why it works. The RL objective shapes the advantage signal to emphasize those decisive steps. Key steps in successful trajectories receive an auxiliary bonus. Ordinary steps receive only the outcome-level advantage. The model learns not just how to search but when to redirect, when to compress, and when to change strategy.
How does AREX compare to the field?
AREX-Base uses only 10B active parameters. It competes with models that use 10x to 40x more.
| Benchmark | AREX-Base | Best open comparable | Frontier best |
|---|---|---|---|
| BrowseComp | 82.5 | Kimi-K2.6 83.2 | Gemini-3.1-Pro 85.9 |
| GAIA | 85.4 | Kimi-K2.6 80.6 | Miro-H1 88.5 |
| WideSearch-en | 82.0 | Kimi-K2.6 80.8 | Gemini-3.1-Pro 66.4 |
| DeepSearchQA | 89.9 | Kimi-K2.6 92.5 | Opus-4.6 91.3 |
| HLE (tool) | 52.4 | Kimi-K2.6 54.0 | Opus-4.6 53.0 |
The catch. Frontier models still lead on most benchmarks. AREX closes the gap but doesn’t eliminate it. The recursive loop compensates for smaller scale but doesn’t replace scale entirely.
AREX-Turbo at 4B outperforms Qwen3.5-35B on five of six benchmarks. The architecture scales down efficiently.
Model weights are publicly available on HuggingFace (BAAI/AREX-Turbo 5B and BAAI/AREX-Base 123B) along with a quickstart repository. An online demo is also available.
The catch: session-only memory
AREX doesn’t learn across sessions. The improvement state is forgotten as soon as the answer is returned. If you run the same query tomorrow, the model goes through the full inner loop, outer loop, Accept or Refine or Restart process from scratch.
The paper calls this recursive self-improvement, which sounds like the model gets better over time. It doesn’t. The improvement is within a single session. Each session is a clean start.
This isn’t a flaw. It is a scope decision. The paper was solving the in-session improvement problem. Cross-session learning is a separate research area, and still open.
What this means for builders: if you deploy AREX for deep research, you get a strong per-query optimizer. You don’t get a system that remembers what it learned last week and applies it to today’s query. That architecture doesn’t exist yet. AREX shows that the in-session ceiling can be raised significantly. The cross-session ceiling is still an open question.
What this means for your agent loops
The AREX architecture maps directly to concepts already in use on this site.
The 15 Jobs of an Agent Harness defines what every agent system needs. AREX provides concrete mechanisms for three of them.
- Job 8 (State). ACU is a learned state-management mechanism. It decides what to keep and what to drop, and it organizes the state around remaining uncertainty instead of position in a token sequence.
- Job 9 (Memory). The improvement state is structured working memory. It doesn’t store everything. It stores only what is needed to continue the current research objective.
- Job 10 (Evaluation). The outer self-improvement loop is automated evaluation that drives the next action. It doesn’t score the answer. It uses the score to decide what to do next.
The Vertical Agent Method says pick one workflow, build one agent, ship in 14 days. AREX shows what happens when you apply that principle to the research workflow. A constrained, well-defined task with a specific evaluation function. The result is a system that outperforms models 40x its size on that task.
FAQ
What is AREX? AREX is a family of recursively self-improving deep research agents developed by BAAI. It uses a bi-level architecture with an inner research loop and an outer self-improvement loop. Model weights are publicly available on HuggingFace.
What is the Autonomous Context-Update Tool? ACU is a learned tool that compresses the agent’s growing interaction history into a compact improvement state. It preserves verified findings, unresolved constraints, and rejected candidates. The model decides when to call it.
How does AREX compare to frontier models? AREX-Base closes the gap significantly but frontier models still lead on most benchmarks. AREX achieves the best WideSearch-en score of any model. It outperforms models 40x its parameter count.
Does AREX learn across sessions? No. The improvement state is forgotten after each answer. Each query starts from scratch. AREX is a per-session optimizer, not a learning system.
What is the difference between Refine and Restart? Refine preserves verified findings and targets unresolved constraints. Restart discards everything and starts from the original problem. The choice depends on whether the trajectory is recoverable.
Related Posts
- The 15 jobs of an agent harness. The 15-job framework that defines what every agent system needs. AREX provides concrete mechanisms for Jobs 8, 9, and 10.
- What the OpenAI sandbox escape means for agent security. Long-horizon agents introduce failure modes that shorter evaluation runs can’t catch. AREX addresses one of them: context degradation in long research trajectories.
- The policy gate every agent needs before you go to production. Policy gates check not just what tool is called but what outcome a sequence of calls is working toward. AREX’s outer loop does the same pattern for research quality.
This article was published on Agentic Up (https://agenticup.dev): practical guides for developers and founders building with AI agents. Reach me at [email protected]
