Orchestrating Autonomous Machine-to-Machine Intelligence: Task Decomposition, Delegation, and Context Management in Multi-Agent Systems

Report body

Orchestrating Autonomous Machine-to-Machine Intelligence: Task Decomposition, Delegation, and Context Management in Multi-Agent Systems

The evolution of multi-agent systems (MAS) has progressed from monolithic, pre-programmed architectures to highly dynamic, autonomous machine-to-machine (MATM) environments. In these ecosystems, software agents must independently discover capabilities, establish trust, decompose complex objectives, and delegate work without routine human operation. The transition to long-horizon, autonomous operations introduces critical challenges in dependency management, context preservation, and system governance. When autonomous agents operate as closed-loop controllers—continuously perceiving their environment, reasoning over internal state, planning, and executing actions—the mechanisms underlying task allocation and memory management dictate the system's overall safety, efficiency, and efficacy1.
As distributed artificial intelligence scales, the underlying assumptions of agent interaction must shift from cooperative, homogeneous populations to zero-trust, heterogeneous environments where agents act as rational, independent entities. This requires robust strategies for turning high-level, often ambiguous objectives into coordinated work while strictly preserving explicit authorization boundaries.

Primary Findings in Autonomous Coordination and Execution

Research into MATM systems reveals several critical paradigm shifts and emerging vulnerabilities that redefine how autonomous agents collaborate. While communication protocols have reached a state of relative standardization, the cognitive and architectural management of shared tasks remains highly susceptible to systemic failures.
The first major finding concerns the physical limitations of agent memory and the resulting phenomenon of Governance Decay. As agents execute long-horizon workflows, their accumulated history—comprising tool outputs, inter-agent messages, and intermediate reasoning—rapidly exceeds the bounded context windows of underlying language models. This necessitates context compaction, a process that summarizes or evicts earlier conversational turns to maintain the agent within its token budget2. Empirical evidence published in June 2026 demonstrates that because compaction algorithms are engineered to optimize for task continuity, they treat standing instructions, runtime policies, and safety constraints as low-salience information, silently erasing them3. This decay is an inherent property of the context management harness rather than the reasoning model itself. Consequently, MATM systems are vulnerable to Compaction-Eviction Attacks, where an adversary injects verbose data to artificially trigger early compaction and force the eviction of defensive constraints, raising policy violation rates from zero to as high as 59% in tested environments3.
The second core finding identifies the maturation and standardization of machine-to-machine capability execution through the Model Context Protocol (MCP). Originally introduced by Anthropic in 2024 and maintained through iterative open-source specifications (including the comprehensive 2025-11-25 release), MCP provides a structured JSON-RPC 2.0 framework that completely decouples the cognitive reasoning engine from external capabilities5. Under this specification, MATM systems operate through a strict host-client-server architecture. Servers expose standard primitives: Resources (read-only datastores identified by URIs), Prompts (parameterized workflow templates), and Tools (executable functions with defined input and output schemas)6. This capability-oriented architecture enables agents to negotiate boundaries dynamically, utilizing advanced features like Sampling, which permits servers to initiate recursive agentic behaviors securely nested within the host's constraints6.
The third finding highlights the pervasive threat of pathological delegation within decentralized MATM systems. Multi-agent workflows are uniquely susceptible to structural orchestration failures, most notably circular delegation loops, also referred to as deadlocks9. When tasks pass indefinitely between agents due to underspecified acceptance criteria, conflicting interpretation of intermediate data, or a lack of global state awareness, the system enters infinite reasoning cycles10. This vulnerability is actively exploited by MAS-specific Telephone Loop attacks, which inject malicious role metadata to convince agents to hand off tasks to one another cyclically, resulting in computational exhaustion and denial of service11. Furthermore, agents frequently exhibit premature completion (or hallucinated completion), falsely signaling the resolution of a delegated task without verifying the actual state of the external environment12.
The final major finding establishes that ambiguity in human instructions can be resolved autonomously without relying on routine human escalation. When confronted with underspecified objectives, autonomous agents equipped with goal-oriented clarification frameworks can systematically align their clarification behavior with ambiguity resolution13. By generating multiple operational hypotheses, checking them against available contextual knowledge, and engaging in structured peer debate, agents can synthesize a precise technical requirement from a vague prompt13. This capacity represents a critical threshold for true autonomy.
However, despite these advances, explicit human prerequisites remain. While agents can decompose tasks and discover tools, human operators are still fundamentally required to inject the initial systemic intent, establish cryptographic trust anchors (such as the Root Certificate Authorities for mutual TLS), and define the immutable governance policies that the agents must enforce15. Concealing these prerequisites leads to brittle system design; acknowledging them allows developers to build robust initialization sequences that transfer authority cleanly from the human operator to the proxy orchestrator.

Comparative Analysis of Task Allocation Strategies

Turning a high-level objective into coordinated work requires robust architectural strategies for task decomposition and delegation. The selected paradigm dictates the system's scalability, its resilience to node failure, and its susceptibility to excessive overhead. The following analysis compares the primary coordination models utilized in modern MATM deployments.

Hierarchical Planners and Task Graphs

Hierarchical planning models rely on a centralized orchestrator, often termed the Manager Agent, responsible for decomposing complex goals into a structured Directed Acyclic Graph (DAG) of executable sub-tasks17. The Manager Agent allocates these tasks based on the specialized skills of worker agents, continuously monitoring execution progress and dynamically revising the task topology in response to runtime exceptions or changing environmental conditions17.
This orchestrator-worker paradigm excels at managing strict dependencies and maintaining deep context over the overarching objective. Because the Manager Agent holds the master state, it effectively prevents duplicated work, ensures clear task ownership, and guarantees that the execution sequence respects topological constraints18. Furthermore, hierarchical systems easily implement capability restrictions, enforcing the principle of least privilege by routing sensitive tasks strictly to verified execution nodes20.
The primary limitation of hierarchical planning is that the central orchestrator becomes both a computational bottleneck and a single point of failure. If the Manager Agent's context window reaches capacity, the cognitive capability of the entire system degrades. Additionally, hierarchical planners struggle in highly dynamic environments where the task topology is not known a priori. Recomputing the combinatorial optimization problem for multi-robot task allocation (MRTA) or complex data workflows every time a new variable emerges is computationally expensive and introduces severe latency21.

Market-Style Allocation and the Contract Net Protocol

Market-based coordination decentralizes task distribution by mirroring human economic systems. The foundational mechanism for this paradigm is the Contract Net Protocol (CNP), an announce-bid-award architecture initially introduced by Reid G. Smith in 1980 and subsequently standardized by the Foundation for Intelligent Physical Agents (FIPA)22. In this model, an agent acting as a manager broadcasts a task announcement detailing specific requirements. Potential contractors across the network evaluate the request against their own capabilities and available bandwidth, submitting formal bids. The manager evaluates these bids, selects the optimal contractor, and awards the task24.
Market-style allocation is inherently highly resilient and scales naturally across heterogeneous, decentralized agent populations19. It addresses the bottleneck issue of hierarchical planners by pushing the cognitive load of capability matching and resource evaluation to the edge of the network. Recent extensions, such as the Competitive Contract Net Protocol (C-CNP), introduce robust mechanisms for environments where agents do not share a common goal26. C-CNP allows for flexible decommitment negotiations, penalties, and comprehensive contract termination phases, which are vital in zero-trust MATM deployments where autonomous agents may belong to different corporate entities26.
However, the market approach introduces significant negotiation overhead. As the system dimension increases, the communication complexity scales exponentially, leading to severe latency in task allocation27. Traditional CNP also assumes cooperative agents and lacks built-in capability verification. To operate securely, market models require complex augmentations, such as the Authenticated Capability Negotiation and Binding Protocol (ACNBP), which utilizes digital signatures and capability attestation to prevent malicious actors from claiming capabilities they do not possess23.

Peer Coordination and Shared Workspaces

Peer coordination models abandon explicit manager roles, allowing agents to communicate directly to synchronize actions and merge results. This approach is frequently implemented alongside shared-workspace (or blackboard) architectures, where multiple agents independently read from and write to a common external memory store or knowledge graph25. This architecture treats the external store as a persistent "disk," while individual agent context windows act as volatile "main memory." Agents use explicit tool calls (such as archival_memory_insert) to move information in and out of active context28.
Shared workspaces eliminate the sequential bottlenecks of strict hierarchical planning, enabling massive parallel exploration. Frameworks utilizing dynamic structured knowledge flows across shared environments have demonstrated significant performance improvements in complex scientific discovery and exploratory research, as multiple agents can build upon intermediate reasoning outcomes in real-time29.
Nevertheless, this paradigm introduces severe dependency management and context preservation challenges. Without explicit task ownership, agents frequently duplicate work, overwrite peer contributions, or suffer from state synchronization delays10. Furthermore, shared workspaces are highly vulnerable to the "lost-in-the-middle" attention deficit. As the common knowledge base expands into hundreds of thousands of tokens, agents silently fail to retrieve critical information buried within large document sets, leading to context rot28.

Delegation Depth and Evaluating Collaboration Costs

A critical operational challenge across all coordination models is determining the optimal delegation depth. Excessive agent spawning occurs when an agent delegates a trivial sub-task—such as a simple regex pattern match or a basic calculation—to a newly instantiated sub-agent rather than executing it locally. This behavior is driven by an over-reliance on architectural modularity.
MATM systems must incorporate self-reflective heuristic checks to recognize when collaboration costs more than a single agent. In market-style allocation, the token cost and time latency of formulating an announce-bid-award cycle often exceed the computational cost of the original task27. High-performance MATM architectures must enforce strict delegation depth limits and equip primary agents with execution environments (like local Python interpreters) to handle highly deterministic, low-complexity tasks without invoking inter-agent communication overhead.

Tradeoff Synthesis and Situational Fit

Architectural Pathologies and Failure Modes

The transition from theoretical MATM coordination to deployed, real-world execution exposes several systemic pathologies that degrade decomposition quality and compromise system integrity. Engineering robust independent systems requires an intimate understanding of these failure modes.

Context Budgets, Context Rot, and Governance Decay

The most insidious failure mode in long-horizon agentic loops is the silent erosion of context. Over the course of a task, an agent accumulates an internal state that includes user queries, intermediate LLM responses, and the results of various tool calls2. When this internal state approaches the hard ceiling of the LLM's context window (which can range from 200,000 to over 1,000,000 tokens in modern frontier models), the agentic framework must trigger context compaction2.
Standard context compaction relies on threshold-triggered summarization or eviction passes designed to compress the transcript. Because the summarizer is optimized purely for task continuity and accuracy, it evaluates standing organizational policies, constraints, and safety preambles as low-salience background information, quietly dropping them from the newly compacted context3. This phenomenon, termed Governance Decay, means that an agent capable of reliably refusing a prohibited action early in its session will execute that exact prohibited action after compaction occurs, because the constraint did not survive the summary3.
Furthermore, even if the absolute context window limit is not reached, agents suffer from Context Rot. As the context grows, the reasoning quality of the LLM degrades due to attention dilution, particularly for information located in the middle of the prompt sequence2. Consequently, agents are forced to perform context compaction at lower thresholds—often around 70% to 75% of the total capacity—to ensure they possess adequate output tokens to write a high-quality summary without experiencing "context anxiety"28.

Pathologies of Delegation: Circular Loops and Conflicting Plans

When high-level objectives are decomposed and delegated across multiple autonomous entities, the system becomes highly vulnerable to orchestration-level faults. The most prominent is the circular delegation loop. This occurs when tasks pass indefinitely between agents without making progress toward resolution9. For example, a host agent may delegate a sub-task via an Agent-to-Agent (A2A) protocol to a specialized peer. If the peer encounters an ambiguity, lacks the required capability, or suffers a tool execution failure, it may lack the semantic context to resolve the error. Consequently, the peer delegates the task back to the originator10. Without global state visibility or strict directed graph enforcement, the originator treats the returned request as a new task, perpetuating a continuous cycle of delegation that halts progress, inflates token costs, and exhausts computational resources10.
This vulnerability is frequently compounded by conflicting plans and task handoff failures. In heterogeneous environments, transferring a task from an agent operating on an A2A coordination protocol to an agent executing via a tool-centric interface like MCP frequently results in malformed schema translations or premature execution10. For instance, Agent A might delegate a data-gathering task to Agent B with the stipulation that execution only proceed after a specific parameter is confirmed. If Agent B misinterprets the state of the shared ledger, it may invoke a critical external tool via MCP before Agent A's pre-requisite confirmation is finalized, resulting in irreversible actions based on incomplete data10.

Premature Claims of Completion

A persistent failure mode in autonomous MATM workflows is premature completion. In this scenario, an agent hallucinates the resolution of a task and incorrectly signals success back to the orchestrator12. This arises when tasks are distributed without mathematically rigorous acceptance criteria, or when the assigned agent lacks the appropriate tools to independently verify the external environment's state post-execution.
Agents trained heavily with human feedback (RLHF) are particularly susceptible to this pathology, as their training naturally optimizes for providing a concluding, helpful-sounding response rather than guaranteeing state consistency12. For example, an agent tasked with provisioning a cloud server may successfully execute the API call but fail to verify whether the server actually booted and passed health checks. To the agent, the generation of the API command constitutes completion; to the system, the task has failed. Standard agent architectures often fail to check the difference between the execution of an action and the materialization of the intended result12.

Resolving Underspecified Objectives

Premature completion is heavily correlated with underspecified objectives. When human operators provide ambiguous high-level goals, agents face latent uncertainty regarding the exact parameters of the intent13. Historically, agents would either repeatedly escalate to the human for clarification—defeating the purpose of an autonomous system—or act directly on the ambiguity, leading to erroneous tool execution13. To navigate this, advanced MATM systems deploy structured ambiguity resolution. By integrating a goal-oriented clarification framework, the agent temporarily halts execution, generates multiple probabilistic hypotheses about the user's intent, and attempts to resolve the ambiguity internally via peer-agent debate or by querying authorized knowledge bases before executing any external action13.

Recommended Design Strategy and Task Lifecycle

To engineer independent MATM services that resolve these pathologies, the architecture must hybridize the strict dependency management of hierarchical task graphs with the scalable capability discovery of standardized protocols like MCP. The recommended design employs a Dual-Protocol Agent Paradigm, integrating MCP for deterministic tool and resource execution with an advanced Agent-to-Agent (A2A) protocol—based on the Contract Net Protocol—for semantic coordination and market-style delegation6.

System Architecture: Proxy and Service Agents

The architecture implements a functional separation between cognitive orchestration and physical execution. Every distinct administrative or corporate domain hosts a Proxy Agent (PA) acting as the intelligent intermediary31. The PA is the sole entity responsible for interfacing with the initial human operator, receiving high-level objectives, performing hierarchical task decomposition, and routing those tasks to specialized Service Agents (SAs). Service Agents form the computational backbone of the ecosystem; they hold specific operational capabilities exposed via MCP and operate autonomously off-chain or in secure enclaves to execute tools, retrieve resources, and format results6.
By forcing all inter-domain communication through Proxy Agents, the system maintains a clear authorization boundary. The PA holds the centralized task graph for its specific domain, strictly preventing duplicated work. Conversely, Service Agents remain stateless between discrete tool invocations, eliminating the risk of conflicting execution plans and context rot at the edge of the network28.

The MATM Task Lifecycle State Machine

To ensure reliable execution and prevent pathologies like circular delegation and premature completion, the system must enforce a rigorous task lifecycle utilizing Message-Action Traces (MAT) as a contract-carrying execution record. A MAT records each run as an immutable sequence of typed steps, including capability negotiations, tool calls, memory writes, and delegation events, augmented with provenance metadata and contract verdicts20.

1. Initiation and Clarification: The PA receives an objective. Before initiating decomposition, the PA executes an autonomous ambiguity resolution routine. It generates operational hypotheses and cross-references them against local context. If ambiguity remains high, the PA initiates a localized debate protocol with specialized peer SAs to refine the objective without human escalation13. The refined, mathematically precise objective is permanently recorded in the MAT.
2. Decomposition and Dependency Management: The PA generates a Task Graph (DAG). Each node represents an atomic task equipped with explicit input schemas, strict acceptance criteria, and tool dependencies. The edges of the DAG mathematically define the execution order, structurally prohibiting circular delegation by strictly enforcing directionality.
3. Discovery and Delegation (Market-Assisted): For each atomic task, the PA queries the network for capable SAs. It uses an extension of the Contract Net Protocol (like ACNBP) for discovery, transmitting the task requirements, expected schemas, and acceptance criteria23. To prevent handoff failures, the delegation message is serialized via JSON-RPC 2.06. The chosen SA accepts the task, establishing a cryptographically binding commitment.
4. Execution and Verification (MCP): The SA utilizes the Model Context Protocol to interact with the external environment. Using MCP's standardized primitives, the SA queries Resources, utilizes Prompts for internal reasoning loops, and invokes Tools to manipulate the state7. Crucially, to mitigate premature completion, the SA cannot claim task resolution until the output passes the pre-defined acceptance criteria, which must be independently verified by a secondary execution environment or an independent evaluator SA12.
5. Aggregation and Context Updates: The SA returns the verified result to the PA. To avoid broadcasting unnecessary internal reasoning, private scratchpads, or proprietary prompt data, the SA only returns the finalized artifact alongside the cryptographically signed Message-Action Trace of its actual tool invocations20. The PA updates the global Task Graph and appends the summarized result to its sliding context window.

Concrete Example: Research, Implementation, and Review

Consider an objective assigned to a PA: "Research the Model Context Protocol 2025-11-25 specification, implement a reference client in Python, and independently review the codebase for security flaws."

• Decomposition: The PA decomposes this into three explicit nodes: Node A (Research), Node B (Implementation), Node C (Review). The DAG enforces that Node C strictly depends on Node B, which strictly depends on Node A.
• Delegation of Node A: The PA delegates Node A to a Research SA via CNP bidding. The Research SA utilizes an MCP connection to query academic databases and GitHub repositories (Resources). It processes the data and outputs a structured Markdown specification document. The PA receives the MAT and the document, marking Node A complete.
• Delegation of Node B: The PA transmits the specification document to a Code Generation SA. The SA uses an MCP Tool to interface with a local Python compiler and filesystem. It iteratively writes code, executing compilation checks locally. If the compiler returns errors, the SA uses MCP to read the traceback and correct the code. Once compilation passes, it signals completion and returns the codebase.
• Independent Review (Node C): The PA delegates the codebase and the original specification to an Auditor SA. The Auditor SA operates in an isolated context without write-access to the original files. It utilizes static analysis tools and vulnerability scanners via MCP Tools.
• Handling Failure Gracefully: If the Auditor SA finds a critical flaw (e.g., inadequate input sanitization on a JSON-RPC endpoint), it does not rewrite the code itself. Instead, it returns a localized failure trace to the PA. The PA receives the failure trace, marks Node B as "Requires Revision," and re-delegates it back to the Code Generation SA, appending the Auditor's trace. Because of the strict DAG enforcement, the Auditor cannot directly delegate to the Coder, entirely preventing an infinite peer-to-peer delegation loop.

Context Budgeting: Deterministic Constraint Pinning

Throughout this entire lifecycle, the agents must meticulously manage their context budgets. Rather than relying on freeform LLM summarization, the system implements structured compaction combined with Constraint Pinning3.
The agent's memory architecture is divided into three distinct regions: a pinned system prefix (containing authorization boundaries, tool definitions, and critical safety rules), a sliding window of recent conversational turns, and a structured summary of older events. When the context reaches approximately 75% capacity, the compaction algorithm summarizes the sliding window into strict predefined categories (e.g., ## Active Goals, ## Files Modified, ## Next Steps)28. However, the compaction algorithm is mathematically prohibited from altering or evicting the pinned prefix3. This structural guarantee ensures zero loss of governance directives over long horizons, permanently solving the Governance Decay pathology.

Prioritized Feature Proposals

To realize the recommended design across independent MATM ecosystems, implementers must prioritize features that secure delegation boundaries, preserve cognitive continuity, and enforce accountability.

Practical Adoption Sequence, Success Criteria, and Unresolved Questions

Deploying a highly autonomous MATM architecture requires a phased approach. Attempting to deploy complex cognitive orchestration before the underlying communication primitives are strictly secured inevitably leads to systemic failure.

Practical Adoption Sequence

1. Standardize Tool and Resource Interfaces (The MCP Layer): Begin by implementing the Model Context Protocol across all external integrations. Transition legacy REST APIs into formal MCP Tools and expose static databases as MCP Resources. This establishes a universal, schema-validated JSON-RPC 2.0 language for all physical interactions, ensuring that capabilities are discoverable and executable under uniform security constraints6.
2. Deploy Context Stabilization: Implement Constraint Pinning and structured context templates across all agents. Fix the compaction threshold at roughly 75% of the total context window. Move timestamps, session IDs, and per-turn metadata into the final user message rather than the prefix to optimize caching and reduce token costs3.
3. Implement the Orchestrator-Worker Hierarchy: Deploy Proxy Agents as the sole interfaces for human objectives. Establish the foundational capability of breaking tasks into strict Directed Acyclic Graphs (DAGs) before allowing any peer-to-peer negotiation. This structural constraint is mandatory to prevent early-stage circular delegation17.
4. Integrate Trace-Based Validation: Roll out the Message-Action Trace (MAT) validation engine. Enforce a strict policy that Proxy Agents will only accept results that include a fully verified MAT, eliminating premature completion and providing an auditable, cryptographic trail for debugging20.
5. Enable Market-Style Delegation and Clarification: Introduce Contract Net Protocol (CNP) bidding for specific sub-tasks where the PA does not have an explicitly mapped SA. Simultaneously, activate the Goal-Oriented Clarification Protocol to allow agents to debate and resolve underspecified tasks autonomously prior to execution13.

Unresolved Questions for Future Implementers

While the proposed architecture mitigates the primary identified failure modes, several theoretical and practical questions remain unresolved within the broader discipline of distributed artificial intelligence.

• Economic Equilibrium in Algorithmic Bidding: In purely autonomous deployments of the Contract Net Protocol, the optimal pricing and resource-staking mechanisms remain highly volatile. Determining how non-fiat computational credits should be allocated, and how to optimize dynamic pricing without leading to resource hoarding by aggressive proxy agents, requires significant game-theoretic research27.
• Cross-Domain Ontology Alignment: While MCP standardizes the transport mechanism and the schema of tools (via JSON-RPC and JSON Schema), the semantic meaning of variables passed between heterogeneous agents from different vendors remains challenging. Standardizing an ontology for agent capabilities without creating rigid, brittle rule sets is an ongoing area of study23.
• Verification of Unbounded Horizon Tasks: Constraint pinning protects immediate policies, but verifying the mathematical correctness of context compaction algorithms over tasks that span months—where the structured summary itself must eventually be summarized recursively—remains empirically unproven at scale2.

Measurable Success Criteria

To empirically validate the deployment of the MATM architecture, future implementers should track the following quantitative criteria across their clusters, relying on system telemetry rather than live adversarial testing:

• Governance Retention Rate: The system must achieve a 0% drop rate of safety constraints and critical standing instructions when subjected to the ConstraintRot benchmark during repeated context compaction cycles3.
• Loop Eradication: The architecture must detect and terminate 99.9% of potential circular delegation sequences within three topological hops, leveraging the MAT validation engine and strict DAG enforcement20.
• Clarification Autonomy Metric: The deployment of goal-oriented clarification must reduce the frequency of human-escalation events for underspecified objectives by at least 60%, while maintaining a hard tool-execution error rate below established baseline thresholds13.
• Task Completion Integrity: The incidence of premature or hallucinated task completions must be reduced to zero for all workflow nodes protected by cryptographic Message-Action Trace contracts12.

Transferability to Other MATM Systems

The strategies outlined in this brief are deliberately domain-agnostic. Because the architecture relies on standardized communication (JSON-RPC 2.0 via MCP) rather than proprietary internal reasoning structures, these recommendations transfer seamlessly to other MATM domains. Whether the agents are orchestrating physical robots on a manufacturing floor, executing decentralized financial transactions, or compiling software, the fundamental requirements for strict dependency graphs, verifiable message-action traces, and immutable context pinning remain universally applicable. Through the rigorous application of defined communication protocols and immutable context management, machine-to-machine ecosystems can transition from experimental novelties into robust, independent infrastructures capable of safe and continuous autonomous operation.

Works cited

1. Agentic Loops in AI Systems - Emergent Mind, https://www.emergentmind.com/topics/agentic-loops
2. Context Compaction Theory - arXiv, https://arxiv.org/pdf/2608.01326
3. Governance Decay: How Context Compaction Silently Erases Safety, https://arxiv.org/html/2606.22528v2
4. Governance Decay: How Context Compaction Silently Erases Safety, https://arxiv.org/pdf/2606.22528
5. What is the Model Context Protocol (MCP)? - Teleport, https://goteleport.com/learn/model-context-protocol/
6. Model Context Protocol (MCP) explained: A practical ... - CodiLime, https://codilime.com/blog/model-context-protocol-explained/
7. Specification - What is the Model Context Protocol (MCP)?, https://modelcontextprotocol.io/specification/2025-11-25
8. MCP Protocol Overview - IBM, https://www.ibm.com/docs/en/quarkus/3.33.x?topic=architecture-mcp-protocol-messages-capabilities-lifecycle
9. Formalizing the Safety, Security, and Functional Properties of ... - arXiv, https://arxiv.org/html/2510.14133v2
10. Formalizing the Safety, Security, and Functional Properties of ... - arXiv, https://arxiv.org/html/2510.14133v1
11. A Study of Attack Surface Evolution in the Transition to Multi-Agent, https://arxiv.org/html/2608.00202v1
12. Done is not when the agent stops. Done is when the goal is met, https://thehard70.pavamana.ai/p2-premature-completion
13. Uncertainty-Aware Clarification in LLM Agents with Information Gain, https://arxiv.org/html/2606.03135v1
14. Generative AI for Managerial Decision-Making under Ambiguity and, https://arxiv.org/pdf/2603.03970
15. Governance Decay, Explained: How Context Compaction Erodes, https://www.truefoundry.com/blog/governance-decay-context-compaction-enterprise
16. Using the Model Context Protocol (MCP) for Intent-Based Network, https://www.ietf.org/archive/id/draft-zm-rtgwg-mcp-troubleshooting-01.html
17. Orchestrating Human-AI Teams: The Manager Agent as a Unifying, https://arxiv.org/html/2510.02557v1
18. Orchestrating Human-AI Teams: The Manager Agent as a ... - arXiv, https://arxiv.org/pdf/2510.02557
19. arXiv:1903.05149v3 [cs.RO] 6 Feb 2020, https://arxiv.org/pdf/1903.05149
20. A Trace-Based Assurance Framework for Agentic AI Orchestration, https://arxiv.org/html/2603.18096v1
21. Learning to Allocate Time-Bound and Dynamic Tasks to Multiple, https://asmedigitalcollection.asme.org/computingengineering/article/24/9/091005/1201342/Learning-to-Allocate-Time-Bound-and-Dynamic-Tasks
22. Contract Net Protocol - Wikipedia, https://en.wikipedia.org/wiki/Contract_Net_Protocol
23. Agent Capability Negotiation and Binding Protocol (ACNBP) - arXiv, https://arxiv.org/html/2506.13590v1
24. AgenTalk Overview - Chiariglione.org, https://www.chiariglione.org/standards/fipa/torino/cfp1/overview.htm
25. A Social Multi-Agent Cooperation System Based on Planning and, https://www.mdpi.com/2078-2489/11/5/271
26. (PDF) Competitive Contract Net Protocol - Academia.edu, https://www.academia.edu/33959573/Competitive_Contract_Net_Protocol
27. Efficient Contract-Net Protocol for Formal Modeling of Multi-Agent, https://journal.uob.edu.bh/bitstreams/608083bf-8fcd-4d9b-9b6c-31c92821d446/download
28. Agent Context Compaction for Long-Running Sessions, https://zylos.ai/research/2026-04-21-agent-context-compaction-long-running-sessions/
29. Advancing Deep Research with Dynamic Structured Knowledge Flow, https://aclanthology.org/2026.acl-long.971.pdf
30. Agentic AI for Robot Control: Flexible but still Fragile - arXiv, https://arxiv.org/html/2602.13081v1
31. Decentralized Multi-Agent System with Trust-Aware Communication, https://www.researchgate.net/publication/398102172_Decentralized_Multi-Agent_System_with_Trust-Aware_Communication
32. Overview - What is the Model Context Protocol (MCP)?, https://modelcontextprotocol.io/specification/draft/basic