ArXiv: 2510.24699

🎯 Pitch

A 30B-parameter web agent surpasses models 20× its size by learning to fold its context like a human scratchpad, pruning dead ends and distilling multi-step sub-tasks while preserving crucial details. It reaches only 7k tokens after 100 turns, enabling effective reasoning over 500 interactions where standard agents become overwhelmed by noise.

1. Executive Summary

This paper introduces AgentFold, a novel web agent paradigm that replaces the passive context accumulation of ReAct-based agents with proactive, learned context management through a "folding" operation — a mechanism that dynamically curates the agent's working memory by performing either Granular Condensation (preserving a single step's key detail as a compact summary, e.g., crystallizing the latest tool call and observation into a concise record) or Deep Consolidation (abstracting an entire multi-step sub-task into one high-level conclusion, e.g., collapsing an 11-step failed investigation into a single "dead end" summary). When implemented via supervised fine-tuning on Qwen3-30B-A3B and evaluated on long-horizon information-seeking benchmarks, AgentFold achieves 36.2% on BrowseComp and 47.3% on BrowseComp-ZH, surpassing open-source agents over 20× its size — including DeepSeek-V3.1-671B-A37B at 30.0% — and matching proprietary agents like OpenAI's o4-mini, while maintaining a context that grows sub-linearly from roughly 3.5k to only 7k tokens over 100 turns (versus over 84k tokens for ReAct). Critically, the folding mechanism enables the agent to scale to 500 interaction turns with context mostly remaining below 20k tokens and non-monotonically shrinking when dead-end sub-investigations are consolidated — establishing that test-time context management can substitute for model scale, but only when the agent is trained to treat its workspace as a dynamically sculptable cognitive resource rather than a passive log.

2. Context and Motivation

The Core Problem: Long-Horizon Web Agents Are Bottlenecked by Context Management

The fundamental challenge AgentFold tackles is deceptively simple: how should a web agent manage its own memory during a task that might require dozens or hundreds of sequential web interactions? This is not a peripheral engineering concern — it is the central bottleneck determining whether an agent can succeed on complex, multi-step information-seeking tasks that require sustained reasoning over extended trajectories.

The paper frames this through a trade-off that every web agent architecture must confront, explicitly or implicitly: the tension between context comprehensiveness (keeping all historical information available) and context conciseness (keeping the working context small enough for the model to reason over effectively). This trade-off becomes acute — and strategy-dependent — on long-horizon tasks where the interaction history grows far beyond what is practical to retain in full.

Why this matters now. The paper identifies three converging trends that make context management urgent rather than merely interesting:

First, the pragmatic reality of context window constraints. While modern LLMs support context windows of 128k tokens or more, the paper shows that raw ReAct trajectories can easily exceed 84k tokens within 100 turns (illustrated in Figure 1, right panel). Even when hardware can technically fit the context, reasoning quality degrades as the model must attend over a sprawling, noisy history where critical signals are buried in the verbatim records of irrelevant web pages, failed searches, and abandoned investigation branches. This is the context saturation problem the paper identifies as endemic to ReAct-style agents.

Second, the ambition to tackle genuinely long-horizon tasks. The benchmarks AgentFold targets — BrowseComp, BrowseComp-ZH, WideSearch — specifically evaluate an agent's ability to locate hard-to-find information through sustained exploration, often requiring dozens of strategic pivots, dead-end recoveries, and multi-source cross-referencing. These are not single-hop retrieval tasks (where you search once, read a page, and answer). They demand agents that can maintain a coherent investigation over 50, 100, or even 500 interaction turns. As the paper demonstrates in Section 4.1, Agents that hit context saturation well before exhausting their turn budget simply cannot attempt these tasks — performance plateaus or collapses.

Third, the emerging role of web agents as autonomous research assistants. The paper positions itself against the backdrop of systems like OpenAI's Deep Research, which demonstrate that LLM-based agents can perform sophisticated, multi-source information synthesis — but only if they can manage the informational complexity that comes with sustained exploration. Making such capabilities accessible via open-source, smaller models (the paper trains on a 30B-total, 3B-activated architecture) requires solving context management efficiently rather than relying on brute-force long-context processing by massive proprietary models.

The Two Existing Paradigms — And Why Both Fail

The paper organizes prior work into two broad approaches to context management, each of which represents an extreme on the comprehensiveness-conciseness spectrum — and each of which fails on long-horizon tasks for a different reason.

Paradigm 1: ReAct — Append-Only History (Complete but Saturated). The dominant paradigm in contemporary web agents is ReAct (Yao et al., 2023), where the agent iteratively generates a reasoning step, calls a tool, and receives an observation, with the full history of all (thought, action, observation) triplets accumulated in the context window. The paper cites a range of agents built on this pattern, including WebThinker, WebDancer, WebSailor, WebSailor-V2, WebShaper, and WebExplorer.

The strength of this approach is that no information is ever lost. Every search result, every visited page, every intermediate deduction remains available for the model to reference. If a detail from step 12 becomes critical at step 87, it's still there — in principle.

The failure mode is context saturation: as the trajectory lengthens, the context grows without bound, eventually including vast amounts of noise. The paper is explicit about why this is catastrophic:

the agent's context exhibits an uncontrolled, near-linear growth, accumulating a massive token count as the task progresses.

This is not merely a token-count problem. It is a signal-to-noise ratio problem. The raw HTML or text from visited web pages, the multiple search queries exploring dead ends, the partial observations from failed tool calls — all of these remain permanently entombed in the context, making it increasingly difficult for the model to identify and attend to the genuinely relevant pieces of information. The paper's Figure 3b contrasts AgentFold's sub-linear block count growth against the linear explosion of ReAct, naming it as "runaway structural complexity over long horizons."

Critically, this failure is deterministic — it's not a probabilistic degradation but a structural guarantee that the context will eventually become unwieldy. The paper notes that on BrowseComp, over 20% of trajectories hit the experimental turn limit of 100 and are forcibly terminated as failures, yet AgentFold's context at that point is only roughly 7k tokens (Section 4.1). The ReAct agent hits a context wall long before it hits a reasoning wall.

Paradigm 2: Uniform Full-History Summarization — Compact but Irreversibly Lossy. A more recent line of work attempts to solve context saturation by mechanically summarizing the entire history at every step. The paper cites MEM1 (Zhou et al., 2025b) and MemAgent (Yu et al., 2025) as representative examples of this approach. After each action-observation cycle, these agents compress the accumulated history into a single summary, keeping the context concise.

The strength is that context size remains bounded regardless of trajectory length. The agent always operates within a compact workspace.

The failure mode is what the paper calls "the premature and irreversible loss of crucial details" (Section 1). This is a subtle but devastating problem. The paper provides a formal argument in Section 3.5:

if we assume a modest 1% chance of a key detail being lost each time the full history is re-summarized, the probability of a finding from step 1 surviving until step 100 reduces to just ≈36.6% (0.99^100).

This is the compounding information loss problem unique to uniform summarization. Every re-summarization is another opportunity for the model to misjudge what matters — to discard a seemingly minor detail that later proves critical, to conflate distinct findings, or to lose the precise temporal or logical relationships between pieces of evidence. After 500 steps, the survival probability under this model collapses to 0.66%.

The deeper issue is that uniform summarization makes a static, uninformed decision about what information matters. It compresses step 1's findings before knowing whether step 37 will need those exact details. It cannot distinguish between a routine navigation step (where aggressive compression is safe) and a pivotal discovery (where even minor details must be preserved verbatim). The policy is applied mechanically and uniformly regardless of content.

The paper also notes that these methods have been "primarily evaluated on simpler, retrieval-focused tasks like HotpotQA" — which involve far fewer interaction steps and less complex information dependencies than the long-horizon benchmarks AgentFold targets. Their adequacy for genuinely extended investigations was never established.

Where both paradigms fall short: the lack of proactive, content-aware curation. The paper's diagnosis is that both ReAct and uniform summarization share a deeper architectural flaw: they treat the agent's context as a passive log to be accumulated (ReAct) or mechanically compressed (summarization) according to a fixed, external policy. Neither approach gives the agent itself any agency over what to remember, what to abstract, and what to discard — and critically, neither allows the agent to delay curation decisions until it understands the significance of what it has found.

How This Paper Positions Itself: The Cognitive Workspace Metaphor

The paper's core framing is explicitly cognitive: an ideal agent should manage its context like a human's mental scratchpad — "a workspace to be actively managed, not passively filled" (Section 1). This is not merely an evocative metaphor; it drives specific architectural commitments that distinguish AgentFold from prior work.

The paper draws on established concepts from cognitive psychology, citing Miller (1956) on working memory capacity limits and Newell et al. (1972) on human problem-solving as a process of "disciplined, retrospective consolidation performed at critical points." The key claim is that human problem-solvers engage in a "dynamic 'look-back' mechanism" : after a sequence of actions, they pause to mentally review — discarding irrelevant steps, distilling intermediate findings, and abstracting key insights. This is not a rigid per-step compression but a flexible, content-dependent process performed when enough context has accumulated to evaluate what mattered.

Three structural commitments distinguish AgentFold:

  1. Context as a structured cognitive workspace, not a monolithic log. The paper partitions the agent's context into explicit components with distinct roles: the invariant question (the anchor), the available tools (the action space), the Multi-Scale State Summaries (curated long-term memory), and the Latest Interaction (high-fidelity working memory). This is formalized in Equation 1 as a triplet Ct=(Q,T,St−2,It−1)C_t = (Q, T, S_{t-2}, I_{t-1}). The structural separation means that historical information lives in St−2S_{t-2} — a sequence of summary blocks that can be independently modified, merged, or retracted — while the immediate past remains fully available in It−1I_{t-1}. This is not mere labeling; it creates a clear operational boundary: folding operations target one component (the state summaries), while situational reasoning targets another (the latest interaction).

  2. Folding as a learned, core action, not a passive policy. The paper's most distinctive claim is that context curation should be an intrinsic part of the agent's reasoning process — something the model learns to do rather than something done to the model by an external summarizer. At each step, the agent generates both a folding directive (specifying which range of past steps to fold and what summary to replace them with) and an action (the next tool call). This is formalized in Equation 3 as Rt=AgentFold(Ct;θ)→(tht,ft,et,at)R_t = \text{AgentFold}(C_t; \theta) \rightarrow (th_t, f_t, e_t, a_t), where ftf_t is the folding directive. The folding operation is thus a product of the same chain-of-thought deliberation that produces the next action — the agent reasons about what to fold simultaneously with reasoning about what to do next.

  3. Delayed, multi-scale curation rather than rigid per-step compression. The two folding operations — Granular Condensation (folding a single step, k=t−1k = t-1) and Deep Consolidation (folding a range of steps, k<t−1k < t-1) — give the agent the flexibility to curate at different scales depending on content. A single step containing a crucial fact can be preserved as its own fine-grained summary block. A completed sub-investigation — even one spanning dozens of steps — can be collapsed into one high-level conclusion once its outcome is clear. The paper explicitly frames this as transcending "the brutal trade-off between retaining noisy details and risking catastrophic information loss" (Section 1) by making the curation decision informed by hindsight — the agent knows what the sub-task achieved before deciding how much to compress it.

Position relative to prior work. The paper positions AgentFold not as an incremental improvement along either existing axis (better ReAct, better summarization) but as a conceptual leap to a new class of agent that is a "self-aware knowledge manager" (Section 3.5). It contrasts with ReAct on the conciseness axis (AgentFold never accumulates unbounded noise) and with uniform summarization on the comprehensiveness axis (AgentFold never irreversibly discards information prematurely). The paper's Section 2 explicitly separates its contribution from both External Context Augmentation (injecting knowledge from outside the current trajectory) and the prior Intra-Task Context Curation work (MEM1, MemAgent) that used rigid per-step summarization on simpler tasks.

The training challenge as a central motivation. A significant portion of the paper's motivation is about data: training an agent to perform this kind of proactive context curation requires trajectories that demonstrate sophisticated interleaving of folding decisions and task actions, and no such dataset exists. The paper's Fold-Generator pipeline (Section 3.4) is thus not merely an implementation detail but a necessary component of the research contribution — it addresses the bootstrapping problem that even "the most advanced LLMs cannot reliably produce AgentFold's structured, multi-part responses through prompt engineering alone" (Section 3.4). This creates a chicken-and-egg problem: you need folding-capable agents to generate training data for folding-capable agents. The paper's solution — using rejection sampling with powerful LLMs to generate validated trajectories, then distilling that capability into a smaller model via SFT — is a core part of the approach's feasibility argument.

The scaling ambition. The paper is explicit that its ultimate target is not just better performance on existing benchmarks, but enabling a class of investigation that is currently impossible: "truly extended interactions — potentially lasting for hundreds of steps — to perform the kind of broad and deep web exploration required for complex research and analysis tasks" (Section 4.1). The context efficiency numbers — 7k tokens at 100 turns, mostly below 20k tokens at 500 turns — are presented not as an achievement but as evidence of headroom: the model's 128k context window is barely used, suggesting that the architectural innovation, not the hardware constraint, is what unlocks long-horizon capability. This reframes the research question from "how do we fit long trajectories into limited context windows?" to "how do we build agents that can sustain coherent reasoning across arbitrarily long investigations?"

3. Technical Approach

3.1 Reader Orientation

This paper presents AgentFold, a web agent that manages its own memory by "folding" (compressing) its interaction history at different granularities during a task rather than passively accumulating it. The system solves the problem that existing web agents either keep everything in their context (which becomes enormous and unusable after 50+ web interactions) or blindly summarize everything at every step (which risks losing the one critical detail needed 40 steps later). AgentFold's solution shape is to make context management a learned skill — the agent is trained, via supervised fine-tuning on specially constructed trajectories, to decide for itself which steps to keep as detailed summaries, which multi-step sub-investigations to collapse into a single high-level conclusion, and when to recognize a dead end and consolidate an entire failed line of inquiry before pivoting strategies.

3.2 Big-Picture Architecture (Diagram in Words)

The system consists of five major components that interact in a structured loop:

  1. The Structured Context Workspace — the agent's working memory at any step, partitioned into four fixed slots: the user's question (immutable anchor), the list of available tools (action schema), the Multi-Scale State Summaries (a sequence of previously folded summary blocks serving as long-term memory), and the Latest Interaction (the complete record of the immediately preceding step, including the explanation, tool call, and tool response).

  2. The AgentFold Model — a fine-tuned LLM (Qwen3-30B-A3B) that receives the structured context and produces a multi-part response containing four components: internal thinking (chain-of-thought), a folding directive (a JSON object specifying which range of past steps to fold and what replacement summary to use), an explanation (concise motivation for the upcoming action), and a tool call (the next action — a search, page visit, or final answer).

  3. The Folding Executor — not a learned component but a deterministic mechanism that applies the model's folding directive to update the Multi-Scale State Summaries for the next step, either appending a new single-step summary (Granular Condensation) or retracting a range of existing summaries and replacing them with one coarser summary (Deep Consolidation).

  4. The Tool Environment — the external web browser/search engine that executes the agent's tool calls and returns observations (search results, page contents), which become the observation component of the new Latest Interaction.

  5. The Fold-Generator Training Pipeline — an offline data-generation system that uses powerful LLMs with rejection sampling to produce validated trajectories of (context, correct response) pairs, which are then used to fine-tune the AgentFold model via standard supervised learning.

Information flow in a single step: The current context (Question + Tools + Multi-Scale State Summaries + Latest Interaction) is assembled → fed into the AgentFold model → the model generates a thinking block, then a folding directive (JSON with a range and summary text), then an explanation, then a tool call → the folding directive is immediately applied to update the State Summaries (removing the specified range and inserting the new summary) → the tool call is executed in the environment → the resulting observation, combined with the explanation and tool call, becomes the new Latest Interaction → the cycle repeats until the model outputs a final answer instead of a tool call. Critically, the folding happens before the tool execution, meaning each subsequent step sees an already-curated long-term memory.

3.3 Roadmap for the Deep Dive

  • First, the structured context architecture (Section 3.2 content): understanding exactly what information the agent sees at each step and how it is organized — the four-slot workspace design, the formal definition of Multi-Scale State Summaries, and the rationale for separating long-term memory (summaries) from working memory (latest interaction). This is foundational because everything else operates on this structure.

  • Second, the agent's response format (Section 3.3 content): the four-part output (thinking, folding directive, explanation, action) and the critical interaction between the folding directive and the context — specifically, how Granular Condensation and Deep Consolidation differ, how they are encoded as a single JSON format, and how the choice between them is a learned decision made during chain-of-thought reasoning.

  • Third, the folding mechanics in detail: how the folding directive transforms the state summaries mathematically (the retraction and replacement operation), including edge cases like the initial steps where no folding occurs.

  • Fourth, the training pipeline (Section 3.4): how Fold-Generator creates training trajectories when the target output format is too complex for prompt engineering alone — the rejection sampling mechanism, the distillation from powerful LLMs into a smaller model via SFT, and the specific question set used.

  • Fifth, the theoretical motivation for delayed curation (Section 3.5): the compounding information loss argument that formalizes why uniform per-step summarization fails, and why AgentFold's ability to preserve individual critical details in distinct blocks (exempt from reprocessing) avoids this failure mode.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and architecture paper whose core idea is that an agent should be trained to manage its own context as an intrinsic part of reasoning — executing a "folding" operation that curates historical information at multiple scales (single-step granular vs. multi-step abstract) based on content-aware, hindsight-informed decisions made during the same chain-of-thought that plans the next action.

The Structured Context Workspace

At any step $t$, the agent does not receive an undifferentiated history. Instead, it receives a context $C_t$ explicitly partitioned into components with distinct cognitive roles. The paper formalizes this as:

Ct=(Q,T,St−2,It−1)C_t = (Q, T, S_{t-2}, I_{t-1})

where $Q$ is the invariant user question (the task anchor, never modified throughout the trajectory), $T$ is the schema of available tools (including their names, descriptions, and required parameters), $S_{t-2}$ is the Multi-Scale State Summaries — a curated sequence of summary blocks covering steps 1 through $t-2$ — and $I_{t-1}$ is the Latest Interaction, the complete verbatim record of step $t-1$.

What it computes: this is not a computation but a data-structuring decision. The context presented to the model at step $t$ is assembled by concatenating the four components according to a fixed template (shown in the case study in Figure 5: first the question, then a "Previous Steps" section listing all summary blocks in $S_{t-2}$, then the full text of step $t-1$ as $I_{t-1}$).

Why this form: the separation of $S_{t-2}$ and $I_{t-1}$ is the architectural mechanism that resolves the comprehensiveness-conciseness trade-off. The Latest Interaction $I_{t-1}$ provides complete, lossless detail about the most recent step — the model can see exactly what tool it called, what it was thinking (via the explanation), and what the raw observation was. This ensures situational awareness for short-term decisions. Simultaneously, the Multi-Scale State Summaries $S_{t-2}$ provide noise-free, abstracted knowledge about everything before that — the model has a clean historical narrative without the verbosity. The critical property is that these components are independently updateable: folding operations modify only $S_{t-2}$, while each new step simply replaces $I_{t-1}$. This is fundamentally different from ReAct, where the entire history is one growing monolith, and from uniform summarization, where the Latest Interaction is already summarized and therefore lossy even for the immediate past.

The Multi-Scale State Summaries $S_{t}$ are formally defined as an ordered sequence of summary blocks:

St=(sx1,y1,sx2,y2,…,sxm,ym)S_t = (s_{x_1, y_1}, s_{x_2, y_2}, \ldots, s_{x_m, y_m})

where each $s_{x,y}$ is a textual summary of the contiguous block of steps from $x$ to $y$. The step ranges partition the entire history up to step $t-2$, meaning $x_1 = 1$, $y_m = t-2$, and $x_{i+1} = y_i + 1$ for all $i$ (no gaps, no overlaps). A summary of a single independent step is denoted $s_{x,x}$ where $y = x$ — this is the result of Granular Condensation. A summary representing the consolidation of a multi-step process is denoted $s_{x,y}$ where $y > x$ — this is the result of Deep Consolidation.

The Latest Interaction $I_{t-1}$ is formed by concatenating three elements from the previous step:

It−1=(et−1,at−1,ot−1)I_{t-1} = (e_{t-1}, a_{t-1}, o_{t-1})

where $e_{t-1}$ is the explanation (the agent's concise motivation for the action), $a_{t-1}$ is the executed tool call (search query, URL visit, or final answer), and $o_{t-1}$ is the resulting observation from the environment (search results snippet, page content, or null for final answer).

Initialization edge cases. For the very first step ($t = 1$), there is no prior history, so both the State Summaries and Latest Interaction are empty: $C_1 = (Q, T, \emptyset, \emptyset)$. The agent sees only the question and available tools. For the second step ($t = 2$), the State Summaries are still empty (since there is only one prior step and it exists as the Latest Interaction, not yet folded into a summary), so: $C_2 = (Q, T, \emptyset, I_1)$. This means the initial step's output is treated as a special case — the agent produces a response without a folding directive (since there is nothing to fold), and that response's explanation, action, and observation become $I_1$ for step 2. Only from step 3 onward does the State Summaries component become non-empty (since step 2's folding will typically create the first summary block from step 1's interaction).

The AgentFold Response Format: Thinking, Folding, Explanation, Action

At each step $t$, the AgentFold model $\theta$ receives the structured context $C_t$ and produces a single coherent block of text that is parsed into four components:

Rt=AgentFold(Ct;θ)→(tht,ft,et,at)R_t = \text{AgentFold}(C_t; \theta) \rightarrow (th_t, f_t, e_t, a_t)

where $th_t$ is the thinking process (a detailed internal monologue analyzing the context and weighing options for both folding and the next action), $f_t$ is the folding directive (a structured command for updating the Multi-Scale State Summaries), $e_t$ is the explanation (a concise articulation of the motivation behind the chosen action), and $a_t$ is the external action (either a tool call with specified name and arguments, or a final answer if the task is deemed complete).

What it computes: the model performs a single forward pass that generates all four components as contiguous text with special XML-style tags (<thinking>, <folding>, <motivation>, <tool_call>) enabling deterministic parsing. The thinking block is an unstructured chain-of-thought — the model reasons about what has been accomplished, what information gaps remain, which steps are worth preserving in detail, which can be consolidated, and what the next strategic move should be. From this deliberation, the other three structured components are derived. The paper emphasizes that this is not separate generation passes — it is one coherent output where the thinking process influences both the folding decision and the action selection simultaneously.

Why this form: the integration of folding and acting into a single response is the paper's central architectural claim. The explicit requirement to produce a folding directive compels the agent to retrospectively evaluate its trajectory — to decide what mattered and what didn't — before deciding what to do next. Conversely, the process of planning a new action forces the agent to interrogate recent history for relevant clues, which directly informs what is worth preserving in a folded summary. The paper calls this a "powerful cognitive symbiosis" (Section 3.3): the folding decision improves the quality of the subsequent action (by clarifying what is known and unknown), and the action-planning process improves the quality of the folding decision (by revealing what information is actually relevant to the next step). This coupling is what distinguishes AgentFold from architectures where summarization is applied externally by a separate mechanism — here, the same model that decides what to do also decides what to remember, using the same reasoning process.

An important pragmatic detail: the initial step ($t = 1$) omits the folding directive because there is no prior history to fold. The paper states that "the initial step being a special case that omits the folding directive due to the absence of prior history" (Section 3.1). This means the model is trained to recognize when it is at step 1 and produce only thinking, explanation, and action without the <folding> block.

The Folding Directive: Two Operations, One Format

The folding directive $f_t$ is a JSON object with exactly two keys:

ft={"range":[k,t−1],"summary":σt}f_t = \{\text{"range"}: [k, t-1], \text{"summary"}: \sigma_t\}

where $k$ is the starting step ID for the folding operation (an integer between 1 and $t-1$), $t-1$ is always the ending step ID (the folding always extends through the most recent completed step — the one that just became part of history), and $\sigma_t$ is the replacement summary text — a string that the agent itself generates to describe the folded range.

What it computes: this directive specifies exactly which range of the trajectory's history should be compressed into a single summary, and what that summary should say. The deterministic executor then applies this directive by: (1) identifying all existing summary blocks in $S_{t-2}$ whose step ranges fall within $[k, t-1]$, (2) retracting (removing) those blocks from the sequence, (3) also retracting the Latest Interaction $I_{t-1}$ (which covers step $t-1$), and (4) inserting a single new summary block $s_{k, t-1} = \sigma_t$ at the appropriate position in the sequence. The result is a new sequence $S_{t-1}$ that covers steps 1 through $t-1$ with potentially fewer blocks than before.

Why this form: the [k, t-1] range format supports both folding operations with a single syntax. The distinction between Granular Condensation and Deep Consolidation is determined entirely by the value of $k$:

  • Granular Condensation occurs when $k = t-1$. The range covers exactly one step — the most recently completed step. In this case, the Latest Interaction $I_{t-1}$ is folded into a new fine-grained summary block (e.g., [Compressed Step 5] Found a new candidate XYZ that needs further exploration.), and this block is appended to the existing $S_{t-2}$ sequence. The key characteristic is that the summary preserves "the highest resolution of the historical trajectory" — it captures what happened in that single step in enough detail to be useful later, but without the raw verbosity of the full web page or search result snippet that was in the observation.

  • Deep Consolidation occurs when $k < t-1$. The range spans multiple steps — the Latest Interaction plus some number of prior steps whose summaries already exist in $S_{t-2}$. In this case, all summary blocks covering steps in $[k, t-2]$ are retracted from $S_{t-2}$, the Latest Interaction $I_{t-1}$ is also consumed, and the entire range is replaced by a single coarse-grained summary (e.g., [Compressed Step 5 to 9] Confirmed that XYZ does not fit all criteria after checking several sources.). This is a "change of scale" — the agent abstracts away noisy intermediate steps once a sub-task is complete, packaging the entire investigation into its final conclusion.

When each operation is used — the content-aware decision. The paper's case study (Figure 5) demonstrates the strategic logic. Granular Condensation is used for incremental progress — each step that produces useful, distinct findings gets its own summary block, preserving fine-grained detail. Deep Consolidation is used for two scenarios: (1) when a sub-task is complete and the intermediate steps are no longer individually relevant (e.g., spending multiple steps verifying a single fact, then collapsing the verification into a conclusion), and (2) when the agent recognizes a dead end — an extended series of failed attempts that should be abstracted into a single lesson-learned summary to free cognitive space for a new investigative direction. The paper's 500-turn experiment reveals a sophisticated dynamic: Deep Consolidation of failed sub-investigations can actually reduce context size, creating non-monotonic context growth where the agent "resets" its workspace after abandoning a fruitless line of inquiry.

A critical constraint: the range $[k, t-1]$ always ends at $t-1$ — the folding operation always includes the most recently completed step. This means the agent cannot fold an arbitrary isolated segment of older history while leaving the latest interaction untouched. It must always fold a suffix of the trajectory ending at the current step. This constraint makes conceptual sense: the Latest Interaction $I_{t-1}$ is part of the active workspace, and after it has been used for the current step's reasoning, it gets folded into long-term memory before the next step begins. The agent cannot retroactively fold step 5 to 8 without also folding step 9 (the latest) — if those earlier steps are worth consolidating, the latest step (which presumably relates to or completes that sub-task) must be included in the consolidation.

The Context Update Dynamics: From Step $t$ to Step $t+1$

The full update cycle that transforms $C_t$ into $C_{t+1}$ proceeds as follows:

  1. Model inference: the AgentFold model receives $C_t = (Q, T, S_{t-2}, I_{t-1})$ and produces $R_t = (th_t, f_t, e_t, a_t)$.

  2. Folding execution: the folding directive $f_t = \{\text{"range"}: [k, t-1], \text{"summary"}: \sigma_t\}$ is applied to $S_{t-2}$ and $I_{t-1}$. All summary blocks in $S_{t-2}$ whose step ranges fall entirely within $[k, t-2]$ are retracted. The Latest Interaction $I_{t-1}$ (covering step $t-1$) is consumed. A single new summary block $s_{k, t-1} = \sigma_t$ is inserted at the position corresponding to step $k$. The result is $S_{t-1}$ — the updated Multi-Scale State Summaries covering steps 1 through $t-1$.

  3. Tool execution: the action $a_t$ is executed in the environment. If $a_t$ is a tool call (e.g., a search query or page visit), the environment returns an observation $o_t$ (search results, page content, or an error message). If $a_t$ is a final answer, there is no observation and the trajectory terminates.

  4. Context assembly for next step: the new Latest Interaction is formed: $I_t = (e_t, a_t, o_t)$. The new context for step $t+1$ is: $C_{t+1} = (Q, T, S_{t-1}, I_t)$.

What happens to the thinking component. The thinking block $th_t$ is not included in the context for future steps. It serves only as the scaffolding for the model's current reasoning — generating it helps the model produce better folding directives and actions, but it is not preserved in the agent's memory. This aligns with the cognitive metaphor: the thinking is the internal deliberation, not part of the externalized workspace. The folding summary $\sigma_t$ and the explanation $e_t$ serve as the externalized, communicable products of that deliberation.

Implicit in this design: the agent cannot "undo" a fold. Once a range of steps has been consolidated and the original detailed summaries or raw interactions have been retracted, they are gone. The only record going forward is the replacement summary $\sigma_t$. This means the agent must decide, at the moment of folding, what information from the retracted steps is worth preserving in the summary text — the summary itself is the only vehicle for carrying forward knowledge from those steps. This is a high-stakes decision, which is why the paper emphasizes the importance of making it an informed, content-aware, hindsight-based decision rather than a mechanical per-step compression.

The Fold-Generator Training Pipeline

Training AgentFold requires a dataset of trajectories where each step demonstrates the desired four-part response format — and critically, where the folding decisions are correct: the agent folds at appropriate granularity, preserves essential details, and appropriately consolidates completed sub-tasks. The paper identifies this as a bootstrapping problem:

even the most advanced LLMs cannot reliably produce AgentFold's accurate, structured, multi-part responses through prompt engineering alone

The solution is Fold-Generator, an offline data collection pipeline that generates validated training trajectories using powerful but imperfect LLMs, then filters out bad examples.

Question set. To ensure fair comparison with prior work, the paper uses "the same question set as the recent WebSailor work" (Li et al., 2025a) — a collection of information-seeking questions used as training prompts for generating trajectories.

Trajectory generation. The pipeline uses a powerful open-source LLM (the paper does not specify which model, but it is implied to be significantly larger/more capable than the target Qwen3-30B-A3B) to interact with a web environment, generating AgentFold-format responses at each step. The model is prompted to produce the thinking-folding-explanation-action format, but — crucially — it often fails to do so correctly. The paper identifies two failure modes that motivate the rejection sampling design: (1) format violations, where the model fails to produce properly structured JSON for the folding directive or fails to include required components, and (2) environmental errors, where the model makes tool calls that fail in the environment (e.g., attempting to visit inaccessible URLs or producing malformed search queries).

Rejection sampling. The pipeline discards any generated step that fails to strictly adhere to the required format, and discards any entire trajectory that contains too many environmental errors. The paper states:

discarding any generated step that fails to strictly adhere required formats, or any trajectory that contains too many environmental errors. This ensures every data point in our collection is a clear example of the desired reasoning process.

What this produces. The output of Fold-Generator is a collection of $N$ high-quality interaction pairs:

{(Ct,Rt∗)}N\{(C_t, R^*_t)\}^N

where each $C_t$ is the structured context at a particular step (assembled according to the four-component format described above) and $R^*_t$ is the validated, gold-standard response that the powerful LLM produced (after filtering) for that context. $N$ is the total number of interaction steps across all questions — each question generates a trajectory of multiple steps, so $N$ is larger than the number of questions.

Supervised fine-tuning. This curated dataset is then used to fine-tune the target model (Qwen3-30B-A3B-Instruct-2507) via standard supervised fine-tuning (SFT). The training objective is simple next-token prediction on the gold-standard responses $R^*_t$ given the context $C_t$. The paper specifies:

The training objective is to distill the complex, multi-step, validated reasoning of our pipeline into a single, efficient forward pass, thereby teaching the model to produce the entire structured output intrinsically.

No reinforcement learning, no continual pre-training, no specialized loss functions — just standard SFT. This is explicitly positioned as a design choice to demonstrate that the folding capability can be learned through behavior cloning from a stronger model, without requiring more complex training paradigms (though the paper's "What's next" section does identify RL as a natural extension for discovering non-obvious folding policies).

Why this approach? The paper identifies three advantages of the distillation-via-SFT strategy:

  1. Skill internalization. The folding capability is transformed "from a fragile, prompt-dependent instruction into a robust, internalized skill." The fine-tuned model learns to generate folding directives as part of its native output distribution rather than following an externally provided instruction format that might be inconsistently followed.

  2. Inference efficiency. The SFT process distills "the computationally intensive 'generate-and-filter' strategy into the weights of the final AgentFold model." At inference time, the fine-tuned 30B model produces valid structured outputs in a single forward pass, without the need for the rejection sampling or the computational cost of running the larger generation model.

  3. Transparency and control. By building the entire pipeline on open-source models, the paper maintains "full transparency and control over the data and training process, enabling detailed inspection and future iteration." This is both a practical consideration (reproducibility) and a research consideration (ability to analyze what the model learns).

Training hyperparameters. The paper does not provide detailed SFT hyperparameters in the main body or appendix. It specifies only: the base model is Qwen3-30B-A3B-Instruct-2507 (30B total parameters, 3B activated during inference, a mixture-of-experts architecture), the maximum number of tool calls per trajectory is 100 (trajectories exceeding this are forcibly terminated), and the training uses the WebSailor question set. The absence of explicit learning rate, batch size, optimizer, and training duration specifications is a notable gap in the experimental reporting.

The Compounding Information Loss Argument: Why Delayed Curation Matters

Section 3.5 provides a theoretical motivation for why AgentFold's ability to delay consolidation until a sub-task's outcome is clear is not merely convenient but structurally necessary for long-horizon tasks. The argument formalizes the failure mode of uniform full-history summarization.

The model. Consider a key detail discovered at step 1 that proves critical at step 100. Under a uniform summarization policy, the full history is re-summarized at each step — meaning step 1's content is reprocessed (and potentially degraded) 99 times before it reaches step 100. If we assume a modest 1% probability that any single re-summarization loses or distorts the detail, the probability that the detail survives all 99 reprocessings is:

P(survival after step n)=(1−p)n=0.99100P(\text{survival after step } n) = (1 - p)^n = 0.99^{100}

What it computes: the probability that a specific piece of information from step 1 is still accurately represented in the context after 100 steps of uniform re-summarization, assuming independence of loss events across steps. With $p = 0.01$, this gives approximately 36.6%. At 500 steps — the scale AgentFold targets — this collapses to:

0.99500≈0.0066=0.66%0.99^{500} \approx 0.0066 = 0.66\%

Why this form: the exponential form captures the compounding nature of the risk. Each summarization step is an independent opportunity for information degradation, and the total survival probability is the product of survival probabilities at each step. This is a standard model for serial reliability — the same mathematics that describes why a chain with many links is much weaker than any individual link, even if each link is fairly reliable.

The paper's claim about what this means. The paper argues that this "compounding risk" (Section 3.5) is inherent to any policy that re-processes all historical information at every step. AgentFold's Granular Condensation directly mitigates this because once a detail is preserved in its own distinct summary block (e.g., [Compressed Step 1]), it is "exempted from unnecessary reprocessing" — subsequent folding operations that consolidate other ranges do not touch this block, so it has zero probability of being degraded by those operations. The detail survives not because each summarization is more accurate, but because it is never re-summarized in the first place.

The complementary argument for Deep Consolidation. While Granular Condensation protects critical details, Deep Consolidation addresses the opposite problem: ReAct's context saturation. The paper frames this as a "deterministic certainty" — "after 100 steps the context is burdened by the full verbosity of every past interaction" (Section 3.5). Deep Consolidation "surgically prunes" irrelevant traces by abstracting an entire sub-investigation into its conclusion. The paper's 500-turn experiment provides empirical evidence: when the agent recognizes a dead end, Deep Consolidation of the failed sub-trajectory reduces context size, and the agent pivots to a new strategy with a "reset" workspace.

The conceptual leap. The paper positions this dual-capability as more than an engineering optimization:

This represents a conceptual leap from agents with static, predefined context policies to those as self-aware knowledge managers. By integrating context curation as a learnable, core action, AgentFold learns sophisticated, task-specific strategies for what to remember, what to abstract, and what to discard.

The key word is "strategies" — the agent does not apply a uniform rule but develops content-dependent heuristics for when to preserve detail, when to consolidate, and when to recognize and recover from dead ends. These heuristics are learned from the training data (the Fold-Generator trajectories) rather than hard-coded.

4. Key Insights and Innovations

Innovation 1: Context Management as a Learned Core Action, Not an External Policy

The most fundamental conceptual move in this paper is the redefinition of what context management is within a web agent architecture. Prior to AgentFold, context management was universally treated as something done to the agent by an external mechanism: ReAct agents had no explicit context management at all (the history simply accumulated as a byproduct of the interaction loop), and summarization-based approaches like MEM1 and MemAgent applied a fixed, externally-designed compression policy at each step regardless of the content being compressed. In both paradigms, the agent itself had no agency over its own memory — it was a passive consumer of whatever context the system provided.

AgentFold makes a categorically different architectural commitment: context curation is part of the agent's reasoning process. The folding directive is generated by the same model, in the same forward pass, from the same chain-of-thought deliberation that produces the next action. This is not merely an implementation detail — it transforms the agent from a task-executor that happens to receive curated context into a self-aware knowledge manager that actively decides what to remember, what to abstract, and what to discard. The paper makes this explicit in Section 3.5:

This represents a conceptual leap from agents with static, predefined context policies to those as self-aware knowledge managers.

The significance of this shift goes beyond the specific folding mechanism. It opens a new research direction: what strategies do agents learn for memory management when they are given agency over it? The paper provides evidence that the learned strategies are non-trivial and content-dependent — Granular Condensation for incremental progress on active investigations, Deep Consolidation for completed sub-tasks and recognized dead ends (Figure 5 and the 500-turn experiment in Section 4.1). These are not hard-coded rules but emergent behaviors from the training data, and the paper explicitly notes (in its "What's next" section) that reinforcement learning could discover "optimal and potentially non-obvious folding policies" that even human designers might not anticipate. This reframes context management from a systems engineering problem (how to fit more history into the context window) into an agent capability problem (what strategies enable sustained coherent reasoning over arbitrarily long horizons).

Comparison to prior work: ReAct agents (Yao et al., 2023; and derivative web agents like WebThinker, WebDancer, WebSailor) have no context management — the full history is an append-only log. MEM1 (Zhou et al., 2025b) and MemAgent (Yu et al., 2025) do compress context, but the compression policy is uniform and external: every step triggers a full-history re-summarization. The agent does not choose what to summarize or when. AgentFold's folding directive — where the range [k, t-1] and the summary text $\sigma_t$ are both generated by the agent itself — represents a qualitative shift in who (or what) controls memory, not just how memory is represented.

Evidence anchoring: The claim that learned folding is not merely functional but enables behaviors that external policies cannot replicate is supported by the 500-turn scaling experiment (Section 4.1). Context does not grow monotonically — Deep Consolidation of failed sub-investigations causes context to shrink, a self-correcting dynamic that would be impossible under a uniform per-step compression policy (which would re-summarize everything regardless of content) and nonexistent under ReAct (which never removes anything). This non-monotonic context behavior is direct evidence that the agent is making content-aware, strategic decisions about when to "reset" its workspace, not following a mechanical rule.

Innovation 2: The Multi-Scale Folding Operations Resolve the Comprehensiveness-Conciseness Trade-off by Separating Two Independent Risks

The paper's central framing of the context management challenge — the trade-off between comprehensiveness (keeping everything) and conciseness (keeping things small) — is not itself novel; it is the explicit motivation for most prior work on context summarization. What is novel is the paper's diagnosis that this trade-off is actually two independent failure modes masquerading as one tension, and that each failure mode requires a different solution mechanism:

  • Context saturation (the ReAct failure mode) is caused by verbosity accumulation — the indiscriminate retention of raw, noisy interaction records. Its harm is that it degrades reasoning quality by burying signals in noise and, eventually, exceeds hardware-imposed context limits.

  • Catastrophic information loss (the uniform summarization failure mode) is caused by premature, uninformed compression — the decision to discard or abstract information before its relevance to future steps can be assessed. Its harm is that it introduces a compounding probability of losing any specific detail with each re-processing.

Prior work treated these as two extremes of a single spectrum (keep everything on one end, compress everything on the other). AgentFold's architecture implicitly recognizes that these are orthogonal problems that can be addressed simultaneously through different mechanisms operating at different scales: Deep Consolidation addresses verbosity accumulation by abstracting away entire sub-investigations once their outcome is clear (pruning irrelevance), while Granular Condensation addresses information loss by preserving individual critical details in their own summary blocks that are exempted from further compression (protecting importance). The same architecture thus avoids both failure modes — context remains concise (because completed sub-tasks and dead ends are consolidated) without being lossy (because key findings are preserved in distinct, stable blocks).

The compounding information loss argument in Section 3.5 formalizes this diagnosistic distinction. The exponential model $0.99^{100} \approx 36.6\%$ survival probability under uniform summarization is not merely a rhetorical device — it identifies the specific mathematical structure that makes uniform summarization inadequate for long horizons: the probability of preserving any specific detail decays exponentially with trajectory length because every step is an independent opportunity for degradation. AgentFold's Granular Condensation breaks this exponential by removing individual details from the set of things that get re-processed — once a detail is placed in its own summary block, subsequent folding operations that consolidate other ranges do not touch it, so its survival probability is no longer a function of how many steps occur after its discovery. This is a structural property of the architecture, not an empirical claim about better summarization quality.

Comparison to prior work: MEM1 and MemAgent apply a uniform per-step compression policy — the full history is re-summarized at each step, meaning every piece of information is subject to the compounding loss risk the paper formalizes. ReAct applies no compression at all, so verbosity grows without bound. Neither architecture distinguishes between information that should be protected (critical details) and information that should be pruned (completed sub-tasks, dead ends). AgentFold's dual-operation design is the first to separate these concerns architecturally.

Why this is fundamental rather than incremental: The innovation is not that AgentFold summarizes better than prior summarizers (which would be an incremental improvement) but that it identifies context management as a selective attention and protection problem, not a uniform compression problem. This is a conceptual reframing with architectural consequences: it implies that any context management system for long-horizon agents must have some mechanism for exempting critical information from reprocessing, not just a mechanism for compression. The paper does not claim to have solved all aspects of this problem (the summary quality still depends on the model's judgment of what is critical), but the architectural principle — separate the "what should survive unmodified" decision from the "what can be abstracted away" decision — is the core conceptual contribution.

Evidence anchoring: Figure 3b shows that AgentFold's block count grows sub-linearly while ReAct's grows linearly — this is evidence that Deep Consolidation is successfully pruning structural complexity. Figure 1 (right panel) shows a 92% token reduction versus ReAct at 100 turns. The 500-turn experiment shows non-monotonic context growth — evidence that the system can recognize and consolidate dead ends, something a uniform compression policy could not selectively trigger. However, the paper does not provide a direct ablation isolating Granular Condensation's protective effect on information preservation (e.g., measuring whether details preserved in individual blocks are more likely to be correctly recalled at later steps than details embedded in consolidated summaries). This is a notable gap — the theoretical argument for exempting details from reprocessing is compelling, but the empirical validation is indirect.

Innovation 3: Empirical Demonstration That Test-Time Context Management Can Substitute for Model Scale — With Sharp Architectural Prerequisites

The paper's headline empirical result — a 30B-parameter model achieving 36.2% on BrowseComp versus the 671B DeepSeek-V3.1's 30.0% (Table 1) — is striking as a performance claim, but its intellectual significance runs deeper. The result demonstrates something that was not obvious prior to this work: effective context management is not merely an efficiency optimization that lets you do more with the same model, but a capability multiplier that can compensate for an order-of-magnitude difference in model scale. A ~20× larger model using a standard ReAct architecture performs worse than a small model with proactive context folding on the same long-horizon benchmark.

This is a different class of claim than typical efficiency gains. Efficiency claims assert that a method achieves the same performance with less compute (e.g., the earlier example paper claims ~4× test-time compute savings). AgentFold's claim is stronger: the method achieves strictly better performance while using dramatically fewer parameters. This is not a cost-equivalence argument but a capability argument — the smaller model is not just matching the larger model; it is exceeding it.

The paper's interpretation of why this happens is equally significant. The larger model's failure is not due to insufficient reasoning capability (a 671B model has enormous raw capacity) but due to an architectural limitation: its append-only context policy causes context saturation that prevents it from effectively deploying that reasoning capability on long-horizon tasks. The paper's evidence for this mechanism is Figure 4: the GLM-4.5-355B-A32B baseline (a large ReAct agent) "saturates and fails beyond 64 turns," while AgentFold-30B-A3B continues to improve up to 256 turns. The larger model's capacity is structurally locked behind a context bottleneck that the smaller model's architecture avoids. This is not a claim that folding is "better reasoning" — it is a claim that reasoning capability is useless if the agent cannot maintain a coherent working memory over the timescale the task demands.

Comparison to prior work: Scaling laws research (Hoffmann et al., 2022; Sardana and Frankle, 2023) has established that model performance improves predictably with pretraining compute. The natural assumption — visible in the trend toward ever-larger models for agent tasks (DeepSeek-V3.1-671B, GLM-4.5-355B) — has been that bigger models are better agents, and architectural choices about context management are secondary. AgentFold provides a counterexample: a specific architectural innovation (proactive folding) can invert the expected scaling relationship, making a 30B model outperform a 671B model on the very tasks where long-context reasoning is most critical. The earlier example paper made a similar claim about test-time compute versus pretraining, but that claim was conditioned on problem difficulty — test-time compute helped on easy-to-medium problems, not hard ones. AgentFold's claim is broader: on long-horizon web tasks (which are defined by their difficulty), context management architecture matters more than raw scale.

Caveats and boundaries: The paper does not claim that folding universally substitutes for scale. The benchmarks tested (BrowseComp, BrowseComp-ZH, WideSearch, GAIA) are all information-seeking tasks where success depends on sustained, structured exploration rather than deep domain knowledge or novel reasoning. A 30B model folded to the extreme would not match a 671B model on tasks requiring massive factual recall or complex mathematical derivation. The paper's contribution is to identify a specific regime — long-horizon interactive information seeking — where context architecture is the dominant bottleneck, not model capacity. This is a more precise claim than "folding beats scaling" and is well-supported by the evidence.

Evidence anchoring: Table 1 provides the core numerical claim. Figure 4's scaling curves demonstrate the mechanism: AgentFold's accuracy continues to improve as turns increase, while the large baseline saturates. The 500-turn experiment (Section 4.1, Figure 1 context dynamics) shows the architectural scalability that enables this — context remains manageable even at lengths where ReAct would be impossible.

Innovation 4: The Fold-Generator Pipeline and the Bootstrapping Problem for Learned Context Management

A less flashy but pragmatically critical innovation is the paper's identification and solution of a bootstrapping problem specific to learned context management: you need high-quality trajectories demonstrating sophisticated folding behavior to train an agent, but the very capability you are trying to train — generating structured, content-aware folding directives alongside actions — is what produces those trajectories. The paper is explicit that "even the most advanced LLMs cannot reliably produce AgentFold's structured, multi-part responses through prompt engineering alone" (Section 3.4), which means you cannot simply prompt a powerful model to generate training data and expect it to work.

This is not a generic data-collection challenge. It arises because AgentFold's response format is tightly constrained across multiple dimensions simultaneously: the folding directive must specify a valid range that respects the trajectory structure, the summary text must accurately capture the essential content of the steps being folded, the explanation must articulate a coherent motivation for the upcoming action, and all of this must be consistent with the chain-of-thought reasoning. Even a very capable LLM, prompted to produce this format, will frequently make errors — format violations (malformed JSON, missing tags), semantic errors (folding the wrong range, producing summaries that omit critical information or include irrelevant details), or strategic errors (folding too aggressively before a sub-task is complete, or failing to consolidate a clear dead end).

The paper's solution — using powerful LLMs with rejection sampling to generate many trajectories and filtering out the bad ones — is conceptually straightforward but represents a specific, replicable recipe for solving the bootstrapping problem without requiring human annotation of folding decisions. The Fold-Generator pipeline produces the training data by brute-force generation plus validation, then distills the validated behavior into a smaller model via SFT. This is a pragmatic contribution: it establishes a viable path for building learned-context-management agents without requiring a pre-existing dataset of expert folding trajectories.

Comparison to prior work: Prior work on training web agents (WebThinker, WebSailor, WebDancer, WebExplorer) has focused on generating trajectories that demonstrate effective search and navigation strategies — which tools to call, when to read pages, how to synthesize information. These trajectories follow the ReAct format and can be generated by prompting LLMs to explore the web, with success determined by whether the final answer is correct. The context management behavior in those trajectories is implicit (ReAct has no explicit context management actions) or external (summarization is applied by a separate mechanism, not generated by the agent). AgentFold's data requirement is fundamentally different: the trajectories must demonstrate explicit, structured context curation decisions interleaved with task actions, where the quality of the folding decisions matters independently of the final answer correctness (you can get the right answer while making poor folding decisions, or vice versa). The Fold-Generator pipeline is the first system designed to produce this type of training data at scale.

Evidence anchoring: The paper reports that the Fold-Generator pipeline successfully produces training data that, after SFT on Qwen3-30B-A3B, yields an agent whose behavior includes sophisticated context curation strategies — recognizing dead ends, consolidating completed sub-tasks, preserving granular details of active investigations (Figure 5 case study). The fact that the fine-tuned 30B model exhibits these behaviors without any explicit hard-coded rules or reward shaping (the training is pure SFT on the generated trajectories) is indirect evidence that the pipeline successfully captured and transferred the relevant skills.

Limitation: The paper does not provide an ablation or analysis of the Fold-Generator's yield rate — what fraction of generated steps/trajectories pass the rejection sampling filter — or characterize the types of errors that are most commonly filtered out. Understanding this would clarify how much of the training capability comes from the powerful generation model versus the filtering criteria. The paper also does not specify which model was used for generation, making it difficult to assess whether the approach requires a specific capability threshold in the generation model.

Innovation 5: The Cognitive Workspace as an Architectural Principle — Not Just a Metaphor

The paper consistently uses cognitive language — "mental scratchpad," "long-term memory," "working memory," "retrospective consolidation" — but it would be easy to dismiss this as evocative framing rather than a substantive contribution. The deeper contribution is that the paper operationalizes these cognitive concepts as specific architectural constraints that directly shape the system's behavior, not merely as loose analogies:

  • Working memory vs. long-term memory separation is implemented concretely as the $I_{t-1}$ (Latest Interaction) vs. $S_{t-2}$ (Multi-Scale State Summaries) split. Working memory is high-fidelity but volatile (it lasts exactly one step before being folded into long-term memory). Long-term memory is curated and stable (summary blocks persist unless explicitly retracted by a Deep Consolidation that covers their range). This separation of fidelity and persistence maps directly onto the cognitive distinction between the rich but fleeting contents of working memory and the schematized but durable contents of long-term memory (Miller, 1956).

  • Retrospective consolidation — the cognitive process of reviewing and reorganizing memories after an experience — is implemented as the folding operation, which always operates on a suffix ending at the most recent step. Critically, the agent cannot fold old history without also folding the latest step (the range is $[k, t-1]$), which enforces that consolidation is retrospective — the agent must integrate the most recent experience into its long-term memory before proceeding. This prevents the agent from maintaining a pristine long-term memory while ignoring inconvenient recent evidence.

  • Chunking and abstraction — the cognitive process of grouping individual items into higher-level units — is implemented as the multi-scale property of the summary blocks. The sequence $S_{t-2}$ contains blocks at different granularities (single-step summaries alongside multi-step consolidated summaries), and the agent can flexibly create new chunks (Deep Consolidation) or preserve existing chunks (Granular Condensation). This mirrors how humans represent complex sequences of actions at multiple levels of abstraction (Newell et al., 1972).

What makes this more than a metaphor is that these constraints are enforced by the architecture, not just suggested by the prompt. The folding range format, the context update rules, and the separation of $S_{t-2}$ and $I_{t-1}$ are structural properties of the system that the agent cannot violate. This is a different approach from prior work that used cognitive language to describe desired behaviors (e.g., "the agent should maintain a coherent memory") without building architectural mechanisms to enforce the corresponding structure. AgentFold's architecture implements the cognitive principles as hard constraints, and the training process teaches the agent to operate effectively within those constraints.

Comparison to prior work: MEM1 and MemAgent implement memory as a compressed summary, but without the temporal-structural distinctions (working vs. long-term, the retrospective constraint, the multi-scale chunking). They have a single memory representation (one summary of the full history) updated uniformly at each step — cognitively, this is more like repeatedly overwriting a single memory slot than maintaining a structured cognitive workspace. ReAct has no explicit memory structure at all — the entire history is undifferentiated context. AgentFold's contribution is the architectural instantiation of a specific cognitive theory of memory management, making it falsifiable: if the cognitive theory is wrong, the architectural constraints should harm performance rather than help it.

Evidence anchoring: The case studies in Appendix A.1 (Tables 2-3, Figures 6-9) provide concrete traces of the architecture in operation. The context tables show how the summary blocks evolve over time — single steps being preserved, multi-step ranges being consolidated, the Latest Interaction providing full detail of only the most recent step. The response figures show how the agent's thinking process references both the consolidated history (for strategic context) and the latest interaction (for situational detail) when deciding on the next action. These traces demonstrate that the architectural constraints shape behavior in predictable, cognitively interpretable ways — not just that the system works, but that it works through mechanisms analogous to human memory management.

Limitation: The paper does not test whether all components of the cognitive architecture are necessary. An ablation removing the $I_{t-1}$ component (i.e., folding the latest step before presenting it as context, making all history equally abstracted) would test whether the working memory / long-term memory distinction is functionally important or merely aesthetic. Similarly, an ablation allowing the agent to fold arbitrary ranges (not constrained to end at $t-1$) would test whether the retrospective consolidation constraint is beneficial or restrictive. Without such ablations, the cognitive architecture remains a well-motivated design choice but not a validated necessity.

5. Experimental Analysis

Evaluation Methodology

  • Dataset. The paper evaluates on four benchmarks: BrowseComp (Wei et al., 2025) — a challenging benchmark for locating hard-to-find information on the web; BrowseComp-ZH (Zhou et al., 2025a) — a Chinese-language analogue of BrowseComp; WideSearch-en (Wong et al., 2025) — specifically the Item-F1 metric, which evaluates broad search capability; and GAIA (Mialon et al., 2023) — the text-only subset, a general benchmark for AI assistant capabilities. For benchmarks with fewer than 200 samples, results are averaged over 3 trials to reduce variance.

  • Base model(s). AgentFold is trained via supervised fine-tuning on Qwen3-30B-A3B-Instruct-2507 (Yang et al., 2025), a mixture-of-experts model with 30 billion total parameters and 3 billion activated parameters during inference. The paper describes this as "representative of the capabilities of many contemporary LLMs" (Section 4), though this claim is made in the context of a single model family. No other base models are tested, meaning all results are conditional on this specific architecture and pretraining.

  • Metrics. The primary metric is task accuracy — the fraction of evaluation questions for which the agent produces the correct final answer. For WideSearch, the paper uses the Item-F1 metric (the most detailed of WideSearch's evaluation metrics), which measures the agent's ability to find and correctly identify specific items of information across broad search trajectories. The paper does not describe the exact grading procedure used to determine answer correctness for each benchmark (e.g., exact string matching, fuzzy matching, or LLM-based evaluation).

  • Baselines. The paper compares AgentFold-30B-A3B against a broad set of open-source agents: WebThinker-32B (Li et al., 2025c), WebDancer-32B (Wu et al., 2025), WebSailor-32B and WebSailor-72B (Li et al., 2025b), ASearcher-Web-32B (Gao et al., 2025), MiroThinker-32B-DPO-v0.2 (MiroMind AI Team, 2025), WebExplorer-8B (Liu et al., 2025), DeepDive-32B (Shi et al., 2025, though cited as Lu et al., 2025 in the paper), DeepDiver-V2-38B (OpenPangu Team, 2025), Kimi-K2-Instruct-1T (Team et al., 2025), GLM-4.5-355B-A32B (Zeng et al., 2025), and DeepSeek-V3.1-671B-A37B (DeepSeek Team, 2025). Several proprietary agents are also reported for reference: Claude-4-Sonnet, Claude-4-Opus (anthropic, 2025), OpenAI-o4-mini, OpenAI-o3 (OpenAI, 2025b), and OpenAI Deep Research (OpenAI, 2025a). Some baseline results are taken from "corresponding papers or leaderboards" rather than re-evaluated under controlled conditions.

  • Generation budget / compute accounting. The paper measures compute in interaction turns (tool calls) with a maximum limit of 100 turns per trajectory; any trajectory exceeding this limit is forcibly terminated. This is the standard accounting unit for web agents — each turn involves one model forward pass plus one environment interaction. The maximum context length is 128k tokens (the underlying model's capacity), but the paper's central claim is that AgentFold operates far below this limit. Wall-clock time, latency, and total FLOPs are not reported or used as comparison metrics — agents are compared purely on accuracy at comparable turn limits.

  • Cross-validation / statistical protocol. The paper does not employ cross-validation for hyperparameter selection or strategy optimization. For benchmarks with fewer than 200 samples, results are averaged over 3 trials to provide variance reduction. The paper does not report confidence intervals, standard deviations, or statistical significance tests for any of the main results in Table 1 or the scaling curves in Figures 3-4. This is a notable gap — with a 500-question test set for BrowseComp, differences of several percentage points between agents may or may not be statistically reliable, and the paper provides no information to assess this.

Main Quantitative Results

Aggregate Benchmark Performance

Table 1 presents the headline results. AgentFold-30B-A3B achieves 36.2% on BrowseComp, 47.3% on BrowseComp-ZH, 62.1% on WideSearch (Item-F1), and 67.0% on GAIA. These numbers are compared against the baselines listed above.

On BrowseComp, the most challenging benchmark for long-horizon information seeking:

  • AgentFold-30B-A3B (36.2%) outperforms all open-source agents, including DeepSeek-V3.1-671B-A37B (30.0%) — a model with approximately 22× more total parameters and roughly 12× more activated parameters. This ~6 percentage point absolute gap represents roughly a 20% relative improvement.
  • AgentFold surpasses the largest open-source baseline, GLM-4.5-355B-A32B (26.4%), by 9.8 percentage points — a 37% relative improvement from a model roughly 12× larger in total parameters.
  • Against the leading proprietary baseline, OpenAI-o4-mini (28.3%), AgentFold leads by 7.9 percentage points. It trails only OpenAI-o3 (49.7%) and OpenAI Deep Research (51.5%), both substantially larger proprietary systems.
  • The weakest open-source agents (WebThinker-32B at 2.8%, WebDancer-32B at 3.8%) demonstrate that raw ReAct-based approaches with similar parameter counts to AgentFold struggle severely on this benchmark — AgentFold outperforms them by over 12×.

On BrowseComp-ZH:

  • AgentFold (47.3%) places second among open-source agents, slightly behind DeepSeek-V3.1-671B-A37B (49.2%) by 1.9 percentage points, and ahead of GLM-4.5-355B-A32B (37.5%) by 9.8 percentage points.
  • It leads the proprietary OpenAI-o4-mini (44.3%) by 3.0 percentage points, and trails OpenAI-o3 (58.1%).

On WideSearch, measured by Item-F1:

  • AgentFold (62.1%) achieves the highest score among all reported agents, both open-source and proprietary. It surpasses OpenAI-o3 (60.0%), Kimi-K2-Instruct-1T (59.9%), and Claude-4-Sonnet (62.0%, effectively tied). The paper presents this as evidence that AgentFold's context management is particularly effective for broad search tasks requiring sustained exploration.

On GAIA (text-only subset):

  • AgentFold (67.0%) ranks competitively: it trails Claude-4-Sonnet (68.3%) by 1.3 points, matches OpenAI-o3 (70.5%) within ~3.5 points, and leads all open-source baselines including GLM-4.5-355B-A32B (66.0%) and DeepSeek-V3.1-671B-A37B (63.1%).
  • The strongest open-source baseline on GAIA is MiroThinker-32B-DPO-v0.2 at 64.1%, which AgentFold exceeds by 2.9 points.

Context Growth Dynamics

The paper analyzes AgentFold's context management behavior on 200 trajectories sampled from BrowseComp (Figure 3a). The primary metric is the average context token count At at each turn t, computed as:

At=1∣Tt∣∑j∈TtTokenCount(Cj,t)A_t = \frac{1}{|T_t|} \sum_{j \in T_t} \text{TokenCount}(C_{j,t})

where Tt is the set of trajectories surviving to turn t. The grey bars in Figure 3a show the number of surviving trajectories at each turn (starting at 200 and declining as trajectories terminate).

The key finding: AgentFold's context grows from approximately 3.5k tokens to roughly 7k tokens over 100 turns — less than doubling. This is described as "a remarkably slow, sub-linear rate." The paper notes that over 20% of trajectories are forcibly terminated at the 100-turn experimental limit, and at this termination point, the context is only ~7k tokens — approximately 5.5% of the underlying model's 128k context capacity. The paper interprets this vast remaining capacity as evidence that "simply scaling the number of allowed interactions could unlock higher success rates" and that AgentFold "has significant potential for tackling extremely complex and long-horizon problems."

Figure 3b analyzes the structural complexity of the context by measuring the number of discrete "blocks" in the Multi-Scale State Summaries plus the one Latest Interaction. The blocks include entries like [Compressed Step 52 to 67] (one block) and the Latest Interaction (one block). For ReAct, this count necessarily increases linearly with each turn (shown as a reference line). The finding is twofold: (1) AgentFold's block count grows at a "slow, sub-linear rate" due to Deep Consolidation merging multiple past steps into single summaries, and (2) the divergence between the AgentFold curve and the ReAct reference line widens over time, indicating "compounding efficiency" — the advantage of proactive curation grows larger on longer tasks.

A direct context comparison between AgentFold and a standard ReAct baseline across the same trajectories is reported in Section 4.1: at the 100th turn, AgentFold's context is over 84k tokens (92%) smaller than ReAct's. The paper translates this to "an estimated memory saving of nearly 7GB per inference instance at this trajectory length," though the methodology for this estimate is not described.

Scaling Properties of Interaction Turns

Figure 4 shows AgentFold's accuracy on BrowseComp as the turn limit is scaled from 16 to 256, compared against the much larger GLM-4.5-355B-A32B baseline (a ReAct-based agent). Two findings are reported:

  1. AgentFold-30B-A3B consistently outperforms the 355B baseline at all comparable turn limits. The paper states that the 355B baseline's "performance saturates and fails beyond 64 turns as its append-only context fills," while AgentFold's accuracy continues to improve steadily up to 256 turns. Specific accuracy values at each turn limit are not provided in the text — the claims are supported visually by Figure 4.

  2. The paper conducted an extended experiment increasing the maximum turns to 500 (context length dynamics reported in Figure 1, right panel). The results show that context "mostly remains below 20k tokens and, notably, does not grow monotonically." The non-monotonic behavior is attributed to Deep Consolidation of dead ends — when the agent recognizes a failed line of inquiry, it consolidates the entire failed sub-trajectory, which can reduce context size as it abstracts away the lengthy but irrelevant history. The paper frames this as "a sophisticated, self-correcting form of context management."

Ablation Studies and Robustness Checks

The paper's Section 4 does not contain formal ablation studies in the traditional sense — there are no controlled experiments removing individual components of the architecture (e.g., removing the Latest Interaction, disabling Deep Consolidation, comparing against a ReAct baseline trained on the same data) and measuring the performance impact. The analyses that serve as partial ablations or robustness checks are:

Context size analysis as an implicit architecture ablation: The comparison of AgentFold's context growth against ReAct (Figure 1, right panel; Figure 3b) demonstrates the effect of the folding mechanism on context conciseness. However, this is not a controlled ablation — ReAct uses a different architecture entirely, not a variant of AgentFold with folding disabled. The 92% token reduction at 100 turns establishes that the folding mechanism dramatically reduces context size compared to append-only accumulation, but it does not isolate the contributions of Granular Condensation versus Deep Consolidation, nor does it demonstrate that the reduced context size causes the performance improvement rather than merely correlating with it.

Turn-limit scaling as an architecture stress test: Figure 4's comparison of AgentFold against GLM-4.5-355B-A32B at varying turn limits indirectly tests whether the folding architecture enables sustained performance at longer horizons. The finding that the large ReAct agent saturates beyond 64 turns while AgentFold continues improving to 256 turns is consistent with the claim that context saturation is the bottleneck for ReAct and that folding mitigates it. However, this comparison conflates the architecture (folding vs. ReAct) with the model size (30B vs. 355B), the model family (Qwen vs. GLM), and the training procedure (AgentFold's SFT vs. GLM's unknown training). It does not establish that folding alone enables the scaling — a ReAct agent based on the same Qwen3-30B-A3B base model, trained on comparable data, would be needed to isolate the architectural contribution.

500-turn extended experiment: The paper reports an experiment scaling to 500 turns with context dynamics shown in Figure 1 (right panel). This demonstrates that the architecture does not hit a hard failure mode at extreme lengths — context remains largely below 20k tokens and can shrink through dead-end consolidation. The paper does not report the accuracy achieved in this 500-turn setting, nor does it compare against any baseline at this scale. This is presented primarily as a proof-of-capability rather than a quantitative ablation.

Case studies (Figures 5-9, Tables 2-3 in Appendix A.1): The paper provides detailed traces of AgentFold's behavior on specific questions, showing the context structure at each step and the agent's folding decisions. These demonstrate qualitative capabilities — recognizing dead ends, switching strategies after consolidation, preserving granular details of active investigations — but do not constitute controlled experiments. They illustrate how the system works, not whether specific components are necessary for performance.

Notable absent ablations: The paper does not test:

  • AgentFold without the Latest Interaction component (i.e., folding the most recent step before presenting it as context, so no high-fidelity working memory exists)
  • AgentFold restricted to only Granular Condensation (no Deep Consolidation) or only Deep Consolidation (every step must be part of a multi-step consolidation)
  • AgentFold with a uniform full-history summarization policy comparable to MEM1 or MemAgent, trained on the same data
  • AgentFold with the same base model using a ReAct format but trained on comparable trajectories to control for data quality effects
  • A direct comparison where the same Qwen3-30B-A3B model is used with ReAct and with AgentFold, isolating the architectural contribution from the model family and scale
  • Varying the training data quantity or quality to assess how sensitive folding behavior is to the Fold-Generator pipeline's output

Without these, the claim that folding (as opposed to better training data, the specific base model, or the use of SFT itself) is the causal mechanism for performance improvements remains plausible but not experimentally isolated.

Critical Assessment

Does the evidence support the claim that AgentFold's folding mechanism — as opposed to other factors — causes the performance improvement over baselines?

The paper's central empirical claim is that a 30B-parameter model with proactive context folding can match or surpass agents 20× its size on long-horizon benchmarks. Table 1 clearly establishes that AgentFold-30B-A3B achieves higher accuracy than much larger models. However, the causal attribution of this improvement to the folding mechanism specifically — as opposed to the training data, the base model choice, or the SFT procedure — is not experimentally isolated.

The comparison confounds three variables simultaneously: (1) architecture (AgentFold's folding vs. ReAct's append-only), (2) model family and scale (Qwen3-30B-A3B vs. DeepSeek-V3.1-671B, GLM-4.5-355B, etc.), and (3) training procedure (AgentFold's Fold-Generator SFT vs. each baseline's unknown training regime). A cleaner comparison would hold the base model constant — train both a ReAct agent and an AgentFold agent on the same Qwen3-30B-A3B base using comparable training data — and measure the marginal contribution of the folding architecture. The paper does not report such an experiment. The comparison against GLM-4.5-355B in Figure 4 partially addresses the scale question (showing that a smaller folded agent scales better than a larger ReAct agent), but the model family and training regime differences remain unaccounted for.

The paper's claim that AgentFold outperforms WebThinker-32B (2.8%) and WebDancer-32B (3.8%) by over 12× on BrowseComp is striking, but these baselines are based on the ReAct paradigm and were trained on different data with different objectives. The performance gap may partly reflect differences in training data quality, task-specific optimization, or benchmark-specific engineering rather than the architectural innovation alone. This is a field-wide challenge in web agent evaluation — comprehensive controlled comparisons are difficult because each agent involves a complex pipeline of data generation, training, and environment interaction — but the paper does not acknowledge or discuss this limitation.

Does the evidence support the claim that context saturation is the bottleneck for large ReAct agents?

The scaling comparison in Figure 4 provides suggestive but not definitive evidence. The GLM-4.5-355B agent's performance saturates beyond 64 turns while AgentFold continues improving. However, without access to the GLM agent's context sizes, failure modes, or an analysis of why it fails beyond 64 turns, the attribution to context saturation is inferential. The agent could fail for other reasons — poor search strategies, inability to recover from dead ends, or sensitivity to particular question types that happen to require more turns — that are not directly related to context length. The paper's claim that the GLM agent's "append-only context fills" is a hypothesis consistent with the observed pattern but not demonstrated through evidence like context token measurements for the GLM agent or an analysis of whether its failures correlate with context length.

The comparison of AgentFold's context (7k tokens at 100 turns) against a generic ReAct baseline (84k+ tokens) does provide evidence that AgentFold's context is dramatically more concise. However, this comparison is between AgentFold and "a standard ReAct baseline" — it is not clear whether this ReAct baseline uses the same base model, the same training data, or the same web environment as AgentFold. The paper states this comparison is across "the same set of trajectories," but it does not explain how ReAct trajectories were generated (whether by running a separate ReAct agent or by simulating what a ReAct agent's context would look like given AgentFold's actions). If the ReAct context was computed by simply accumulating all raw observations from AgentFold's own trajectory, then the comparison shows that AgentFold's context is smaller than what the context would have been if it had used an append-only policy on the same actions — but not that this context size reduction causes better performance, since the same actions were taken in both cases.

Does the evidence support the claim that Granular Condensation prevents compounding information loss?

The paper's theoretical argument in Section 3.5 — that Granular Condensation protects critical details from the compounding loss risk of uniform summarization — is mathematically elegant but empirically untested. The paper provides no experiment measuring information preservation: no probe of whether details stored in individual summary blocks are more accurately recalled at later steps than details embedded within larger consolidated summaries, no comparison against a summarization baseline to measure whether AgentFold suffers less from information loss over long horizons, and no analysis of whether the specific details preserved in granular summaries are actually the ones that prove critical for later steps. The 500-turn experiment shows that context size remains manageable and that the system can operate at extreme lengths, but it does not test whether the information from early steps is still accurate and accessible after hundreds of turns. The survival probability calculation (0.99^500 ≈ 0.66%) is an argument about what would happen under uniform summarization — it does not demonstrate that AgentFold avoids this fate.

Does the evidence support the claim that folding enables scaling to 500+ turns?

The paper reports that context remains below 20k tokens in the 500-turn experiment, which is strong evidence that the architecture does not hit a context-window ceiling even at extreme lengths. However, the paper does not report the accuracy achieved in this 500-turn setting, making it impossible to assess whether the system remains effective at this scale or merely operational. A system that maintains a compact context but produces incorrect answers is not a successful long-horizon agent. The paper frames this experiment as evidence of "significant potential for tackling extremely complex and long-horizon problems" but defers detailed evaluation to "future work due to time constraints." This is a reasonable scope limitation, but the reader should understand that the 500-turn capability is demonstrated only in terms of context management, not task success.

Does the evidence support the claim of a 92% token reduction versus ReAct?

The 92% figure (84k tokens smaller at turn 100) is likely computed correctly given the reported context sizes, but its interpretation requires caution. If the ReAct context was simulated by accumulating raw observations from AgentFold's trajectory, then the comparison shows that given the same sequence of web interactions, AgentFold's context representation is far more compact. This is a useful efficiency metric, but it does not represent a head-to-head agent comparison — it does not show that AgentFold makes better decisions than a ReAct agent would, only that it represents the decisions it does make more compactly. In a deployment setting, the relevant comparison would be between AgentFold and a ReAct agent each solving tasks independently, with the ReAct agent potentially taking different (possibly better or worse) actions.

Methodological concerns that affect interpretation of all results:

  • Single model family, single training paradigm: All results are conditional on Qwen3-30B-A3B and SFT on Fold-Generator data. The paper does not demonstrate that folding can be successfully trained on other base models (e.g., Llama, DeepSeek, Gemma) or using other training paradigms. This leaves open the possibility that the results depend on specific properties of the Qwen3 architecture or the SFT procedure.

  • Small and specific benchmark set: BrowseComp has a 500-question test set (implied by the 200-trajectory sample for context analysis representing 40% of the test set). BrowseComp-ZH, WideSearch, and GAIA have unspecified but presumably similar or smaller sizes. With 500 test questions and gaps between agents of a few percentage points, some of the comparisons in Table 1 may not be statistically significant. The paper does not report statistical tests or confidence intervals.

  • No latency analysis: The folding mechanism adds inference-time overhead — the model must generate additional tokens (the folding directive, the thinking block, the explanation) beyond what a ReAct agent would produce for the same action. The paper does not measure wall-clock time, tokens generated per step, or total inference cost. The 92% context reduction represents memory savings, but the generation cost of producing folding directives may partially offset the efficiency gains from shorter contexts (since attention cost scales quadratically with context length but linearly with generation length for short contexts). The paper's claim of "significant potential" for efficiency needs this dimension to be fully evaluated.

  • Missing baseline: an AgentFold trained on ReAct-format data to control for data quality: The Fold-Generator pipeline uses powerful LLMs with rejection sampling to create high-quality trajectories. It is possible that simply training a ReAct agent on similarly high-quality trajectories (with the same questions, same environment, same rejection sampling, but without the folding format) would yield significant improvements over existing ReAct baselines. Without this control, the paper cannot distinguish between improvements attributable to the folding architecture versus improvements attributable to better training data.

  • The 500-turn experiment is preliminary: It demonstrates context scalability but not task success, and the paper explicitly defers full evaluation. Readers should treat the 500-turn capability as a promising direction rather than a validated result.

What would strengthen the paper:

  1. An ablation where the same Qwen3-30B-A3B base model is trained as a ReAct agent on comparable data and compared against AgentFold on the same benchmarks. This would isolate the marginal contribution of the folding architecture.

  2. An ablation removing or modifying individual architectural components — e.g., removing the Latest Interaction (folding it before presenting it as context), disabling Deep Consolidation (only Granular Condensation allowed), or comparing against a per-step uniform summarization variant — to test which aspects of the architecture are necessary for the observed performance.

  3. A probe task measuring whether details preserved in granular summaries are correctly recalled at later steps, testing the central theoretical claim about information preservation.

  4. Statistical measures (confidence intervals, significance tests) for the comparisons in Table 1, particularly for benchmarks with small test sets.

  5. An analysis of the Fold-Generator pipeline's yield rate and error modes to help others replicate the training approach.

  6. Wall-clock time and token generation cost measurements to complement the context-size efficiency analysis.

6. Limitations and Trade-offs

6.1 Context Management Strategy Selection Is Trained via Behavior Cloning, Not Optimized for Task Success

The assumption or constraint. AgentFold's folding behavior is learned entirely through supervised fine-tuning on trajectories generated by a powerful LLM and filtered via rejection sampling (Section 3.4). The training objective is next-token prediction on these gold-standard responses — it teaches the model to imitate folding patterns that the generating LLM produced, not to discover folding strategies that maximize task success. The paper explicitly acknowledges this choice as a scope limitation rather than a fundamental constraint, stating in Section 5:

"In this work, we prioritize demonstrating the potential of the AgentFold paradigm, thus employing a straightforward SFT approach without extensive optimization."

The consequence. The model learns folding behaviors that correlate with — but are not causally optimized for — correct task completion. This introduces several risks. First, the generating LLM may exhibit systematic errors in its folding strategy (e.g., folding too aggressively and losing critical details, or folding too conservatively and retaining noise) that the fine-tuned model faithfully reproduces. The rejection sampling mechanism filters out format violations and trajectories with too many environmental errors, but it does not filter based on whether the folding decisions themselves were strategically optimal — a trajectory can be format-valid and environment-error-free while still making suboptimal choices about what to preserve versus what to consolidate. Second, the generating LLM's folding strategy may be implicitly adapted to its own capabilities (e.g., it may preserve detail at a granularity appropriate for a very large model with strong long-context reasoning, which may be inappropriate for a 3B-activated model). Third, SFT provides no mechanism for the model to learn from its own mistakes — it cannot discover that certain folding patterns lead to task failure and adjust accordingly, because the training signal is purely imitative.

What evidence exists in the paper. The paper provides no analysis of whether the folding decisions in the training trajectories are actually optimal or even consistently good. The Fold-Generator pipeline's rejection sampling criteria (format adherence, environmental error count) are described in Section 3.4, but there is no evaluation of folding quality beyond these surface-level checks. The case studies (Figures 5-9) demonstrate plausible and interpretable folding behaviors, but these are cherry-picked examples that illustrate the mechanism, not evidence that the learned policy is near-optimal. The paper's claim that Deep Consolidation of dead ends causes context to shrink in the 500-turn experiment (Section 4.1) shows that the model can exhibit this behavior, not that it does so at the right times or that the resulting summaries capture the right information.

Mitigation status. The paper explicitly identifies this as the primary limitation and the natural next step. The "What's next" section states:

"The clear next step is to leverage reinforcement learning (RL) to enable the agent to autonomously discover optimal and potentially non-obvious folding policies by directly optimizing for task success."

This is a strong and appropriate acknowledgment. However, in the current paper, the imitation-trained policy is the only one evaluated, and the reader should understand that the folding behaviors observed — while sophisticated and interpretable — are not demonstrated to be near the performance frontier that RL-trained policies might achieve. The gap between imitation and optimization is particularly significant for a mechanism as central to the architecture as folding: suboptimal folding degrades both context quality (what the agent remembers) and action quality (since the agent reasons from a suboptimally curated context), creating a compounding penalty that imitation learning cannot self-correct.

6.2 The Architecture Is Validated on a Single Model Family with No Evidence That Folding Transfers Across Base Models

The assumption or constraint. All experiments train and evaluate AgentFold on a single base model: Qwen3-30B-A3B-Instruct-2507 (Yang et al., 2025), a mixture-of-experts architecture with 30B total parameters and 3B activated during inference. The paper states in Section 4 that it believes this model is "representative of the capabilities of many contemporary LLMs," but no evidence is provided for this claim. Critically, the model is fine-tuned on trajectories generated by (the paper implies) a larger, more capable LLM from the same or a compatible model family, and the SFT procedure may rely on specific properties of the Qwen architecture — its instruction-following capabilities, its ability to produce structured JSON output, its in-context reasoning style — that may not transfer to other model families.

The consequence. A practitioner attempting to replicate AgentFold on a different base model (e.g., Llama-4, Gemma-3, DeepSeek-V3, or a non-MoE architecture) cannot assume that the approach will succeed. Several failure modes are plausible. First, the base model may lack the instruction-following precision needed to reliably produce the four-part structured output (thinking, folding directive as valid JSON, explanation, tool call) in a single forward pass — a capability that the rejection sampling pipeline depends on the generating model possessing and that the SFT process may or may not successfully transfer to a model with different pretraining characteristics. Second, the Fold-Generator pipeline uses a powerful LLM to generate training trajectories; if this generating model produces trajectories that are implicitly adapted to its own reasoning style, those trajectories may not serve as effective training data for a base model with a different reasoning style. Third, the specific SFT hyperparameters (learning rate, batch size, training duration — which the paper does not report) may be tuned to the Qwen3-30B-A3B architecture and may not transfer. Fourth, the mixture-of-experts architecture (30B total, 3B activated) is specifically designed for inference efficiency — a dense 30B model would have different compute and memory characteristics, and a smaller dense model might not have the capacity to learn the dual task of folding and acting simultaneously.

What evidence exists in the paper. None. The paper conducts zero experiments with any base model other than Qwen3-30B-A3B. The claim of representativeness is made without citation or empirical support. The comparison against other open-source agents in Table 1 involves different model families (DeepSeek, GLM, Kimi, etc.), but these comparisons use different architectures and different training procedures and different agent paradigms — they cannot serve as evidence that AgentFold's approach transfers across base models.

Mitigation status. The paper does not discuss this limitation explicitly. The "What's next" section focuses on RL rather than cross-model validation. A reader considering adopting AgentFold should treat the current results as a proof-of-concept on a specific model family, not a general recipe that works out-of-the-box on arbitrary base LLMs. Replication on Llama, Gemma, or DeepSeek-base models — or at minimum, a discussion of which model properties the approach depends on — would be needed to establish transferability.

6.3 The Causal Role of Individual Architectural Components Is Not Experimentally Isolated

The assumption or constraint. AgentFold's architecture makes several simultaneous design commitments: the structured context workspace (separating Multi-Scale State Summaries from Latest Interaction), the folding response format (generating both a folding directive and an action in one forward pass), the two-scale folding operations (Granular Condensation and Deep Consolidation), and the Fold-Generator training pipeline. The paper evaluates these as a package — AgentFold with all components against baselines that use entirely different architectures (ReAct, uniform summarization). No experiments isolate the contribution of any individual component.

The consequence. It is unknown whether all components of the architecture are necessary for the observed performance, or whether a simpler variant would achieve comparable results. Several specific questions are unanswered. Does the separation of Latest Interaction (high-fidelity working memory) from Multi-Scale State Summaries (curated long-term memory) actually improve performance, or would the agent perform equally well if all history were represented as summary blocks at the same fidelity? Is Deep Consolidation necessary, or does Granular Condensation alone (with perhaps a different context pruning strategy) suffice? Is the dual-output format (generating folding directive and action together) important, or would a two-stage approach (first decide what to fold, then decide what to do) work equally well? Does the folding mechanism help primarily by reducing context size (which could be achieved by simpler compression), or does the content-aware, hindsight-informed nature of the folding summaries provide benefits beyond size reduction? Without component-level ablations, the paper demonstrates that a particular architectural package works well, but does not provide guidance on which aspects of that package are essential versus incidental.

What evidence exists in the paper. Implicitly suggestive but not causally isolating. The context growth curves (Figures 1, 3a-b) show that the folding mechanism dramatically reduces context size compared to ReAct, but this demonstrates the aggregate effect of all architectural choices, not the marginal contribution of any one. The case studies (Figures 5-9) show Deep Consolidation being used to collapse dead ends and Granular Condensation being used to preserve individual steps, demonstrating that both operations occur in practice, but not that both are necessary for the observed benchmark performance. The 500-turn experiment shows context can shrink through Deep Consolidation, showing the mechanism functions, but not that this shrinkage causally improves task success.

Mitigation status. The paper does not acknowledge this as a limitation. The caption of Figure 1 presents the folding mechanism as the enabler of performance ("This is enabled by its proactive context folding"), implying a causal attribution that the experimental design does not fully support. The most informative ablation — training a ReAct agent on the same base model with comparable data and comparing against AgentFold — is absent. A reader seeking to implement a minimal version of the approach has no guidance on which components are load-bearing.

6.4 Difficulty Estimation Overhead and the Practical Cost of the Fold-Generator Pipeline

The assumption or constraint. The Fold-Generator pipeline described in Section 3.4 requires access to a powerful LLM capable of generating AgentFold-format trajectories with sufficient quality that rejection sampling can produce a clean training set. The paper does not specify which model was used, what the yield rate of the rejection sampling was (what fraction of generated steps passed the filter), or what the total compute cost of generating the training data was. Furthermore, the pipeline uses the WebSailor question set as training prompts, and the resulting agent is evaluated on benchmarks (BrowseComp, BrowseComp-ZH, WideSearch, GAIA) that may differ in distribution from the training questions.

The consequence. A practitioner attempting to reproduce or extend AgentFold faces several unknown costs. First, the pipeline requires a model capable enough to produce the structured four-part output format with reasonable reliability — the paper states that "even the most advanced LLMs cannot reliably produce" this format, implying that the generation model must be very capable (and correspondingly expensive to run). The total generation cost depends on the rejection rate: if only (say) 30% of generated steps pass the filter, then the effective cost per training example is roughly 3.3× the per-step inference cost of the generation model. Second, the SFT process distills the generation model's behavior into the target model, but the quality of the distilled policy is bounded by the quality of the generation model's policy — if the generation model itself makes suboptimal folding decisions on some fraction of steps, those suboptimal decisions become training targets. The rejection sampling filters format errors and excessive environmental errors but does not assess folding quality, so suboptimal-but-valid folding patterns propagate into the training data. Third, if the training question distribution (WebSailor) differs materially from the evaluation benchmarks, the agent may learn folding strategies that are maladapted to the evaluation tasks — for example, folding at a granularity appropriate for WebSailor's typical task length but suboptimal for BrowseComp's longer, more complex investigations.

What evidence exists in the paper. Very little. The paper provides no yield rates, no model specification for the generator, no analysis of filter pass rates broken down by error type, and no comparison of the training question distribution against the evaluation benchmarks. The paper states that it uses "the same question set as the recent WebSailor work" for training, which is a transparency-positive disclosure, but does not analyze whether this choice creates a distribution shift relative to the evaluation benchmarks.

Mitigation status. The paper does not discuss these practical costs or the pipeline's efficiency. The positioning of the Fold-Generator as a contribution (Section 3.4) describes its conceptual design but not its operational characteristics. A reader planning to replicate the approach needs to budget for unknown generation and filtering costs, and should anticipate that the quality of the resulting agent is upper-bounded by the (unmeasured) quality of the generation model's folding strategy. This is a practical limitation for adoption, though not a fundamental flaw in the research contribution — the paper could be strengthened by reporting these operational parameters.

6.5 Long-Horizon Scaling Is Demonstrated for Context Management but Not for Task Success at Extreme Lengths

The assumption or constraint. The paper makes strong claims about AgentFold's ability to scale to extreme interaction lengths: "it demonstrates the profound potential for agents to engage in truly extended interactions — potentially lasting for hundreds of steps" (Section 4.1), and the title of Figure 1 mentions "capable of scaling to 500 turns." The 500-turn experiment (Section 4.1) measures context token counts, showing that context remains below 20k tokens and exhibits non-monotonic behavior through dead-end consolidation. However, the paper explicitly does not report task accuracy in this 500-turn setting, stating:

"We provide a conceptual verification in the following Figure 4 but defer detailed explorations to future work due to time constraints."

Similarly, the turn-scaling experiment in Figure 4 only extends to 256 turns for BrowseComp, and the context analysis in Figure 3 covers only 100 turns (with over 20% of trajectories forcibly terminated at that limit).

The consequence. The demonstrated capability is about context efficiency, not task effectiveness. A system can maintain a compact, well-structured context across 500 turns while producing incorrect answers at every step — context efficiency is necessary but not sufficient for long-horizon task success. The paper does not establish that AgentFold can actually solve problems that require hundreds of turns; it establishes that if such problems exist, AgentFold's context architecture would not be the bottleneck. This is an important architectural property, but it is not a demonstrated capability.

Furthermore, the trajectory survival curve in Figure 3a shows that over 20% of trajectories are forcibly terminated at the 100-turn experimental limit and counted as failures. This means that on BrowseComp, a significant fraction of questions remain unsolved even after 100 turns of exploration. The 256-turn scaling curve in Figure 4 shows continuing improvement, suggesting that some of these terminated trajectories might succeed with more turns, but the paper does not report what accuracy is reached at 256 turns (only the qualitative claim of continued improvement). The reader cannot assess whether the improvement from 100 to 256 turns is practically meaningful (e.g., 2 percentage points vs. 10 percentage points) or whether further scaling to 500 turns would yield diminishing or substantial returns.

What evidence exists in the paper. Figure 3a (context growth to 100 turns), Figure 4 (accuracy scaling to 256 turns without specific numbers), and the 500-turn context dynamics mentioned in Section 4.1 (context mostly below 20k tokens, non-monotonic). None of these include task accuracy at 500 turns or even at 256 turns with specific numerical values. The case studies (Figures 5-9) illustrate the folding mechanism on long trajectories (Tables 2-3 show contexts evolving over 35-60+ turns), but these are individual examples, not aggregate performance metrics.

Mitigation status. The paper is partially transparent — it acknowledges deferring the detailed 500-turn evaluation to future work. However, the strong framing language ("profound potential," "capable of scaling to 500 turns" in Figure 1) may lead casual readers to infer that task-level scaling has been demonstrated when only context-level scaling has been shown. The paper would benefit from clearer separation between demonstrated context management scaling and hypothesized task performance scaling, and from providing specific accuracy numbers at the higher turn limits that were actually tested (256 turns in Figure 4).

6.6 No Analysis of Inference-Time Overhead from the Folding Mechanism

The assumption or constraint. The paper measures efficiency exclusively in terms of context size — tokens in the agent's working memory — and reports a 92% reduction versus ReAct at 100 turns, translating this to "an estimated memory saving of nearly 7GB per inference instance" (Section 4.1). However, the folding mechanism itself consumes inference compute: at each step, the model generates additional tokens beyond what a ReAct agent would generate, including the thinking block (potentially extensive chain-of-thought), the folding directive (JSON with a range and summary text), and the explanation (a concise motivation). The paper does not measure wall-clock time, tokens generated per step, total inference FLOPs, or end-to-end latency. Furthermore, the LLM inference cost scales differently with context length (quadratic attention cost for long contexts in standard transformer implementations) versus generation length (linear in the number of tokens generated), so the net compute tradeoff between shorter context and longer generation is not straightforward.

The consequence. The paper's efficiency claim — that AgentFold is more efficient than ReAct — is supported for memory usage but unmeasured for total inference cost. Two offsetting effects exist. On one hand, AgentFold's dramatically shorter context (7k vs. 84k+ tokens at 100 turns) reduces the quadratic attention cost per forward pass, which can be substantial for long contexts — this is where the claimed 7GB memory saving comes from. On the other hand, AgentFold generates additional tokens (thinking, folding directive, explanation) that a ReAct agent might not generate (or would generate in a different form). If the thinking block is extensive — and the case studies in Figures 7 and 9 show thinking blocks of several hundred to over a thousand tokens — the per-step generation cost may be significantly higher for AgentFold than for a ReAct agent that generates only an action. For tasks that complete in relatively few turns (where context length is not yet a bottleneck for ReAct), AgentFold may actually have higher total inference cost due to the generation overhead without the compensating benefit of attention savings on short contexts. The crossover point where AgentFold becomes net cheaper in FLOPs — if it ever does — is unknown.

Additionally, the folding mechanism adds serial dependencies to the agent's operation. While the folding directive is generated alongside the action (in the same forward pass, so no additional serial step), the folding directive must be applied to update the context before the next step begins, and the quality of the next step's reasoning depends on the quality of the folding summary. This is not a latency adder over ReAct (which also processes one step at a time serially), but it means that errors in folding propagate forward — a poor summary at step t degrades reasoning at step t+1 — which is a different kind of cost (reliability cost) not captured by token or memory metrics.

What evidence exists in the paper. None. The paper reports only context token counts (Figures 1, 3a) and block counts (Figure 3b). There are no measurements of tokens generated per step, wall-clock time per trajectory, total inference FLOPs, or GPU memory usage beyond the 7GB estimate (whose methodology is not described). The thinking blocks in the case studies are truncated with <omitted for visualization> tags, so the reader cannot even estimate typical thinking length from the provided examples.

Mitigation status. Not addressed. The paper does not acknowledge this as a tradeoff or a limitation. The efficiency discussion is entirely about memory/context size, with the 92% figure and 7GB estimate presented as unambiguous wins. A complete efficiency analysis — measuring total FLOPs or wall-clock time against a ReAct baseline at comparable accuracy levels across varying trajectory lengths — would be needed to determine whether AgentFold is more efficient in practice or merely trades generation overhead for context savings. A practitioner deploying AgentFold in a latency-sensitive or cost-sensitive setting currently has no basis for estimating the total compute budget required.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not merely offer a better summarization technique — it reframes what context management is within an agent architecture. Before AgentFold, the field implicitly treated context management as an external systems concern: either you accumulate everything until the window overflows (ReAct), or you apply a uniform compression policy from outside the agent (MEM1, MemAgent). The agent was a consumer of context, not a curator of it. AgentFold challenges this division of labor directly by making context curation a learned, core action generated by the same model in the same reasoning pass that plans the next tool call. This is a category shift: context management moves from infrastructure to capability.

The magnitude of this shift is most visible in the architectural consequence it forces. Once you accept that the agent should curate its own memory, you must answer hard design questions that the prior paradigm never asked: What is the right memory representation (structured blocks vs. monolithic summaries)? When should curation happen (after every step, or only after enough context has accumulated to evaluate significance)? What degrees of freedom should the agent have (can it fold arbitrary ranges, or must it always include the latest step)? AgentFold's answers — the Multi-Scale State Summaries and Latest Interaction split, the retrospective $[k, t-1]$ range constraint, the Granular Condensation and Deep Consolidation dual operations — constitute the first concrete architectural template for self-curating agents. The template is more important than any specific performance number because it gives the field a starting point to iterate on.

A subtler landscape shift is diagnostic rather than prescriptive. The paper's analysis of why existing approaches fail — ReAct's deterministic context saturation, uniform summarization's compounding information loss (formalized as $0.99^{500} \approx 0.66\%$ survival probability in Section 3.5) — provides clear, falsifiable failure modes that future architectures can be evaluated against. A researcher proposing a new context management approach can now ask: Does it exhibit linear growth in structural complexity (the ReAct failure)? Does it subject all information to repeated reprocessing with compounding loss risk (the uniform summarization failure)? Does it allow the agent to exempt critical details from reprocessing and to consolidate dead ends? These are sharp criteria that prior work lacked because the failure modes weren't cleanly separated.

The paper also reconciles a silent tension in the web agent literature. The ReAct-dominated line of work (WebThinker, WebDancer, WebSailor, WebExplorer) consistently used larger and larger models to push benchmark performance, implicitly betting that raw reasoning capacity could overcome context saturation through sheer attention quality. The summarization-based line (MEM1, MemAgent) bet that compression alone could solve the problem, but was tested primarily on simpler, shorter-horizon tasks where the compounding loss risk hadn't yet become catastrophic. AgentFold's results — a 30B-parameter model outperforming 671B ReAct agents on BrowseComp — suggest that neither bet was right. Context management architecture matters more than model scale for long-horizon reasoning, and uniform compression alone isn't enough without a mechanism to protect critical details from reprocessing. This doesn't negate prior work; it explains why the two lines reached seemingly incompatible conclusions (ReAct scales poorly with turns; summarization works on short tasks but hasn't been proven on long ones) by showing they were optimizing for different failure modes.

Which research directions become more attractive? Learned memory management is now a first-class research problem, not a peripheral engineering optimization. The paper opens a design space around memory representations, curation timing, and the tradeoff between agent autonomy (the model decides what to fold) and architectural constraints (the system enforces memory structure). Work on verifier robustness and over-optimization — the dominant concern in test-time compute scaling, as the earlier example paper showed — now has a parallel in context management: the risk is not verifier exploitation but curation errors (folding too aggressively and losing critical details, or folding too conservatively and retaining noise). Reinforcement learning for folding policies becomes the obvious next step, which the paper explicitly names in its "What's next" section.

Which become less attractive? Brute-force long-context processing as the primary path to better web agents — the assumption that 128k or 1M token context windows, combined with ever-larger models, will eventually make context management irrelevant. AgentFold's 7k-token context at 100 turns (versus 84k+ for ReAct) demonstrates that even models with large context windows benefit dramatically from curation, because the problem is not just fitting the context but reasoning over it effectively. The paper's finding that the GLM-4.5-355B agent "saturates and fails beyond 64 turns" despite its enormous capacity suggests that raw attention over long, noisy histories is not a scalable strategy regardless of model size. Research effort may shift from "how do we process longer contexts?" to "how do we maintain a tractably small working context over arbitrarily long interactions?"

Follow-Up Research This Work Enables

Reinforcement learning for optimal folding policies. The paper's most clearly identified gap is that folding behavior is learned via imitation (SFT on Fold-Generator trajectories) rather than optimized for task success. A natural follow-up would train AgentFold with RL, where the reward is task completion and the agent can discover folding policies that maximize long-horizon accuracy — potentially including non-obvious strategies like preemptively preserving details that seem irrelevant but correlate with downstream success, or aggressively consolidating even before a sub-task is certainly complete. The experiment would compare RL-trained folding against the SFT baseline on BrowseComp and WideSearch, measuring both final accuracy and the qualitative properties of the learned policy (consolidation timing, preservation selectivity). A strong negative result — RL failing to improve over SFT, or discovering degenerate policies like never folding (degenerating to ReAct) or always folding (degenerating to uniform summarization) — would reveal whether effective folding requires architectural constraints beyond what reward optimization alone can discover, or whether the SFT initialization provides a necessary inductive bias.

Component-wise ablation of the cognitive workspace architecture. The paper's architecture bundles several design choices — the Latest Interaction as high-fidelity working memory, the Multi-Scale State Summaries as curated long-term memory, the retrospective range constraint, the dual folding operations — without isolating their individual contributions. A systematic ablation would test: (1) AgentFold without the Latest Interaction (folding it before presentation, so all history is equally abstracted — testing whether the working memory / long-term memory distinction matters), (2) AgentFold restricted to only Granular Condensation (no multi-step consolidation — testing whether Deep Consolidation is load-bearing or merely cosmetic), (3) AgentFold with the range constraint relaxed (allowing folding of arbitrary non-contiguous ranges — testing whether the retrospective constraint helps or hinders), and (4) AgentFold trained on the same base model and data but using a standard ReAct format with an external summarizer applying the same summary blocks (testing whether the agent's authorship of folding decisions matters, or whether any curation mechanism of comparable quality would work). Each condition would be evaluated on BrowseComp at multiple turn limits (64, 128, 256) to test whether the ablated component's importance grows with trajectory length — the cognitive workspace theory would predict that the Latest Interaction and Deep Consolidation matter more at longer horizons. This experiment would produce a minimal specification of which architectural constraints are necessary, directly informing practitioners building simplified versions.

Information preservation probing. The paper's theoretical argument about compounding information loss under uniform summarization (the $0.99^{500} \approx 0.66\%$ calculation in Section 3.5) is compelling but empirically untested. A probe experiment would construct trajectories where a specific detail discovered at step 1 becomes critical for answering a question at step N (for N = 10, 50, 100, 200), and measure whether AgentFold's Granular Condensation successfully preserves that detail in its distinct summary block while a uniform summarization baseline loses it at the predicted exponential rate. The experiment requires controlled trajectories where the critical detail is known in advance and its presence in the context at step N can be checked (either by inspecting the summary blocks or by probing the model's ability to answer a targeted question about the detail). This would provide direct causal evidence for the paper's central information-preservation claim, which is currently supported only by the mathematical model and indirect evidence from overall accuracy. A null result — finding that AgentFold loses details at comparable rates to uniform summarization despite Granular Condensation — would indicate that the model's folding summaries are lossier than assumed, or that the agent misidentifies which details to preserve.

Cross-model and cross-benchmark replication. All current results are on Qwen3-30B-A3B evaluated on four specific benchmarks (BrowseComp, BrowseComp-ZH, WideSearch, GAIA). A replication study would train AgentFold on at least two architecturally distinct base models (e.g., a dense model like Llama-4-30B and a different MoE model like DeepSeek-V3-Lite) and evaluate on a broader set of long-horizon tasks including code-focused exploration (SWE-bench variants requiring multi-file investigation), scientific literature review (multi-paper synthesis tasks), and open-ended research queries without ground-truth answers (evaluated by human judgment or LLM-as-judge). The key question is whether folding is a general architectural principle that transfers across model families and task types, or whether it depends on specific properties of the Qwen architecture (instruction-following precision, JSON generation reliability, multi-turn reasoning style) or the information-seeking benchmark format (clear correctness criteria, web-based observations). If folding consistently improves performance across model families, it strengthens the claim that context management architecture — not model-specific capability — is the dominant factor. If folding only works on certain model families, it reveals coupling between the folding mechanism and the base model's pretraining characteristics that would guide practical adoption.

Dynamic and hierarchical folding policies. The paper's folding operates on a flat sequence of steps with a fixed binary choice (Granular Condensation vs. Deep Consolidation) at each step. More sophisticated memory representations are now tractable: (1) hierarchical folding where summaries can themselves be summarized (a summary of summaries), creating a multi-level memory structure that more closely mirrors human hierarchical planning; (2) dynamic folding triggers where the agent can choose not to fold (keeping the Latest Interaction available for an additional step without folding it into long-term memory), which would be valuable when the agent is in the middle of a multi-step operation and wants to keep full detail available for the next step's reasoning; (3) conditional folding where the folding decision depends on an explicit prediction of future relevance — the agent could generate a brief note about why it is preserving each detail, which could be used as an attention key for later retrieval. An experiment would compare these variants against the base AgentFold architecture on BrowseComp trajectories exceeding 200 turns, where the limitations of flat, fixed-schedule folding would be most apparent. The prediction is that hierarchical folding enables even slower context growth (summaries of summaries reduce the block count further) while conditional folding improves information preservation (details are preserved with explicit relevance tags that guide later attention).

Cost-benefit analysis of curation overhead. The paper demonstrates memory savings (92% context reduction, ~7GB per instance) but does not measure the total compute cost of the folding mechanism — the additional tokens generated for thinking, folding directives, and explanations. A cost study would measure, across trajectory lengths from 10 to 200 turns: (1) total inference FLOPs for AgentFold vs. a comparable ReAct agent solving the same tasks, (2) wall-clock time per trajectory, (3) the relationship between thinking-block length and folding quality (do longer thinking blocks produce better folding decisions, or is there a saturating return?), and (4) the crossover point where AgentFold's context savings outweigh its generation overhead. The experiment would use BrowseComp tasks solved to completion (not just to a turn limit) to ensure the comparison reflects actual task-solving cost rather than per-step cost. This would determine whether AgentFold is genuinely more efficient than ReAct in total compute, or whether it trades one resource (memory) for another (generation tokens) without net savings. A finding that AgentFold is more expensive in total FLOPs despite memory savings would change the adoption calculus — organizations might still prefer it for long-horizon capability rather than efficiency, but the efficiency framing would need revision.

Practical Applications and Downstream Use Cases

Long-horizon research assistance and competitive benchmarking. The most immediate application is for organizations building autonomous research agents that must sustain coherent investigation over dozens or hundreds of web interactions. The paper's BrowseComp results — 36.2% for AgentFold-30B-A3B vs. 30.0% for DeepSeek-V3.1-671B-A37B — demonstrate that a deployment can achieve superior accuracy on hard information-seeking tasks using a model that is ~22× smaller and correspondingly cheaper to serve, provided it uses the folding architecture. The practical benefit is not just accuracy but deployability: a 3B-activated-parameter model can run on hardware where a 671B model cannot, and the 7k-token average context at 100 turns means inference memory requirements are a fraction of what a ReAct deployment would need at comparable turn counts. For organizations running batch evaluation on benchmarks like BrowseComp or WideSearch, the cost savings from serving a 3B-active model instead of a 671B model while achieving higher accuracy could be substantial — potentially 10-50× cheaper per query depending on hardware and batching, assuming the generation overhead from thinking tokens doesn't fully offset the parameter-count savings. The missing piece for deployment decisions is the cost study described above (total FLOPs, not just memory), but the parameter-count reduction alone makes a strong prima facie case.

On-device or edge-deployed web agents with constrained memory. The paper's context efficiency numbers — ~3.5k tokens at start, ~7k tokens at 100 turns, mostly below 20k tokens at 500 turns — make AgentFold viable on hardware with severely limited memory where a ReAct agent (84k+ tokens at 100 turns) would be impossible. A 7k-token context requires roughly two orders of magnitude less KV-cache memory than an 84k-token context for the same model, which could mean the difference between running on a consumer GPU (8-12GB VRAM) versus requiring a datacenter GPU (40-80GB). This opens the possibility of local, privacy-preserving web agents that can conduct extended research sessions without sending interaction history to cloud APIs — the agent's context remains compact enough to fit entirely in local memory even after hundreds of steps. The 500-turn experiment, while preliminary on task success, demonstrates that the architecture does not hit a memory wall at scales that would cripple a ReAct agent, meaning the primary constraint becomes the model's reasoning quality at extreme lengths rather than hardware capacity. The practical impact depends on whether the 500-turn capability translates to task success (currently unmeasured) and whether the base model's 3B-activated-parameter footprint can be further reduced through quantization without degrading folding quality.

Training data generation for self-improving agents. The paper's Fold-Generator pipeline — using powerful LLMs with rejection sampling to produce trajectories demonstrating sophisticated context curation, then distilling that behavior into a smaller model via SFT — is a specific recipe for bootstrapping learned memory management without human annotation. This recipe generalizes beyond web search: any domain with sequential interaction (dialogue systems, code generation with iterative debugging, multi-step tool use in enterprise workflows) could use the same pattern to train agents that proactively manage their interaction history. The key requirement is that a powerful LLM can generate (imperfect) demonstrations of the desired curation behavior, and that format validity and task-progress criteria can serve as rejection filters. Organizations building domain-specific agents (customer support with long conversation histories, legal document review with multi-step investigation, scientific literature synthesis) could adapt the Fold-Generator approach to train custom folding agents on proprietary interaction data, potentially achieving the same kind of context-efficiency gains the paper demonstrates for web search. The practical requirement — access to a generation model capable enough to produce structured curation trajectories — is increasingly feasible as open-source frontier models improve, and the SFT step operates on the smaller, cheaper target model that will actually be deployed.

Research prioritization: context architecture over raw model scale for agent deployment. For organizations deciding how to allocate their LLM budget between larger pretrained models and better agent architectures, this paper provides empirical evidence that architecture matters more than scale for long-horizon interactive tasks. The finding that a 30B-parameter folded agent outperforms 355B and 671B ReAct agents on BrowseComp (Table 1) and continues scaling while the 355B agent saturates (Figure 4) suggests that for web agent deployments, investing in context management architecture — whether through AgentFold-style folding or alternative learned curation mechanisms — will yield better returns than simply upgrading to a larger base model. This is not a universal claim (the paper doesn't test tasks outside information seeking), but for the specific and growing category of long-horizon web exploration tasks, the evidence is strong enough to inform budget allocation: a team with a fixed compute budget for serving web agents should prefer a smaller model with proactive context management over a larger model with append-only history, especially if their task distribution includes problems requiring more than ~50 interaction turns. The 92% context reduction and 7GB memory savings per instance add operational efficiency to the accuracy advantage, making the case stronger when total cost of deployment (not just accuracy) is the optimization target.