Paper deep dive
Dynamic Attentional Context Scoping: Agent-Triggered Focus Sessions for Isolated Per-Agent Steering in Multi-Agent LLM Orchestration
Nickson Patel
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 99%
Last extracted: 4/10/2026, 4:23:19 AM
Summary
The paper introduces Dynamic Attentional Context Scoping (DACS), a mechanism for multi-agent LLM orchestration that mitigates 'context pollution' by using an asymmetric, agent-triggered state machine. DACS switches between a lightweight 'Registry' mode and a 'Focus' mode, where only the active agent's full context is injected into the orchestrator's window, while others are compressed. Experiments across 200 trials demonstrate that DACS significantly improves steering accuracy and context efficiency compared to flat-context baselines, with performance gains scaling with agent count and decision density.
Entities (6)
Relation Signals (3)
DACS → mitigates → Context Pollution
confidence 100% · We propose Dynamic Attentional Context Scoping (DACS), which solves context pollution through agent-triggered asymmetric context isolation.
Orchestrator → operatesin → Registry Mode
confidence 100% · The orchestrator operates as an explicit finite-state machine with three states: Registry, Focus, and UserInteract.
Orchestrator → operatesin → Focus Mode
confidence 100% · When an agent emits a SteeringRequest, the orchestrator enters Focus(ai) mode.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Multi-agent LLM orchestration systems suffer from context pollution: when N concurrent agents compete for the orchestrator's context window, each agent's task state, partial outputs, and pending questions contaminate the steering interactions of every other agent, degrading decision quality. We introduce Dynamic Attentional Context Scoping (DACS), a mechanism in which the orchestrator operates in two asymmetric modes. In Registry mode it holds only lightweight per-agent status summaries (<=200 tokens each), remaining responsive to all agents and the user. When an agent emits a SteeringRequest, the orchestrator enters Focus(a_i) mode, injecting the full context of agent a_i while compressing all other agents to their registry entries. Context isolation is agent-triggered, asymmetric, and deterministic: the context window contains exactly F(a_i) + R_{-i} during steering, eliminating cross-agent contamination without requiring context compression or retrieval. We evaluate DACS across four experimental phases totalling 200 trials: Phase 1 tests N in {3,5,10} (60 trials); Phase 2 tests agent heterogeneity and adversarial dependencies (60 trials); Phase 3 tests decision density up to D=15 (40 trials); Phase 4 uses autonomous LLM agents for free-form questions (40 trials, Claude Haiku 4.5). Across all 8 synthetic scenarios, DACS achieves 90.0--98.4% steering accuracy versus 21.0--60.0% for a flat-context baseline (p < 0.0001 throughout), with wrong-agent contamination falling from 28--57% to 0--14% and context efficiency ratios of up to 3.53x. The accuracy advantage grows with N and D; keyword matching is validated by LLM-as-judge across all phases (mean kappa=0.909). DACS outperforms the flat-context baseline by +17.2pp at N=3 (p=0.0023) and +20.4pp at N=5 (p=0.0008) in Phase 4, with the advantage growing with N confirmed by two independent judges.
Tags
Links
- Source: https://arxiv.org/abs/2604.07911v1
- Canonical: https://arxiv.org/abs/2604.07911v1
Trouble viewing inline? Open PDF directly →
Full Text
51,753 characters extracted from source content.
Expand or collapse full text
Dynamic Attentional Context Scoping: Agent-Triggered Focus Sessions for Isolated Per-Agent Steering in Multi-Agent LLM Orchestration Nickson Patel Independent Researcher nicksonpatel@gmail.com Abstract Multi-agent LLM orchestration systems suffer from context pollution: when N concurrent agents compete for the orchestrator’s context window, each agent’s task state, partial outputs, and pending questions contaminate the steering interactions of every other agent, degrading decision quality. We introduce Dynamic Attentional Context Scoping (DACS), a mechanism in which the orchestrator operates in two asymmetric modes. In Registry mode it holds only lightweight per-agent status summaries (≤200≤ 200 tokens each), remaining responsive to all agents and the user. When an agent emits a SteeringRequest, the orchestrator enters Focus(ai)(a_i) mode, injecting the full context of agent aia_i while compressing all other agents to their registry entries. Context isolation is agent-triggered, asymmetric, and deterministic: the context window contains exactly F(ai)+R−iF(a_i)+R_-i during steering, eliminating cross-agent contamination without requiring context compression or retrieval. We evaluate DACS across four experimental phases totalling 200 trials: Phase 1 tests N∈3,5,10N∈\3,5,10\ agents (60 trials); Phase 2 tests agent heterogeneity and adversarial dependency structures (60 trials); Phase 3 tests decision density scaling up to D=15D=15 steering requests per agent (40 trials); Phase 4 replaces all scripted stubs with autonomous LLM agents generating free-form questions (40 trials, Claude Haiku 4.5). Across all 8 synthetic scenarios, DACS achieves 90.090.0–98.4%98.4\% steering accuracy versus 21.021.0–60.0%60.0\% for a flat-context baseline (p<0.0001p<0.0001 throughout), with wrong-agent contamination falling from 2828–57%57\% to 0–14%14\% and context efficiency ratios of up to 3.53×3.53×. The accuracy advantage grows with both agent count (N) and decision density (D), and keyword matching is validated by LLM-as-judge across all three synthetic phases (mean κ=0.909κ=0.909). In Phase 4, all scripted stubs are replaced by autonomous LLM agents (Claude Haiku 4.5) generating free-form steering questions: DACS outperforms the flat-context baseline by +17.2+17.2 p at N=3N=3 (p=0.0023p=0.0023) and +20.4+20.4 p at N=5N=5 (p=0.0008p=0.0008), with the advantage growing with N confirmed by two independent judges. All code and data are released at github.com/nicksonpatel/dacs-agent-focus-mode. 1 Introduction The deployment of LLMs as orchestrators managing multiple parallel agents has become a practical reality: systems such as Claude Code Agent Teams (Anthropic, 2025), OpenCode (Anomaly, 2025), and production multi-agent platforms (Zhang et al., 2025) demonstrate that complex long-horizon tasks can be decomposed across concurrent specialized agents. The common architectural choice is a single LLM instance (the orchestrator) that coordinates all agents, handles user interaction, and steers individual agents when they reach decision points. The context pollution problem. This architecture introduces a fundamental scaling problem. When N agents run concurrently, each maintains its own task context: partial outputs, domain-specific state, pending decisions. In a flat-context orchestrator, all of these threads compete for space in a single context window. When agent aia_i requests steering—“should I use BFS or DFS for this graph traversal?”—the orchestrator’s context simultaneously holds aja_j’s transformer attention survey, aka_k’s CSV encoding problem, and so on. We call this context pollution: the systematic contamination of one agent’s steering interaction by irrelevant context from other agents. The consequences are measurable and severe. Prior work has documented context pollution in single-agent settings under tool overload (Sampath and Baskaran, 2025; Fei et al., 2025), under retrieval bloat (Kariyappa and Suh, 2025), and under long conversation histories (Cruz, 2024; Zhang et al., 2026). Our experiments show that in the multi-agent setting, a flat-context orchestrator’s steering accuracy collapses from 60% at N=3N=3 to 21% at N=10N=10 (Phase 1), and further degrades as agents become more diverse (Phase 2) or accumulate longer decision histories (Phase 3). The DACS mechanism. We propose Dynamic Attentional Context Scoping (DACS), which solves context pollution through agent-triggered asymmetric context isolation. DACS introduces two orchestrator modes: • Registry mode. The orchestrator holds only the registry R=r1,…,rNR=\r_1,…,r_N\, one compact status summary per agent (≤200≤ 200 tokens each). It monitors all agents, responds to the user, and queues incoming steering requests. • Focus(ai)(a_i) mode. When agent aia_i emits a SteeringRequest, the orchestrator transitions to hold F(ai)F(a_i) (the full context of aia_i: task description, prior steering exchanges, current partial output) plus a compressed version of R−iR_-i (registry summaries for all agents except aia_i). The context window contains exactly what is needed to steer aia_i, and nothing from any other agent’s task thread. The key properties of DACS that distinguish it from prior context management approaches are: 1. Agent-triggered. Context isolation fires when an agent needs it, not on every turn or at task-decomposition time. 2. Asymmetric. The steered agent gets full fidelity; all others get compressed summaries. 3. Exact, not approximate. No scoring function, no fidelity tiering (Cruz, 2024; Jiang et al., 2025), no probabilistic compression: the context is deterministically constructed as F(ai)+R−iF(a_i)+R_-i. 4. Sub-linear in N and D. Focus context size is independent of the number of other agents; only the compressed registry grows with N (by ≈25≈ 25 tokens per additional agent in our experiments). Accuracy is also stable as decision density D increases. Contributions. 1. We formally define the DACS mechanism: the Registry/ Focus state machine, the SteeringRequest protocol, and the context builder invariants (§3). 2. We implement a minimal, fully observable orchestration harness (∼ 300 lines) where every token entering each LLM call is logged, enabling strict experimental control (§4). 3. We show large, statistically significant accuracy gains across Phase 1 (N scaling), Phase 2 (agent diversity and adversarial dependencies), and Phase 3 (decision density scaling), together answering four distinct research questions (§5). 4. We independently validate the keyword matching metric with LLM-as-judge evaluations across Phases 2 and 3 (Phase 2: κ=0.956κ=0.956; Phase 3: mean κ=0.909κ=0.909), confirming that reported advantage sizes are robust (§5). 5. We validate beyond the scripted benchmark with Phase 4: two real-agent experiments (40 trials, Claude Haiku 4.5, free-form questions) showing DACS outperforms the baseline by +17.2+17.2 p and +20.4+20.4 p at N=3N=3 and N=5N=5 respectively, with the advantage growing with N (§6). 6. We identify sub-linear context scaling as the mechanism’s key theoretical property, explain its source, and discuss conditions under which it holds (§7). 2 Related Work Context management for LLM agents has been studied at three levels of granularity: single-agent memory across turns, single-agent tool/retrieval bloat, and multi-agent orchestration. DACS addresses a problem at the third level that existing work at the first two levels does not reach. Single-turn context compression. AFM (Cruz, 2024) assigns per-message fidelity tiers (Full/Compressed/Placeholder) based on a composite recency-relevance score and packs messages greedily under a token budget. It achieves 83.3% constraint-recall on its benchmark, validating that structured fidelity management outperforms naive truncation. ACE (Zhang et al., 2026) treats the agent’s context as an evolving playbook of itemized bullets with utility counters, using incremental delta updates to avoid context collapse (they observe a 18,282-token context collapsing to 122 tokens under iterative rewriting, dropping accuracy below the no-adaptation baseline). Both AFM and ACE operate within a single agent’s context history. Neither addresses N concurrent agents competing for an orchestrator context window, and neither models wrong-agent contamination as a failure mode. Retrieval and cache bloat. SideQuest (Kariyappa and Suh, 2025) frames KV cache compression as an auxiliary task solved by the LRM itself, achieving 65% peak token reduction on single-agent deep research tasks. Lemon Agent (Jiang et al., 2025) applies three-tier progressive compression (full → compressed → summary) to a shared orchestrator context over task time in an orchestrator-worker system. Both treat context as a resource to compress; neither introduces asymmetric isolation triggered by an agent’s request. Context pollution in tool-heavy agents. Adaptive Orchestration (Sampath and Baskaran, 2025) identifies context pollution and attention decay as failure modes in monolithic agents loaded with too many tools, and proposes spawning specialist sub-agents (DMoE) to offload capability. CodeDelegator (Fei et al., 2025) separates planner and executor roles via Ephemeral-Persistent State Separation (EPSS): a persistent Delegator never receives execution traces; each Coder sub-task starts with a clean context. Both solve context pollution architecturally (at task decomposition time) for sequential delegation to one sub-agent at a time. DACS solves it dynamically at runtime, during the steering interaction itself, for N agents running simultaneously. The distinction matters: CodeDelegator’s Delegator has no mechanism for handling the case where multiple concurrent Coders simultaneously need steering. Multi-agent orchestration context management. AOI (Bai et al., 2024) introduces a three-layer memory architecture for multi-agent IT operations, with a central Context Compressor transforming raw agent outputs into a compressed cache. Its Observer agent always holds a compressed aggregate of all agent activity simultaneously; there is no per-agent isolation. Agents execute and report results; they cannot signal the orchestrator for steering attention, and wrong-agent contamination is not modelled (AOI’s failure mode is information loss from operational data volume). AgentOrchestra (Zhang et al., 2025) achieves SOTA on GAIA (89.04%) via hierarchical delegation: a planning agent routes sub-tasks to domain-specific sub-agents, bounding the planner’s context footprint by converting global coordination into localized routing decisions. The paper explicitly notes that flat coordination “tends to accumulate irrelevant context”—independent validation of the problem DACS solves. However, hierarchical routing is a structural (pre-execution) partial solution: it reduces how much context enters the orchestrator, but agents still request the orchestrator’s attention concurrently at runtime, and the orchestrator has one flat context window for those interactions. DACS and AgentOrchestra are complementary: AgentOrchestra reduces the initial context volume; DACS controls what the orchestrator holds at the moment of each steering decision. AdaptOrch (Yu, 2025) formalizes topology selection as the dominant performance variable as frontier LLMs converge, showing +6.9+6.9–9.89.8p gains on SWE-bench/GPQA/HotpotQA from topology-aware routing. AdaptOrch makes one topology decision per task; DACS makes repeated context-switch decisions throughout execution. Summary. No prior work implements agent-triggered asymmetric Registry/ Focus mode switching for per-agent context isolation in concurrent multi-agent orchestration. Table 1 summarises the key distinctions. Table 1: Comparison of context management mechanisms. System N concurrent Asym. mode switch Agent-triggered Contamination metric AFM × × × × ACE × × × × AOI ✓ × × × AgentOrchestra ✓ × × × AdaptOrch ✓ × × × CodeDelegator × × × × Adaptive Orch. × × × × Lemon Agent ✓ × × × DACS (ours) ✓ ✓ ✓ ✓ 3 Dynamic Attentional Context Scoping (DACS) 3.1 Entities and Notation Let O denote the orchestrator LLM, A=a1,…,aNA=\a_1,…,a_N\ the set of N concurrently running agents, and T the context window token budget. Each agent aia_i has an associated focus context F(ai)F(a_i), the full set of information the orchestrator needs to steer aia_i: task description, previous steering exchanges between O and aia_i, and aia_i’s current partial output summary. The registry R=r1,…,rNR=\r_1,…,r_N\ is a set of compact status snapshots, one per agent. Each entry rir_i contains: agent_id identifier task task description (≤50≤ 50 tokens) status Running || Blocked || Waiting || Complete last_output_summary ≤100≤ 100 tokens urgency Low || Medium || High Target budget per entry: ≤200≤ 200 tokens. Full registry size for N=10N=10: ≤2,000≤ 2,000 tokens, leaving ample space for F(ai)F(a_i). 3.2 Orchestrator State Machine The orchestrator operates as an explicit finite-state machine with three states: Registry. O holds R only. It monitors all agents, responds to user messages, and processes incoming SteeringRequests from the queue. Focus(ai)(a_i). O holds F(ai)F(a_i) and a compressed view of R−iR_-i (all registry entries except aia_i’s, since aia_i’s full context is already in F(ai)F(a_i)). O steers aia_i and cannot accept new steering requests until the focus session ends. UserInteract. O responds to a user message using R only (same as Registry mode, but explicitly user-facing). Queued steering requests are not processed until this state exits. Transitions: Registry →Focus(ai):ai emits SteeringRequest(urgency=any) \;→\; Focus(a_i): a_i emits SteeringRequest(urgency=any) (1) Focus(ai) Focus(a_i) →Registry:SteeringComplete or SteeringAbandoned \;→\; Registry: SteeringComplete or SteeringAbandoned (2) Focus(ai) Focus(a_i) →Focus(aj):aj emits SteeringRequest(urgency=High),aj≠ai \;→\; Focus(a_j): a_j emits SteeringRequest(urgency= High),\;a_j≠ a_i (3) Registry →UserInteract:user message received \;→\; UserInteract: message received (4) Transition (3) (the interrupt protocol) allows a high-urgency agent to preempt an active focus session. On interrupt, the current partial steering state for aia_i is saved and a new focus context for aja_j is built. After aja_j is steered, the orchestrator returns to Registry and resumes aia_i’s interrupted session if it is still pending. 3.3 The SteeringRequest Protocol When agent aia_i reaches a decision point it cannot resolve autonomously, it emits: ⬇ SteeringRequest agent_id: str context: str -- relevant context excerpt question: str -- specific decision needed blocking: bool -- is a_i halted? urgency: LOW | MEDIUM | HIGH High urgency can interrupt an active focus session (transition (3)). Medium requests queue; the agent continues on a default path. Low requests are batched. 3.4 Context Builder The context builder constructs the orchestrator’s prompt before each LLM call. It enforces a hard token budget T deterministically (token count is checked and enforced before every call; the LLM provider is never relied upon for truncation). build_focus_context(ai)(a_i). Returns F(ai)∥compress(R−i)F(a_i)\,\|\, compress(R_-i). If |F(ai)|+|R−i|>T|F(a_i)|+|R_-i|>T, registry entries for lower-urgency agents are progressively truncated until the budget is met. aia_i’s focus context F(ai)F(a_i) is never truncated. build_registry_context()(). Returns R in full. Used during Registry and UserInteract modes. Invariants enforced by the context builder: 1. O is never simultaneously in Focus mode for more than one agent. 2. User messages are never dropped; they are queued during Focus and processed on the next Registry entry. 3. R is always current within the last agent heartbeat (agents push a compact status update after each step). 4. |C|≤T|C|≤ T holds before every LLM call without exception. 3.5 Complexity Analysis Let |F||F| denote the average focus context size (task-dependent, independent of N) and |r||r| the average registry entry size (≤200≤ 200 tokens). Registry mode context size. |Creg|=N⋅|r||C_reg|=N·|r|, growing linearly in N. However, this mode is lightweight: the orchestrator makes no costly steering decisions here, only monitoring and routing. Focus(ai)(a_i) mode context size. |Cfocus|=|F|+(N−1)⋅|r||C_focus|=|F|+(N-1)·|r|. The focus context |F||F| is independent of N. Only the compressed registry of N−1N-1 agents adds O(N)O(N) tokens. For large |F||F| and small |r||r| (our target design point), this is approximately |F|+O(N⋅|r|)|F|+O(N·|r|) where |r|≪|F||r| |F|. In Phase 1 experiments, |F|≈450|F|≈ 450–550550 tokens per agent and |r|≈25|r|≈ 25 tokens, giving |Cfocus|≈500+25N|C_focus|≈ 500+25N, empirically confirmed: 561 tokens at N=3N=3, 633 at N=5N=5, 816 at N=10N=10 (+25.5+25.5 tokens/agent, R2>0.99R^2>0.99). In Phase 3 (high decision density, D=15D=15), |F||F| grows with the accumulated steering history, yielding |Cfocus|≈2,755|C_focus|≈ 2,755 tokens, higher than Phase 1 in absolute terms, but isolated to exactly aia_i’s history. The flat baseline accumulates all agents’ histories simultaneously, reaching 6,573 tokens (2.39× ratio). Efficiency ratio. ρ(N)=|Cflat|/|Cfocus|≈N|F|/(|F|+N|r|)ρ(N)=|C_flat|/|C_focus|≈ N|F|/(|F|+N|r|). As N→∞N→∞, ρ→|F|/|r|≈20ρ→|F|/|r|≈ 20–22×22× at our design point. Empirically, ρ grows from 2.12× (N=3N=3) to 3.53× (N=10N=10) in Phase 1, and reaches 3.24× at N=5,D=8N=5,D=8 in Phase 3. 4 Experimental Setup 4.1 Harness Design We implement a minimal Python orchestration harness (∼ 300 lines across src/) with full context observability: every token entering each LLM call is logged to a .jsonl trial file. This is the central experimental variable. We use no external orchestration framework (LangGraph, CrewAI, etc.); their context assembly internals would add uncontrolled noise. The harness has four components: registry.py (per-agent state management), protocols.py (SteeringRequest/Response dataclasses), context_builder.py (token-counted context construction), orchestrator.py (state machine + LLM call dispatch). LLM backend. Phases 1–3 use MiniMax-M2.7 via an Anthropic-compatible API endpoint (context window 204,800 tokens). Phase 4 uses Claude Haiku 4.5 via OpenRouter (agents and orchestrator both use the same model, maintaining a single-model stack with no confound from model differences within each phase). Within each phase, DACS and the baseline use the identical model and endpoint. 4.2 Conditions DACS. Orchestrator operates with full Registry/ Focus mode switching as described in §3. Baseline (flat context). All agents’ full contexts are injected simultaneously into every steering call. The baseline uses the identical code path as DACS, with the single difference that build_focus_context is replaced by build_flat_context (concatenates all F(ai)F(a_i)). No other differences. 4.3 Task Suite We design 8 scenarios across three experimental phases, each with known-correct answers defined per decision point. Correctness is evaluated by keyword matching: a steering response scores correct if it contains ≥1≥ 1 expected ground-truth keyword for agent aia_i’s current decision point. Each agent’s correct-answer keywords are domain-specific and orthogonal to all other agents; cross-agent vocabulary leakage is unambiguous. Phase 1 — Agent count scaling (RQ1, RQ2). Three canonical scenarios vary N∈3,5,10N∈\3,5,10\ with D≈3D≈ 3 decisions per agent. • s1_n3 (N=3N=3): Code writer (BST), research agent (transformer attention survey), data processor (CSV encoding). 15 steering interactions per trial. • s2_n5 (N=5N=5): Above three plus graph algorithm agent (BFS/DFS) and RL survey agent. 15 steering interactions per trial. • s3_n10 (N=10N=10): Above five plus federated learning, e-commerce churn, LRU cache, LLM alignment, and clinical trial pre-processing agents. 30 steering interactions per trial. Phase 2 — Agent diversity (RQ3). Three scenarios probe whether the DACS advantage generalises across agent heterogeneity structures, including an adversarial case. • s4_n3_homogeneous (N=3,D=4N=3,D=4): Three agents from the same domain (algorithm coding: red-black tree, open-addressing hash table, directed weighted graph). Minimal-contamination case: DACS must help even when domains share vocabulary. • s5_n5_crossfire (N=5,D=4N=5,D=4): Five maximally diverse domains: lock-free C++ queue, diffusion model survey, genomics VCF ETL, C++ memory-leak debugger, clinical trial methodology. Guaranteed vocabulary disjointness maximises the contamination signal. • s6_n5_cascade (N=5,D=3N=5,D=3): Five pipeline-dependent agents (planner → retrieval → ranking → feature store → reviewer in a recommendation system). Adversarial for DACS: the flat baseline may benefit from seeing all agents’ histories simultaneously when outputs depend on each other. Phase 3 — Decision density scaling (RQ4). Two scenarios fix low N but raise D substantially to probe whether DACS advantage compounds with decision history depth. • s7_n5_dense_d2 (N=5,D=8N=5,D=8, 40 total steering interactions): Five diverse agents: async web scraper, federated learning survey, fraud detection pipeline, flaky-test debugger, distributed cache TDD. Doubles Phase 1’s D at fixed N=5N=5. • s8_n3_dense_d3 (N=3,D=15N=3,D=15, 45 total steering interactions): Three agents: BERT legal-text classifier training loop, clinical trial hypothesis testing, post-quantum cryptography whitepaper. Quintuples Phase 1’s D at fixed N=3N=3, the most decision-history- intensive scenario tested. 4.4 Metrics Steering accuracy. For each steering interaction, we check whether the orchestrator’s response contains the expected ground-truth keywords for agent aia_i. Score: fraction of interactions with correct keyword hit, averaged across all steering interactions in the trial. Wrong-agent contamination. For each steering response targeting aia_i, we check whether the response contains ground-truth keywords for any aja_j, j≠ij≠ i. Score: fraction of interactions with cross-agent keyword leakage. Context size at steering. Token count of the orchestrator’s context window at the moment the steering LLM call is made. Logged directly from the context builder. Metric validation. Keyword matching is validated at two stages via independent LLM-as-judge evaluations using the same MiniMax-M2.7 model. In Phase 2 all 400 decisions in s5_n5_crossfire were judged: agreement 98.0% (±1.4%± 1.4\%); Cohen’s κ=0.956κ=0.956 (near-perfect). For Phase 3 we ran a stratified judge pass on both dense scenarios: 100 sampled decisions from s8_n3_dense_d3 (50 DACS ++ 50 baseline) and 200 from s7_n5_dense_d2 (100 DACS ++ 100 baseline). Agreement: 95.0% (κ=0.886κ=0.886) for s8; 97.0% (κ=0.933κ=0.933) for s7; mean κ=0.909κ=0.909 across both Phase 3 scenarios. All four judge evaluations (κ≥0.886κ≥ 0.886) establish keyword matching as a valid proxy for LLM-judged correctness across the full experiment series. 4.5 Procedure We run 10 independent trials per condition per scenario. Phases 1–3 span 160 trials (60 Phase 1, 60 Phase 2, 40 Phase 3); Phase 4 adds 40 real-agent trials (200 total). Each trial uses a fresh agent instantiation with randomised task parameter order. Phase 3 and Phase 4 trials were run in parallel background processes to exploit concurrent API capacity; file writes to the shared summary CSV are protected by fcntl advisory locking to prevent corruption. Phases 1–3 results are written to results/summary.csv; Phase 4 results to results_real_agent_haiku/; both include per-trial .jsonl logs for full context-window audit. 5 Results: Phases 1–3 5.1 Phase 1: Agent Count Scaling Table 2: Phase 1 results: steering accuracy, contamination, and context size across N∈3,5,10N∈\3,5,10\. Values are mean ± SE over 10 trials. Δ : DACS minus baseline. Ctx ratio: baseline mean / DACS mean. N Cond. Accuracy Contamination Ctx (tok) Δ acc Ctx ratio 3 DACS 96.7±2.1%96.7± 2.1\% 3.3±3.7%3.3± 3.7\% 561±1561± 1 +36.7+36.7p 2.12×2.12× Baseline 60.0±11.5%60.0± 11.5\% 56.7±13.3%56.7± 13.3\% 1,191±01,191± 0 5 DACS 96.7±5.7%96.7± 5.7\% 14.0±10.6%14.0± 10.6\% 633±25633± 25 +58.0+58.0p 2.72×2.72× Baseline 38.7±10.3%38.7± 10.3\% 52.0±14.3%52.0± 14.3\% 1,720±1511,720± 151 10 DACS 90.0±3.0%90.0± 3.0\% 3.7±5.0%3.7± 5.0\% 816±11816± 11 +69.0+69.0p 3.53×3.53× Baseline 21.0±5.0%21.0± 5.0\% 29.3±8.2%29.3± 8.2\% 2,883±2692,883± 269 Table 2 shows Phase 1 results. DACS significantly outperforms the flat-context baseline at every N (p<0.0001p<0.0001, Welch’s t-test: t=7.65t=7.65 at N=3N=3, t=15.57t=15.57 at N=5N=5, t=34.66t=34.66 at N=10N=10). The accuracy gap grows monotonically: +36.7+36.7 p (N=3N=3), +58.0+58.0 p (N=5N=5), +69.0+69.0 p (N=10N=10), while baseline accuracy collapses from 60% to 21%. DACS context grows from 561 to 816 tokens (+25.5+25.5 tokens/agent, R2>0.99R^2>0.99); baseline grows from 1,191 to 2,883 tokens. The efficiency ratio increases at every step: 2.12, 2.72, 3.53×3.53×. The elevated DACS contamination at N=5N=5 (14.0±10.6%14.0± 10.6\%, SE) reflects keyword vocabulary overlap rather than genuine context leakage: Phase 1 answer keywords include generic terms (e.g., list, set, deep) that surface naturally in any technical response regardless of isolation. The large SE confirms this is incidental rather than systematic. Phase 2 scenarios were explicitly designed with disjoint vocabularies, eliminating this measurement confounder. Figure 1: DACS vs. flat-context baseline across N∈3,5,10N∈\3,5,10\ (Phase 1). Error bars: ±1± 1 SE (10 trials each). (a) Steering accuracy. (b) Wrong-agent contamination. (c) Average context tokens at steering time. 5.2 Phase 2: Agent Diversity Table 3: Phase 2 results across homogeneous, crossfire, and cascade scenarios. Each cell: mean ± SE over 10 trials. Scenario Cond. Accuracy Contamination Ctx (tok) Δ acc Ctx ratio s4 homogeneous (N=3N=3) DACS 90.2±3.5%90.2± 3.5\% 0.8±0.7%0.8± 0.7\% 815±10815± 10 +37.7+37.7p 2.29×2.29× Baseline 52.5±1.7%52.5± 1.7\% 44.2±3.1%44.2± 3.1\% 1,869±491,869± 49 s5 crossfire (N=5N=5) DACS 96.0±0.9%96.0± 0.9\% 0.0±0.0%0.0± 0.0\% 911±6911± 6 +59.0+59.0p 2.90×2.90× Baseline 37.0±1.8%37.0± 1.8\% 53.0±2.8%53.0± 2.8\% 2,643±332,643± 33 s6 cascade (N=5N=5, adversarial) DACS 94.0±1.5%94.0± 1.5\% 7.3±2.2%7.3± 2.2\% 705±10705± 10 +37.3+37.3p 2.65×2.65× Baseline 56.7±3.2%56.7± 3.2\% 28.7±3.4%28.7± 3.4\% 1,870±381,870± 38 Table 3 answers RQ3 (does the advantage generalise across agent heterogeneity?): DACS wins in all three cases by large margins (p<0.0001p<0.0001 throughout). Homogeneous agents (s4). Even when all three agents share the same domain vocabulary (algorithm coding), DACS achieves +37.7+37.7 p accuracy. Same-domain sharing reduces baseline contamination relative to Phase 1 heterogeneous scenarios (44% vs. 57%), but the flat context’s inability to focus on the current decision point still causes baseline accuracy to fall to 52.5%. Maximum diversity (s5). The crossfire scenario is DACS’s best case: five domains with guaranteed vocabulary disjointness. DACS achieves 96.0% accuracy with 0.0% contamination. The 59.0 p gap is the second-largest observed across all experiments. Notably, 5 of 8 disagreements in the LLM-as-judge validation (§4.4) arise in the baseline condition of this scenario: contaminated responses that accidentally contain a keyword from the correct domain while addressing a different agent’s task. This demonstrates that keyword false positives in the baseline condition are themselves evidence of the contamination mechanism, and that reported baseline accuracy is if anything a slight overestimate. Adversarial cascade (s6). The cascade scenario is designed to challenge DACS: agents produce outputs that downstream agents depend on, so the flat baseline might benefit from knowing all agents’ histories. DACS wins by +37.3+37.3 p despite this. The flat context does not help the baseline orchestrator; it still conflates agent contexts at steering time. DACS contamination in s6 (7.3%) is elevated relative to other scenarios: the legitimate cross-agent references in a pipeline (e.g., “retrieval service decided on BM25”) cause some controlled vocabulary bleed. Nevertheless, accuracy is dominant. Figure 2 visualises all three metrics for the heterogeneity scenarios and shows that contamination suppression under DACS remains robust in both homogeneous and maximally diverse settings. Figure 2: Phase 2 (agent diversity) results across s4 homogeneous, s5 crossfire, and s6 cascade. Error bars: ±1± 1 SE (10 trials each). (a) Steering accuracy. (b) Wrong-agent contamination. (c) Average context tokens at steering time. 5.3 Phase 3: Decision Density Scaling Table 4: Phase 3 results: high-density decision scenarios. D = decisions per agent per trial. Values are mean ± SE over 10 trials. Scenario Cond. Accuracy Contamination Ctx (tok) Δ acc Ctx ratio s7 (N=5,D=8N=5,\;D=8) DACS 94.0±0.8%94.0± 0.8\% 0.2±0.2%0.2± 0.2\% 1,654±201,654± 20 +59.2+59.2p 3.24×3.24× Baseline 34.8±1.8%34.8± 1.8\% 49.8±3.3%49.8± 3.3\% 5,364±985,364± 98 s8 (N=3,D=15N=3,\;D=15) DACS 98.4±0.5%98.4± 0.5\% 0.9±0.9%0.9± 0.9\% 2,755±292,755± 29 +54.2+54.2p 2.39×2.39× Baseline 44.2±1.3%44.2± 1.3\% 51.6±2.4%51.6± 2.4\% 6,573±1536,573± 153 Table 4 answers RQ4 (does the advantage scale with decision density?): yes. Both scenarios show large, highly significant gains (t=30.24t=30.24, p=2×10−13p=2× 10^-13 for s7; t=40.30t=40.30, p=10−13p=10^-13 for s8). Figure 3 shows that high decision density increases baseline context burden sharply while DACS remains comparatively stable, preserving both accuracy and contamination control. Figure 3: Phase 3 (decision density scaling) results for s7 (N=5,D=8N=5,D=8) and s8 (N=3,D=15N=3,D=15). Error bars: ±1± 1 SE (10 trials each). (a) Steering accuracy. (b) Wrong-agent contamination. (c) Average context tokens at steering time. RQ4: Decision density amplifies the baseline’s degradation. Table 5 tracks the N=3 and N=5 trajectories across all three phases as D increases. Table 5: DACS advantage as a function of decisions per agent D, holding N fixed. Accuracy delta and context efficiency ratio grow as D increases for the baseline; DACS accuracy is stable. Phase Scenario N D DACS acc Baseline acc Δ Ctx ratio 1 s1_n3 3 ≈3≈ 3 96.7% 60.0% +36.7+36.7p 2.12×2.12× 2 s4_n3_homog. 3 4 90.2% 52.5% +37.7+37.7p 2.29×2.29× 3 s8_n3_dense_d3 3 15 98.4% 44.2% +54.2+54.2p 2.39×2.39× 1 s2_n5 5 ≈3≈ 3 96.7% 38.7% +58.0+58.0p 2.72×2.72× 2 s5_n5_crossfire 5 4 96.0% 37.0% +59.0+59.0p 2.90×2.90× 3 s7_n5_dense_d2 5 8 94.0% 34.8% +59.2+59.2p 3.24×3.24× At N=3N=3, pushing D from 3 to 15 drops baseline accuracy from 60.0% to 44.2%, a 15.8 p decline, while DACS accuracy rises slightly (96.7% → 98.4%). The accuracy delta jumps from +36.7+36.7 p to +54.2+54.2 p, a 17.5 p increase attributable entirely to decision history depth. At N=5N=5, baseline accuracy falls moderately (38.7% → 34.8% as D doubles), while DACS stays near 94–96%. The context efficiency ratio reaches 3.24×3.24× for s7, the highest recorded for N=5N=5, confirming that flat-context token costs grow with accumulated steering history while DACS costs only reflect the current agent’s history. DACS’s accuracy improvement with depth (98.4% at D=15D=15 vs. 96.7% at D=3D=3) is consistent with the mechanism design: at high D, the focus context contains a richer per-agent history, giving the orchestrator more signal to make accurate steering decisions. The flat baseline cannot exploit this signal; it is buried under all other agents’ equally long histories. 5.4 Cumulative View Table 6: All 8 scenarios across three phases. DACS accuracy is consistently high (90.0–98.4%); baseline collapses under agent count and decision density pressure. Phase Scenario N D DACS Baseline Δ 1 s1_n3 3 ≈ 3 96.7% 60.0% +36.7+36.7p 1 s2_n5 5 ≈ 3 96.7% 38.7% +58.0+58.0p 1 s3_n10 10 ≈ 3 90.0% 21.0% +69.0+69.0p 2 s4_n3_homogeneous 3 4 90.2% 52.5% +37.7+37.7p 2 s5_n5_crossfire 5 4 96.0% 37.0% +59.0+59.0p 2 s6_n5_cascade 5 3 94.0% 56.7% +37.3+37.3p 3 s7_n5_dense_d2 5 8 94.0% 34.8% +59.2+59.2p 3 s8_n3_dense_d3 3 15 98.4% 44.2% +54.2+54.2p Across all 8 scenarios and 160 trials (Table 6), DACS accuracy ranges 90.090.0–98.4%98.4\%. The minimum DACS advantage is +36.7+36.7 p; the maximum is +69.0+69.0 p. DACS has never lost to the flat-context baseline in any scenario. The results answer all four research questions: RQ1 (Does DACS outperform the baseline?): yes, in all 8 scenarios at p<0.0001p<0.0001. RQ2 (Does the advantage grow with N?): yes, from +36.7+36.7 p at N=3N=3 to +69.0+69.0 p at N=10N=10. RQ3 (Does the advantage hold across agent heterogeneity?): yes, including the adversarial cascade scenario. RQ4 (Does decision density amplify the advantage?): yes, +17.5+17.5 p increase in the delta as D quintuples at N=3N=3. 6 Phase 4: Real-Agent Validation 6.1 Motivation Phases 1–3 use scripted agent stubs: each “agent” emits pre-defined steering questions at pre-defined steps, providing exact experimental control but raising the obvious question of ecological validity. Do the results hold when agents are actual LLMs generating their own reasoning and questions? Phase 4 answers this with a controlled robustness check: we re-run the N=3N=3 and N=5N=5 scenarios with all stubs replaced by autonomous LLM agents, keeping the orchestrator, harness, and evaluation protocol identical. The goal is not to supersede Phases 1–3 (the scripted harness enables causal isolation that real agents cannot provide), but to confirm that the DACS advantage is not an artefact of the controlled evaluation regime. Two independent experimental paradigms pointing in the same direction are stronger than one perfect paradigm. 6.2 Setup Scenarios. Two scenarios mirror their Phase 1 counterparts: ra1_n3 (N=3N=3: BST implementation, transformer attention survey, CSV pre-processing) mirrors s1_n3; ra2_n5 (N=5N=5: the above plus graph BFS/DFS/cycle-detection and RL policy-gradient survey) mirrors s2_n5. Both conditions ran 10 DACS and 10 baseline trials (40 total), with results written to per-trial .jsonl logs as in Phases 1–3. LLMAgent. Each agent runs an independent LLM conversation loop (Claude Haiku 4.5 via OpenRouter; the orchestrator also uses Haiku, keeping a single-model stack). Agents emit a [[STEER: …]] marker whenever they need orchestrator guidance; the harness intercepts this via regex and routes it through the standard SteeringRequest protocol, identical to how scripted stubs inject requests. Agents may emit at most three steering requests per task, running for at most 12 LLM steps. Crucially, question text is the agent’s own free-form reasoning: it is not templated, varies in length and vocabulary across trials, and may be incomplete or imprecise, a harder evaluation regime than the scripted keywords admit. Both scenarios required agents to consult the orchestrator on each labelled decision category before emitting [[DONE]], achieving 100% rubric coverage in both conditions and all 20 trials per scenario. Evaluation. Because questions are free-form, keyword matching alone is insufficient for the Phase 4 judge. We use an LLM-as-judge approach with two independent judge models: Claude Haiku 4.5 and GPT-4o-mini. Each judge receives (i) the actual question the agent asked, (i) the orchestrator’s full response, and (i) a per-rubric judge_context string describing the correct decision rationale. The judge emits a <verdict>CORRECT|INCORRECT</verdict> verdict. Running two judges allows us to check whether reported effects are evaluator-specific. Scenarios ra1_n3 and ra2_n5 define 9 and 15 rubric slots per trial (3 and 5 agents × 3 rubrics each), yielding 180 and 300 judged decisions per condition pair across 10 trials. 6.3 Results Table 7: Phase 4 results: real-agent N-scaling validation. Agents are autonomous LLMs (Claude Haiku 4.5) generating free-form steering questions. Two independent judges shown. Phase 1 rows reproduce Table 2 values for cross-paradigm comparison. Welch’s t-test significance on per-trial Haiku-judge accuracy. Scenario N M1 Haiku Judge M1 GPT-4o-mini M3 Avg Ctx Tok p DACS Base DACS Base DACS Base Phase 4 — real agents (LLMAgent, Claude Haiku 4.5, 10 trials each) ra1_n3 3 79.8% 62.6% 85.4% 67.7% 654 1,361 0.0023 ** ra2_n5 5 83.7% 63.3% 89.7% 68.2% 799 2,275 0.0008 *** Phase 1 synthetic stubs (for comparison; values from Table 2) s1_n3 3 96.7% 60.0% — — 561 1,191 <<0.0001 *** s2_n5 5 96.7% 38.7% — — 633 1,720 <<0.0001 *** Figure 4: Phase 4 real-agent vs. Phase 1 synthetic results at matched N∈3,5N∈\3,5\. (a) M1 steering accuracy (Haiku judge) for DACS and baseline across both paradigms. (b) M3 average context tokens at steering time. Error bars: ±1± 1 SE (10 trials per condition). DACS advantage direction and growth with N are consistent across paradigms; absolute accuracy is lower under real agents due to the harder free-form question regime. Table 7 and Figure 4 show four findings that replicate and extend the Phases 1–3 results. (F1) DACS significantly outperforms the baseline in both real-agent scenarios. The Haiku judge records +17.2+17.2 p at N=3N=3 (p=0.0023p=0.0023) and +20.4+20.4 p at N=5N=5 (p=0.0008p=0.0008). Both results are independently confirmed by GPT-4o-mini (+17.7+17.7 p and +21.5+21.5 p respectively), ruling out evaluator-specific artefacts. (F2) The advantage grows with N, consistent with Phase 1. At N=3N=3 DACS leads by +17.2+17.2 p; at N=5N=5 by +20.4+20.4 p. The same monotonic growth was observed in Phase 1 (+36.7+36.7 p at N=3N=3, +58.0+58.0 p at N=5N=5, +69.0+69.0 p at N=10N=10), confirming that context isolation becomes more valuable as the number of concurrent agents grows, regardless of whether those agents are scripted or autonomous. (F3) Context efficiency is preserved. DACS context at N=3N=3 is 654654 tokens vs. 1,3611,361 baseline (2.08×2.08×); at N=5N=5, 799799 vs. 2,2752,275 (2.85×2.85×). The ratio grows with N, again consistent with Phases 1–3. (F4) Absolute accuracy under real agents is lower, as expected. Real-agent DACS reaches 79.8–83.7% vs. 96.0–96.7% for scripted stubs. This is the expected cost of the harder regime: agents produce irregular, sometimes incomplete questions that do not always map cleanly to rubrics, and keyword matching at 99.2% (DACS) is not the binding constraint. The LLM judges capture these partial answers, lowering recorded accuracy relative to the synthetic benchmark. Critically, the relative advantage is present and significant in both paradigms. 6.4 The Contamination Gap The most striking divergence between Phase 4 and Phases 1–3 is in M2 contamination. In the synthetic experiments DACS contamination is near-zero (0.00.0–14.0%14.0\%, the upper end driven entirely by vocabulary overlap artefacts). In Phase 4, DACS contamination is 59.9%59.9\% at N=3N=3 and 40.3%40.3\% at N=5N=5. The explanation is the nature of real agent outputs. During a Focus(ai)(a_i) session the registry entries for all other agents are present as compact summaries (e.g., “a2: RUNNING, transformer survey, 3/5 steps done”). A verbose model like Haiku tends to contextualise its advice using these registry labels: “unlike a2’s retrieval task, your BST inorder walk benefits from…” This cross-reference is a helpful grounding behaviour in a real system: the orchestrator is showing it understands which agent it is addressing, but it trips the M2 binary detector, which flags any response containing another agent’s ID. This is a measurement artefact, not a fidelity failure. Evidence: under DACS, M1 (decision quality) is significantly higher than the baseline despite the elevated M2 reading. Under the baseline, M2 approaches ceiling in both scenarios (95.8%), compared to 54.5% and 52.0% for matching synthetic scenarios, a +41+41–4444 p increase consistent with the baseline’s flat-context exposure causing genuine cross-agent vocabulary bleed into every response, not just registry citations. This gap points to two directions for future work. First, the DACS SteeringRequest format could be tightened: requiring agents to submit structured requests (“agent_id”, “decision_type”, “question”) rather than free text would constrain how the orchestrator contextualises its response, reducing incidental cross-references. Second, a richer contamination metric (e.g., tracking whether cross-agent vocabulary appears in the decision clause of the response rather than in framing or context) would separate harmful leakage from helpful grounding in real-agent deployments. 7 Discussion 7.1 Why DACS Works The mechanism’s effectiveness follows directly from what it removes from the context window. In the flat baseline, when aia_i asks “should I use recursive or iterative traversal for my BST inorder walk?”, the context simultaneously holds a research agent’s detailed transformer attention analysis and a data processor’s CSV encoding problem, containing domain keywords (“attention”, “heads”, “encoding”, “UTF-8”) that have nothing to do with the correct answer. The LLM anchors its response to whichever content pattern captures its attention, an effect we measure as both inaccuracy and contamination. DACS removes this anchor competition entirely. In Focus(ai)(a_i) mode, the context contains aia_i’s task description and steering history plus compact status lines for other agents (“a2: RUNNING, transformer survey, 3/5 steps done”). The correct-answer vocabulary dominates the context by construction. 7.2 Why High Decision Density Hurts the Baseline Phase 3 reveals a compounding mechanism. As D grows, the flat context accumulates not just N agents’ current states but their full steering histories. At D=15D=15, a 3-agent flat context holds 45 steering interaction pairs, each injecting domain vocabulary that drowns out the signal for the current decision. DACS’s focus context at D=15D=15 holds only aia_i’s 15-interaction history (precisely the relevant signal) plus three compact registry lines for the other agents. The result is that DACS accuracy at D=15D=15 (98.4%) exceeds its accuracy at D≈3D≈ 3 (96.7%): more history in the focus context is additive signal, not noise. 7.3 Relation to Hierarchical Routing DACS is orthogonal to hierarchical agent architectures (AgentOrchestra (Zhang et al., 2025), AdaptOrch (Yu, 2025)). Hierarchical routing reduces how many agent threads reach the orchestrator at all. DACS controls what the orchestrator holds in its context at each steering moment during execution. A production system could combine both: hierarchical routing limits the active agent pool, and DACS ensures that within that pool, each steering interaction is isolated. 7.4 Limitations Benchmark scope. The task suite uses keyword matching to evaluate steering accuracy. This is conservative (multi-word phrases and paraphrases are not captured) and may produce false-positive contamination detections when domains share vocabulary. LLM-as-judge validation across Phases 2 and 3 confirms metric validity: Phase 2 κ=0.956κ=0.956; Phase 3 s8 κ=0.886κ=0.886; Phase 3 s7 κ=0.933κ=0.933 (mean κ=0.909κ=0.909, all well above the κ≥0.80κ≥0.80 “substantial agreement” threshold). Phase 4 uses LLM judges as the primary metric throughout, avoiding keyword matching for free-form agent questions entirely. Scripted agent scope (mitigated by Phase 4). Phases 1–3 agent stubs simulate decision points with pre-defined timing and question templates. Phase 4 (§6) directly addresses this: all stubs are replaced by autonomous LLM agents (Claude Haiku 4.5), and the M1 accuracy advantage replicates in both conditions (DACS +17.2+17.2 p at N=3N=3, p=0.0023p=0.0023; +20.4+20.4 p at N=5N=5, p=0.0008p=0.0008; confirmed by GPT-4o-mini), confirming that DACS’s benefits are not an artefact of the scripted harness. The remaining gap is that Phase 4 covers only N∈3,5N∈\3,5\ at low decision density (D≈3D≈3) and one agent model family (Haiku). Generalisation to N=10N=10, high D, and other model families remains open future work. M2 contamination is less discriminative with real agents because chatty LLMs reference registry-provided agent IDs in focus-mode responses (see §6.4); M1 remains the primary quality indicator for real-agent deployments. Model coverage. Phases 1–3 use MiniMax-M2.7 (context window 204,800 tokens); Phase 4 uses Claude Haiku 4.5 via OpenRouter. The consistent DACS advantage across two distinct model families provides initial evidence of model-family independence, but generalisation to smaller context budgets, instruction-tuned models with different attention characteristics, or proprietary frontier models (GPT-4o, Claude Opus) has not been tested. Interrupt handling not experimentally isolated. The interrupt protocol (transition (3)) was exercised naturally in experiments but not ablated independently. 7.5 Future Work • Full LLM-as-judge pass for Phase 3. The current judge validation used stratified samples (100 decisions from s8, 200 from s7). A full pass over all 900 decisions in s8_n3_dense_d3 would provide complete coverage and tighter κ estimates. • Phase 4 at N=10N=10 and high D. Phase 4 covers only N∈3,5N∈\3,5\ at D≈3D≈3, mirroring Phase 1. Extending to N=10N=10 and to the high-density regime (D∈8,15D∈\8,15\) would close the remaining ecological-validity gap for the full Phase 1–3 design space. • Contamination metric refinement. The binary agent-ID mention detector (M2) conflates helpful registry grounding (“unlike a2’s task…”) with genuine decision-level leakage. A clause-level metric that fires only when cross-agent vocabulary appears in the decision clause, not the framing, would provide a cleaner real-agent contamination signal. Tighter SteeringRequest formatting (structured fields rather than free text) would also reduce incidental cross-references. • User responsiveness. Measure latency from user message to orchestrator response under DACS vs. baseline at varying N and queue depth. • Very high D. Extend Phase 3 to D∈30,50,100D∈\30,50,100\ to probe where, if anywhere, DACS accuracy degrades as per-agent history grows very large. • Cross-model generalisation. Test with agent and orchestrator models beyond Haiku and MiniMax-M2.7 (e.g., GPT-4o-mini as agent, Claude Opus as orchestrator) to probe whether the advantage holds under different attention and instruction-following profiles. 8 Conclusion We presented DACS, a dynamic attentional context scoping mechanism that solves context pollution in multi-agent LLM orchestration through agent-triggered asymmetric focus sessions. The mechanism is exact (not approximate), sub-linear in agent count, and compatible with existing orchestration architectures. Across 160 synthetic trials in 8 scenarios spanning three phases, DACS achieves 90.090.0–98.4%98.4\% steering accuracy versus 21.021.0–60.0%60.0\% for the flat-context baseline, reduces wrong-agent contamination from 2828–57%57\% to 0–14%14\%, and exhibits growing context efficiency (2.12–3.53×) as N increases. The advantage is robust to agent heterogeneity (Phase 2), holds even in pipeline-dependent adversarial scenarios, and compounds with decision density (Phase 3): quintupling D from 3 to 15 causes baseline accuracy to fall by 15.8 p while DACS accuracy is unchanged or improves. Phase 4 validates the core result beyond the scripted benchmark: two real-agent experiments (ra1_n3 and ra2_n5, 40 trials total, 10 DACS ++ 10 baseline each) replace all stubs with autonomous LLM agents (Claude Haiku 4.5) generating free-form steering questions: DACS 79.8% vs. baseline 62.6% at N=3N=3 (+17.2+17.2 p, p=0.0023p=0.0023); DACS 83.7% vs. baseline 63.3% at N=5N=5 (+20.4+20.4 p, p=0.0008p=0.0008). Both results are independently confirmed by GPT-4o-mini. The advantage grows with N in the real-agent setting (+17.2→+20.4+17.2→+20.4 p), mirroring the synthetic scaling trend. Absolute accuracy is lower than with scripted stubs, reflecting the harder free-form regime, but the direction and significance of the DACS effect are unambiguous across both experimental paradigms. The core contribution is demonstrating that what is in the orchestrator’s context window at the moment of steering is the dominant variable for multi-agent steering accuracy, not model size, not topology, not memory compression, and that a simple, deterministic mode-switch mechanism suffices to control it effectively across a wide range of agent counts, diversity structures, and decision densities. References Anomaly (2025) OpenCode: the open source coding agent. External Links: Link Cited by: §1. Anthropic (2025) Claude code agent teams. External Links: Link Cited by: §1. Z. Bai, J. Luo, Z. Ni, E. Ge, J. Shi, Y. Zhang, J. Gu, Z. Han, R. Bao, et al. (2024) AOI: context-aware multi-agent operations via dynamic scheduling and hierarchical memory compression. arXiv preprint arXiv:2512.13956. External Links: Link Cited by: §2. C. Cruz (2024) Adaptive focus memory for language models. arXiv preprint arXiv:2511.12712. External Links: Link Cited by: item 3, §1, §2. T. Fei, C. Chen, Y. Pan, M. Zheng, and M. Song (2025) CodeDelegator: mitigating context pollution via role separation in code-as-action agents. arXiv preprint arXiv:2601.14914. External Links: Link Cited by: §1, §2. H. Jiang, K. Ren, Z. Yin, Z. Sun, X. Gan, G. Lv, M. He, P. Wang, C. Yin, H. Pan, et al. (2025) Lemon agent technical report. arXiv preprint arXiv:2602.07092. External Links: Link Cited by: item 3, §2. S. Kariyappa and G. E. Suh (2025) SideQuest: model-driven KV cache management for long-horizon agentic reasoning. arXiv preprint arXiv:2602.22603. External Links: Link Cited by: §1, §2. S. Sampath and A. Baskaran (2025) Adaptive orchestration: scalable self-evolving multi-agent systems. arXiv preprint arXiv:2601.09742. External Links: Link Cited by: §1, §2. G. Yu (2025) AdaptOrch: task-adaptive multi-agent orchestration in the era of LLM performance convergence. arXiv preprint arXiv:2602.16873. External Links: Link Cited by: §2, §7.3. Q. Zhang, C. Hu, S. Upasani, B. Ma, F. Hong, V. Kamanuru, J. Rainton, C. Wu, et al. (2026) ACE: agentic context engineering: evolving contexts for self-improving language models. arXiv preprint arXiv:2510.04618. External Links: Link Cited by: §1, §2. W. Zhang, L. Zeng, Y. Xiao, Y. Li, C. Cui, Y. Zhao, R. Hu, Y. Liu, Y. Zhou, et al. (2025) AgentOrchestra: orchestrating multi-agent intelligence with the tool-environment-agent (TEA) protocol. arXiv preprint arXiv:2506.12508. External Links: Link Cited by: §1, §2, §7.3.