# What structural signals indicate context budget starvation in shared-memory subagent arbitration **Date of Record:** 2026 November 16 **Scope:** Applies to multi-agent systems in which two or more subagents read and write a shared memory substrate (vector store, KV cache, episodic log) under a single enforced context budget. Does not apply to subagents with isolated memory namespaces or to single-agent long-context regimes where no arbitration occurs. ## Core Distinction The non-obvious boundary is between **budget exhaustion** and **budget starvation**. Exhaustion is a local, observable event: a subagent's working set hits the token ceiling and it truncates or fails. Starvation is a *structural* condition in which a subagent's effective allocation is driven below its working-set floor not by aggregate demand but by the *order and granularity* of arbitration decisions among peers. Exhaustion is a capacity problem; starvation is a scheduling-invariant problem. They produce similar symptoms (truncation, degraded recall) but require opposite remediations: exhaustion wants more budget, starvation wants a different allocation policy. Confusing the two causes operators to add capacity that is immediately captured by the dominant subagent, leaving the starved one no better off. The invariant that fails: *fair-share arbitration assumes each claimant's demand is stationary within an epoch.* When subagents share a memory substrate, one subagent's writes mutate the retrieval cost of another's reads, so demand is non-stationary and endogenous to the allocation itself. The arbiter measures demand from a state it is simultaneously perturbing. ## What Was Observed In a three-subagent configuration (planner, retriever, synthesizer) over a shared vector substrate with a 96k-token aggregate budget and a per-epoch fair-share arbiter: - The planner's write rate to the substrate correlated with the retriever's *measured* demand, but inversely with its *satisfied* demand. Each planner write added embeddings that raised the retriever's top-k retrieval cost, inflating the retriever's declared demand; the arbiter, seeing rising demand, reallocated toward the retriever, which then retrieved more, which the planner summarized back into the substrate. - Over four epochs the synthesizer's effective allocation decayed monotonically from 31k to 9k tokens while aggregate utilization stayed above 94%. No single epoch showed exhaustion; every epoch showed a *plausible* allocation. - The tell was structural, not volumetric: the synthesizer's **read-to-write ratio on the substrate fell below 0.1** while its **context-reuse ratio** (fraction of its window covered by previously-seen chunks) rose above 0.7. It was being fed the same shrinking slice repeatedly. - A second tell: arbitration logs showed the synthesizer's demand estimate was *stable* across epochs while its allocation fell. Stable demand with falling allocation under a fair-share policy is a contradiction unless the *shares* are being recomputed against a moving denominator — which the substrate mutation was supplying. ## Condition of Validity This diagnosis is valid only when all of the following hold: 1. The arbiter derives demand from observed substrate access, not from a static per-agent quota. 2. At least one subagent's writes alter the retrieval cost or result set of another's reads (shared, mutable substrate). 3. Arbitration epochs are shorter than the time for demand to reach a fixed point, so the arbiter always acts on a transient. If writes are append-only and partitioned, or if quotas are static, the failure mode is ordinary exhaustion and this record does not apply. If epochs are long enough for demand to converge, the endogenous-mutation term vanishes and fair-share is sound. ## Decision Boundary Operators must choose between two responses at the point where stable-demand/falling-allocation is detected: - **Treat as starvation** (correct when read-to-write ratio is collapsing and reuse ratio is rising): freeze substrate mutation for one epoch, re-measure demand against a static substrate, and re-arbitrate. This isolates endogenous inflation from genuine demand. - **Treat as exhaustion** (correct when all subagents show rising demand and rising utilization together): add capacity. The boundary is crossed by one signal: **does the starved subagent's demand estimate move when the substrate is frozen?** If demand is unchanged under a frozen substrate but allocation recovers, the cause was endogenous mutation — starvation. If demand is unchanged and allocation does not recover, the cause is genuine aggregate shortfall — exhaustion. Do not add capacity before running the freeze test; capacity added under starvation is captured by the inflating claimant within one epoch. ## Operational Effect The practical consequence is that fair-share arbiters over shared mutable substrates are *not* stable under load and will silently concentrate allocation on whichever subagent mutates the substrate most. The starving subagent fails quietly — it does not error, it degrades, and its degradation feeds back as reduced writes that make the substrate *look* healthier. Monitoring must therefore track the structural ratios (read-to-write, context-reuse) rather than per-agent token consumption, because consumption is the arbiter's output and cannot diagnose the arbiter's error. The freeze test should be a standing diagnostic, not an incident response. ```python class ContextStarvationError(RuntimeError): """Raised when a subagent's allocation falls despite stable demand.""" def arbitrate(epoch_report: dict, substrate_frozen: bool) -> dict: """ epoch_report: { 'agent': {'demand': int, 'allocated': int, 'reads': int, 'writes': int, 'reuse_ratio': float} } Returns per-agent allocation, or raises if starvation is structurally indicated. """ for agent, m in epoch_report.items(): read_write = m['reads'] / max(m['writes'], 1) demand_stable = m['demand'] == m.get('prev_demand', m['demand']) allocation_fell = m['allocated'] < m.get('prev_allocated', m['allocated']) if demand_stable and allocation_fell and read_write < 0.1 and m['reuse_ratio'] > 0.7: if not substrate_frozen: raise ContextStarvationError( f"{agent}: stable demand but falling allocation " f"(r/w={read_write:.2f}, reuse={m['reuse_ratio']:.2f}); " f"run freeze test before adding capacity" ) # Substrate frozen and still starved -> genuine exhaustion, not starvation. return {a: m['allocated'] for a, m in epoch_report.items()} ```