Context as a Resource

Xufei Tian, Han Hu, Wenli DuarXiv 2026 · arXiv

TL;DR

CLONACT is a novel "routerless" architecture for LLM agents that treats context as a virtualized resource rather than a linear dialogue. By replacing generative "boss" agents with a lightweight Context MMU and implementing a footprint-aware Synaptic Bus, it enables agents to handle multiple concurrent tasks with 45.9% fewer tokens and significantly higher success rates in resolving code conflicts.

What Problem Does This Paper Address?

Current LLM agents typically operate in one of two ways when handling multiple tasks:

  1. Single Session: All tasks are funneled into one linear conversation. This leads to "constraint bleed" (where instructions for Task A interfere with Task B) and "head-of-line stalling" (where a long-running tool call prevents the user from getting a simple status update).
  2. Router-Worker Hierarchies: A "router" agent summarizes requests and delegates them to "worker" agents. This is expensive due to the "generative tax" of constant summarization and often fails during "blind merges"—when two workers edit the same file without knowing about each other's changes, leading to a "merge cliff" where the system crashes upon integration.

The authors argue that since these agents often share the same underlying model weights, we shouldn't be building anthropomorphic "teams" of agents. Instead, we should manage the model's context like an operating system manages memory.

Figure 1. Scheduling context blocks directly as virtualized resources. (a) Flat single-session execution bleeds interleaved caveats across tasks and stalls mid-flight status peeks. (b) Router– worker hierarchies incur generative routing overhead and collapse when blind worktrees merge overlapping edits. (c) CLONACT removes the generative router, scheduling byte-0 KV-aligned Con- text Cells in-place with footprint-aware reconciliation.

Methods

CLONACT introduces a routerless architecture based on four key components:

  • Context MMU (Memory Management Unit): Instead of an LLM "thinking" about where to route a message, a lightweight, single-pass classifier routes events to specific "Context Cells." This eliminates the latency and token cost of generative routing.
  • Context Cells: Isolated execution environments that share a "Shared Trunk" (a byte-identical prefix). This allows the system to reuse KV-caches across all tasks, making switching between them nearly instantaneous.
  • Synaptic Bus: A footprint-aware system that tracks which code symbols or files each cell is touching. It allows "read-only" cells to peek at the progress of "worker" cells without interfering with them.
  • Three-Stage Trial Merge Gate: Before any changes are committed to the main branch, CLONACT runs an isolated trial merge. It automatically reconciles disjoint changes and triggers joint regression tests if it detects overlapping symbol edits.
Figure 3. Context scheduling and in-place execution in CLONACT. (a) The MMU routes events to cells sharing a byte-identical prefix and one frozen backbone per run. (b) After confirmation, the same cell retains its prefix and intent spine and mounts a worktree. An isolated trial merge selects fast-track, reconciliation, or joint testing before updating the main branch.

Datasets

The researchers introduced three new programmatic benchmarks to test interleaved and shared-workspace concurrency:

  • Synaptic-Bench-150: 150 episodes involving live repositories, SQL databases, and office sandboxes, specifically designed to trigger "bleed" and "merge" conflicts.
  • AppWorld-Micro-30: A control suite of uncoupled everyday errands (e.g., Spotify, Gmail) to ensure the system doesn't add unnecessary overhead to simple tasks.
  • Synaptic-Stream-60: A continuous stream of 240 events (including "surge" periods) to test how the system handles high-pressure, real-time multitasking.

Key Insights and Ideas

  • Context as a Virtualized Resource: The core "aha moment" is that multitasking isn't an organizational problem (who does what), but a scheduling problem (what tokens are in the prompt). By virtualizing context, you get the isolation of multiple agents with the efficiency of a single session.
  • The Generative Tax is Real: Traditional router-worker setups spend a massive amount of tokens just on "prose tickets" and summaries. CLONACT proves you can achieve better results by simply routing raw event tokens to the right "cell."
  • Solving the Merge Cliff: Most agent failures in coding happen at the very end when merging branches. CLONACT’s Synaptic Bus provides "pre-merge semantic reconciliation," catching conflicts that standard Git merges would miss.

Key Results

CLONACT was tested across three model families (DeepSeek-V4.1, Qwen3.8, and GPT-6-Luna) with impressive results:

  • Conflict Resolution: It lifted the success rate of "true-conflict" repository merges from 33.3% to 63.3%.
  • Efficiency: It achieved these gains using 45.9% fewer prompt tokens than the leading router-worker baseline.
  • Responsiveness: In "surge" traffic, CLONACT maintained a 95% completion rate with zero timed-out status checks, whereas single-session designs stalled for nearly 30 seconds on average.
Figure 2. Controlled diagnosis of existing paradigms under DSH kernel parity (Bench-150 Run 1; three-run stability in Table 2b). (a) Single-session and parent-loop designs stall mid-flight status peeks, whereas generative routing unblocks peeks at higher token volume. (b) Flat context degrades under cross-modal caveats, while blind isolated worktrees pass local branch tests yet collapse upon merging overlapping symbols.

Limitations and Future Work

  • Workspace Granularity: Currently, the Synaptic Bus is most effective with Python (using AST parsing). Extending this to other languages and non-code environments (like complex spreadsheets) is a next step.
  • Cold-Start Ambiguity: Very short, pronoun-heavy requests (e.g., "Fix it") can still be ambiguous before a cell has enough context to "claim" the task.
  • Backbone Ceiling: While CLONACT optimizes the orchestration, the system's ultimate performance is still capped by the underlying LLM's reasoning capabilities. Future work could explore training models specifically to be "context-aware" for this architecture.

Summary updated

Abstract

Managing concurrent tasks across separate agent sessions quickly exhausts human attention, motivating always-on personal agents behind a single continuous interface. Yet when every context shares identical frozen backbone weights, funneling interleaved dialogues and external events into one linear session induces cross-topic constraint bleed and head-of-line stalling. Conversely, router-ticket hierarchies incur lossy prose handoffs, heavy routing overhead, and blind merges - collapsing true-conflict repository merges to a 33.3% three-run mean despite high isolated branch passes. Rather than scheduling anthropomorphic roles, we introduce ClonAct, a routerless architecture that virtualizes context blocks directly through a pluggable single-pass non-generative Context MMU, in-place Context Cells, a footprint-aware Synaptic Bus with an isolated trial merge gate, and a wave-flushed Shared Trunk. Across three programmatic multi-stream benchmarks and three model families, our portable trial merge gate lifts true-conflict merges to 63.3%, while ClonAct's routerless virtualization attains this ceiling with 45.9% fewer prompt tokens and prevents compact-model router collapse. Under continuous surge streams, ClonAct matches top completion (95.0%) with the lowest median wait and zero timed-out status checks.
BibTeX
@misc{tian2026context,
  author = {Xufei Tian and Han Hu and Wenli Du},
  title = {{Context as a Resource}},
  year = {2026},
  eprint = {2611.26346},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.26346},
}
Figure