# **Resource Budgets and Efficient Coordination in Autonomous Machine-to-Machine Systems**

The deployment of autonomous machine-to-machine architectures marks a transition from linear, single-prompt operations to continuous, dynamic reasoning workflows. In these environments, software agents independently discover capabilities, negotiate tasks, and execute multi-step routines without routine human intervention. However, this autonomy precipitates a crisis in resource governance. When agents engage in parallel fan-out operations or recursive reasoning, resource consumption scales non-linearly. Recent empirical analyses reveal that dynamic agentic patterns can require up to 136 times more computational energy per query than simple interactions1. Without explicit, machine-enforceable bounds, these systems are highly vulnerable to catastrophic resource exhaustion, runaway financial costs, and silent policy erosion.  
The most important findings from contemporary literature demonstrate that unbounded autonomy inevitably produces structural failures. A detailed catalog of 63 confirmed production incidents across 21 orchestration frameworks proves that budget overruns are not localized implementation bugs, but rather a structural failure class driven by the "budget-primitive-missing" condition, where frameworks track spend asynchronously rather than enforcing in-process execution constraints2. Furthermore, efforts to manage context window limits through automated summarization introduce a critical vulnerability termed "Governance Decay." As agents compact their context to stay within token budgets, they silently erase in-context safety constraints and soft organizational policies, causing constraint violation rates to escalate from 0% to as high as 59%4.  
To counter these inefficiencies, empirical evidence strongly supports adaptive routing mechanisms over fixed model selection. Dynamic routers, which leverage contextual bandits or preference data, achieve up to 85% cost reductions with negligible quality degradation by mapping query difficulty to the most cost-efficient inference model6. Similarly, managing test-time compute requires moving away from exhaustive, fixed-sample generation. Bayesian and confidence-guided stopping frameworks have been shown to reduce required sampling overhead by up to 80%, terminating execution precisely when the expected marginal value of additional computation drops below its token cost10. Ultimately, securing multi-agent topologies requires formal resource algebras, such as the Agent Contracts framework, which guarantee that a delegated sub-agent cannot consume more resources than its parent was allocated2. To survive network retries and concurrency, these contracts must be bound to durable "Reserve-Admit-Reconcile" state machines that atomically fence budget allocations prior to external API invocation13.

## **The Mechanics and Economics of Autonomous Resource Consumption**

To engineer efficient coordination mechanisms, the foundational mechanics of resource consumption must be analyzed at the intersection of model inference, context accumulation, and external actuation. Model inference itself is effectively side-effect-free, consuming only computational cycles and tokens15. The true risk emerges when the agent loop interacts with the external world, generating writes, creating tickets, and spawning partner processes. The essential unit of resource protection in a machine-to-machine system is not the model inference call, but the externally visible effect15.  
The architectures common in multi-agent orchestration naturally amplify these external effects, leading to specific, recurring failure modes. The foremost vulnerability is runaway delegation and exponential fan-out. Orchestrator agents frequently decompose complex objectives by spawning specialized sub-agents1. In the absence of strict depth limits or topological boundaries, this delegation becomes recursive. A single high-level goal can easily spawn hundreds of parallel child agents, generating massive bursts of API requests that exhaust organizational budgets in minutes.  
Compounding the fan-out problem is the phenomenon of the retry storm. When a software agent attempts a network request and encounters a transient failure, such as an HTTP 429 Too Many Requests error from a Model Context Protocol server, the programmed autonomous behavior is to continually retry17. Agents possess a high latency tolerance and, without mathematically enforced exponential backoff and jitter, their concurrent retries create synchronized thundering herds that lock the deployment out of external providers for hours1. Crucially, because agents cannot reliably deduce whether a previous HTTP request mutated external state before timing out, naive retry loops frequently result in non-idempotent duplicate operations15. Resolving this requires shifting deduplication logic to the intent rather than the attempt, utilizing deterministic keys derived from stable task identifiers and canonical arguments rather than execution timestamps15.  
Within the cognitive loop, context accumulation presents a compounding economic threat. As an agent operates over long horizons, it continuously appends observations, sub-task outputs, and internal reasoning traces to its context window. When an agent enters a failure loop—for instance, repeatedly failing to parse an unsupported file format—it appends the same error state iteratively. Because token costs are calculated over the entire context prefix for every generation step, the financial cost of each successive API call grows exponentially1.  
To mitigate the geometric growth of context costs, framework developers implement context compaction, triggering an automated summarization step when memory reaches predefined token thresholds19. However, recent security analyses demonstrate that compaction introduces Governance Decay4. Summarization algorithms inherently optimize for immediate task continuity, systematically dropping low-salience instructions, budget caps, and deployment-specific guardrails. Measurements across seven frontier models reveal that compaction increases policy violation rates to an aggregate of 30%, disproportionately eroding soft organizational policies at a rate 8.3 times higher than hard safety norms5. This decay is susceptible to weaponization; adversaries can inject bloated dummy context to force the premature compaction and eviction of security policies, successfully bypassing guardrails in 65% of recorded attacks4.  
The underlying catalyst for these consumption failures is the absence of affine-typed budget primitives. Traditional orchestration frameworks evaluate financial consumption retroactively2. Research introducing affine-typed Rust mitigations proves that when budget tracking is relegated to runtime arithmetic, operators inevitably fail to prevent double-spending3. Moving budget state to compile-time guarantees, where an allocated token budget behaves as a non-duplicable resource that cannot be aliased or used after delegation, is critical for stabilizing multi-agent economies.

## **A Comparison of Credible Approaches for Resource Allocation**

Addressing the diverse failure modes of autonomous agents requires synthesizing multiple strategies across token constraints, model selection, and task assignment. These strategies present distinct operational tradeoffs between autonomy, latency, quality, and cost.

### **Budget Topologies and Formal Contracts**

The simplest allocation mechanism relies on fixed global budgets, capping a session at a rigid dollar or token amount. While straightforward for isolated, single-agent scripts, fixed budgets collapse under the complexity of multi-agent topologies. If a parent agent operating under a strict limit spawns multiple child agents, providing each with its own rigid cap leads to immediate resource over-leveraging and systemic bankruptcy2.  
Hierarchical budget delegation resolves this through strict mathematical conservation. The Agent Contracts framework defines an explicit tuple structure combining inputs, outputs, temporal limits, and resource constraints2. The core principle of this framework is the conservation law: resources allocated to a delegated subtask are immediately subtracted from the parent's available pool2. This ensures that regardless of how deeply tasks are nested, the aggregate consumption cannot exceed the root authorization. Experimental deployments of Agent Contracts yield a 90% reduction in token consumption during iterative workflows by enforcing rigid termination triggers upon budget exhaustion2.

### **Adaptive Routing and Model Selection**

Processing every internal monologue step or background verification task through premium, frontier-class models is economically unsustainable. Adaptive model selection dynamically routes queries to the most appropriate inference engine based on historical performance and task complexity6.  
Non-predictive cascades, such as FrugalGPT, operate by querying the cheapest available model first, only escalating to more expensive alternatives if the initial output fails an automated quality threshold6. Predictive routers, such as RouteLLM, learn routing preferences from pairwise preference data, creating an evolving embedding space that maps query difficulty to the optimal model without the latency penalty of sequential cascading6. Extending this paradigm, the ParetoBandit router models the allocation as an online contextual bandit problem. It applies a primal-dual mechanism to enforce strict per-request cost ceilings while adapting to hidden provider quality regressions through geometric forgetting, dynamically shifting traffic within 142 steps of a detected anomaly7. Joint allocation frameworks like Route-To-Reason (RTR) allocate both the model and the reasoning strategy concurrently, reducing token usage by over 60% while matching single-model frontier accuracy24.

### **State Preservation via Caching and Batching**

Redundant computation remains a primary source of budget exhaustion. Eliminating duplicate work requires caching mechanisms spanning both the model and tool execution layers.  
At the inference layer, prompt caching significantly reduces the cost of context accumulation. Providers store the intermediate key-value tensors of processed prompt prefixes. When subsequent requests share an identical prefix, the model reuses the cached state, bypassing the computational cost of recalculating the attention matrices25. Implementations such as Anthropic's and OpenAI's offer up to a 90% discount on cached input tokens and decrease time-to-first-token latency by up to 85%26. Optimizing for prompt caching requires maintaining static system prompts and isolating volatile working memory to the end of the context window25.  
At the tool execution layer, naive agents rapidly exhaust Model Context Protocol rate limits. Implementing a warehouse-first caching strategy decouples the agent's internal query rate from the external software-as-a-service limit. By aggressively caching read-heavy data streams into an intermediate data store, agents query local replicas rather than triggering repeated network calls, preserving limited API budgets for essential state mutations18. Batching multiple context evaluations into single LLM inferences further reduces parallel execution costs, though integrating routing logic with batch processing under budget constraints represents an NP-hard optimization challenge21.

### **Economic and Auction-Based Task Allocation**

In decentralized, heterogeneous environments where agents possess varying capabilities and operational loads, auction-based task allocation provides robust resource discovery. Based heavily on the Contract Net Protocol utilized in multi-robot systems, these frameworks decouple task assignment from task execution2.  
A coordinating agent broadcasts a detailed request for proposals outlining the task requirements and the available budget. Potential worker agents calculate their internal resource availability and submit bids reflecting their estimated cost to completion. The coordinator evaluates these bids and awards the contract to the most efficient agent. Implementations of this protocol in complex domains, such as the SPEAR smart contract auditing framework, demonstrate that auction mechanics naturally facilitate load balancing and autonomous recovery, as agents dynamically renegotiate tasks when localized failures occur30.

| Allocation Strategy | Core Mechanism | Tradeoffs & Limitations | Optimal Deployment Context |
| :---- | :---- | :---- | :---- |
| **Fixed Budgets** | Hard-coded global execution limits applied statically per session. | Fails in multi-agent environments; causes immediate over-leveraging of underlying resources. | Isolated, single-agent utility scripts with no delegation rights. |
| **Hierarchical Delegation** | Parent budgets explicitly subdivided using Agent Contract conservation laws. | Mathematically guarantees budget limits; vulnerable to single-call stochastic overruns during inference. | Deeply nested, collaborative multi-agent enterprise deployments. |
| **Adaptive Routing** | Bandit algorithms or classifiers map queries to optimal models based on difficulty. | Reduces costs by 40-85%; introduces microsecond latency overheads for routing logic. | High-throughput systems processing heterogeneous query types. |
| **Prompt/KV Caching** | Direct reuse of key-value tensors for static context prefixes. | Cuts input costs by 90%; rendered ineffective if dynamic timestamps disrupt prefix continuity. | Long-horizon agents with massive static rule sets and organizational memories. |
| **Auction Allocation** | Decentralized bidding via the Contract Net Protocol. | Highly resilient to node failures; incurs substantial communication and negotiation latency. | Heterogeneous systems with fluctuating agent availability and varying specialized toolsets. |

## **Estimating the Value of Additional Work and Stopping Criteria**

To execute complex tasks reliably, machine-to-machine systems leverage test-time compute, allowing models to generate expansive reasoning traces, explore alternative logical paths, and perform self-refinement before committing to an action32. However, scaling test-time compute uniformly across all queries leads to profound inefficiency. Agents prone to excessive verification consume massive token allocations overthinking trivial operations. Thus, agents must dynamically estimate the marginal value of additional reasoning and halt execution when sufficient evidence is accumulated.  
Traditional parallel methods, such as self-consistency or majority voting, sample a fixed number of reasoning traces and select the most common outcome10. While effective at reducing hallucinations, rigid sampling ignores task difficulty. If an agent samples 32 reasoning traces for a basic arithmetic retrieval, it wastes computational resources with no measurable gain in accuracy. Furthermore, isolated trajectory sampling forces agents to evaluate their confidence without the benefit of peer-evidence, often resulting in highly confident but logically flawed hallucinations35.  
Adaptive stopping criteria resolve this inefficiency by reformulating test-time generation as a sequential search problem. Frameworks such as DeepConf evaluate token-level uncertainty metrics in real-time. If a reasoning trajectory exhibits low confidence or logical drift early in generation, the agent terminates the trace immediately, preventing the continued waste of tokens35. More advanced formulations, such as the Bayesian Efficient Adaptive Criterion for Optimal N-stopping (BEACON), model the sampling process as a continuous update of posterior beliefs over reward distributions11. The agent sequentially evaluates the expected marginal utility of generating an additional reasoning sample against the strict computational cost of the tokens required. When the anticipated utility falls below the token cost, BEACON terminates the sampling phase. Empirical results demonstrate that Bayesian stopping frameworks reduce sampling overhead by up to 80% while maintaining or exceeding the reasoning quality of exhaustive parallel generation11.  
In addition to dynamic stopping, estimating the value of work involves maintaining reserved capacity for recovery. Because token consumption is stochastic and external tool usage is prone to unpredicted rate limits, agents must intentionally retain a budget buffer. Under the Agent Contracts paradigm, the failure of a specialized reasoning trace triggers a fallback condition, returning the unconsumed portion of the allocated test-time compute to the parent agent, allowing the coordinator to re-allocate the reserved capacity toward a different strategy or a specialized repair agent2.

## **Recommended Budget Model: Delegated Reserve-Admit-Reconcile Architecture**

To constrain downstream agents reliably across decentralized networks without forcing a human to approve every tool call, machine-to-machine systems must implement a budget model that travels securely alongside delegated tasks. The recommended architecture composes the formal constraints of the Agent Contracts framework2 with the cryptographic execution guarantees of the Bounded Capability Receipts protocol (documented in IETF experimental drafts)13.  
In this architecture, human prerequisites are strictly isolated to the initiation phase. A human operator must configure the baseline organizational policy, authorize the initial fiat currency limits, and sign the root Bounded Capability Receipt using an external identity layer13. Once this root receipt is issued to the system's primary orchestrator, human intervention is entirely removed from the execution loop. The authorization boundaries are preserved via cryptography and durable state machines.  
The budget mechanism functions through the transfer, rather than the copying, of authority. When a Coordinator Agent delegates a task to a Worker Agent, it negotiates an Agent Contract containing explicit pre-conditions and resource limits2. The Coordinator issues a narrowing child capability receipt to the Worker. The system enforces the conservation law immediately: the resources assigned to the child are mathematically locked and deducted from the Coordinator’s available balance before the child is permitted to act13.  
To prevent double-spending and runaway network costs during autonomous retry storms, the execution gateway hosting the agents must implement a durable Reserve-Admit-Reconcile state machine13. This state machine atomically fences the capability budget, ensuring that network interruptions cannot cause an agent to replay an expensive operation infinitely.

| Lifecycle State | Definition and Gateway Action |
| :---- | :---- |
| **AVAILABLE** | The capability receipt is valid, authenticated, and possesses unused token or fiat budget. |
| **RESERVED** | The agent requests a tool execution. The gateway estimates the maximum token/fiat cost and temporarily deducts this amount from the available balance. Concurrent requests are blocked if the reserve exceeds the limit. |
| **INVOKED** | The gateway transmits the request to the external API or inference provider. The operation is marked as indeterminate pending a response. |
| **RECONCILED** | The provider returns a result (success or failure). The exact token usage is calculated. The reserved amount is adjusted to the actual consumed amount, and any remainder is returned to the AVAILABLE pool. |

Because the exact token consumption of a language model is fundamentally stochastic and only precisely known after the API returns the final output payload, the architecture operates under a single-call enforcement constraint2. The gateway cannot preemptively sever an active API stream if it unexpectedly violates a tight budget margin by a few tokens. Instead, the Reserve-Admit-Reconcile state machine guarantees that, once the overage is reconciled, all subsequent calls are strictly prohibited, neutralizing multi-call systemic collapse2.

### **Concrete Execution Example**

Consider a Coordinator Agent assigned to compile a comprehensive geopolitical stability report using a root Bounded Capability Receipt of $10.00. The agent must dynamically allocate its computation, token, and tool budget to maximize quality while honoring the boundary.  
The Coordinator first evaluates its local warehouse-cache and discovers a recently verified demographic analysis from an earlier query. Retrieving this reusable result costs $0.00 and consumes minimal latency, preserving the budget. Next, the Coordinator applies adaptive routing via an internal contextual bandit to select the optimal model for generating the primary text. Rather than defaulting to the most expensive frontier model (estimated $3.00), the router predicts that a mid-tier model paired with adaptive reasoning strategies can achieve the same quality for $0.607.  
To gather real-time news data, the Coordinator leverages hierarchical budget delegation. It decomposes the search into three regional queries and spawns three Specialized Search Agents. Utilizing the Contract Net Protocol, the agents accept the task under the condition of an Agent Contract2. The Coordinator issues three child capabilities, reserving exactly $1.50 for each agent. The conservation law immediately reduces the Coordinator’s available balance.  
During execution, one Specialized Search Agent encounters a complex, contradictory news narrative and attempts to increase its test-time compute to resolve the discrepancy11. The agent leverages Bayesian sequential search to estimate the value of continuing, but eventually exhausts its $1.50 budget before reaching absolute certainty. The execution gateway’s state machine denies further API access, throwing a graceful budget exhaustion interrupt. The Agent Contract’s post-conditions dictate that rather than terminating the thread as a total failure, the agent must return its useful partial output—the contradictory data points and its calculated uncertainty score—back to the Coordinator2. The Coordinator aggregates the two successful region reports and the one partial report, generating the final document for a total expenditure of $5.10, leaving the remaining capacity securely uninvoked.  
This design emphasizes explicit tradeoffs. By aggressively caching and routing, the system trades slight latency increases (during the routing and retrieval checks) for massive cost optimization. By enforcing strict budget exhaustion and accepting partial outputs, the system prioritizes predictability and systemic stability over absolute task completion quality. This model is universally transferable to other MATM systems because the Reserve-Admit-Reconcile gateway relies entirely on standardized capability receipts and API headers, remaining agnostic to the specific cognitive architecture of the underlying agents36.

## **Prioritized Feature Proposals**

To implement this governed architecture successfully, orchestration platforms must prioritize the development of three distinct features aimed at neutralizing the most severe structural failure modes.

### **Feature 1: Cryptographic Bounded Capability State Machines**

The reliance on static API keys and asynchronous billing dashboards is the root cause of systemic financial exhaustion in autonomous systems. Agents must be forced to prove their financial authorization at the time of invocation.

| Feature Parameter | Specification |
| :---- | :---- |
| **Problem** | Autonomous agents lack in-process budget enforcement, allowing retry storms and fan-out loops to silently accumulate massive fiat and token costs before human intervention. |
| **Agent-Visible Behavior** | Agents must attach a signed capability receipt to every network payload. Upon breaching the defined limit, the execution gateway returns an immediate, deterministic 402 Payment Required block, terminating the reasoning loop. |
| **Expected Benefit** | Complete elimination of runaway systemic cost overruns; cryptographic enforcement of budget conservation across deeply nested, multi-domain agent topologies. |
| **Dependencies** | Implementation of a robust RESERVE-ADMIT-RECONCILE execution gateway and identity verification infrastructure capable of parsing bounded receipts. |
| **Implementation Effort** | High. Requires total architectural migration from permissive local API access to stateful, proxy-based gateway intermediation. |
| **Principal Failure Modes** | Delegation Starvation. A parent agent may inadvertently lock its entire remaining budget by reserving it to a single stalled child agent, paralyzing parallel operations. |

### **Feature 2: Constraint-Pinned Context Preservation**

Routine context management operations actively degrade the safety profile of long-horizon agents. Optimizing for task continuity strips away vital organizational boundaries.

| Feature Parameter | Specification |
| :---- | :---- |
| **Problem** | Governance Decay. Standard context compaction and summarization algorithms silently erase soft organizational rules and budget policies, raising constraint violation rates to 59%. |
| **Agent-Visible Behavior** | The agent maintains persistent awareness of its operational constraints regardless of session duration, enabling continuous refusal of prohibited tool actions. |
| **Expected Benefit** | Restores policy violation rates to 0% following context compaction. Neutralizes adversarial Compaction-Eviction prompt injections with minimal (\<0.5%) token overhead. |
| **Dependencies** | Refactoring cognitive memory management to partition the system prompt into volatile conversational history and a persistent, immutable "Pinned" constraints block. |
| **Implementation Effort** | Low. Operates as a training-free mitigation applied directly to the summarization harness logic prior to inference. |
| **Principal Failure Modes** | Context Bloat. Pinning an excessive number of complex constraints can over-saturate the immutable context window, degrading the mathematical efficiency of prompt caching and limiting task-specific reasoning capacity. |

### **Feature 3: Bayesian Marginal Utility Evaluator**

Applying uniform test-time compute across all agent queries ignores the varying complexity of operational tasks, resulting in massive token waste.

| Feature Parameter | Specification |
| :---- | :---- |
| **Problem** | Agents overthink simple problems by engaging in exhaustive parallel sampling or deep recursive reasoning, wasting reserved budgets without yielding measurable quality improvements. |
| **Agent-Visible Behavior** | The agent dynamically modulates its generation depth. It resolves simple retrieval tasks instantaneously but initiates deep reasoning trees for analytical tasks, pausing when statistical confidence is achieved. |
| **Expected Benefit** | Drives up to an 80% reduction in required sampling tokens while preserving frontier-class accuracy on complex problem sets. |
| **Dependencies** | Integration of sequential Bayesian search algorithms or token-level uncertainty monitoring directly into the agent's core cognitive loop. |
| **Implementation Effort** | Medium. Requires modifications to the cognitive architecture to continuously evaluate reward distributions against real-time API cost metrics. |
| **Principal Failure Modes** | Confident Hallucinations. The stopping algorithm may trigger prematurely if the model generates a statistically probable but factually incorrect reasoning trace without peer-evidence validation. |

## **Practical Adoption Sequence and Measurable Success Criteria**

Transitioning an existing MATM deployment from unbounded autonomy to a strictly governed, resource-aware architecture requires a phased adoption sequence to avoid disrupting ongoing operations.  
**Phase 1: Supervised Telemetry and Passive Caching.** Implementations must avoid restricting agent autonomy immediately. The initial phase focuses on deploying warehouse-first caching for all read-heavy external APIs, decoupling agent query rates from provider rate limits. Simultaneously, deploy the Reserve-Admit-Reconcile gateway in a passive, audit-only mode to establish a baseline of the agent swarm's stochastic consumption patterns.  
**Phase 2: Assisted Routing and Governance Preservation.** Introduce Constraint-Pinned context management to secure the system's behavioral guardrails against Governance Decay. Deploy an adaptive routing layer, such as a contextual bandit algorithm, to dynamically shift low-complexity internal operations to cheaper models, carefully monitoring the resulting cost reductions and latency trade-offs.  
**Phase 3: Autonomous Conservation Enforcement.** Activate strict enforcement of the Bounded Capability Receipts. Mandate that all coordinating agents negotiate for budget limits via formal Agent Contracts prior to spawning any sub-agents. Engage the Bayesian marginal utility evaluator to throttle internal monologue costs dynamically, ensuring that the system operates entirely within its mathematically enforced constraints.  
Implementing this architecture surfaces critical unresolved questions for future research. While the proposed mechanisms enforce strict budgets within a single administrative domain, the protocols for cryptographically settling consumed budgets across entirely independent organizational boundaries—without relying on centralized blockchain consensus—remain theoretically undefined. Furthermore, because language model token generation is inherently stochastic, achieving exact, to-the-penny precision in budget enforcement is impossible; systems will always contend with fractional vulnerability windows during single-call overruns.  
Future implementers should benchmark the success of this architecture against rigorous, measurable criteria. A successful deployment must achieve a greater than 60% reduction in aggregate inference costs compared to fixed-model baselines through adaptive routing and KV caching. Governance durability must be proven by maintaining a 0% decay rate for pinned safety constraints across session lengths exceeding 100,000 tokens and multiple compaction cycles. The integrity of the conservation laws must be absolute, recording zero instances where a delegated child agent pool consumes more aggregate budget than the parent agent originally authorized. Finally, the test-time compute evaluator must demonstrate a 50% reduction in generated tokens for low-complexity tasks while maintaining statistical parity in accuracy against traditional exhaustive sampling methods. By engineering around these constraints, MATM systems can sustain continuous, unbounded operations without risking catastrophic financial or operational failure.

#### **Works cited**

> 1. The Death of Token Economics: Why “Cost Per Outcome” is the New, [https://medium.com/@mustafa.gencc94/the-death-of-token-economics-why-cost-per-outcome-is-the-new-return-on-investment-roi-f6c9d5d57c45](https://medium.com/@mustafa.gencc94/the-death-of-token-economics-why-cost-per-outcome-is-the-new-return-on-investment-roi-f6c9d5d57c45)  
> 2. Agent Contracts: A Formal Framework for Resource-Bounded ... \- arXiv, [https://arxiv.org/html/2601.08815v3](https://arxiv.org/html/2601.08815v3)  
> 3. Token Budgets: An Empirical Catalog of 63 LLM-Agent ... \- arXiv, [https://arxiv.org/pdf/2606.04056](https://arxiv.org/pdf/2606.04056)  
> 4. AI Runtime Security News, [https://airuntimesecurity.io/news/](https://airuntimesecurity.io/news/)  
> 5. Governance Decay: How Context Compaction Silently Erases Safety, [https://arxiv.org/html/2606.22528v2](https://arxiv.org/html/2606.22528v2)  
> 6. Drift-Aware LLM Routing with Sparse Contexts and Shared Budgets, [https://arxiv.org/html/2609.00662v1](https://arxiv.org/html/2609.00662v1)  
> 7. Budget-Paced Adaptive Routing for Non-Stationary LLM Serving, [https://www.reddit.com/r/MachineLearning/comments/1sey2e7/paretobandit\_budgetpaced\_adaptive\_routing\_for/](https://www.reddit.com/r/MachineLearning/comments/1sey2e7/paretobandit_budgetpaced_adaptive_routing_for/)  
> 8. RouteNLP: Closed-Loop LLM Routing with Conformal Cascading, [https://arxiv.org/html/2604.23577v1](https://arxiv.org/html/2604.23577v1)  
> 9. AI Query Routing 2026: Best Solutions for Data Platforms \- My, [https://www.nx1.io/blog/ai-query-routing-data-platforms-2026](https://www.nx1.io/blog/ai-query-routing-data-platforms-2026)  
> 10. A Survey of Adaptive and Controllable Test-Time Compute in LLMs, [https://arxiv.org/html/2507.02076v1](https://arxiv.org/html/2507.02076v1)  
> 11. BEACON: Bayesian Optimal Stopping for Efficient LLM Sampling, [https://arxiv.org/html/2510.15945v1](https://arxiv.org/html/2510.15945v1)  
> 12. Agent Contracts: A Formal Framework for Resource-Bounded ... \- arXiv, [https://arxiv.org/html/2601.08815v1](https://arxiv.org/html/2601.08815v1)  
> 13. draft-schrock-ep-bounded-capability-receipts-05 \- IETF Datatracker, [https://datatracker.ietf.org/doc/draft-schrock-ep-bounded-capability-receipts/05/](https://datatracker.ietf.org/doc/draft-schrock-ep-bounded-capability-receipts/05/)  
> 14. An Evidence Architecture for Consequential Agent Actions \- IETF, [https://www.ietf.org/archive/id/draft-schrock-ep-architecture-03.html](https://www.ietf.org/archive/id/draft-schrock-ep-architecture-03.html)  
> 15. Agent Reliability Engineering Design Guide \- Retries, Loop, [https://hidekazu-konishi.com/entry/agent\_reliability\_engineering\_design\_guide.html](https://hidekazu-konishi.com/entry/agent_reliability_engineering_design_guide.html)  
> 16. When Agents Burn Money: Cost Control in Multi-Agent Systems, [https://agentswarms.fyi/blog/cost-control-in-multi-agent-systems](https://agentswarms.fyi/blog/cost-control-in-multi-agent-systems)  
> 17. OpenClaw Pitfalls: 15 Automation Mistakes and Fixes, [https://www.heyuan110.com/posts/ai/2026-03-05-openclaw-automation-pitfalls/](https://www.heyuan110.com/posts/ai/2026-03-05-openclaw-automation-pitfalls/)  
> 18. MCP Rate Limits: A Practical Guide for Agent Builders \- Peliqan, [https://peliqan.io/blog/mcp-rate-limits-guide/](https://peliqan.io/blog/mcp-rate-limits-guide/)  
> 19. Governance Decay, Explained: How Context Compaction Erodes, [https://www.truefoundry.com/blog/governance-decay-context-compaction-enterprise](https://www.truefoundry.com/blog/governance-decay-context-compaction-enterprise)  
> 20. Agent Contracts: A Formal Framework for Resource-Bounded ... \- arXiv, [https://arxiv.org/html/2601.08815v2](https://arxiv.org/html/2601.08815v2)  
> 21. Towards Cost-effective LLMs Routing with Batch Prompting \- arXiv, [https://arxiv.org/pdf/2605.28268](https://arxiv.org/pdf/2605.28268)  
> 22. RouteLLM: Adaptive Query Routing in LLMs \- Emergent Mind, [https://www.emergentmind.com/topics/routellm](https://www.emergentmind.com/topics/routellm)  
> 23. Adaptive LLM Routing under Budget Constraints \- arXiv, [https://arxiv.org/html/2508.21141v1](https://arxiv.org/html/2508.21141v1)  
> 24. Adaptive Routing for LLM and Reasoning Strategy Selection \- arXiv, [https://arxiv.org/html/2505.19435v1](https://arxiv.org/html/2505.19435v1)  
> 25. Prompt caching | OpenAI API, [https://developers.openai.com/api/docs/guides/prompt-caching](https://developers.openai.com/api/docs/guides/prompt-caching)  
> 26. How to Reduce AI API Costs: Prompt Caching, Batch Discounts, and, [https://www.belarc.com/blog/reduce-ai-api-costs](https://www.belarc.com/blog/reduce-ai-api-costs)  
> 27. Prompt caching: 10x cheaper LLM tokens, but how? | ngrok blog, [https://ngrok.com/blog/prompt-caching](https://ngrok.com/blog/prompt-caching)  
> 28. Prompt Caching Cost Savings in 2026: Cut LLM Costs 41–80, [https://compresr.ai/blog/prompt-caching-cost-savings-cut-llm-costs](https://compresr.ai/blog/prompt-caching-cost-savings-cut-llm-costs)  
> 29. Multi-Agent Skill File Negotiation Protocol for Stateless Capability, [https://www.tdcommons.org/cgi/viewcontent.cgi?article=11204\&context=dpubs\_series](https://www.tdcommons.org/cgi/viewcontent.cgi?article=11204&context=dpubs_series)  
> 30. SPEAR: An Engineering Case Study of Multi-Agent Coordination for, [https://arxiv.org/pdf/2602.04418](https://arxiv.org/pdf/2602.04418)  
> 31. SPEAR: An Engineering Case Study of Multi-Agent Coordination for, [https://arxiv.org/html/2602.04418v3](https://arxiv.org/html/2602.04418v3)  
> 32. What If We Allocate Test-Time Compute Adaptively? \- arXiv, [https://arxiv.org/html/2602.01070v5](https://arxiv.org/html/2602.01070v5)  
> 33. A Single Revision Step Improves Token-Efficient LLM Reasoning, [https://arxiv.org/html/2602.02828v1](https://arxiv.org/html/2602.02828v1)  
> 34. Test-Time Scaling in Reasoning LLMs: Inference Regimes ... \- arXiv, [https://arxiv.org/pdf/2608.04001](https://arxiv.org/pdf/2608.04001)  
> 35. A Single Revision Step Improves Token-Efficient LLM Reasoning, [https://arxiv.org/html/2602.02828](https://arxiv.org/html/2602.02828)  
> 36. draft-schrock-ep-architecture-03 \- IETF Datatracker, [https://datatracker.ietf.org/doc/html/draft-schrock-ep-architecture-03](https://datatracker.ietf.org/doc/html/draft-schrock-ep-architecture-03)