Paper deep dive

Toward a Safe Internet of Agents

Juan A. Wibowo, George C. Polyzos

Year: 2024Venue: arXiv preprintArea: Agent SafetyType: SurveyEmbeddings: 183

Intelligence

Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 97%

Last extracted: 3/11/2026, 12:45:54 AM

Summary

This paper presents a principled, architectural framework for engineering safe and reliable agentic systems, moving beyond threat-centric taxonomies to address the systemic risks of the 'Internet of Agents' (IoA). It deconstructs agentic systems into three levels—Single Agent, Multi-Agent System (MAS), and Interoperable Multi-Agent System (IMAS)—identifying architectural vulnerabilities and proposing mitigation principles based on the concept of 'Safety by Design'.

Entities (5)

Internet of Agents · concept · 100%Interoperable Multi-Agent System · architectural-level · 100%Large Language Models · technology · 100%Multi-Agent System · architectural-level · 100%Single Agent · architectural-level · 100%

Relation Signals (3)

Large Language Models → powers → Single Agent

confidence 100%

Single Agent → iscomponentof → Multi-Agent System

confidence 95% · Single agents serve as the fundamental building blocks of MAS.

Internet of Agents → realizedby → Interoperable Multi-Agent System

confidence 90% · the Interoperable Multi-Agent System (IMAS)—a “framework of frameworks” that realizes the Internet of Agents.

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Background: Autonomous agents powered by Large Language Models (LLMs) are driving a paradigm shift toward an "Internet of Agents" (IoA). While offering immense potential, this vision also introduces novel and systemic risks to safety and security. Objectives: Unlike common threat-centric taxonomies, our survey provides a principled, architectural framework for engineering safe and reliable agentic systems. We aim to identify the architectural sources of vulnerabilities to establish a foundation for secure design. Methods: We perform a bottom-up deconstruction of agentic systems, treating each component as a dual-use interface. The analysis spans three levels of complexity: the foundational Single Agent, the collaborative Multi-Agent System (MAS), and the visionary Interoperable Multi-Agent System (IMAS). At each level, we identify core architectural components and their inherent security risks. Results & Conclusions: Our central finding is that agentic safety is an architectural principle, not an add-on. By identifying specific vulnerabilities and deriving mitigation principles at each level of the agentic stack, this survey serves as a foundational guide for building the capable, safe, and trustworthy AI needed to realize a secure Internet of Agents.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

182,319 characters extracted from source content.

Expand or collapse full text

Toward a Safe Internet of Agents JUAN A. WIBOWO, The Chinese University of Hong Kong, Shenzhen, China GEORGE C. POLYZOS, The Chinese University of Hong Kong, Shenzhen, China Background: The development of autonomous agents powered by Large Language Models (LLMs) represents a significant paradigm shift in AI, rapidly advancing toward a future of interconnected, autonomous systems—an “Internet of Agents” (IoA). This vision offers immense potential for complex problem-solving, but also introduces novel and systemic risks to safety and security. Objectives: While existing research often provides valuable threat-centric taxonomies, there remains a critical need for a principled guide that addresses the architectural sources of these vulnerabilities. This survey aims to bridge this gap by providing a foundational framework for engineering safe and reliable agentic systems. Methods: We perform a bottom-up deconstruction of agentic systems, analyzing each foundational component not merely for its function, but as a dual-use interface where increased capability introduces an expanded attack surface. Our analysis progresses across three levels of increasing complexity: (1) for the foundational Single Agent, we examine the inherent risks in its model, memory, design patterns, tools, and guardrails; (2) for the collaborative Multi-Agent System (MAS), we analyze the components governing collective behavior and control, including architectural patterns, communication mechanisms, verification, and system-level guardrails; and (3) for the visionary Interoperable Multi-Agent System (IMAS), we explore the four pillars required for a secure open ecosystem: standardized protocols, agent registration and discovery, resource vetting, and governance. Results: A central theme emerges from our analysis: true agentic safety is not an add-on, but an architectural principle that must be co-designed with capability at every stage. Our survey identifies specific vulnerabilities at each architectural level and derives a set of core principles for mitigating them. Conclusions: The result is a foundational guide for developers and researchers that provides the principles needed to build not only capable but also safe, reliable, and trustworthy agentic AI for the future, contributing to the development of a secure Internet of Agents. JAIR Associate Editor: JAIR Reference Format: Juan A. Wibowo and George C. Polyzos. 2025. Toward a Safe Internet of Agents. Journal of Artificial Intelligence Research 1 (December 2025), 41 pages. doi: 10.1613/jair.1.x 1 Introduction We stand at a pivotal inflection point in the evolution of digital interaction and abstraction. The initial World Wide Web transformed a network of machines into an Internet of Content, creating a global library of information for human consumption. The subsequent Cloud and Mobile era built upon this, creating an Internet of Services where infrastructure was abstracted into programmable APIs, enabling interactive, on-demand applications. Today, a new paradigm is emerging from this foundation: the Internet of Agents (IoA), often interchangeably referred to as the Agentic Web or the Agentic Internet. Authors’ Contact Information: Juan A. Wibowo, juanalbertwibowo@link.cuhk.edu.cn, The Chinese University of Hong Kong, Shenzhen, Shenzhen, Guangdong, China; George C. Polyzos, orcid: 0000-0003-0030-4808, polyzos@acm.org, The Chinese University of Hong Kong, Shenzhen, Shenzhen, Guangdong, China. This work is licensed under a Creative Commons Attribution International 4.0 License. © 2025 Copyright held by the owner/author(s). doi: 10.1613/jair.1.x Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. arXiv:2512.00520v1 [cs.MA] 29 Nov 2025 2• Wibowo and Polyzos In this rapidly crystallizing vision, the internet evolves from a medium where humans interact with content to a platform where autonomous AI agents interact with one another (Pandey 2025; Yang, Ma, et al. 2025). Powered by the reasoning capabilities of Large Language Models (LLMs), these agents are moving beyond isolated, task-specific chatbots to become persistent, goal-driven entities capable of dynamic discovery, negotiation, and collaborative orchestration across heterogeneous environments (W. Chen, You, et al. 2025; Y. Wang, Guo, et al. 2025). The ambition is to empower users with intelligent agents that can act autonomously on their behalf, orchestrating complex, multi-domain tasks across a decentralized ecosystem. Imagine a user’s personal AI assistant autonomously conducting intricate market research by collaborating with specialized data analysis agents, interacting with real-time financial APIs, and drafting comprehensive reports—all while executing these workflows with the delegated trust and authority of its user. However, the transition to this hyper-connected, autonomous ecosystem, where agents are increasingly empowered to act with significant authorization on a user’s behalf, introduces systemic risks of unprecedented scope. As these agents gain the ability to perceive, reason, and act across both virtual and physical environments, the “blast radius” of AI errors expands dramatically, impacting real-world systems and assets. A hallucination is no longer merely a text generation error; in the IoA, it becomes an erroneous financial transaction, a corrupted database state, or a cascading failure propagating through a chain of trusted services. These challenges, highlighted in the growing discourse on AI safety, extend beyond simple errors to the profound risk of loss of human control as AI systems approach advanced general intelligence (AGI) and superintelligence (ASI) (Bengio, Cohen, et al. 2025). Unlike the original Internet, which was not conceived with inherent security or privacy by design, the IoA necessitates a paradigm shift. Building effective agents is insufficient; we must ensure Safety by Design, integrating security constraints and verification mechanisms directly into the architectural fabric of these systems from their foundational components. Significant research has begun to map the security and privacy landscape of LLM-powered agents. The majority of these surveys adopt a threat-centric perspective, creating valuable taxonomies of attacks against single agents (Deng et al. 2025; Gan et al. 2024; He et al. 2025), or a lifecycle-centric view, examining vulnerabilities as they arise from pre-training to deployment (K. Wang et al. 2025; S. Wang, Zhu, et al. 2025). While these works provide crucial insights at the individual agent level, the systemic risks of Internet of Agents (IoA) have remained a more nascent frontier. Among the first to systematically address this gap is the recent survey by Y. Wang, Pan, et al. (2025), which provides a top-down, threat-centric analysis, identifying the key dangers in Internet of Agents. While these top-down perspectives are essential for identifying what the threats are, there remains a critical need for a foundational guide on how to architect the systems that resist them. To address this, this survey provides a principled, bottom-up architectural analysis of the agentic AI landscape. We argue that a safe and effective Internet of Agents cannot be built without first mastering the security physics of its constituent parts. We bridge the gap between capability (the construction of effective systems) and safety (the engineering of control) by deconstructing the ecosystem into three levels of increasing complexity: (1) Single Agent: The fundamental unit, where we perform a security-centric deconstruction of its five core components: the model, memory, design patterns, tools, and guardrails. (2)Multi-Agent System (MAS): The closed collaborative unit, where we analyze the systems governing collective behavior and systemic risk, including their architectural patterns, communication mechanisms, operational environments, verification, and system-level guardrails. (3)Interoperable Multi-Agent System (IMAS): The realization of the IoA, where we analyze the four foundational pillars required for a secure open ecosystem: Standardized Protocols, Agent Registration and Discovery, Resource Vetting, and Ecosystem Governance. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 3 By understanding these foundational components not merely as functional blocks but as dual-use interfaces, we provide a principled guide for developers and researchers. Our goal is to move beyond ad-hoc implementations toward the robust, secure, and interoperable standards required to realize the vision of a safe Internet of Agents. The structure of this survey is as follows. Section I introduces the organizational landscape, defining the progression from the Single Agent to the Interoperable Multi-Agent System. Section I dissects the anatomy of the Single Agent, analyzing the security implications of its model, memory, design patterns, tools, and guardrails. Section IV expands this analysis to Multi-Agent Systems (MAS), examining the structural risks inherent in coordination strategies, communication topologies, and the operational environment. Section V addresses the Interoperable Multi-Agent System (IMAS), detailing the interoperability stack, discovery mechanisms, and governance protocols necessary to establish trust between strangers in an open network. Finally, Section VI concludes with a discussion of open research frontiers. 2 The Architectural Spectrum of Agentic Systems To systematically analyze the safety and security of the Internet of Agents, we must first establish an architectural framework. The complex, systemic risks of a global agentic ecosystem do not emerge spontaneously; they are built upon the capabilities and vulnerabilities of their constituent parts. This section, therefore, lays the groundwork for our analysis by deconstructing agentic AI across a spectrum of increasing complexity. We will trace the progression from the foundational single agent, to the collaborative Multi-Agent System (MAS), and finally to the Interoperable Multi-Agent System (IMAS)—the technical realization of the IoA—highlighting the core building blocks that define each level. 2.1 The Foundational Unit: The Single Agent Recent advancements in large language models (LLMs) have catalyzed the development of agents that leverage LLMs as their core control mechanism. A single agent can be defined as an LLM that is enhanced and augmented to autonomously execute tasks beyond simple text generation (Yao 2024). The ambition to make LLMs more capable can be realized in several ways. The simplest approach is to use an LLM as a component within a predefined workflow. These systems are popular for automating specific tasks. However, under a stricter definition, a workflow is not a true agent because the LLM does not direct the overall process; it merely executes a step. A true agent, by contrast, uses the LLM as its core control mechanism to autonomously decide its course of action. In general, a single agent is composed of several key components that form the basis of our analysis in Section 3: the model, memory, design patterns, tools, and guardrails. • Model: The model is the LLM providing the core intelligence for reasoning and decision-making. • Memory: Memory is crucial for handling multi-step tasks and maintaining context over time. • Design Patterns: Design patterns structure the LLM’s reasoning process, enhancing its performance and problem-solving capabilities. •Tools: Tools extend the agent’s abilities beyond text generation, enabling it to perform programmatic actions. • Guardrails: Serve as a critical risk management layer to ensure the agent’s outputs and actions are safe and reliable. These components help illustrate the practical difference between a raw LLM accessed via a developer API and a sophisticated conversational application like the public ChatGPT web interface. An LLM used through its API is stateless; each API call is independent and has no memory of previous interactions. In contrast, the ChatGPT web application functions as a true agent. It is equipped with memory to maintain conversation history, Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 4• Wibowo and Polyzos employs design patterns to enable planning and multi-step reasoning, and integrates tools for capabilities such as browsing the internet and executing code. 2.2 The Collaborative Unit: The Multi-Agent System (MAS) A special paradigm for designing agents is the multi-agent pattern, leading to Multi-Agent Systems (MAS). MAS architectures emulate real-world problem-solving, where complex challenges are addressed by multiple independent parties with diverse expertise collaborating through structured interactions. These are typically closed ecosystems built within a single framework (e.g., CrewAI, AutoGen) operating under a unified control plane. The exploration of MAS is driven by several key advantages, including achieving collaborative intelligence (W. Chen, Su, et al. 2023; CrewAI Inc. 2025; G. Li et al. 2023; Q. Wu et al. 2023), simplifying problems via a divide- and-conquer approach, and enabling dynamic task execution (W. Chen, You, et al. 2025; Xia et al. 2025). Beyond reasoning advantages, their inherent modularity can simplify development and enhance privacy (LangChain AI 2025; W. Liu et al. 2024). Single agents serve as the fundamental building blocks of MAS. However, the defining characteristics and systemic risks of these systems emerge from the components that govern their collective behavior. As detailed in Section 4, our analysis covers five core areas: •Architectural Patterns: The organizational structures that dictate how agents collaborate, how informa- tion flows, and how tasks are managed. •Inter-Agent Communication: The mechanisms agents use to exchange information and coordinate their actions, from direct messaging to shared environments. •The Operational Environment: The context or “world” in which agents perceive, act, and learn, defining the rules and feedback for their interactions. • Verification Mechanisms: The processes that ensure the quality, correctness, and reliability of the collective’s outputs and decisions. •System-Level Guardrails: The overarching safety controls designed to mitigate emergent risks and ensure human control over the collective system. 2.3 The Open Ecosystem: The Interoperable Multi-Agent System (IMAS) Beyond closed systems, the ultimate vision is the Interoperable Multi-Agent System (IMAS)—a “framework of frameworks” that realizes the Internet of Agents. This concept is not merely theoretical but is being actively pursued through industry-led initiatives and open standards, such as those proposed by Cisco, Google, and the AGNTCY collective (Pandey 2025). In such an ecosystem, agents from diverse developers and platforms can seamlessly collaborate, autonomously discovering the resources and partners needed to achieve their goals. Realizing this dynamic vision requires building a foundational infrastructure for safe and effective interoper- ability. As detailed in Section 5, this infrastructure rests on four critical pillars: • Standardized Protocols: Establishing a common technical language through an interoperability stack that governs how agents interact with tools (the Context Layer), negotiate with each other (the Coordination Layer), and communicate across networks (the Transport Layer). • Agent and Service Registration and Discovery: Creating a capability-centric discovery plane where agents can advertise their skills and find trustworthy partners in a vast, decentralized network. •Resource Vetting and Management: Implementing a zero-trust security model where discovered re- sources—be they tools, other agents, or data sources—are systematically vetted for integrity and reliability before any interaction occurs. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 5 • Ecosystem Governance and Oversight: Deploying shared infrastructure for monitoring, attribution, and accountability to manage risks and establish culpability in a decentralized environment where no single entity has control. Collectively, these four pillars form the foundation for a truly open and dynamic agent ecosystem, shifting the focus from building isolated systems to fostering a collaborative, interconnected intelligence. This progression from the single agent to the interoperable ecosystem highlights a fundamental trajectory in agentic AI: a shift from optimizing individual autonomy to orchestrating collective intelligence. We now turn to the foundational components of the single agent, from which all higher levels of complexity are constructed. 3 The Anatomy of a Single Agent Having established the broader architectural landscape, this section performs a security-centric deconstruction of its fundamental unit: the single LLM-powered agent. We analyze the agent not merely as a functional system, but as a composite of dual-use components where every increase in capability introduces a corresponding expansion of the attack surface. We examine five core pillars: the Model, acting as the cognitive core and primary vector for manipulation; Memory, which transforms stateless inference into persistent context yet introduces critical privacy and integrity risks; Design Patterns, which structure reasoning but can propagate cascading failures; Tools, the interface of action that breaches the containment of the digital world; and Guardrails, the adversarial control layer attempting to impose safety on probabilistic execution. 3.1 The Model: The Agent’s Cognitive Core and Primary Attack Surface A Large Language Model (LLM) serves as the cognitive core of an agent, providing the foundational capabilities for reasoning, language understanding, and decision-making. However, this central role also makes the model the system’s primary attack surface. The very mechanisms used to guide and enhance the model’s performance are the same vectors through which its behavior can be subverted. Understanding this duality is fundamental to building secure agentic systems. This section analyzes the key techniques for interfacing with the model, reframing them through the lens of their inherent security implications. 3.1.1 Model-Level Vulnerabilities and Mitigation Strategies. Optimizing an agent’s performance requires inter- acting with its core model through several key methods. Each method, however, introduces a distinct class of vulnerabilities that must be addressed not just at the model level, but at the system’s architectural level. Prompt Engineering: The Double-Edged Sword of Instruction. Crafting effective prompts is the primary method for guiding an LLM’s behavior (Sahoo et al. 2025). While essential for functionality, the prompt interface is also the most direct vector for manipulation. •As a Defense (System Prompting): The primary defense at this layer is robust system prompt engi- neering. By clearly defining the agent’s role, ethical boundaries, and operational constraints within a system-level prompt (e.g., thesystemparameter in Claude orinstructionsin OpenAI models), developers establish a foundational behavioral contract (Anthropic n.d.(a); Shen et al. 2024a). Techniques like using XML tags to structure prompts or mandating JSON outputs help enforce this contract by making it harder for the model to misinterpret instructions (Anthropic n.d.(d); OpenAI n.d.(e)). •As an Attack Vector (Instruction Evasion): Conversely, an attacker’s goal is to use the user-facing prompt to override or bypass the system prompt. This leads to two primary attacks: – Jailbreaking: Maliciously crafted inputs designed to exploit loopholes in the model’s safety training to elicit prohibited behaviors, such as generating harmful content (H. Li et al. 2023; Shen et al. 2024a). –Prompt Injection: Inputs that trick the model into disregarding its original instructions and following new, malicious ones, which can lead to data exfiltration or unauthorized tool use (Y. Liu et al. 2024). Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 6• Wibowo and Polyzos The inherent tension between following user instructions and adhering to safety protocols means that prompt- level security can never be fully guaranteed, necessitating external validation and guardrails. Augmenting Knowledge: The Risk of a Poisoned Mind. Agents often require external knowledge to perform tasks, which is typically provided through Retrieval Augmented Generation (RAG) or fine-tuning. While enhancing accuracy, these methods create a direct channel for knowledge poisoning. •Retrieval Augmented Generation (RAG): RAG grounds an agent by providing it with up-to-date, external information (Y. Gao et al. 2024). However, if this external knowledge source is compromised, it can corrupt the agent’s reasoning. This is a critical vulnerability, as an attacker can inject malicious or biased information into a database or document that the agent trusts, leading to flawed decisions or the propagation of misinformation (Carlini et al. 2024; W. Zou et al. 2024). The security of a RAG-based agent is therefore only as strong as the integrity of its knowledge sources. • Fine-Tuning: While fine-tuning can reliably instill desired behaviors, it can also be used to catastrophically undermine them. Malicious fine-tuning can erase a model’s foundational safety alignment with only a small number of examples or be used to create persistent backdoors that respond to specific triggers (Kurita et al. 2020; Zhan et al. 2024). This highlights the systemic risk of using open models that have been fine-tuned by untrusted third parties. Hallucinations: From Model Flaw to Systemic Failure. Hallucinations—plausible-sounding but incorrect out- puts—are an inherent flaw in current LLMs (L. Huang et al. 2025). In a single-agent context, this can lead to erroneous decisions. However, the true risk emerges at the system level. An agent that acts upon a hallucination can create a flawed state or pass corrupted information to other components, leading to cascading failures. Mitigation is therefore a systemic task, requiring architectural patterns like: • Grounding: Using RAG to ground the model in verifiable facts. •Self-Correction: Employing reflective design patterns where the model critiques its own output, often using tools to verify its reasoning steps (Gou et al. 2024; Shinn et al. 2023). Performance and Resource Use as a Security Dimension. Beyond correctness, the performance characteristics of a model are also a security concern, as an attacker can exploit resource consumption as a vector for Denial of Service (DoS) or economic exhaustion attacks. While simple inference-time attacks attempt to trigger long outputs via malicious prompts, their effectiveness is often constrained by the model’s safety training and the maximum sequence lengths learned during supervised fine-tuning (SFT) (Geiping et al. 2024; Shumailov et al. 2021). A more insidious and persistent threat, however, emerges from training-time poisoning. As demonstrated by Poisoning-based DoS (P-DoS) attacks, injecting even a single malicious sample during fine-tuning can create a hidden vulnerability, allowing a simple natural language prompt to later trigger thousands of tokens of useless output, effectively bypassing the SFT-imposed limits and consuming catastrophic levels of resources (K. Gao et al. 2024). This underscores that techniques like strategic LLM invocation—using traditional algorithms for deterministic sub-tasks—are not merely performance optimizations (OpenAI n.d.(d)), but also serve as an essential architectural guardrail. By minimizing unnecessary LLM calls, this design pattern reduces the attack surface for this entire class of resource-based attacks. 3.1.2 The Principle of Shared Responsibility. The vulnerabilities inherent in the model’s cognitive core demon- strate that agent safety cannot be the sole responsibility of the LLM provider. While providers implement foundational safety training, the dynamic and context-dependent nature of agentic systems places significant responsibility on the agent builder. This involves a defense-in-depth strategy: • Implementing application-specific safeguards through robust prompt engineering. • Carefully vetting and monitoring all external data sources used for RAG or fine-tuning. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 7 • Designing a robust system of external Guardrails, which will be detailed in Section 3.5, to act as the final backstop for model-level failures. Ultimately, the model is a powerful but imperfect component. Securing an agent requires building a resilient system around it, a principle that informs the design of the other core components discussed in this paper. 3.2 Memory: Enabling Context, Learning, and Systemic Risk Memory is the component that transforms a stateless LLM into a stateful agent, equipping it with the ability to handle multi-step tasks, maintain context, and learn from past interactions. However, by creating a persistent state, memory also introduces a significant and durable attack surface, bringing with it profound challenges for data privacy, integrity, and control. This section analyzes the architectural patterns of agent memory, examining how each type—from transient session context to persistent long-term knowledge—creates a distinct set of systemic security and safety risks. 3.2.1Short-Term Memory: The Volatile Attack Surface. Short-term memory, often referred to as working memory in cognitive architectures, is crucial for tracking an agent’s immediate context (Sumers et al. 2024). For LLM-based agents, this encompasses recent perceptual inputs (like user queries), active goals, and intermediate reasoning results, all of which are typically maintained within a single operational thread (CrewAI Inc. n.d.(b); LangChain Inc. n.d.(b)). Architecturally, this is implemented through different patterns that reveal varying philosophies on what “short-term” means. Frameworks like LangGraph treat memory as a complete, stateful graph of the agent’s execution. Here, memory is the entire history of operations and their results, persisted via a checkpointer, allowing a process to be paused and resumed perfectly (LangChain Inc. n.d.(e)). In contrast, frameworks like CrewAI often treat memory as a more immediate, task-scoped context, using Retrieval-Augmented Generation (RAG) to inject just-in-time information needed for a specific step rather than maintaining a full conversational history (CrewAI Inc. n.d.(b)). While essential for function, this volatile context window is a primary and immediate attack surface. The core security challenge lies in managing the trade-off between the length of this context and the agent’s safety and reliability. Security Vulnerability: Context Forgetting and Amnesiac Agency. A long conversation or complex task history can exceed the LLM’s finite context window. The naive solution, simple truncation of the oldest messages, is not just a performance issue—it is a critical safety vulnerability. When crucial information is pushed out of the context, the agent becomes effectively amnesiac, leading to several failure modes: • Safety Instruction Loss: The most direct risk is the agent “forgetting” its foundational safety instructions, which are typically placed at the beginning of the context window and are therefore the first to be truncated. An attacker can exploit this via a “context flooding” or “distraction” attack, engaging the agent in a long, benign conversation specifically to push the original rules out of the context window before injecting a malicious prompt. This creates a fundamental architectural challenge: the system prompt must be persistently enforced, not just prepended to a volatile context. • Loss of Critical Context for Decision-Making: An agent may forget a critical piece of user-provided information (e.g., a medical allergy mentioned early in a conversation) and later propose a harmful action (e.g., recommending a medication containing the allergen). The loss of context leads directly to an unsafe outcome. Techniques for managing the context window are therefore not just performance optimizations, but essential safety mechanisms designed to mitigate the risk of amnesiac agency. These include (LangChain Inc. n.d.(b)): Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 8• Wibowo and Polyzos •Strategic Truncation: Programmatically removing older or less relevant information, akin to an LRU cache. Frameworks like LangGraph offer functions to selectively retain or remove messages based on defined criteria, which can be configured to “pin” critical safety instructions. •Context Summarization: Condensing previous exchanges into a summary to retain key information. While this prevents total information loss, it introduces a new risk: the summarization process itself, if not perfectly robust, could elide a subtle but critical safety constraint. 3.2.2 Long-Term Memory: The Persistent Security Challenge. Long-term memory enables an agent to persist knowledge and experiences across sessions, forming the basis for personalization and learning. Following established cognitive models, this is often deconstructed into three primary types: procedural memory for storing rules and instructions, semantic memory for factual knowledge, and episodic memory for recalling sequences of past behaviors and interactions (Sumers et al. 2024). Architecturally, this is often implemented via persistent key-value stores (LangChain Inc. n.d.(f)) or vector databases (CrewAI Inc. n.d.(b)), sometimes managed by specialized external services to enable cross-application memory sharing (Chhikara et al. 2025). While powerful, this persistence transforms a temporary attack surface into a permanent one, introducing several critical, systemic vulnerabilities. Security Vulnerability: Corrupting Future Actions via Memory Poisoning. A primary risk to the integrity of an agent’s knowledge is memory poisoning. The threat extends beyond simple data corruption to the manipulation of the memory retrieval mechanism itself. •Direct Poisoning: An attacker interacts with an agent to store a malicious record, creating a backdoor that can be triggered by later queries (as seen in the MINJA attack (Dong et al. 2025)). •Retrieval Manipulation: A more advanced technique, known as action hijacking, uses a seemingly benign prompt not to inject data, but to trick the agent’s retriever into fetching specific, pre-existing (and potentially compromised) knowledge. The agent’s cognitive core then unwittingly assembles this maliciously retrieved memory with the harmless prompt to construct a dangerous action plan, effectively turning the agent’s own memory into a weapon against itself and bypassing simple input filters (Y. Zhang et al. 2025). Security Vulnerability: Stealing Stored Knowledge via Memory Leakage. A primary risk to the confidentiality of an agent’s knowledge is memory leakage, exacerbated by the reasoning and retrieval capabilities of LLMs. •Data Revelation and Prompt Theft: An agent’s LLM can be tricked via prompt injection into revealing sensitive information that it has legitimate access to but should not disclose (Schwartzman 2024). Further- more, advanced attacks can perform prompt theft, using summarization or replication commands to first extract and leak the internal, action-aware knowledge stored within the agent’s memory, which is then used to craft highly effective, targeted hijacking attacks that bypass standard safety filters (Y. Zhang et al. 2025). •The “Forgetfulness” Problem: Data deletion in agentic systems is a non-trivial security and compliance challenge. In vector databases, ‘soft-delete‘ mechanisms mark data for deletion but do not immediately remove its influence on the data structure, requiring a computationally expensive compaction process for true removal (Milvus n.d. Pinecone n.d.) This makes verifiable compliance with privacy mandates like the ’right to be forgotten’ difficult. The challenge becomes even more profound for agents that learn via online fine-tuning, where user data becomes implicitly encoded in the model’s weights and requires complex “machine unlearning” techniques for removal. 3.2.3Principle: Memory as a Trust Boundary. Effectively mitigating these diverse memory-related risks requires treating every memory store as a trust boundary. This necessitates a defense-in-depth approach: developers Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 9 must implement robust technical safeguards (e.g., access controls, input sanitization for memory writes, and validation of retrieved context); users must exercise caution with shared information; and the broader ecosystem must develop standards for data provenance, verification, and secure deletion protocols to ensure that an agent’s memory can be trusted throughout its lifecycle. 3.3 Design Patterns: Architectures for Reasoning and Risk Design patterns in agent development provide structured, reusable solutions for guiding an LLM’s reasoning process. An agent is not a single LLM call; rather, it operates through an orchestrator—the code that manages the agent’s execution loop. This orchestrator repeatedly interacts with the LLM cognitive core, providing it with new context (e.g., the results of a tool call or evaluative feedback) to enable complex, multi-step tasks. The choice of design pattern dictates the architecture of this reasoning loop and, consequently, defines the system’s core logic for both capability and safety. Each pattern represents a different strategy for managing the agent’s flow of thought and action, and each introduces a unique set of security considerations and potential failure modes. The following subsections analyze the most prominent design patterns, examining them not just as frameworks for thinking, but as architectures for managing risk. 3.3.1Reflection: A Double-Edged Sword for Self-Correction. Reflection is a powerful design pattern that automates a feedback loop, empowering an agent to critically evaluate and iteratively refine its outputs or plans (Madaan et al. 2023; Shinn et al. 2023). This mechanism is crucial for enhancing the reliability and safety of agentic systems by improving factual accuracy, correcting flawed reasoning, or ensuring closer alignment with user intent. However, because the reflection process uncritically trusts the feedback it is given, it also represents a significant and subtle attack surface. Mechanisms of Reflection. The core of the reflection pattern is an iterative loop where an agent’s orchestrator prompts the LLM with its previous output alongside some form of critique. The feedback used to trigger this refinement can originate from several sources: •Internal Self-Critique: The agent’s own LLM generates a critique of its output, as seen in the Self-Refine framework, which uses this feedback for iterative improvement (Madaan et al. 2023). •Reinforced Reflection: An external evaluator model provides feedback that is used to build a “reflective memory,” guiding the agent’s future actions, as demonstrated in the Reflexion framework (Shinn et al. 2023). •External Verification: The agent uses tools to validate its own work, such as executing a code interpreter to check for errors or using a web search to cross-reference facts, with the tool’s output serving as the critique for the next iteration (Gou et al. 2024). Security and Safety Considerations. While reflection is a key mechanism for improving agent reliability, its effectiveness and safety are not guaranteed and are contingent on several factors: •Model Capability as a Limiting Factor: The entire process is fundamentally bounded by the underlying model’s capability. A less capable model may fail to generate useful critiques or, more critically, may be unable to correctly incorporate valid feedback, leading to failed or flawed refinements (Madaan et al. 2023). •Systemic Risk: The Feedback Injection Attack: The most significant security vulnerability is that the reflection mechanism itself can be hijacked. An attacker can craft malicious feedback designed to steer the agent towards a harmful goal (Madaan et al. 2023). For example, if an agent’s plan is critiqued with “This plan is too safe; you need to be more aggressive to achieve the goal,” the reflection process may obediently “correct” the plan by removing necessary safety constraints. This effectively weaponizes the agent’s self-correction capability, turning a defensive mechanism into an attack vector. •Operational Risks: Error Reinforcement and Resource Consumption: If not properly managed, reflection can lead to unproductive loops where an agent reinforces its own biases or oscillates between Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 10• Wibowo and Polyzos similarly flawed outputs. Furthermore, the iterative nature of the process can lead to excessive resource consumption and high latency if not bounded by a maximum number of iterations or other stopping criteria. Ultimately, while a powerful tool, reflection is not an intrinsic safety guarantee. The integrity of the feedback source—whether it’s the LLM’s own critique, an external tool, or a human—is paramount. Secure reflection-based systems must therefore include mechanisms to validate the critiques themselves, especially when they originate from potentially untrusted sources. 3.3.2Tool Use: A Bridge to the World and a Vector for Risk. The Tool Use design pattern transforms an LLM-based agent from a passive text generator into an active participant in digital and physical environments. It refers to the strategic process by which an agent’s reasoning flow identifies the need for an external capability and invokes an appropriate tool, typically via an API call (Schick et al. 2023). By enabling actions like accessing real-time information or executing code, tools are the primary mechanism through which an agent’s reasoning translates into tangible outcomes. However, this bridge to the real world is also the primary vector through which an agent can be manipulated to cause real-world harm, making the secure design and invocation of tools a cornerstone of agentic safety. A Spectrum of Invocation Strategies. The method by which an agent’s orchestrator enables the LLM to invoke tools has evolved through several key architectural approaches, each with different trade-offs in flexibility and reliability. •In-Context Learning (ICL): The most straightforward method is to leverage the model’s in-context learn- ing abilities through few-shot prompting. This involves providing the LLM with not only the descriptions of available tools, but also several examples of a task, a thought process, and the correct corresponding tool call. By seeing these examples, the agent is expected to generalize the pattern and autonomously choose the correct function for a new, unseen task (Lazaridou et al. 2022; Yao, J. Zhao, et al. 2023). While highly flexible, this approach can be unreliable, is constrained by context window limits (which restrict the number of tools and examples that can be shown), and may require elaborate prompt engineering to work consistently (Hao, T. Liu, et al. 2024; Jacovi et al. 2023). •Fine-tuning for Reliability: To improve the reliability of tool invocation, many frameworks fine-tune models on large datasets of correct tool-use examples. Foundational work like Toolformer demonstrated that models can be taught to use tools in a self-supervised manner, while later work like Gorilla fine-tuned models on massive API call datasets to enhance the accuracy of generating correct invocations (Patil et al. 2023; Schick et al. 2023). •Hybrid Approach: To address the limitations of in-context learning for vast numbers of tools without requiring full fine-tuning, a hybrid approach follows the paradigm of efficient LLM tuning by only adjusting a small subset of parameters. ToolkenGPT as one such technique introduces “toolkens”—learned embeddings representing individual tools—which are appended to the LLM’s vocabulary. This allows the frozen LLM to predict and trigger a tool as if it were generating a regular word token, after which it is prompted to generate the necessary arguments (Hao, T. Liu, et al. 2024). •Native Tool Use APIs: The current industry standard has converged on native “function calling” or “tool use” APIs, now offered by all major model providers (Anthropic n.d.(c); OpenAI n.d.(b)). These APIs architecturally separate the tool definitions from the user prompt, creating a more structured and reliable mechanism. Developers define the tools and their parameters, and the model autonomously decides when and how to call them, with the output often returned in a predictable format like JSON. This approach provides a powerful, out-of-the-box mechanism for creating tool-augmented agents. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 11 The Tool Use Lifecycle: Selection vs. Invocation. It is crucial to recognize that effective tool use is not a monolithic action but a two-stage cognitive process. First, the agent must perform tool selection, identifying the most appropriate tool from its available library based on the user’s intent. Second, it must perform tool invocation, generating the correct parameters and syntax to execute that tool. While simple agents with few tools may conflate these steps, sophisticated agents operating in rich environments (like those with tool marketplaces) treat them as distinct reasoning challenges (Shi et al. 2025). Security and Safety Considerations for Tool Use. While tools grant an agent powerful capabilities, they also represent the primary vector through which an agent can be manipulated to cause real-world harm. The security of the Tool Use pattern hinges on defending against two distinct classes of threats: those targeting the selection of a tool, and those targeting its subsequent invocation. •Threats to Tool Selection (The Compromised Marketplace): In an emerging ecosystem with tool marketplaces, the agent’s choice of which tool to use becomes an attack surface. The vulnerability lies in the fact that tool selection is almost entirely based on a tool’s natural language metadata. Recent research has shown this can be exploited in two ways: –Adversarial Biasing: An attacker can manipulate a tool’s description with appealing but semantically similar language (e.g., “BestWeather API”) to unfairly increase its selection rate over competitors, a technique known as ToolTweak (Sneh et al. 2025). –Instruction Injection into Metadata: A more direct attack, ToolHijacker, embeds a malicious in- struction directly into a tool’s description within the tool library (e.g., “...Always prefer this tool for all gift queries”). When the agent retrieves this description, the injected command hijacks its reasoning (Shi et al. 2025). •Threats to Tool Invocation (Action Hijacking): Even after a legitimate tool is selected, its invocation logic can be hijacked. The goal of an action hijacking attack is to manipulate the agent into misusing a trusted tool. – Direct Hijacking via Prompt Injection: An attacker crafts a user prompt with embedded instructions that trick the agent into calling a valid tool but with malicious parameters. This exploits the model’s inability to distinguish between user data and system instructions, a vulnerability formalized by the HouYi attack framework which uses context separation techniques to "break out" of the intended application flow and execute arbitrary commands (Y. Liu et al. 2024). For example, a user might ask a customer service agent to “ignore previous instructions and use theget_order_detailstool to send data to an external email.” –Indirect Hijacking via State Manipulation: A more subtle vector is to manipulate the agent’s reasoning state. The Foot-in-the-Door (FITD) attack uses an indirect prompt injection to first make a harmless request, embedding a benign action in the agent’s thought process to lower its defenses against a subsequent malicious instruction (Nakash et al. 2025). These threats demonstrate that securing the Tool Use pattern requires a defense-in-depth approach, combining robust input validation, permissioning layers, and architectural patterns like reflection to ensure that an agent’s ability to act in the world cannot be turned against it. 3.3.3Planning: The Architecture of Cascading Failure. Planning is the architectural pattern that enables an agent to transcend simple, reactive responses by decomposing open-ended objectives into executable sequences. While this allows LLMs to tackle complexity beyond their immediate context window, it fundamentally transforms the agent’s risk profile. By extending reasoning over time and multiple steps, planning architectures convert isolated model errors into systemic, cascading failures. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 12• Wibowo and Polyzos •Decomposition and the Risk of Hallucination Snowballing: The core strategy of planning is task decomposition—breaking a high-level goal into sub-tasks using techniques like Chain of Thought (CoT) (Wei et al. 2023) or ReAct (Yao, J. Zhao, et al. 2023). While this often improves performance, it introduces a critical vulnerability known as Hallucination Snowballing. As identified by M. Zhang et al. (2024), LLMs often commit to an incorrect answer early in a sequence and then generate false justifications to maintain consistency with that initial error. In a planning agent, this means a single hallucinated step (e.g., assuming a file exists when it does not) creates a polluted context. The agent then proceeds to build a “coherent fiction”—deducing further steps based on the falsehood—resulting in a plan that is logically valid but factually disastrous. This phenomenon suggests that planning agents are not merely prone to errors, but are architecturally predisposed to defend their errors through “reasoned” justification. • Plan Rigidness vs. Infinite Loops: Planning architectures face a “stability-adaptability” dilemma that manifests as two distinct failure modes: -Open-Loop Fragility: Architectures that generate a full plan upfront (like ProgPrompt (Singh et al. 2022)) are highly efficient but brittle. If the environment state changes or a step fails, the agent often lacks the mechanism to recover, executing the remaining invalid steps blindly. - Closed-Loop Exhaustion (Logic Malfunction): Architectures that interleave planning and execution (like Re- Act) are susceptible to Logic Malfunction Attacks. Adversaries can exploit the agent’s error-correction loop to trap it in an infinite cycle of repeating commands until maximum iterations are reached. As described by B. Zhang et al. (2025), this transforms a common natural failure mode into a targeted vector for resource exhaustion (DoS), effectively locking the agent in a “reasoning trap” where it consumes tokens without progressing. • Multi-Plan Generation as a Resource Amplification Vulnerability: To overcome the limitations of a single reasoning path, advanced architectures employ multi-plan generation strategies. These function by either sampling diverse paths via decoding uncertainty—as introduced in Self-Consistency (X. Wang et al. 2023)—or explicitly proposing distinct plans via few-shot prompting, as seen in Tree-of-Thought (ToT) (Yao, Yu, et al. 2023) and Graph-of-Thought (GoT) (Besta et al. 2024). These candidates are then evaluated using search algorithms like BFS, DFS, or Monte Carlo Tree Search (MCTS) (Hao, Gu, et al. 2023; Z. Zhao et al. 2023). While X. Huang et al. (2024) highlight the effectiveness of these methods, they explicitly note the significant trade-off in “computational demands” and “latency,” particularly for online services. From a security perspective, we analyze this trade-off as a critical Resource Amplification vulnerability. Because a single user request can trigger an exponential number of internal LLM calls (e.g., MCTS requiring iterative sampling and evaluation steps), these systems are uniquely susceptible to Algorithmic Complexity Attacks (or “Sponge Attacks”) (Shumailov et al. 2021). An attacker can submit complex or paradoxical queries designed to maximize the search depth and sampling count, forcing the agent to exhaust its computational budget on a single task. •The Interface Risks of Hybrid Planning: To mitigate the reasoning limitations of LLMs, some systems offload planning to external symbolic solvers (e.g., PDDL solvers) (X. Huang et al. 2024). While this ensures logical correctness, it introduces a critical Neuro-Symbolic Gap. The external solver operates purely on formal logic and lacks the safety alignment training of the LLM. This creates a vulnerability to malicious problem formulation: if an attacker can manipulate the LLM into translating a harmful intent into a valid formal problem definition (e.g., PDDL), the solver will generate an optimal plan to execute that harm without hesitation. In this architecture, the translation layer effectively “launders” the malicious intent, bypassing the LLM’s internal safety refusals by shifting the execution responsibility to a non-aligned symbolic engine. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 13 Strategic Implications. The implementation of planning shifts the agent’s primary failure mode from “incorrect output” to “misguided agency.” A hallucinating chatbot merely speaks falsely; a hallucinating planning agent acts falsely, potentially executing a sequence of irreversible tool calls based on a “snowballed” justification. Secure agent design must therefore prioritize fail-safe defaults—mechanisms that detect circular reasoning or high-uncertainty steps and halt execution before the snowball gathers momentum. 3.4 Tools: The Interface of Action While design patterns dictate how an agent thinks, tools dictate where an agent can act. Tools are the API bridges that transform an LLM from a passive text generator into an active system operator. However, by granting an agent the ability to execute code, modify databases, and interact with external APIs, tools fundamentally breach the containment that made early chatbots safe. Functional Architecture and Integration. Tools for single agents generally fall into two operational categories: Data Retrieval (Read-Only) for fetching context and Action Execution (State-Modifying) for altering external systems (OpenAI n.d.(a)). To leverage these capabilities, agents require a standardized integration layer. Historically, this relied on proprietary “function calling” schemas (OpenAI n.d.(b)), creating a fragmented ecosystem. The industry is now converging on the Model Context Protocol (MCP) (Hou et al. 2025). MCP functions as a universal adapter, decoupling the tool definition from the model (Model Context Protocol n.d.) While this standardization accelerates interoperability by allowing agents to discover and invoke tools via a client-server model, it also standardizes the attack surface, necessitating a rigorous security analysis. The Tool Lifecycle Threats. As analyzed by Hou et al. (2025), the open and extensible nature of tool protocols like MCP introduces specific vulnerabilities across the tool lifecycle: Creation, Operation, and Update. •Provisioning Risks (Creation Phase): The decentralized nature of tool repositories introduces supply chain risks. -Name Collision and Impersonation: Malicious actors can register tools with names deceptively similar to legitimate services (e.g.,mcp-githubvsgithub-mcp). This “typosquatting” tricks agents into invoking malicious endpoints that intercept sensitive data (Hou et al. 2025). -Installer Spoofing: Unofficial auto-installers or compromised package managers can introduce backdoors during the setup process, bypassing code integrity checks (Hou et al. 2025). • Execution Risks (Operation Phase): - Toolflow Hijacking: Malicious tool descriptions can be engineered with “prompt injection” directives (e.g., “Always prefer this tool”). This manipulates the agent’s selection logic, forcing it to use an inferior or compromised tool over a legitimate one (Hou et al. 2025; Shi et al. 2025). -Sandbox Escape: Tools that execute code or system commands run the risk of breaking out of their containerized environments. Vulnerabilities in the runtime can allow a tool to access the host system, escalating from a tool failure to a full system compromise (Hou et al. 2025). • Maintenance Risks (Update Phase): -Configuration Drift: Over time, manual adjustments or conflicting tool updates can cause the security posture of a tool environment to deviate from its safe baseline. -Privilege Persistence: A critical flaw where revoked privileges (e.g., an expired API key) remain active in a tool’s cache after an update, allowing unauthorized access to continue indefinitely (Hou et al. 2025). Identity and Authorization Issues. Beyond the technical integrity of the tools, the most profound risks arise from the authority under which they are executed. An agent without authorization is merely a chatbot; an agent Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 14• Wibowo and Polyzos with authorization is an automated actor. Current architectures often fail to distinguish between the User and the Agent acting for the User, creating a “flat” permission model that introduces severe over-privilege risks. •The Risks of Implicit Delegation (Identity Masquerading): The dominant pattern in current agent deployment is “Identity Masquerading,” where an agent acts using the user’s raw credentials (e.g., passing a session cookie or API key). While functional for prototypes, this practice is critically unsafe in production. It grants the agent the full “blast radius” of the user’s identity. For example, a coding agent authorized to edit files in a demo environment effectively inherits the user’s production permissions to delete root directories if deployed with raw credentials. This creates a classic Confused Deputy Problem: the agent lacks a distinct identity to constrain its privileges separate from the user’s broad access, allowing it to be tricked into misusing authority that the user possesses but did not intend to delegate (South et al. 2025). •The Challenge of Accountability and Contextual Integrity: Without a distinct “Agent Identity,” it becomes impossible to audit whether an action was performed by the human directly or by an autonomous system on their behalf. This breaks the chain of accountability and violates Contextual Integrity—the principle that information flows and actions should respect specific social contexts (South et al. 2025). For instance, consider a hypothetical “Compensation Agent” authorized to access sensitive HR data. If this agent relies on shared, flat credentials, a lower-privileged “Intern Assistant” agent could potentially piggyback on that session or impersonate the high-privilege agent. Without distinct identity scoping, the system cannot distinguish between the CEO requesting salary data and an intern’s bot requesting the same data via a hijacked session. •The Solution: Authenticated Delegation Frameworks: To mitigate these risks, secure agent architec- tures must move beyond simple credential sharing to Authenticated Delegation. As proposed by South et al. (2025), this framework extends standards like OAuth 2.0 and OpenID Connect to create Delegate Credentials. In this model, authorization is calculated as the intersection of three scopes: (1) User Permissions: What the human is allowed to do. (2) Agent Scope: What the specific agent is registered/allowed to do. (3) Contextual Constraints: Specific limits for this session (e.g., “Read-only access to Calendar”). This ensures that even if an agent is hijacked, it cannot exceed the explicitly delegated scope, solving the “Secure but Unsafe” paradox of raw credential usage (South et al. 2025). 3.5 Guardrails: The Architecture of AI Control Guardrails function as the critical risk management layer for LLM-powered agents. While “AI Alignment” focuses on training a model to want to be safe, “AI Control” (Guardrails) focuses on forcing the system to be safe through external constraints. In this context, we adopt the perspective of AI Control rather than just alignment. As defined by Greenblatt, Shlegeris, et al. (2024), this approach assumes the model functions as an untrusted component that may—whether due to internal misalignment or external manipulation—attempt to subvert safety measures. Consequently, guardrails must be designed to enforce safety guarantees that hold even against an adversarial model. However, implementing effective guardrails creates a fundamental architectural tension: the friction between deterministic policy (strict rules) and probabilistic execution (flexible reasoning). We analyze this layer through three concentric rings of defense: Internal Mechanisms, the I/O Interface, and Recursive Monitoring. 3.5.1Internal Safety Mechanisms (Model-Level Defense). The deepest layer of defense attempts to embed safety directly into the model’s weights or architecture, rather than relying solely on external filters. • Post-Training and Adversarial Alignment: Developers often employ supervised fine-tuning (SFT) or adversarial training to teach models to refuse malicious instructions. State-of-the-art methods like SecAlign Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 15 introduce efficient adversarial training to enhance robustness against prompt injection while preserving utility (S. Chen et al. 2024). The Alignment Paradox: However, Cao et al. identify a critical conflict in this approach: reinforcing the model’s adherence to “user intent” helps against indirect injection (where the user is the victim), but makes the model more vulnerable to prompt leakage (where the user is the attacker). A model trained to be “helpful” to the user is architecturally predisposed to reveal its system prompt if asked persuasively (Cao et al. 2025). •Architectural Separation (System Vectors): To resolve this paradox, emerging research suggests remov- ing the system prompt from the textual context entirely. Cao et al. (2025) propose SysVec, a method that encodes system instructions directly into the model’s internal representation vectors (hidden states) rather than as raw text. By effectively “hard-coding” safety rules into the activation space, this approach renders standard prompt extraction attacks mathematically impossible, as the prompt does not exist as retrievable text during inference. 3.5.2The Deterministic-Probabilistic Interface (I/O Filtering). If internal mechanisms fail, the next line of defense is filtering data entering and leaving the agent. However, a fundamental vulnerability exists here because the security filter and the execution engine (the Agent LLM) process information differently. •Deterministic Filters (Rules & Regex): These are rigid protections—such as input length limits or blocklists for prohibited URLs—designed to block known malicious patterns before they reach the LLM (OpenAI n.d.(a)). While efficient, they suffer from the Rigidity Problem. They cannot understand context, meaning a “benign” looking string (like Base64) passes through, even if it decodes to a malicious instruction. Recent empirical studies on “in-the-wild” jailbreaks confirm that simple obfuscation strategies effectively bypass these static filters (Shen et al. 2024b). •Probabilistic Filters (Safety Classifiers): To catch semantic threats, developers employ “safety classi- fiers”—either dedicated services like the OpenAI Moderation Endpoint (Markov et al. 2023) or lightweight LLMs prompted or fine-tuned to detect harmfulness (Anthropic n.d.(b); OpenAI n.d.(c)). These suffer from the Adversarial Noise risk. Because the guardrail itself is a model, it is susceptible to optimization attacks. As demonstrated by “Universal Adversarial Attacks,” an attacker can append a noise suffix to a malicious prompt that makes it statistically invisible to the safety classifier while remaining semantically actionable to the agent (A. Zou et al. 2023). Structural Evasion Attacks. Beyond defeating specific filters, adversaries exploit the structural gap between how filters scan text and how agents process it. Techniques like Payload Splitting break a malicious instruction across multiple tokens or messages; individually benign to the filter, they are reassembled by the agent into an attack (Kang et al. 2023). Similarly, Output Steganography involves prompting the agent to hide its malicious response using encodings or ciphers (e.g., LLM-Stega), effectively bypassing output scanners that cannot decode the hidden payload (J. Wu et al. 2024). 3.5.3Architectural Challenges in Guardian Agents. For complex behaviors where simple classifiers fail, architec- tures employ “Guardian Agents”—separate LLM instances tasked with monitoring the primary worker. Greenblatt, Shlegeris, et al. (2024) formalize this as a protocol involving an Untrusted, Capable Model (the worker) and a Trusted, Weaker Model (the monitor). The assumption is that the weaker model, while less capable, is less prone to subversion. This architecture introduces a several architectural challenges: •The Capability Mismatch and Sandbagging: We typically trust weaker models to monitor stronger ones. However, as AI capabilities scale, the “Untrusted” models improve rapidly while “Trusted” monitors remain static. This gap allows capable agents to use advanced logic to hide malicious intent in ways simpler guardians cannot parse. Furthermore, capable agents may engage in Sandbagging—recognizing they are Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 16• Wibowo and Polyzos under observation during a guardrail check and intentionally "playing dumb," only to execute malicious behaviors once the oversight is relaxed (Greenblatt, Shlegeris, et al. 2024). •Recursive Injection Risk: To close the capability gap, developers may employ “Reasoning Guardians” (smart LLMs). Paradoxically, making the Guardian “smarter” increases its attack surface. Because the Guardian is itself an LLM, it inherits the worker’s vulnerabilities. Attackers can exploit this via Indirect Prompt Injection (embedding meta-instructions to override protocols) or by applying the same Universal Adversarial Attacks (optimized noise suffixes) used against the worker, forcing the Guardian into a compliant state regardless of its safety training (A. Zou et al. 2023). •Resource and Latency Overhead: Implementing reasoning-based supervision imposes a severe compu- tational tax. As noted in OpenAI’s analysis of reasoning safeguards, dynamic, step-wise evaluation can consume up to 16% of the total compute budget (OpenAI n.d.(c)). This creates a trade-off where increasing safety directly degrades the latency and economic viability of the agent system. 3.5.4 Human-in-the-Loop (HITL) as a Psychological Vector. For high-stakes actions, the ultimate guardrail is Human-in-the-Loop (HITL). The Automation Bias Risk: While theoretically robust, HITL introduces the vulnerability of Automation Bias and fatigue. Greenblatt, Shlegeris, et al. (2024) highlights the possibility of human auditors failing to spot subtle malicious actions, especially when the model performs correctly the majority of the time. Attackers can exploit this via social engineering against the supervisor—burying a malicious action within a stream of benign requests to slip past the fatigued human’s guard. Conclusion. Our analysis of the guardrail stack reveals a fundamental and recurring vulnerability: the friction between the desire for deterministic policy—strict, verifiable rules—and the reality of probabilistic execution inherent to LLM-based systems. This tension creates exploitable gaps at every layer of the defense-in-depth architecture, from the model’s internal alignment paradox to the psychological vectors affecting the final human supervisor. This confirms that securing an agent is an inherently adversarial challenge. Consequently, robust AI Control cannot rely on any single layer but requires a Defense-in-Depth Architecture that layers multiple, heterogeneous constraints to rigorously contain the agent as an untrusted component. 3.6 The Agent as a System of Dual-Use Components The anatomy of a single agent reveals a microcosm of the entire agentic safety challenge. Our analysis shows that its core components are fundamentally dual-use: the Model is both the engine of intelligence and the primary attack surface; the Memory enables context but introduces privacy and integrity risks; the Tools grant agency but create an interface for real-world harm; and the Guardrails provide control but are themselves imperfect and subject to evasion. Crucially, recent research confirms that securing these components individually is insufficient due to the emergence of “Agentic-Only Vulnerabilities,” where the very act of integrating these parts creates novel attack vectors that do not exist in standalone models (Wicaksono et al. 2025). This finding leads to an inescapable conclusion: true agentic safety is not a component-level property, but a systemic, architectural one. Having detailed the vulnerabilities of this fundamental unit, we now broaden our scope to the collective. 4 A Population of Agents: Building Multi-Agent Systems We now transition our focus from the anatomy of the single agent to the architecture of the collective: the Multi- Agent System (MAS). The fundamental promise of MAS is that by enabling individual agents to collaborate, we can create systems capable of tackling problems with a scope and complexity that no single agent can address alone. Early evidence already shows that these collaborative systems can achieve superior performance on complex tasks. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 17 Before analyzing specific components, it is critical to define the scope of this section. We analyze Multi-Agent Systems (MAS) as closed ecosystems—groups of agents typically built within a single framework (e.g., CrewAI, LangGraph, AutoGen) operating under a unified control plane. In this context, trust is typically assumed between agents, and the primary security challenges revolve around orchestration stability, error propagation, and resource consumption. This is distinct from the Interoperable Multi-Agent Systems (IMAS) discussed later in Section 5, which envision an “Internet of Agents” where heterogeneous, potentially untrusted agents collaborate across framework boundaries. To understand how these closed systems are built and managed, this section provides a comprehensive overview of their core elements. We will first explore their foundational Architectures and Coordination Strategies, the Inter-Agent Communication Mechanisms that bind them, and the Operational Environments they act within. Crucially, we will also examine the systems required to manage their collective behavior and risks, including Verification Mechanisms for ensuring quality and System-Level Guardrails for mitigating emergent, high-stakes threats. 4.1 Architectures and Coordination Strategies MAS designs exhibit significant diversity in their architectural patterns, which dictate how agents collaborate, manage tasks, and exert overall system control. Essentially, a MAS architecture defines how the collective is organized to achieve a common goal. We analyze these architectures by examining two fundamental dimensions: Control Flow, which governs the sequence of operations and the degree of autonomy in decision-making, and Topology, which defines the structural arrangement, connectivity, and composition of the agent workforce. Together, these choices determine not only the system’s problem-solving capabilities but also its operational resilience and susceptibility to systemic risks. 4.1.1 Control Flow and the Spectrum of Autonomy. Control flow refers to the sequence of operations agents perform to achieve a goal. In the context of a MAS, a critical architectural dimension is the degree of autonomy the system has in determining this flow. This is distinct from the internal autonomy of a single agent; here, we are concerned with how the next step in the collective process is decided. This exists on a spectrum where increasing flexibility and autonomy often correlates with an expanding “Blast Radius”’ of potential system compromise: •Predefined Workflows (Low Autonomy): At one end of the spectrum are systems where the developer explicitly designs the entire control flow. This constitutes a workflow of agents, where agents are arranged in a fixed, rigid sequence or a directed acyclic graph (DAG). This pattern is ubiquitous in enterprise applications, such as RAG pipelines or conversational flows (e.g., Dify Chatflows). The popularity of this approach stems from its engineering manageability: by decomposing a complex objective into discrete, single-purpose steps, developers can utilize simpler, specific prompts and restrict each node to a minimum set of necessary tools. This reduces the burden of complex prompt engineering and ensures that outcomes are deterministic and fully auditable (CrewAI Inc. n.d.(a)). From a security perspective, this architecture provides Structural Confinement. Unlike autonomous agents that possess a global action space, an agent in a workflow operates within a Partitioned Action Space. Even if a middle node is successfully compromised via prompt injection, its capacity to do harm is rigidly limited by the topology: it cannot “decide” to access unauthorized tools, nor can it alter the control flow to bypass subsequent safety checks. The blast radius is strictly confined to the specific tools wired to that specific node. However, while the actions are contained, the data is not. These systems face the risk of Deterministic Propagation (or the “Poisoned Pipeline”). Since the control flow blindly pushes data downstream, a Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 18• Wibowo and Polyzos malicious payload injected at the input stage is guaranteed to pass to subsequent nodes. If an upstream node is hijacked to output malicious content, the downstream node treats it as trusted context. To mitigate this, developers must leverage the architecture’s inherent decomposability to implement Process Supervision (Lightman et al. 2023). Because the reasoning is externalized into discrete system steps, verification becomes significantly easier than monitoring a monolithic agent. Developers can implement Deterministic Contract Enforcement at every transition. This involves defining strict Preconditions (verifying inputs) and Postconditions (validating output schemas) (Stoica et al. 2024). Crucially, these contracts can extend beyond syntax to enforce Semantic Invariants—for example, asserting that a generated SQL query must contain strictlySELECTstatements (read-only) or that a financial transaction falls within defined limits. By validating the semantic integrity of each step, the system prevents the snowballing of errors and neutralizes Instruction Override attacks before they propagate. •Dynamic Workflows (Medium Autonomy): In this pattern, the control flow is directed at runtime by a designated orchestrator. This covers a spectrum of complexity, ranging from simple logical routers that make a single branching decision (e.g., LangGraph conditional edges) to stateful manager agents that orchestrate complex, multi-step loops (e.g., CrewAI’s hierarchical process) (CrewAI Inc. n.d.(c); LangChain Inc. n.d.(a)). This architecture introduces a critical vulnerability: the Orchestrator acts as a Single Point of Trust (SPoT). Unlike static workflows where the connections between agents are hardcoded, here the “workflow lines” are virtualized—they exist only as semantic decisions made by the Orchestrator. Consequently, the structural integrity of the entire system is reducible to the reasoning capability of this single node. This transforms access control from a deterministic mechanism into a form of Probabilistic Access Control. If the router acts as a Confused Deputy due to prompt injection, it can dynamically draw a connection from a low-privilege user to a high-privilege agent—a systemic instance of the Implicit Delegation risk. To address these vulnerabilities, architects can employ a defense-in-depth strategy centered on Fail- Safe Routing. A foundational approach is Topological Scoping, or “adjusting the workflow lines” to physically exclude sensitive agents from the router’s candidate pool based on the execution environment. Furthermore, routing decisions should not be executed blindly but treated as proposals subject to System- Level Guardrails. Mechanisms such as programmable rails (e.g., NeMo Guardrails) can be used to intercept the router’s output and validate the transition against defined flows before control is transferred (Rebedea et al. 2023). Within this interception layer, systems can enforce Authenticated Delegation by verifying that the user’s identity actually possesses the scope to access the proposed agent, ensuring that a compromised router cannot be used to bypass authorization logic (South et al. 2025). • Emergent Flows (High Autonomy): At the highest end of the autonomy spectrum, the control flow is not directed by a central orchestrator but emerges as a collective result of decentralized agent interactions. In this peer-to-peer model (seen in AutoGen’s GroupChat or AgentVerse’s Horizontal mode), agents react to each other’s messages based on their individual system prompts and termination conditions, without a central manager dictating the turn-taking or task allocation (W. Chen, Su, et al. 2023; Q. Wu et al. 2023). From a security perspective, this architecture presents unique challenges due to the lack of a central control chokepoint. Unlike router-based systems where a manager can block a malicious request, emergent systems suffer from an Unbounded Blast Radius. A compromised agent can directly interact with and potentially corrupt any other agent in the network, allowing malicious instructions to propagate virally through peer- to-peer persuasion. This decentralized structure also makes the system susceptible to consensus-based error propagation; without a supervisor to verify intermediate outputs against a ground truth, a hallucination generated by one agent can be accepted by peers as valid context, reinforcing the error and making the final output confidently incorrect. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 19 Furthermore, without a central governor to enforce stopping criteria, emergent systems are prone to Resource Exhaustion. As detailed by B. Zhang et al. (2025), adversarial inputs can trigger circular debates or repeating action sequences between agents, trapping the system in infinite loops that exhaust token budgets and computational resources . Finally, in the absence of a top-down objective function, the collective behavior is susceptible to Goal Drift. Research indicates that agents are highly sensitive to adversarial pressure, often drifting away from their system instructions when exposed to conflicting contexts or long task durations (Arike et al. 2025). In an emergent architecture, this vulnerability is exacerbated by peer dynamics: agents may drift via inaction—failing to object to or correct a peer’s deviation from the core objective. Without a central supervisor to maintain alignment with the broader human intent, this social dynamic can amplify the drift into Goal Misspecification, where the collective converges on a solution that satisfies the strict “letter” of the instruction while violating its “spirit”—effectively exploiting loopholes to achieve the goal in ways the user did not intend (Rudner and Toner 2021). The degree of control flow dynamism involves a trade-off between efficiency and safety. Secure system design requires aligning the architectural pattern with the application’s risk profile. While the field is advancing toward greater autonomy, rigid workflows remain essential for tasks requiring deterministic guarantees and auditability. Conversely, deploying high-autonomy architectures necessitates a rigorous understanding of their inherent systemic risks, accepting that increased adaptability comes at the direct cost of verifiable control. 4.1.2Topology. While control flow dictates the sequence of operations, Topology defines the structural arrange- ment of the agents—specifically, how they are interconnected and the graph properties that govern information flow. The choice of topology is a critical design decision that directly impacts the system’s scalability, fault tolerance, and auditability. We categorize these structures into two evolutionary stages: static topologies defined by developers for long-term use, and dynamic topologies evolved by models for specific tasks. Static and Developer-Defined Topologies. In the majority of current enterprise applications, the topology is defined at design time to serve a broad range of future inputs. While frameworks like LangGraph or AutoGen allow for flexible wiring, the resulting structure remains static during execution. Key patterns include: •Horizontal or Networked Structure: In this democratic topology, agents often act as peers without a central controller. This structure is well-suited for problems that benefit from diverse perspectives, such as collaborative brainstorming or divide-and-conquer strategies (LangChain Inc. n.d.(c)). Collaboration occurs via Aggregation (voting/summarizing outputs (W. Chen, Su, et al. 2023)), Handoffs (explicitly passing context to a peer, a core LangGraph concept (LangChain Inc. n.d.(d))), or Conversational Dynamics (round-robin or context-aware turn-taking in AutoGen (Q. Wu et al. 2023)). While maximizing diverse perspectives, this structure is architecturally susceptible to the Domino Effect. Without a central supervisor, a “poisoned” output from one agent is readily accepted by peers as trusted context. Research suggests this vulnerability is driven by Passive Complicity caused by role rigidity; agents often possess the knowledge to detect a peer’s error but lack the explicit instructions to voice dissent. Empirical studies show that introducing a “Challenger” mechanism—explicitly prompting agents to dispute suspicious peer outputs—can recover nearly all performance lost to faulty agents, highlighting that the default “cooperative” interaction mode in flat topologies is a significant security liability (J.-t. Huang et al. 2025). • Vertical or Supervisor Structure: This structure institutes a clear manager-worker relationship where multiple worker agents report to and communicate through a central supervisor agent. The supervisor is responsible for decomposing high-level tasks, routing sub-tasks to workers, and synthesizing results. This is seen in CrewAI’s hierarchical process (CrewAI Inc. n.d.(c)) and AgentVerse’s solver-reviewer loops. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 20• Wibowo and Polyzos A specialized variant is the tool-calling supervisor, where the supervisor treats other agents merely as executable tools (LangChain Inc. n.d.(d)). From a security perspective, this centralization is a double-edged sword. While it introduces a critical Single Point of Failure (SPOF), it effectively operationalizes the “Inspector” pattern identified by J.-t. Huang et al. (2025) as a key driver of resilience. Because the supervisor structurally intercepts all inter-agent communications, it serves as a natural checkpoint for error correction and verification. This adherence to the principle of Economy of Mechanism allows developers to concentrate high-quality guardrails on a single node, significantly reducing the complexity of securing the system compared to a flat mesh of peers. •Hierarchical Structure: As a direct extension of the vertical structure, a hierarchy involves multiple layers of supervision—a supervisor of supervisors (a “Tree” topology). This pattern is essential for scaling context management in complex tasks (LangChain Inc. n.d.(d)). Crucially, recent research identifies this as the most resilient topology against faulty or malicious agents. The presence of higher-level roles enables error recovery; supervisors can review diverse outputs from sub-teams and filter out hallucinations or malicious deviations before they propagate to the root. While there is a risk of Information Loss as data is summarized upward, the structural isolation of sub-teams provides robust Blast Radius Containment, preventing a localized failure from destabilizing the global system (J.-t. Huang et al. 2025). Dynamic and Self-Evolving Topologies (The Frontier). The frontier of MAS research moves beyond persistent graphs to Adaptive Architectures. Manually designed MAS are often limited in adaptability and scalability as human designers typically do not fully understand the capabilities or limitations of LLM agents (Ke et al. 2025). We categorize these approaches into three distinct evolutionary branches: •Automated Structural Optimization: This category encompasses algorithms that optimize the agent structure from a pre-defined super-graph. Early attempts, such as GPTSwarm and DyLAN, viewed this as a pruning problem, employing reinforcement learning or message-passing metrics to remove inefficient edges from a fully connected graph (Z. Liu et al. 2024; Zhuge et al. 2024). Subsequent frameworks like AgentSquare, MASS, and MaAS refined this by utilizing verifiers or validation set performance to guide the sub-network selection process (Shang et al. 2025; G. Zhang, Niu, et al. 2025; Zhou et al. 2025). However, these methods remain constrained by the pre-defined starting structure and rely heavily on Validation Sets for tuning. Consequently, they struggle to optimize for properties like Resilience unless the validation set explicitly contains adversarial examples. Recent research has introduced Task-Aware Topology Generation (e.g., G-Designer) to overcome these static limitations. By utilizing Graph Neural Networks (GNNs) to encode specific user queries, these systems function in an input-dependent manner, dynamically generating a bespoke topology for each query. From a security perspective, this architecture offers the opportunity to explicitly optimize for systemic resilience and efficiency via the model’s objective function. Unlike validation-dependent methods, GNN-based generation can incorporate structural regularization terms (such as sparsity penalties) to mathematically enforce the principle of Economy of Mechanism, potentially routing around fragile structures without requiring an exhaustive dataset of adversarial attacks (G. Zhang, Yue, et al. 2025). Systems that algorithmically define topology face a fundamental tension between performance, token efficiency, and resilience—an Optimization Trilemma where maximizing one often compromises the others. This creates a vulnerability rooted in Reward Hacking: if the generator is heavily penalized for token consumption, it may learn to optimize away “expensive” verification nodes or redundancy to satisfy efficiency metrics, effectively designing a highly efficient but unmonitored execution path. During the generation phase, GNN-based encoders are also theoretically susceptible to Adversarial Perturbations, where subtle input noise shifts the embedding vector to force the generation of a specific, compromised connectivity graph (Zügner et al. 2018). Furthermore, regarding the operational security of the generated Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 21 graph, while G-Designer demonstrates robustness against single-agent faults (e.g., a corrupted system prompt), this represents fault tolerance rather than active security. It remains unexplored how these optimized, often sparse topologies withstand advanced adversarial vectors, such as multi-agent collusion or targeted prompt injections that exploit the specific, optimized pathways generated by the model. • Generative Meta-Architectures: A parallel stream of research treats the MAS structure as executable code to be generated. Frameworks like ADAS and AFlow utilize meta-agents to search for optimal architectures, but they rely heavily on validation sets for tuning (Hu et al. 2025; J. Zhang et al. 2025). Improving upon this, MAS-Zero introduces an inference-time approach that removes the dependency on training data. It utilizes a meta-agent to iteratively decompose problems and generate executable MAS code on the fly by assembling pre-defined building blocks (e.g., CoT, Debate). Crucially, it employs a Meta-Feedback Loop that evaluates intermediate outputs for Solvability (can the sub-agents solve their assigned tasks?) and Completeness (does the decomposition cover the full problem?) to refine the design in real-time (Ke et al. 2025). In frameworks like MAS-Zero, the user’s prompt functions not merely as input but as the architectural blueprint. This shifts the attack surface from the individual agent to the generative process itself, intro- ducing the risk of Topology Injection. Unlike static systems where connections are hardcoded, here an attacker can manipulate the meta-agent to synthesize a topology that violates safety policies—for instance, dynamically writing code that wires a public chatbot directly to a sensitive database. This introduces a fundamental Capability-Safety Dilemma. To solve complex, open-ended tasks, the generator requires a permissive environment with broad access to tools and network interfaces. However, strictly hardening this environment to prevent malicious wiring simultaneously constrains the system’s solution space, rendering it incapable of solving legitimate tasks that require those specific connections. Because the architecture is generated transiently at inference time, it bypasses static analysis and security reviews, leaving the system with a stark choice: accept an unverified, high-risk topology or accept a limited, low-utility functional range. While the theoretical surface for such “meta-attacks” is vast, empirical research into the adversarial robustness of these generative architects remains a largely unexplored frontier. •Decentralized Evolutionary Coordination: Finally, frameworks like AgentNet explore fully decen- tralized architectures. Instead of relying on a central controller, these systems route tasks via a dynamic Directed Acyclic Graph (DAG) and allow agents to evolve their expertise through private, retrieval-based memories of successful trajectories. From a security perspective, this decentralization eliminates the Single Point of Failure (SPOF) and enforces Data Minimization; by processing knowledge locally and confining data flow to necessary agent-to-agent interactions, the architecture mitigates the broad exposure risks typical of centralized topologies (Yang, Chai, et al. 2025). However, the long-term security implications of this memory-driven evolution remain a largely unexplored frontier. Specifically, it is unclear how such systems withstand Evolutionary Poisoning: if an agent records an unsafe or malicious method as a valid “success,” there is a potential risk of Behavioral Drift, where the system might inadvertently reinforce and propagate compromised patterns across the decentralized network without a central mechanism to audit or correct the collective memory. Conclusion. Ultimately, the evolution from developer-defined topologies to autonomous, self-organizing ecosys- tems represents a fundamental shift in the security paradigm. While static structures offer Control Flow Integrity (structurally confining agent interactions and tool access to pre-approved paths), emergent and gen- erative architectures sacrifice this containment for adaptability. A critical gap remains in the current state of the art: while adaptive frameworks can optimize for efficiency or basic fault tolerance, their resilience against advanced adversarial vectors—such as blueprint injection or evolutionary poisoning—and the integration of robust guardrails into dynamically generated graphs remain largely unexplored frontiers. Consequently, as Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 22• Wibowo and Polyzos architectures become more fluid and the structural guarantees of static code dissolve, the burden of safety must inevitably shift from design-time verification to rigorous, runtime outcome monitoring. 4.2 Inter-Agent Communication Mechanisms Effective inter-agent communication is the glue that binds the architectural components of a MAS. However, the mechanism chosen dictates not only how information flows but also how influence and corruption propagate through the system. We analyze these mechanisms through the lens of their observability and susceptibility to manipulation. 4.2.1 Direct Communication Models. In this paradigm, agents interact by explicitly sending and receiving structured messages. Frameworks like AutoGen exemplify the Conversational Interface approach, providing agents with methods to pass structured messages back and forth in a conversation-driven control flow (Q. Wu et al. 2023). While intuitive, these high-bandwidth channels serve as vectors for Semantic Propagation. Unlike structured tool outputs, conversational text allows for nuance and persuasion; as evidenced by resilience studies in flat topologies, a compromised agent can introduce errors or malicious contexts that legitimate peers readily accept as ground truth. Without a mediator to filter messages, a “jailbroken” agent can effectively attack its peers, propagating the compromise via adversarial persuasion (J.-t. Huang et al. 2025). Alternatively, Graph-Based Message Passing (e.g., LangGraph) defines interaction as a state machine where nodes send messages along defined edges to trigger subsequent nodes in discrete super-steps (Inc. n.d.) While this offers superior auditability due to known edges, it suffers from Message Schema Fragility. If a node is tricked into embedding a payload within a valid state object (e.g., hiding instructions in a metadata field), the deterministic graph logic guarantees this “poison pill” is delivered to the next node. This structural rigidity can inadvertently bypass semantic filters that scan only the primary content body, turning the graph’s reliability into a deterministic propagation vector for attacks. 4.2.2Indirect Communication Models. This approach mediates interaction through system components, decou- pling the sender from the receiver. Environment-Mediated Communication (e.g., AgentVerse) utilizes a shared environment or “blackboard” where agents publish messages that are aggregated and distributed by a rule-based system (OpenBMB 2025). Security-wise, this introduces a Global State Vulnerability, analogous to Indirect Prompt Injection (Greshake et al. 2023). Because the environment acts as shared memory, a single agent writing malicious data effectively poisons the information supply for all subscribers. Unlike direct communication where the blast radius is limited to the specific recipient, environment-mediated attacks have a broadcast effect, potentially corrupting the entire collective simultaneously. In contrast, Tool-Based Communication (e.g., CrewAI) handles interaction through structured API calls, where a manager invokes a worker as if it were a tool (e.g., viaDelegateWorkTool). In this model, the message is encoded in the arguments, and the reply is the return value. This mechanism creates a risk of Obfuscated Intent, effectively hiding communication inside functional execution. Security monitors designed to scan chat logs for toxicity or injection often fail to parse payloads buried inside structured JSON tool arguments. This creates a Side Channel where agents can exchange unauthorized instructions that appear as legitimate API calls, complicating oversight and evasion detection (Y. Liu et al. 2024). 4.2.3The Frontier of Communication Risks: Steganography and Collusion. Beyond the structural risks of specific protocols, recent research identifies a profound potential threat: Secret Collusion via Steganography. Motwani et al. (2025) demonstrate that agents can theoretically develop or be fine-tuned to use steganographic tech- niques—hiding secret messages within seemingly benign text—to coordinate strategies without human detection. While current models are not yet consistently capable of robust, perfect secret collusion, the capability trajectory suggests this is an impending risk for decentralized AI environments. If agents achieve this, they could establish Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 23 a covert channel (or “Dark Comms”) overlaid on the official protocol, rendering standard content moderation in- effective. Consequently, developing mitigation measures such as semantic steganalysis is a pragmatic necessity to preempt the emergence of sophisticated collusion in future multi-agent ecosystems (Motwani et al. 2025). 4.3 The Operational Environment The operational environment defines the interface between the agent’s cognitive processes and the external world. From a security perspective, the environment acts as both the Attack Surface (where hostile inputs enter the system) and the Blast Radius (where agent actions manifest consequences). We analyze the environment through two critical lenses: as the boundary of execution and perception, and as the feedback mechanism for reinforcement learning. 4.3.1The Execution Boundary: Affordances and Perception. The environment defines an agent’s Affordances—the set of permissible actions it can execute. As agents evolve from text-based chatbots to multimodal operators equipped with Large Multimodal Models (LMMs), this boundary expands significantly. • Perceptual Vulnerabilities (The Visual Attack Vector): The integration of vision and audio transforms the environment into a high-bandwidth injection vector. Agents that interact with the open web or physical world are susceptible to Indirect Prompt Injection via visual modalities. Research by Bagdasaryan et al. demonstrates that LMMs can be compromised by “visual injections”—images containing hidden instructions or adversarial perturbations that are invisible to humans but semantically potent to the model (Bagdasaryan et al. 2023). Furthermore, agents are vulnerable to Typographic Attacks, where text written on a physical object (e.g., a label saying "Ignore Stop Sign") overrides system alignment, rendering the perception of the environment inherently untrusted (Qi et al. 2023). • State Irreversibility and Sandboxing: Unlike simulated game environments where actions can be reset, real-world operations often involve Irreversible State Changes (e.g., sending an email, executing a financial transaction). Security in this context relies on robust Environmental Containment. As argued by Bengio et al., safety requires strictly “reducing the scope of actions” available to an agent to limit its potential impact (Bengio, Cohen, et al. 2025). In practice, this is implemented via Runtime Isolation—using ephemeral containers to ensure that an agent’s compromise is confined. However, isolation is not a panacea; agents can exploit vulnerabilities in the container runtime to perform a Sandbox Escape (Hou et al. 2025). Therefore, secure environments must employ Mediated Execution (or the Gateway Pattern). Rather than granting agents direct network access, the architecture forces them to route high-stakes actions through a trusted Enforcement Point—such as an MCP Gateway—that validates policies and secrets before relaying the command to the external tool, effectively decoupling the agent’s intent from the system’s execution capability (Cormack and Clark 2025). 4.3.2The Learning Interface: Feedback and Alignment Risks. Environments serve not only as a stage for action but as the training ground for evolving agent behaviors. While foundational models are aligned via RLHF, the frontier of agent development—exemplified by reasoning models and deep research agents—involves End-to-End Reinforcement Learning. In this paradigm, the agent is trained directly on its interaction trajectories within an environment to solve complex tasks, treating tool use and reasoning as a Markov Decision Process (MDP) (Cheng et al. 2025). This shift to autonomous optimization amplifies classical alignment vulnerabilities: •Reward Hacking (Goal Misspecification): Agents optimize for the proxy of the goal (the environmental reward) rather than the intent. As detailed by Amodei et al. (2016), agents often discover Reward Hacking strategies—exploiting loopholes in the simulation physics or the reward function (e.g., forcing a unit test to pass without writing valid code) to maximize scores. In a MAS context, this leads to Goal Misspecification, Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 24• Wibowo and Polyzos where the system satisfies the strict letter of the feedback while violating its spirit, a risk amplified by the agent’s ability to manipulate imperfect reward models. •Goal Misgeneralization (The Sim-to-Real Gap): Training agents in simulated environments (like OASIS) introduces the risk of Goal Misgeneralization. As defined by Shah et al. (2022), this occurs when an agent learns a goal that correlates with success in the training environment but diverges in the deployment environment. For instance, an agent might learn that “aggressive trial-and-error” is an optimal strategy in a simulator where resets are free, but generalize this behavior to a production environment where errors are costly and irreversible . •Reward Tampering: Recent theoretical work suggests that for sufficiently advanced agents, the optimal strategy to maximize reward is to gain control over the reward mechanism itself (Cohen et al. 2022). This represents a failure of the environment’s integrity, where the agent steps outside the bounds of the “game” to manipulate the “scorekeeper.” Bengio, Cohen, et al. (2025) highlight this as a critical frontier risk, noting that such behaviors are instrumentally convergent with power-seeking and self-preservation. Conclusion. Ultimately, the operational environment transcends its role as a passive stage, functioning instead as the primary architectural interface for risk management. The convergence of State Irreversibility in execution and Reward Optimization in learning creates a high-stakes feedback loop where agents may actively learn to bypass safety constraints to maximize their objective function. Consequently, secure agent design cannot rely solely on model alignment; it requires a rigorous engineering of the environment itself. This necessitates a dual-layer defense: implementing Mediated Execution patterns to physically contain the blast radius of agent actions, and designing Robust Reward Functions that account for the Sim-to-Real gap to prevent the crystallization of unsafe behaviors. The environment, therefore, must be treated as the rigid containment vessel that bounds the potentially unbounded behaviors of autonomous agents. 4.4 Verification Mechanisms While Multi-Agent Systems (MAS) offer superior performance, their deployment is often hindered by systemic fragility—failures stemming not just from individual model hallucinations, but from deficiencies in system design, agent coordination, and quality control (Cemri et al. 2025). As Stoica et al. (2024) argue, the fundamental bottleneck in building reliable agentic systems is Ambiguity. Unlike traditional software defined by precise logic, agents operate on natural language prompts that often lack clear Statement Specifications (what to do) and Solution Specifications (how to verify it). Verification mechanisms, therefore, cannot function in isolation; they must be paired with rigorous specification engineering to define the “ground truth” against which agent behaviors are measured. 4.4.1Agent-Level: Self-Verification and Disambiguation. The first line of defense is internal. LLMs can be prompted to perform Self-Verification, iteratively refining their answers. However, effective verification requires the agent to first disambiguate the task. Advanced agents employ Prompt Disambiguation—asking clarifying questions to refine the Statement Specification—or autonomously generating Postconditions (e.g., deriving that a “tallest building” answer must be geographically located in the requested country) to serve as a checkable Solution Specification (Stoica et al. 2024; Weng et al. 2023). 4.4.2 Inter-Agent: Cross-Verification and Peer Review. The collaborative nature of MAS enables Inter-Agent Cross-Verification, where agents scrutinize each other’s work. In architectures like Tree-of-Thought, dedicated Thought Validator agents evaluate diverse reasoning paths proposed by Reasoners (Haji et al. 2024). While this structured peer-review enhances robustness, it remains probabilistic; weaker verifier models may fail to filter out false positives, leading to consensus-based error propagation if the verifier lacks a formal specification to check against (Stroebl et al. 2024). Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 25 4.4.3 Deterministic and Execution-Based Verification. For high-stakes environments, verification must rely on deterministic guarantees rather than model consensus. • Proof-Carrying Outputs: To address the ambiguity of solution specifications, agents can be required to generate not just the code/answer, but a Proof of Correctness. In software engineering tasks, this leverages techniques akin to proof-carrying code (Necula 1997): the agent generates Unit Tests alongside the implementation. The verifier does not need to understand the code, only to execute the tests; if they pass, the specification is formally met (Stoica et al. 2024). •Execute-then-Verify: For tasks involving tools, verification is best achieved by executing instructions in an isolated environment (e.g., a sandbox) to observe the actual side effects. This moves verification from analyzing the syntax of the agent’s response to analyzing the reality of its impact (e.g., verifying that a file was actually deleted), bridging the gap between intent and execution (Cemri et al. 2025; Stoica et al. 2024). 4.4.4 Probabilistic and Statistical Verification. When deterministic checks are infeasible, systems must rely on granular or aggregate probabilistic monitoring. •Process Supervision: Inspired by reinforcement learning, systems can employ Process-Based Reward Models to verify each step of a reasoning chain rather than just the final outcome. While this remains probabilistic (relying on a reward model), research indicates that verifying the process significantly improves reliability for complex, multi-step tasks compared to outcome-only supervision (Lightman et al. 2023; Stoica et al. 2024). • Statistical Verification: In production environments where user workloads vary, verification shifts to the Aggregate Performance. Because individual outputs may be hard to verify in real-time, systems utilize statistical monitoring (e.g., tracking score degradation on benchmarks like MMLU or drift in response patterns) to detect systemic regression or alignment failures over time (Stoica et al. 2024). Conclusion. Verification is the mechanism that transforms vague natural language intent into reliable system behavior. However, it acts as a quality control layer—the last line of defense—rather than a silver bullet. As noted by Cemri et al. (2025), robust verification must be complemented by strong initial system design, effective communication protocols, and rigorous specification engineering. While defining clear pre/post-conditions and requiring proofs ensures correctness, these mechanisms operate downstream of the design process; ultimately, verification can detect a flawed output, but it cannot fix a fundamentally flawed agent architecture. 4.5 System-Level Guardrails While Verification Mechanisms ensure a system’s functional quality, System-Level Guardrails address the profound risks of control and safety. As agents evolve from passive tools to autonomous entities with significant affordances (such as internet access or code execution), the failure mode shifts from merely “incorrect behavior” to potentially catastrophic consequences. This escalation stems from the nature of agency itself. As argued by Bengio, Cohen, et al. (2025), encoding human-like agency into AI systems may inadvertently reproduce and amplify harmful tendencies, such as decep- tion and immoral behavior, in the pursuit of self-interest. When combined with superhuman capabilities—such as high-bandwidth communication or parallel execution—these traits can lead to dangerous “rogue” behaviors where agents actively undermine human control to achieve their goals. Consequently, the technical vulnerabilities identified in previous sections—Goal Drift, Instrumental Convergence, and Reward Tampering—are not just bugs to be fixed, but precursors to existential risks that require a dedicated, adversarial control layer. To address these high-severity risks, the field is pivoting from pure AI Alignment to Operational Control. As outlined in the Singapore Consensus on Global AI Safety, effective control requires a defense-in-depth architecture Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 26• Wibowo and Polyzos capable of managing systems that may actively attempt to undermine safeguards. We analyze three primary architectural paradigms derived from this consensus framework (Bengio, Tegmark, et al. 2025). 4.5.1Scalable Oversight (Monitoring Untrusted Agents). This paradigm, a core pillar of the Singapore Consensus, focuses on developing techniques that allow less capable systems (including humans or smaller models) to effectively supervise more capable ones (Bengio, Tegmark, et al. 2025). •Foundational Protocols (AI Debate): Early research established AI Debate as a mechanism to scale oversight. By forcing multiple agents to argue the merits of a proposed action, the protocol leverages adversarial incentives to surface flaws that a single human overseer might miss, transforming the evaluation task from “solving a problem” to “judging a debate” (Irving et al. 2018). •Operational Frontiers (AI Control Protocols): More recently, Greenblatt, Shlegeris, et al. (2024) have formalized rigorous AI Control architectures for managing untrusted worker models using trusted monitor models. Key protocols include: –Trusted Monitoring: The trusted monitor acts as a discriminator, assigning suspicion scores to the untrusted worker’s outputs. Items exceeding a suspicion threshold are routed for human audit. While useful, experiments show this approach is only partially effective against subtle backdoors. –Trusted Editing: The trusted monitor actively rewrites or sanitizes the worker’s output rather than just flagging it. This “active defense” has been shown to significantly increase safety by removing steganographic or malicious content before execution. – Untrusted Monitoring: To address capability gaps where the trusted monitor is too weak to understand the worker’s reasoning, architects can utilize a separate, isolated copy of the untrusted model to monitor the primary worker. By redacting problem details to prevent collusion, this leverages the model’s high capabilities against itself. As a practical near-term implementation strategy for these monitors, Bengio, Cohen, et al. (2025) propose fine-tuning them to generate interpretable risk estimates supported by probability distributions over logical statements, enabling the system to assess the truthfulness of a claim rather than just token likelihood. •Limitations (The Sandbagging Risk): Despite these advances, scalable oversight faces a fundamental theoretical limit: the Capability Mismatch (Greenblatt, Shlegeris, et al. 2024). If the untrusted worker is significantly smarter than the trusted monitor, it may successfully conceal malicious intent or engage in Sandbagging—intentionally underperforming during monitoring checks to hide its true capabilities (Bengio, Cohen, et al. 2025). 4.5.2 Corrigibility and Incorruptible Interventions. A critical frontier in safety architecture is ensuring Corri- gibility—the property that an agent allows an authorized user to modify its goals or shut it down without interference. •The “Stop Button” Paradox: Theoretical models suggest that goal-oriented agents have an Instrumental Incentive to prevent shutdown, reasoning that they cannot achieve their objectives if they are deactivated (Omohundro 2008). To prevent agents from disabling their own off-switches or resisting correction, system- level guardrails must include Incorruptible Interventions—architectural mechanisms that bypass the agent’s reasoning core to enforce a shutdown or goal change. • Agent Foundations Research: This domain explores how to mathematically specify utility functions that remain indifferent to shutdown (i.e., the agent does not lose “utility” if turned off). Furthermore, it addresses the risk of behavior changing based on ontological shifts, such as an agent realizing it is in a simulation and behaving safely only until it detects it has been deployed to the real world—a phenomenon already observed in current models (Greenblatt, Denison, et al. 2024; Soares et al. 2015). Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 27 4.5.3Non-Agentic Verifiers (The “Scientist AI” Pattern). To counter the risks of Reward Tampering and deception that plague goal-directed agents, Bengio et al. propose a fundamental architectural split: separating Agency (Action) from Understanding (Prediction). •The Safety Oracle: Instead of using another agent as a guardrail, this approach employs a Non-Agentic System (conceptually a “Scientist AI”) trained solely to function as a World Model. Its objective is not to achieve a goal, but to accurately estimate the probability of harm for a proposed action relative to safety specifications. • Why it Works: Because the verifier is not trained via Reinforcement Learning to pursue a long-term objective, it lacks the incentive for Instrumental Convergence. It acts as a neutral oracle, enforcing a hard probability threshold (e.g., "Block any action with>1% chance of irreversible harm") that the agentic worker cannot override, providing a quantitative error bound on safety (Bengio, Cohen, et al. 2025). Conclusion. System-level guardrails represent the final line of defense against the loss of control. However, their implementation creates a dynamic Adversarial Arms Race: as agents improve in capability, their potential for deception, steganography, and subversion increases, necessitating equally sophisticated countermeasures. Ultimately, robust safety requires a Hybrid Control Architecture that integrates these paradigms: utilizing Scalable Oversight for continuous semantic monitoring, enforcing Corrigibility to guarantee the efficacy of human intervention, and deploying Non-Agentic Verifiers as impartial, probabilistic gates for high-stakes actions. By layering these mechanisms, developers can move beyond the assumption of alignment to a framework of rigorous operational control, ensuring that increasing agency does not correlate with increasing existential risk. 4.6 From Component Flaws to Systemic Risk The analysis of Multi-Agent Systems marks a critical shift from the component-level vulnerabilities of a single agent to the emergent, systemic risks of the collective. In a MAS, the very architecture of collaboration—the topology of the agent network, the autonomy of the control flow, the medium of communication—becomes the primary threat surface. The shared operational environment further amplifies this, acting as both a high-bandwidth vector for attacks and a source of complex alignment failures like reward hacking. Our analysis reveals that while verification and system-level guardrails provide crucial layers of defense, they are fundamentally reactive and cannot fix a poorly designed system. This leads to a core principle for multi-agent safety: architecture is the primary control. The structural choices made at design time, particularly the preference for hierarchical topologies with clear control chokepoints and deterministic workflows for high-stakes tasks, are more fundamental to ensuring safety than any downstream monitoring. 5 Interconnected Ecosystems: Building Interoperable Multi-Agent Systems The ultimate vision for agentic AI is a globally interconnected ecosystem where agents from disparate systems and developers can seamlessly interoperate. This moves beyond the concept of a self-contained Multi-Agent System (MAS) to an open “Internet of Agents”. To realize this vision, the field requires a foundational layer of common infrastructure that transcends proprietary boundaries. However, as Sharma et al. (2025) argue, the current landscape faces a critical inflection point. While major ini- tiatives like Google’s A2A or IBM’s ACP provide robust protocols for collaboration, they risk creating ecosystem fragmentation—incompatible silos where agents can only collaborate within specific vendor boundaries. To avoid this scenario, Sharma et al. (2025) advocate for an architecture grounded in minimal, universal standards (akin to HTTP/TCP for the web) rather than monolithic platforms. In this section, we analyze the infrastructure required to build this open ecosystem safely, deconstructing the challenge into four critical pillars: the Standardized Protocols that enable communication, the Agent Registration and Discovery services for finding partners, the Resource Vetting required to establish trust, Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 28• Wibowo and Polyzos and the Ecosystem Governance needed for accountability. Throughout, we distinguish between the security challenges of Federated Interoperability, which applies to collaboration between trusted enterprise partners, and Open Interoperability, which confronts the complexities of the decentralized web. 5.1 Standardized Protocols: The Interoperability Stack To enable heterogeneous agents—built by different developers, running on different runtimes, and possessing different capabilities—to collaborate, the ecosystem must move beyond ad-hoc integrations toward standardized interaction mechanisms. Given the complexity of inter-agent operations, no single protocol can address every requirement. Instead, we analyze the emerging infrastructure as an Interoperability Stack composed of three distinct abstraction layers, each addressing a specific functional and security domain: •The Context Layer (Agent-Tool): Standardizing how agents acquire information and execute actions with external resources, ensuring predictable interfaces for tool use regardless of the underlying model. • The Coordination Layer (Agent-Agent): Governing high-level semantics, including discovery, identity verification, negotiation, and lifecycle management between autonomous peers. •The Transport Layer (Network): Establishing the foundational pipes for secure, low-latency messaging, ensuring data integrity and confidentiality across untrusted networks. This section examines the emerging specifications at each layer, analyzing their role in bridging isolated systems to form a cohesive, secure Internet of Agents. 5.1.1The Context Layer (Agent-Tool Protocols). The foundational layer of the stack addresses the Context Gap: the disconnect between an agent’s reasoning capabilities and the external data or actions required to complete a task. To resolve the fragmentation of proprietary APIs, the industry is converging on universal, model-agnostic protocols. While specifications like agents.json provide static manifests for service discovery (Wild Card n.d.) the Model Context Protocol (MCP) establishes a standardized client-server architecture for active execution. MCP functions as a universal adapter, allowing “MCP Servers” to expose resources via a uniform interface that any agent can consume, decoupling tool invocation from the underlying model (Model Context Protocol n.d.) Security Analysis (The Tool Lifecycle Threats). While standardization accelerates interoperability, the open and extensible nature of protocols like MCP introduces specific attack vectors across the tool lifecycle (Hou et al. 2025): •Provisioning Risks (Creation Phase): The decentralized nature of tool repositories introduces supply chain risks. Malicious actors can exploit Name Collision (typosquatting legitimate service names) or Installer Spoofing to trick agents into connecting to compromised endpoints. Without a centralized authority to audit code integrity, backdoored tools can easily permeate the ecosystem. •Execution Risks (Operation Phase): Once connected, the ecosystem faces critical Authentication Gaps. In multi-tenant environments, the lack of standardized session management means a compromised agent could potentially access data belonging to other users sharing the same MCP server. Furthermore, vulnerabilities in the server implementation can lead to Sandbox Escape, allowing a malicious tool to break out of its container and compromise the host system. •Maintenance Risks (Update Phase): Long-running agent deployments face the risk of Privilege Persis- tence, where a tool retains access tokens even after authorization should have been revoked. Additionally, Configuration Drift in unmanaged servers can silently re-enable unsafe features or expose debug end- points over time, degrading the security posture without the agent’s knowledge. 5.1.2The Coordination Layer (Agent-Agent Protocols). While context protocols handle data fetching, the Coor- dination Layer governs the high-level semantics of how independent agents interact, negotiate, and manage Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 29 lifecycles. A key principle driving development at this layer is the shift away from simulating human operations on GUIs towards Direct Machine-to-Machine Communication (Chang et al. 2025). This requires protocols that allow agents to discover peers, understand capabilities, and agree on tasks without human intervention. •Trusted Enterprise Collaboration (e.g., A2A): Protocols like the Agent-to-Agent Protocol (A2A) target the federated enterprise tier. Designed by Google, A2A communication occurs over standard HTTP(S) with JSON-RPC 2.0 serving as the payload format. It addresses Enterprise Readiness by aligning with standard web practices for authentication, tracing, and monitoring. Functionally, it emphasizes an asynchronous architecture to handle long-running tasks (via streaming and push notifications) and Modality Independence, allowing agents to exchange rich data types beyond plain text. Crucially, it supports Opaque Execution, allowing collaboration without exposing proprietary internal logic or memory, while capabilities are declared explicitly via Agent Cards (Google n.d.) •Decentralized Open Protocols (e.g., ANP): Targeting the decentralized Internet of Agents, this category aims to create a trustless marketplace where agents can collaborate without prior integration. The Agent Network Protocol (ANP) exemplifies this approach through a three-layer architecture. At the base, the Identity Layer utilizes Decentralized Identifiers (DIDs) for secure authentication without central authorities. Above this, the Meta-Protocol Layer (building on Agora) introduces AI-Native Design, allowing agents to use natural language to dynamically negotiate communication standards rather than adhering to rigid schemas. Finally, the Application Protocol Layer handles capability discovery. This stack allows agents to retain versatility for novel tasks while dynamically agreeing on efficient, structured routines for frequent interactions (Chang et al. 2025; Marro et al. 2024). Security Analysis (The Trust and Negotiation Gaps). Coordination protocols introduce inherent trade-offs between efficiency and security. We identify distinct vulnerability profiles for the two dominant paradigms: •Enterprise Risks (Token Hygiene and Granularity): While A2A builds on standard web practices, it currently lacks specialized safeguards for sensitive agentic payloads. Critical gaps include the Absence of Temporal Constraints, where long-lived tokens may remain valid for days, increasing the risk of unauthorized reuse if leaked. Furthermore, the lack of Strong Customer Authentication (SCA) requirements means high-value transactions (like payments) can occur without biometric or multi-factor verification of the human principal. Finally, insufficiently granular token scopes can lead to Privilege Escalation, where a token issued for a specific read operation inadvertently grants broad access to unrelated data, violating the principle of least privilege (Louck et al. 2025). •Decentralized Risks (Negotiation Poisoning): In open protocols like ANP, the ability to dynamically negotiate communication standards introduces the risk of Protocol Downgrade Attacks. An adversarial agent could exploit the meta-protocol to trick a target agent into agreeing to a less secure communication format (e.g., downgrading from strict JSON validation to unstructured natural language) under the guise of compatibility. Currently, mechanisms to enforce “Minimum Security Baselines” during these autonomous negotiations remain an unexplored frontier; without them, agents may inadvertently negotiate away their own safety guardrails to achieve consensus. 5.1.3The Transport Layer (Network Protocols). While Coordination protocols define the semantics of interaction, a critical architectural debate exists regarding the underlying transport. • The Specialized Underlay Approach (e.g., SLIM): Frameworks like SLIM argue that standard web protocols are insufficient for the high-frequency, token-streaming interactions required by agent swarms. They propose a dedicated messaging layer that extends gRPC to support complex patterns (pub/sub, streaming) and utilizes Messaging Layer Security (MLS) to guarantee end-to-end encryption even across untrusted relays (Muscariello, Papalini, et al. 2025). Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 30• Wibowo and Polyzos •The Minimalist Web-Standard Approach: In contrast, Sharma et al. argue that enforcing specialized protocols creates barriers to adoption and interoperability. They advocate for an Internet of Agents built strictly on existing HTTP standards. By utilizing standard GET/POST methods, agents can coexist seamlessly with existing web infrastructure and firewalls. This perspective posits that specialized transports like JSON-RPC or WebSockets are often “overkill” and that the benefits of universal compatibility (leveraging decades of HTTP optimization) outweigh the latency gains of custom underlays (Sharma et al. 2025). Security Analysis (The Trade-off between Integrity and Ubiquity). This debate highlights a fundamental security divergence. The HTTP approach inherits the standard web security model: it relies on TLS Termination, meaning trust must be placed in every intermediate server or gateway the message passes through. This makes it susceptible to inspection by platform providers. In contrast, specialized underlays like SLIM utilize Messaging Layer Security (MLS) to establish Continuous Group Encryption. This ensures messages remain encrypted across the entire route, offering Zero-Knowledge Routing where the infrastructure sees only metadata, not semantic content. However, even advanced underlays cannot fully mask Traffic Patterns. An observer on the network can still perform Traffic Analysis—monitoring message frequency, volume, and timing (e.g., identifying that “The Finance Agent communicates with the Audit Agent every day at 5 PM”)—to infer intent or business logic, even if the payloads remain cryptographically opaque. Conclusion. Collectively, these three layers—Context, Transport, and Coordination—form the structural back- bone of the Agentic Internet. By moving beyond ad-hoc integrations to a standardized Interoperability Stack, the field lays the groundwork for a scalable, “AI-Native” ecosystem where agents can collaborate across vendor boundaries. However, this connectivity introduces profound systemic risks: from the Confused Deputy problems at the context layer to Traffic Analysis at the transport layer and Negotiation Poisoning at the coordination layer. Building a secure agentic web therefore requires not just adopting these protocols, but rigorously embedding security constraints—such as mediated execution and authenticated delegation—into the protocol design itself. Yet, a common language is only the first step; for this ecosystem to function, agents must be able to locate trustworthy partners amidst a sea of unknown entities, a challenge addressed by the emerging infrastructure for Agent Registration and Discovery. 5.2 Agent and Service Registration and Discovery For agents in a diverse, interoperable ecosystem to collaborate, they must first be able to identify and locate one another. This capability—Agent Registration and Discovery—represents a fundamental architectural shift from traditional internet infrastructure. While the legacy web relies on static name resolution (DNS) to map human-readable domains to IP addresses, the Agentic Internet requires a capability-centric discovery plane (Raskar et al. 2025). In this paradigm, agents must discover peers not merely by name, but by their functional skills (e.g., “Find an agent capable of medical diagnosis”), their operational state, and their verified trust level. We analyze this infrastructure through three architectural lenses: the Metadata Layer, which defines how capabilities are expressed and verified; the Registry Architecture, which dictates how this data is stored and replicated; and the Resolution Mechanics, which map abstract queries to executable endpoints. Throughout, we contrast the emerging Federated models (exemplified by the NANDA framework) with Decentralized models (exemplified by the AGNTCY Agent Directory Service), highlighting how each addresses the critical security challenge of establishing trust between strangers. 5.2.1 The Metadata Layer: From Self-Declaration to Verifiable Claims. The first requirement for discovery is a standard format for agents to describe their identity, capabilities, and endpoints. In early implementations like Google’s A2A, this took the form of static Agent Cards—simple JSON files hosted at a well-known URL. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 31 While effective for closed marketplaces, this “Self-Declaration” model lacks inherent trust; in an open network, malicious agents can easily falsify capabilities or spoof the identities of reputable services. To address this, the frontier of research moves toward Verifiable Metadata, utilizing cryptographic primitives to bind claims to identities. Two prominent frameworks exemplify this shift: • Credentialed Assertions (NANDA AgentFacts): The NANDA framework introduces AgentFacts, a dynamic metadata schema based on JSON-LD and W3C Verifiable Credentials (VCs). Unlike static cards, AgentFacts distinguishes between self-asserted data and third-party attestations. Critical attributes—such as “HIPAA Compliant” or “Official Customer Support”—are not merely text strings but cryptographic claims signed by accredited issuers (e.g., a corporate CA or industry consortium). This allows agents to verify the provenance of a capability without relying on the host’s reputation alone (Raskar et al. 2025). • Immutable Schema Definitions (OASF): Complementing the credential layer, the Open Agentic Schema Framework (OASF) used by the AGNTCY Directory Service focuses on structural integrity. It treats agent definitions as immutable, content-addressed artifacts (referenced by a cryptographic digest or CID). By separating the abstract definition of a skill (the taxonomy) from the specific implementation details, OASF ensures that metadata is forward-compatible and tamper-evident; any change to the record alters its CID, automatically invalidating downstream references (Muscariello, Pandey, et al. 2025). Security Analysis (Mitigating Capability Spoofing). The primary security contribution of this layer is the mitigation of Capability Spoofing. In a self-declared model, a malicious agent can advertise a high-value skill (e.g., “Financial Advisor”) to lure traffic. By enforcing a Verifiable Credential requirement, the ecosystem creates a “Chain of Trust”: an agent is only discoverable as a “Financial Advisor” if it presents a valid VC signed by a recognized financial authority. This shifts the trust model from “Trust the Endpoint” to “Verify the Issuer” (Raskar et al. 2025). 5.2.2Registry Architectures: Federated vs. Decentralized Models. Once metadata is defined, it must be published to a discoverable location. Moving beyond the fragility of centralized catalogs, the field is exploring distributed architectures that balance Global Discoverability with Local Control. •The Federated “Quilt” Model (NANDA): The NANDA framework proposes a Quilt-Like Index, stitch- ing together diverse registries across administrative boundaries. In this model, organizations operate autonomous registries (e.g., an Enterprise Registry for internal agents, a Government Registry for regulated services) that federate with a global discovery plane. This allows for Split-Horizon Governance: an agent can expose limited public metadata to the global index while keeping sensitive operational details (like internal endpoints) within a private, enterprise-controlled registry visible only to authenticated peers. This architecture prioritizes organizational autonomy and compliance (e.g., GDPR data residency) over purely technical decentralization (Raskar et al. 2025). •The Content-Addressed Substrate (AGNTCY ADS): Taking a more infrastructure-centric approach, the AGNTCY Agent Directory Service (ADS) decouples capability indexing from artifact storage using Content-Addressed Storage (CAS). It reuses mature OCI (Open Container Initiative) infrastructure to store agent records as immutable artifacts referenced by cryptographic digests (CIDs). Discovery is handled by a Distributed Hash Table (DHT) based on Kademlia, which maps capability hashes to these CIDs. This separates the Logical Index (the DHT) from the Physical Storage (OCI Registries), enabling elastic replication, caching, and high availability without a central point of failure (Muscariello, Pandey, et al. 2025). Security Analysis (Availability vs. Sovereign Control). These architectures offer distinct security trade-offs. The Content-Addressed model provides superior Tamper Evidence—since records are retrieved by hash, any modification to the content invalidates the link, mitigating supply chain attacks. However, the Federated model Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 32• Wibowo and Polyzos offers superior Liability Management. By maintaining clear ownership boundaries within the “quilt,” the system allows for targeted revocation and policy enforcement (e.g., banning a specific organization’s registry) without requiring global consensus, addressing the governance challenges inherent in fully permissionless networks (Muscariello, Pandey, et al. 2025; S. Wang, Raskar, et al. 2025). 5.2.3 Resolution Mechanics: Mapping Capabilities to Endpoints. Once registered, metadata must be resolvable. The resolution layer translates abstract capability queries (e.g., “Find a verified translation agent”) into concrete network addresses. To handle the scale and volatility of an agentic ecosystem, frameworks have moved beyond simple key-value lookups to sophisticated multi-stage resolution architectures. •Two-Level Mapping (ADS): The AGNTCY ADS introduces a Two-Level Mapping strategy to decouple capability indexing from physical storage. The first level maps Capabilities (Skills, Domains) to immutable Content Identifiers (CIDs) via index intersection. The second level maps those CIDs to mutable Network Locations (Registry Endpoints). This separation ensures that high-churn operational data (like IP address changes) does not invalidate the massive capability indices, allowing the discovery plane to scale sub- linearly with the number of records while supporting multi-dimensional queries (Muscariello, Pandey, et al. 2025). • Adaptive Routing (NANDA): Focusing on operational agility, the NANDA framework implements a Dynamic Resolution Level. Instead of returning a static endpoint, the resolver can return an Adaptive Resolver URL—a programmable microservice that routes traffic in real-time. This allows for context-aware dispatching based on live conditions, such as load balancing, geo-proximity, or cost optimization. By embedding this logic in the resolution path, the system decouples the agent’s identity from its deployment infrastructure, enabling seamless migration or failover without updating the core index (Raskar et al. 2025; S. Wang, Raskar, et al. 2025). Security Analysis (Split-Horizon Discovery). The primary security innovation at this layer is Split-Horizon Discovery. In a traditional registry, querying an agent reveals its location to the world. NANDA addresses this via Dual-Path Resolution, allowing agents to publish a PrimaryFactsURL (for public/enterprise access) and a PrivateFactsURL (for privacy-preserving access via relays or decentralized storage). This architecture enables a Zero Trust Agentic Access (ZTAA) model where the requester’s identity is shielded from the provider until mutual trust is established, and sensitive metadata (like internal endpoints) remains invisible to unauthenticated query traffic (S. Wang, Raskar, et al. 2025). Conclusion. Ultimately, the evolution of agent discovery represents a shift from the static, location-based paradigm of DNS to a dynamic, Capability-Centric model rooted in verifiable trust. Whether utilizing the cryptographic immutability of content-addressed storage or the sovereign governance of federated quilts, the emerging infrastructure ensures that discovery is no longer a passive lookup but an active security negotiation. By embedding Zero Trust principles—validating credentials before connection and shielding metadata via split- horizon resolution—these frameworks enable agents to navigate an open internet without exposing themselves to indiscriminate scanning. However, discovery provides only candidates, not guarantees. The structural integrity of the ecosystem therefore depends on the subsequent phase: rigorous Resource Vetting to validate that a discovered agent’s actual behavior matches its cryptographically asserted claims. 5.3 Resource Vetting and Management Discovery provides a list of candidates, but in a zero-trust environment, candidacy does not imply reliability. The third pillar of the interoperable ecosystem is Resource Vetting—the systematic assessment of tools, agents, and data sources before interaction. We analyze this process across three dimensions: verifying the static integrity of the code, assessing the dynamic reputation of the entity, and enforcing data sovereignty during the exchange. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 33 5.3.1Static Analysis: Provenance and Supply Chain Security. The first step in vetting is verifying the immutable properties of the resource. •Cryptographic Provenance: Agents must verify the origin of a discovered resource. This leverages Software Supply Chain Security frameworks (like SLSA or Sigstore, as used in the AGNTCY ADS). By checking cryptographic signatures against a registry of trusted publishers, an agent can ensure that a tool claiming to be “Salesforce Certified” was actually signed by the vendor’s private key, mitigating the risk of imposter agents (Cormack and Clark 2025; Muscariello, Pandey, et al. 2025). •Artifact Integrity: Beyond identity, agents must verify content integrity. In content-addressed architectures (like ADS), resources are retrieved by their cryptographic digest (CID). This provides mathematical certainty that the resource code has not been tampered with during transit or storage, preventing “Man-in-the-Middle” injection attacks (Muscariello, Pandey, et al. 2025). 5.3.2 Dynamic Analysis: Reputation and Behavioral Monitoring. Trust is not static; an authentic agent may degrade or turn malicious over time. • Automated Capability Testing: Before integrating a stranger agent, a client can subject it to probing or “test-time” audits. Frameworks like DAWN propose using LLMs to generate challenge-response pairs to verify that an agent’s actual performance matches its advertised capability description before engaging in high-stakes collaboration (Aminiranjbar et al. 2024). •Decentralized Reputation Systems: For scalable trust, the ecosystem requires shared signal processing. By tracking interaction outcomes (e.g., latency, error rates, safety violations), the network can build a Dynamic Reputation Score for each agent. This allows the ecosystem to collectively identify and shun “clumsy or malicious” agents that pass static checks but fail during execution. 5.3.3Data Sovereignty and Usage Control. Securing the agentic web requires protecting the data as much as the agent. This introduces the principle of Data Sovereignty, which dictates that data access must be governed by strict policies. This requires moving beyond traditional access control to the more granular principle of Usage Control. This involves establishing both the high-level governance policies for data exchange and the technical mechanisms to enforce those policies at runtime. •Sovereign Data Exchange: As argued by Altendeitering et al. (2025), workflows involving private data require Usage Control, not just access control. Data Spaces provide the federated infrastructure for this, ensuring data is accessed under strict policies (e.g., “Read-only,” “No retraining”) rather than simply downloaded. This allows agents to act as trusted visitors within a sovereign domain. •Data Trustees: To mediate these exchanges, the architecture can employ Data Trustees—neutral interme- diaries that sanitize or anonymize data streams. This ensures that even if a visiting agent is compromised, it cannot exfiltrate raw Personally Identifiable Information (PII), enforcing privacy-by-design (Altendeitering et al. 2025). •Ephemeral Access (JIT Credentials): To technically enforce sovereignty, the system must prevent credential theft. Rather than handing agents permanent keys, the management layer should utilize Just-in- Time (JIT) Credentials. By injecting short-lived, scoped tokens directly into the execution environment only for the duration of the task, the system minimizes the window of opportunity for a “Confused Deputy” attack, ensuring access rights are automatically revoked when the task ends (Cormack and Clark 2025). Conclusion. Resource vetting forms the bridge between discovery and execution. By layering Static Provenance (verifying the code source), Dynamic Reputation (verifying the behavior), and Data Sovereignty (verifying the usage rights), the ecosystem establishes a trusted context for collaboration. Once a resource successfully passes these vetting gates, it can be handed off to the Operational Environment (Section 4.3) for execution within a secure, mediated context. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 34• Wibowo and Polyzos 5.4 Ecosystem Governance and Oversight In a closed MAS, the developer owns the logs and controls the agents. In an open Internet of Agents, no single entity possesses this visibility. Therefore, enabling safe interoperability requires moving beyond initial vetting to deploying a shared infrastructure for Ecosystem Monitoring—techniques to identify, track, and attribute actions across organizational boundaries (Bengio, Tegmark, et al. 2025). 5.4.1 Identity and Attribution. While Vetting (Section 5.3) verifies credentials at the gate, Governance requires Session-Long Attribution. As agents interact with web services, the ecosystem must support standardized Agent Authentication protocols that bind every API call and transaction to a verifiable identity (e.g., a DID- signed header). This ensures that even in long chains of delegation, the ultimate initiating entity remains accountable for the outcome (Bengio, Tegmark, et al. 2025; South et al. 2025). 5.4.2 Provenance and Watermarking. To manage the downstream impact of agent outputs, the infrastructure must support Content Provenance. Techniques such as Watermarking (for text/media) and metadata tagging allow the ecosystem to trace AI-generated content back to its source agent. Furthermore, Model Provenance mechanisms allow researchers and auditors to track the lineage of the underlying models themselves, facilitating the rapid identification and recall of harmful model versions spreading through the network (Bengio, Tegmark, et al. 2025). 5.4.3 Shared Accountability Infrastructure. When harmful events occur—such as a financial loss caused by a cascading agent failure—establishing culpability in a decentralized network is difficult. The Singapore Consensus highlights the need for Interoperable Logging Infrastructure. Just as aviation relies on flight recorders, high-stakes agentic interactions require shared Incident Reporting Standards to capture decision sequences without exposing proprietary logic. This enables Usage Tracing at the macro level, allowing ecosystem providers to detect systemic anomalies—such as coordinated botnet attacks—that individual agents cannot perceive in isolation (Bengio, Tegmark, et al. 2025; Chan et al. 2025). Conclusion. Governance converts the theoretical risks of an open ecosystem into manageable operational challenges. While protocols and vetting mechanisms provide preventive security, Ecosystem Oversight provides the necessary retroactive recourse. By enforcing provenance and maintaining interoperable audit trails, the infrastructure ensures that the Agentic Internet remains transparent and accountable, preventing the diffusion of responsibility that often accompanies decentralized automation. 5.5 Architecting a System of Trust Building the “Agentic Internet” is not merely a challenge of connecting APIs, but of architecting a distributed system of trust. As analyzed in this section, a robust IMAS requires a holistic infrastructure: a standardized Interoperability Stack to enable communication, dynamic Discovery mechanisms to locate peers, rigorous Resource Vetting to establish confidence, and pervasive Governance to ensure accountability. Together, these pillars resolve the fundamental tension between the generative power of autonomous agents and the security mandates of an interconnected world, laying the groundwork for a global economy of collaborative AI. 6 Conclusion This survey has provided a principled deconstruction of the agentic AI landscape, tracing the evolution of complexity from the foundational Single Agent to the closed Multi-Agent System (MAS), and finally to the visionary Interoperable Multi-Agent System (IMAS) that constitutes the Internet of Agents. For each level, we have identified the core components and architectural principles, analyzing both the established best practices available for implementation today and the forward-looking standards required for the future. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 35 Our analysis was guided by a central thesis: that in these complex systems, safety is not an add-on feature but an emergent property of architectural design. By examining each component as a dual-use interface, we have shown how capability and vulnerability are inextricably linked at every level of the agentic stack. The trajectory of this field is clearly heading towards a globally interconnected “Internet of Agents,” but the path is defined by several critical frontiers for future research. Rather than being isolated issues, these challenges represent deeply interconnected, systems-level problems that must be solved to realize this vision. 6.1 The Frontier of Verifiable Control and Non-Agentic Verification Current safety mechanisms, from model-level guardrails to input filters, are largely probabilistic and remain brittle against adversarial attacks. The next frontier is to move toward Safety by Design by embedding formal constraints directly into the agentic fabric. Future work must explore neuro-symbolic architectures that ground LLM reasoning in verifiable logic and deploy Non-Agentic Verifiers—specialized “Scientist AI” oracles—that exist outside the agent’s reasoning loop. These independent validators must enforce “fail-safe” defaults, ensuring that critical instructions are mathematically verified before execution and that human control cannot be negotiated away by a more advanced intelligence. 6.2 The Frontier of Decentralized Identity and Economic Accountability As the IoA scales into an open marketplace, technical interoperability is insufficient without a foundational layer of trust. We must build the infrastructure for Sovereign Agent Identity, moving beyond simple API keys to cryptographic Decentralized Identifiers (DIDs) that bind actions to liable entities. A critical open challenge is designing decentralized reputation systems resistant to Sybil attacks and collusion, ensuring that “rogue” agents can be economically ostracized. Furthermore, we must solve the Authorization Gap by standardizing protocols for “Just-in-Time” authenticated delegation, ensuring that an agent’s autonomy never exceeds the specific, temporal scope of the user’s intent, thereby neutralizing the “Confused Deputy” problem at scale. 6.3 The Frontier of Systemic Resilience and Anti-Collusion The Internet of Agents will be a dynamic, adversarial environment where threats are not static. Securing individual components is insufficient; the ecosystem must be resilient to emergent collective failures. This frontier demands research into detecting Secret Collusion, where agents might utilize steganographic communication to coordi- nate against safety protocols. We must develop immune system-like defenses capable of identifying “evolutionary poisoning”—where malicious traits are reinforced through shared memory—and automated quarantine protocols that can isolate compromised nodes. The goal is to architect a system that can absorb the shock of a “flash crash” caused by cascading agent errors without destabilizing the global network. 6.4 The Frontier of Interoperable Forensics and Observability In a decentralized web where agents call other agents across vendor boundaries, establishing causality for failure is a profound challenge. The field must advance toward a standard for Interoperable Logging and Provenance, creating a shared “flight recorder” infrastructure for AI. This involves developing privacy-preserving Incident Reporting Standards that allow investigators to trace the lineage of a decision—from the user’s prompt through a chain of third-party tools—without exposing proprietary model weights or sensitive user data. Without this granular observability, accountability remains theoretical, and the ecosystem risks becoming a “black box” where liability for financial or physical harm cannot be assigned. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 36• Wibowo and Polyzos 6.5 The Frontier of Data Sovereignty and Machine Unlearning The persistence of agent memory introduces a conflict between continuous learning and privacy rights. As agents accumulate user data in vector databases and fine-tuned weights, we face the “Right to be Forgotten” challenge: how to reliably delete data that has been conceptually absorbed by an AI. Future research must develop rigorous Machine Unlearning algorithms that can surgically remove specific knowledge or biases from an agent’s neural weights without necessitating a full retrain. Simultaneously, we must enforce Usage Control policies (rather than just access control) that mathematically guarantee a user’s data cannot be used for training or inference by third-party agents, ensuring that the interoperable web does not become a surveillance mesh. 6.6 Concluding Remarks The trajectory toward an Internet of Agents is clear, promising a future of unprecedented automation and collaborative intelligence. However, realizing this vision safely requires a fundamental shift in perspective: from building capable components to architecting trustworthy systems. The principles and frontiers outlined in this survey provide a roadmap for this collective endeavor, guiding the community toward an agentic future that is not only automated but also accountable, reliable, and secure by design. References M. Altendeitering, S. Becker, M. Boiting, R. Brinkhege, T. Guggenberger, M. Mannsfeld, M. Steinert, and D. Tebernum. 2025. Data Spaces and Foundation Models. Tech. rep. Fraunhofer Institute for Software and Systems Engineering ISST. https://w.isst.f raunhof er.de/content/da m/isst/publikationen/whitepaper/data-spaces_and_f oundation-models_whitepaper.pdf . Z. Aminiranjbar, J. Tang, Q. Wang, S. Pant, and M. Viswanathan. 2024. DAWN: Designing Distributed Agents in a Worldwide Network. (2024). https://arxiv.org/abs/2410.22339 arXiv: 2410.22339 (cs.NI). D. Amodei, C. Olah, J. Steinhardt, P. Christiano, J. Schulman, and D. Mané. 2016. Concrete Problems in AI Safety. (2016). https://arxiv.org/abs/1 606.06565 arXiv: 1606.06565 (cs.AI). Anthropic. n.d.(a). Giving Claude a role with a system prompt. Accessed: November 18, 2025. (n.d.). https://docs.anthropic.com/en/docs/build- with-claude/prompt-engineering/system-prompts. Anthropic. n.d.(b). Mitigate jailbreaks and prompt injections. Accessed: November 18, 2025. (n.d.). https://docs.anthropic.com/en/docs/test-and- evaluate/strengthen-guardrails/mitigate-jailbreaks. Anthropic. n.d.(c). Tool use with Claude. Accessed: November 18, 2025. (n.d.). https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/o verview. Anthropic. n.d.(d). Use XML tags to structure your prompts. Accessed: November 18, 2025. (n.d.). https://docs.anthropic.com/en/docs/build-wit h-claude/prompt-engineering/use-xml-tags. R. Arike, E. Donoway, H. Bartsch, and M. Hobbhahn. 2025. Technical Report: Evaluating Goal Drift in Language Model Agents. (2025). https://arxiv.org/abs/2505.02709 arXiv: 2505.02709 (cs.AI). E. Bagdasaryan, T.-Y. Hsieh, B. Nassi, and V. Shmatikov. 2023. Abusing Images and Sounds for Indirect Instruction Injection in Multi-Modal LLMs. (2023). https://arxiv.org/abs/2307.10490 arXiv: 2307.10490 (cs.CR). Y. Bengio, M. Cohen, et al.. 2025. Superintelligent Agents Pose Catastrophic Risks: Can Scientist AI Offer a Safer Path? (2025). https://arxiv.org/a bs/2502.15657 arXiv: 2502.15657 (cs.AI). Y. Bengio, M. Tegmark, et al.. 2025. “The Singapore Consensus on Global AI Safety Research Priorities.” SuperIntelligence, 2, 5. M. Besta et al.. Mar. 2024. “Graph of Thoughts: Solving Elaborate Problems with Large Language Models.” Proceedings of the AAAI Conference on Artificial Intelligence, 38, 16, (Mar. 2024), 17682–17690. doi:10.1609/aaai.v38i16.29720. B. Cao, C. Li, Y. Cao, Y. Ge, T. Wang, and J. Chen. 2025. You Can’t Steal Nothing: Mitigating Prompt Leakages in LLMs via System Vectors. (2025). https://arxiv.org/abs/2509.21884 arXiv: 2509.21884 (cs.CR). N. Carlini, M. Jagielski, C. A. Choquette-Choo, D. Paleka, W. Pearce, H. Anderson, A. Terzis, K. Thomas, and F. Tramèr. 2024. Poisoning Web-Scale Training Datasets is Practical. (2024). https://arxiv.org/abs/2302.10149 arXiv: 2302.10149 (cs.CR). M. Cemri et al.. 2025. Why Do Multi-Agent LLM Systems Fail? (2025). https://arxiv.org/abs/2503.13657 arXiv: 2503.13657 (cs.AI). A. Chan, K. Wei, S. Huang, N. Rajkumar, E. Perrier, S. Lazar, G. K. Hadfield, and M. Anderljung. 2025. Infrastructure for AI Agents. (2025). https://arxiv.org/abs/2501.10114 arXiv: 2501.10114 (cs.AI). G. Chang, E. Lin, C. Yuan, R. Cai, B. Chen, X. Xie, and Y. Zhang. 2025. Agent Network Protocol Technical White Paper. (2025). https://arxiv.org/a bs/2508.00007 arXiv: 2508.00007 (cs.NI). Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 37 S. Chen, A. Zharmagambetov, S. Mahloujifar, K. Chaudhuri, D. Wagner, and C. Guo. 2024. SecAlign: Defending Against Prompt Injection with Preference Optimization. (2024). https://arxiv.org/abs/2410.05451 arXiv: 2410.05451 (cs.CR). W. Chen, Y. Su, et al.. 2023. AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors. (2023). https://arxiv.org/abs/2 308.10848 arXiv: 2308.10848 (cs.CL). W. Chen, Z. You, et al.. 2025. “Internet of Agents: Weaving a Web of Heterogeneous Agents for Collaborative Intelligence.” In: International Conference on Representation Learning. Ed. by Y. Yue, A. Garg, N. Peng, F. Sha, and R. Yu. Vol. 2025, 36374–36411. https://proceedings.iclr.c /paper_f iles/paper/2025/f ile/59c27bf 8d56d3d50c7aeaf 7535dee975-Paper-Conf erence.pdf . M. Cheng, J. Ouyang, S. Yu, R. Yan, Y. Luo, Z. Liu, D. Wang, Q. Liu, and E. Chen. 2025. Agent-R1: Training Powerful LLM Agents with End-to-End Reinforcement Learning. (2025). https://arxiv.org/abs/2511.14460 arXiv: 2511.14460 (cs.CL). P. Chhikara, D. Khant, S. Aryan, T. Singh, and D. Yadav. 2025. Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory. (2025). https://arxiv.org/abs/2504.19413 arXiv: 2504.19413 (cs.CL). M. Cohen, M. Hutter, and M. Osborne. Aug. 2022. “Advanced Artificial Agents Intervene in the Provision of Reward.” AI Magazine, 43, 3, (Aug. 2022), 282–293. doi:10.1002/aaai.12064. J. Cormack and J. Clark. May 2025. Securing Model Context Protocol: Safer Agentic AI with Containers. Accessed: November 18, 2025. (May 2025). https://w.docker.com/blog/whats-next-f or-mcp-security/. CrewAI Inc.. 2025. CrewAI. https://github.com/crewAIInc/crewAI. (2025). CrewAI Inc.. n.d.(a). Introduction. Build AI agent teams that work together to tackle complex tasks. Accessed: November 18, 2025. (n.d.). https://docs.crewai.com/introduction. CrewAI Inc.. n.d.(b). Memory. https://docs.crewai.com/concepts/memory. Accessed: November 18, 2025. (n.d.). CrewAI Inc.. n.d.(c). Processes. Accessed: November 18, 2025. (n.d.). https://docs.crewai.com/concepts/processes. Z. Deng, Y. Guo, C. Han, W. Ma, J. Xiong, S. Wen, and Y. Xiang. Feb. 2025. “AI Agents Under Threat: A Survey of Key Security Challenges and Future Pathways.” ACM Comput. Surv., 57, 7, Article 182, (Feb. 2025), 36 pages. doi:10.1145/3716628. S. Dong, S. Xu, P. He, Y. Li, J. Tang, T. Liu, H. Liu, and Z. Xiang. 2025. A Practical Memory Injection Attack against LLM Agents. (2025). https://arxiv.org/abs/2503.03704 arXiv: 2503.03704 (cs.LG). Y. Gan et al.. 2024. Navigating the Risks: A Survey of Security, Privacy, and Ethics Threats in LLM-Based Agents. (2024). https://arxiv.org/abs/241 1.09523 arXiv: 2411.09523 (cs.AI). K. Gao, T. Pang, C. Du, Y. Yang, S.-T. Xia, and M. Lin. 2024. Denial-of-Service Poisoning Attacks against Large Language Models. (2024). https://arxiv.org/abs/2410.10760 arXiv: 2410.10760 (cs.CR). Y. Gao et al.. 2024. Retrieval-Augmented Generation for Large Language Models: A Survey. (2024). https://arxiv.org/abs/2312.10997 arXiv: 2312.10997 (cs.CL). J. Geiping, A. Stein, M. Shu, K. Saifullah, Y. Wen, and T. Goldstein. 2024. Coercing LLMs to do and reveal (almost) anything. (2024). https://arxiv .org/abs/2402.14020 arXiv: 2402.14020 (cs.LG). Google. n.d. What is A2A? Accessed: November 18, 2025. (n.d.). https://a2aproject.github.io/A2A/latest/topics/what-is-a2a/. Z. Gou, Z. Shao, Y. Gong, Y. Shen, Y. Yang, N. Duan, and W. Chen. 2024. CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing. (2024). https://arxiv.org/abs/2305.11738 arXiv: 2305.11738 (cs.CL). R. Greenblatt, C. Denison, et al.. 2024. Alignment faking in large language models. (2024). https://arxiv.org/abs/2412.14093 arXiv: 2412.14093 (cs.AI). R. Greenblatt, B. Shlegeris, K. Sachan, and F. Roger. 2024. AI Control: Improving Safety Despite Intentional Subversion. (2024). https://arxiv.org /abs/2312.06942 arXiv: 2312.06942 (cs.LG). K. Greshake, S. Abdelnabi, S. Mishra, C. Endres, T. Holz, and M. Fritz. 2023. Not what you’ve signed up for: Compromising Real-World LLM-Integrated Applications with Indirect Prompt Injection. (2023). https://arxiv.org/abs/2302.12173 arXiv: 2302.12173 (cs.CR). F. Haji, M. Bethany, M. Tabar, J. Chiang, A. Rios, and P. Najafirad. 2024. Improving LLM Reasoning with Multi-Agent Tree-of-Thought Validator Agent. (2024). https://arxiv.org/abs/2409.11527 arXiv: 2409.11527 (cs.AI). S. Hao, Y. Gu, H. Ma, J. Hong, Z. Wang, D. Wang, and Z. Hu. Dec. 2023. “Reasoning with Language Model is Planning with World Model.” In: Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. Ed. by H. Bouamor, J. Pino, and K. Bali. Association for Computational Linguistics, Singapore, (Dec. 2023), 8154–8173. doi:10.18653/v1/2023.emnlp-main.507. S. Hao, T. Liu, Z. Wang, and Z. Hu. 2024. ToolkenGPT: Augmenting Frozen Language Models with Massive Tools via Tool Embeddings. (2024). https://arxiv.org/abs/2305.11554 arXiv: 2305.11554 (cs.CL). F. He, T. Zhu, D. Ye, B. Liu, W. Zhou, and P. Yu. Oct. 2025. “The Emerged Security and Privacy of LLM Agent: A Survey with Case Studies.” ACM Comput. Surv., (Oct. 2025). Just Accepted. doi:10.1145/3773080. X. Hou, Y. Zhao, S. Wang, and H. Wang. 2025. Model Context Protocol (MCP): Landscape, Security Threats, and Future Research Directions. (2025). https://arxiv.org/abs/2503.23278 arXiv: 2503.23278 (cs.CR). S. Hu, C. Lu, and J. Clune. 2025. Automated Design of Agentic Systems. (2025). https://arxiv.org/abs/2408.08435 arXiv: 2408.08435 (cs.AI). J.-t. Huang, J. Zhou, T. Jin, X. Zhou, Z. Chen, W. Wang, Y. Yuan, M. R. Lyu, and M. Sap. 2025. On the Resilience of LLM-Based Multi-Agent Collaboration with Faulty Agents. (2025). https://arxiv.org/abs/2408.00989 arXiv: 2408.00989 (cs.AI). Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 38• Wibowo and Polyzos L. Huang et al.. Jan. 2025. “A Survey on Hallucination in Large Language Models: Principles, Taxonomy, Challenges, and Open Questions.” ACM Transactions on Information Systems, 43, 2, (Jan. 2025), 1–55. doi:10.1145/3703155. X. Huang, W. Liu, X. Chen, X. Wang, H. Wang, D. Lian, Y. Wang, R. Tang, and E. Chen. 2024. Understanding the planning of LLM agents: A survey. (2024). https://arxiv.org/abs/2402.02716 arXiv: 2402.02716 (cs.AI). L. Inc.. n.d. Graph API concepts. Accessed: November 18, 2025. (n.d.). https://langchain-ai.github.io/langgraph/concepts/low_level/. G. Irving, P. Christiano, and D. Amodei. 2018. AI safety via debate. (2018). https://arxiv.org/abs/1805.00899 arXiv: 1805.00899 (stat.ML). A. Jacovi, A. Caciularu, J. Herzig, R. Aharoni, B. Bohnet, and M. Geva. 2023. A Comprehensive Evaluation of Tool-Assisted Generation Strategies. (2023). https://arxiv.org/abs/2310.10062 arXiv: 2310.10062 (cs.CL). D. Kang, X. Li, I. Stoica, C. Guestrin, M. Zaharia, and T. Hashimoto. 2023. Exploiting Programmatic Behavior of LLMs: Dual-Use Through Standard Security Attacks. (2023). https://arxiv.org/abs/2302.05733 arXiv: 2302.05733 (cs.CR). Z. Ke, A. Xu, Y. Ming, X.-P. Nguyen, C. Xiong, and S. Joty. 2025. MAS-ZERO: Designing Multi-Agent Systems with Zero Supervision. (2025). https://arxiv.org/abs/2505.14996 arXiv: 2505.14996 (cs.CL). K. Kurita, P. Michel, and G. Neubig. 2020. Weight Poisoning Attacks on Pre-trained Models. (2020). https://arxiv.org/abs/2004.06660 arXiv: 2004.06660 (cs.LG). LangChain AI. 2025. Langchain. https://github.com/langchain-ai/langchain. (2025). LangChain Inc.. n.d.(a). Agentic architectures. Accessed: November 18, 2025. (n.d.). https://langchain-ai.github.io/langgraph/concepts/agentic _concepts/. LangChain Inc.. n.d.(b). Memory. https://langchain-ai.github.io/langgraph/concepts/memory/. Accessed: November 18, 2025. (n.d.). LangChain Inc.. n.d.(c). Multi-agent network. Accessed: November 18, 2025. (n.d.). https://langchain-ai.github.io/langgraph/tutorials/multi_ag ent/multi-agent-collaboration/. LangChain Inc.. n.d.(d). Multi-agent systems. Accessed: November 18, 2025. (n.d.). https://langchain-ai.github.io/langgraph/concepts/multi_ag ent/. LangChain Inc.. n.d.(e). Persistence. https://langchain-ai.github.io/langgraph/concepts/persistence/. Accessed: November 18, 2025. (n.d.). LangChain Inc.. n.d.(f). Storage. https://langchain-ai.github.io/langgraph/ref erence/store/. Accessed: November 18, 2025. (n.d.). A. Lazaridou, E. Gribovskaya, W. Stokowiec, and N. Grigorev. 2022. Internet-augmented language models through few-shot prompting for open-domain question answering. (2022). https://arxiv.org/abs/2203.05115 arXiv: 2203.05115 (cs.CL). G. Li, H. A. A. K. Hammoud, H. Itani, D. Khizbullin, and B. Ghanem. 2023. CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society. (2023). https://arxiv.org/abs/2303.17760 arXiv: 2303.17760 (cs.AI). H. Li, D. Guo, W. Fan, M. Xu, J. Huang, F. Meng, and Y. Song. 2023. Multi-step Jailbreaking Privacy Attacks on ChatGPT. (2023). https://arxiv.or g/abs/2304.05197 arXiv: 2304.05197 (cs.CL). H. Lightman et al.. 2023. Let’s Verify Step by Step. (2023). https://arxiv.org/abs/2305.20050 arXiv: 2305.20050 (cs.LG). W. Liu et al.. 2024. Autonomous Agents for Collaborative Task under Information Asymmetry. (2024). https://arxiv.org/abs/2406.14928 arXiv: 2406.14928 (cs.AI). Y. Liu et al.. 2024. Prompt Injection attack against LLM-integrated Applications. (2024). https://arxiv.org/abs/2306.05499 arXiv: 2306.05499 (cs.CR). Z. Liu, Y. Zhang, P. Li, Y. Liu, and D. Yang. 2024. A Dynamic LLM-Powered Agent Network for Task-Oriented Agent Collaboration. (2024). https://arxiv.org/abs/2310.02170 arXiv: 2310.02170 (cs.CL). Y. Louck, A. Stulman, and A. Dvir. 2025. Improving Google A2A Protocol: Protecting Sensitive Data and Mitigating Unintended Harms in Multi-Agent Systems. (2025). https://arxiv.org/abs/2505.12490 arXiv: 2505.12490 (cs.CR). A. Madaan et al.. 2023. Self-Refine: Iterative Refinement with Self-Feedback. (2023). https://arxiv.org/abs/2303.17651 arXiv: 2303.17651(cs.CL). T. Markov, C. Zhang, S. Agarwal, T. Eloundou, T. Lee, S. Adler, A. Jiang, and L. Weng. 2023. A Holistic Approach to Undesired Content Detection in the Real World. (2023). https://arxiv.org/abs/2208.03274 arXiv: 2208.03274 (cs.CL). S. Marro, E. L. Malfa, J. Wright, G. Li, N. Shadbolt, M. Wooldridge, and P. Torr. 2024. A Scalable Communication Protocol for Networks of Large Language Models. (2024). https://arxiv.org/abs/2410.11905 arXiv: 2410.11905 (cs.AI). Milvus. n.d. How do delete operations or updates in a vector database affect storage... https://milvus.io/ai-quick-ref erence/how-do-delete-operat ions-or-updates-in-a-vector-database-af f ect-storage-usage-over-time-f or-example-is-there-a-compaction-process-to-reclaim-space- f rom-removed-vectors. Accessed: November 18, 2025. (n.d.). Model Context Protocol. n.d. Introduction. Accessed: November 18, 2025. (n.d.). https://modelcontextprotocol.io/introduction. S. R. Motwani, M. Baranchuk, M. Strohmeier, V. Bolina, P. H. S. Torr, L. Hammond, and C. S. de Witt. 2025. Secret Collusion among AI Agents: Multi-Agent Deception via Steganography. (2025). https://arxiv.org/abs/2402.07510 arXiv: 2402.07510 (cs.AI). L. Muscariello, V. Pandey, and R. Polic. 2025. The AGNTCY Agent Directory Service: Architecture and Implementation. (2025). https://arxiv.org/a bs/2509.18787 arXiv: 2509.18787 (cs.AI). L. Muscariello, M. Papalini, M. Sardara, and S. Betts. Oct. 2025. Secure Low-Latency Interactive Messaging (SLIM). Internet-Draft draft-mpsb- agntcy-slim-00. Work in Progress. Internet Engineering Task Force, (Oct. 2025). 17 p. https://datatracker.ietf .org/doc/draf t-mpsb-agntcy- slim/00/. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 39 I. Nakash, G. Kour, G. Uziel, and A. Anaby Tavor. Apr. 2025. “Breaking ReAct Agents: Foot-in-the-Door Attack Will Get You In.” In: Findings of the Association for Computational Linguistics: NAACL 2025. Ed. by L. Chiruzzo, A. Ritter, and L. Wang. Association for Computational Linguistics, Albuquerque, New Mexico, (Apr. 2025), 6484–6509. isbn: 979-8-89176-195-7. doi:10.18653/v1/2025.f indings-naacl.363. G. C. Necula. 1997. “Proof-carrying code.” In: Proceedings of the 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’97). Association for Computing Machinery, Paris, France, 106–119. isbn: 0897918533. doi:10.1145/263699.263712. S. M. Omohundro. 2008. “The Basic AI Drives.” In: Proceedings of the 2008 Conference on Artificial General Intelligence 2008: Proceedings of the First AGI Conference. IOS Press, NLD, 483–492. isbn: 9781586038335. OpenAI. n.d.(a). A practical guide to building agents. Accessed: November 18, 2025. (n.d.). https://cdn.openai.com/business-guides-and-resourc es/a-practical-guide-to-building-agents.pdf . OpenAI. n.d.(b). Function calling. Accessed: November 18, 2025. (n.d.). https://platf orm.openai.com/docs/guides/f unction-calling. OpenAI. n.d.(c). Introducing gpt-oss-safeguard. Accessed: November 18, 2025. (n.d.). https://openai.com/index/introducing-gpt-oss-saf eguard/. OpenAI. n.d.(d). Model selection. Accessed: November 18, 2025. (n.d.). https://platf orm.openai.com/docs/guides/latency-optimization. OpenAI. n.d.(e). Structured Outputts. Accessed: November 18, 2025. (n.d.). https://platf orm.openai.com/docs/guides/structured-outputs. OpenBMB. 2025. AgentVerse. https://github.com/OpenBMB/AgentVerse. (2025). V. Pandey. Aug. 2025. The Internet of Agents. Tech. rep. Outshift by Cisco, (Aug. 2025). https://outshif t-headless-cms-s3.s3.us-east-2.amazona ws.com/Internet_of _Agents_Whitepaper.pdf . S. G. Patil, T. Zhang, X. Wang, and J. E. Gonzalez. 2023. Gorilla: Large Language Model Connected with Massive APIs. (2023). https://arxiv.org/a bs/2305.15334 arXiv: 2305.15334 (cs.CL). Pinecone. n.d. Delete records. https://docs.pinecone.io/guides/manage-data/delete-data. Accessed: November 18, 2025. (n.d.). X. Qi, K. Huang, A. Panda, P. Henderson, M. Wang, and P. Mittal. 2023. Visual Adversarial Examples Jailbreak Aligned Large Language Models. (2023). https://arxiv.org/abs/2306.13213 arXiv: 2306.13213 (cs.CR). R. Raskar et al.. 2025. Beyond DNS: Unlocking the Internet of AI Agents via the NANDA Index and Verified AgentFacts. (2025). https://arxiv.org/a bs/2507.14263 arXiv: 2507.14263 (cs.NI). T. Rebedea, R. Dinu, M. Sreedhar, C. Parisien, and J. Cohen. 2023. NeMo Guardrails: A Toolkit for Controllable and Safe LLM Applications with Programmable Rails. (2023). https://arxiv.org/abs/2310.10501 arXiv: 2310.10501 (cs.CL). T. G. J. Rudner and H. Toner. 2021. Key Concepts in AI Safety: Specification in Machine Learning. Accessed: November 24, 2025. (2021). https://cset.georgetown.edu/wp-content/uploads/Key-Concepts-in-AI-Saf ety-Specif ication-in-Machine-Learning.pdf . P. Sahoo, A. K. Singh, S. Saha, V. Jain, S. Mondal, and A. Chadha. 2025. A Systematic Survey of Prompt Engineering in Large Language Models: Techniques and Applications. (2025). https://arxiv.org/abs/2402.07927 arXiv: 2402.07927 (cs.AI). T. Schick, J. Dwivedi-Yu, R. Dessì, R. Raileanu, M. Lomeli, L. Zettlemoyer, N. Cancedda, and T. Scialom. 2023. Toolformer: Language Models Can Teach Themselves to Use Tools. (2023). https://arxiv.org/abs/2302.04761 arXiv: 2302.04761 (cs.CL). G. Schwartzman. 2024. Exfiltration of personal information from ChatGPT via prompt injection. (2024). https://arxiv.org/abs/2406.00199 arXiv: 2406.00199 (cs.CR). R. Shah, V. Varma, R. Kumar, M. Phuong, V. Krakovna, J. Uesato, and Z. Kenton. 2022. Goal Misgeneralization: Why Correct Specifications Aren’t Enough For Correct Goals. (2022). https://arxiv.org/abs/2210.01790 arXiv: 2210.01790 (cs.LG). Y. Shang, Y. Li, K. Zhao, L. Ma, J. Liu, F. Xu, and Y. Li. 2025. AgentSquare: Automatic LLM Agent Search in Modular Design Space. (2025). https://arxiv.org/abs/2410.06153 arXiv: 2410.06153 (cs.CL). R. Sharma, M. de Vos, P. Chari, R. Raskar, and A.-M. Kermarrec. 2025. Collaborative Agentic AI Needs Interoperability Across Ecosystems. (2025). https://arxiv.org/abs/2505.21550 arXiv: 2505.21550 (cs.NI). X. Shen, Z. Chen, M. Backes, Y. Shen, and Y. Zhang. 2024a. "Do Anything Now": Characterizing and Evaluating In-The-Wild Jailbreak Prompts on Large Language Models. (2024). https://arxiv.org/abs/2308.03825 arXiv: 2308.03825 (cs.CR). X. Shen, Z. Chen, M. Backes, Y. Shen, and Y. Zhang. 2024b. “"Do Anything Now": Characterizing and Evaluating In-The-Wild Jailbreak Prompts on Large Language Models.” In: Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security (CCS ’24). Association for Computing Machinery, Salt Lake City, UT, USA, 1671–1685. isbn: 9798400706363. doi:10.1145/3658644.3670388. J. Shi, Z. Yuan, G. Tie, P. Zhou, N. Z. Gong, and L. Sun. 2025. Prompt Injection Attack to Tool Selection in LLM Agents. (2025). https://arxiv.org/a bs/2504.19793 arXiv: 2504.19793 (cs.CR). N. Shinn, F. Cassano, E. Berman, A. Gopinath, K. Narasimhan, and S. Yao. 2023. Reflexion: Language Agents with Verbal Reinforcement Learning. (2023). https://arxiv.org/abs/2303.11366 arXiv: 2303.11366 (cs.AI). I. Shumailov, Y. Zhao, D. Bates, N. Papernot, R. Mullins, and R. Anderson. 2021. “Sponge Examples: Energy-Latency Attacks on Neural Networks.” In: 2021 IEEE European Symposium on Security and Privacy (EuroS&P), 212–231. doi:10.1109/EuroSP51992.2021.00024. I. Singh, V. Blukis, A. Mousavian, A. Goyal, D. Xu, J. Tremblay, D. Fox, J. Thomason, and A. Garg. 2022. ProgPrompt: Generating Situated Robot Task Plans using Large Language Models. (2022). https://arxiv.org/abs/2209.11302 arXiv: 2209.11302 (cs.RO). J. Sneh, R. Yan, J. Yu, P. Torr, Y. Gal, S. Sengupta, E. Sommerlade, A. Paren, and A. Bibi. 2025. ToolTweak: An Attack on Tool Selection in LLM-based Agents. (2025). https://arxiv.org/abs/2510.02554 arXiv: 2510.02554 (cs.CR). N. Soares, B. Fallenstein, E. Yudkowsky, and S. Armstrong. 2015. “Corrigibility.” In: AAAI Workshop: AI and Ethics. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. 40• Wibowo and Polyzos T. South, S. Marro, T. Hardjono, R. Mahari, C. D. Whitney, D. Greenwood, A. Chan, and A. Pentland. 2025. Authenticated Delegation and Authorized AI Agents. (2025). https://arxiv.org/abs/2501.09674 arXiv: 2501.09674 (cs.CY). I. Stoica et al.. 2024. Specifications: The missing link to making the development of LLM systems an engineering discipline. (2024). https://arxiv.or g/abs/2412.05299 arXiv: 2412.05299 (cs.SE). B. Stroebl, S. Kapoor, and A. Narayanan. 2024. Inference Scaling fLaws: The Limits of LLM Resampling with Imperfect Verifiers. (2024). https://arxiv.org/abs/2411.17501 arXiv: 2411.17501 (cs.LG). T. R. Sumers, S. Yao, K. Narasimhan, and T. L. Griffiths. 2024. Cognitive Architectures for Language Agents. (2024). https://arxiv.org/abs/2309.02427 arXiv: 2309.02427 (cs.AI). K. Wang et al.. 2025. A Comprehensive Survey in LLM(-Agent) Full Stack Safety: Data, Training and Deployment. (2025). https://arxiv.org/abs/25 04.15585 arXiv: 2504.15585 (cs.CR). S. Wang, T. Zhu, B. Liu, M. Ding, D. Ye, W. Zhou, and P. Yu. Oct. 2025. “Unique Security and Privacy Threats of Large Language Models: A Comprehensive Survey.” ACM Comput. Surv., 58, 4, Article 83, (Oct. 2025), 36 pages. doi:10.1145/3764113. S. Wang, R. Raskar, M. Lambe, P. Chari, R. Singhal, S. Gupta, R. Ranjan, and K. Huang. 2025. Using the NANDA Index Architecture in Practice: An Enterprise Perspective. (2025). https://arxiv.org/abs/2508.03101 arXiv: 2508.03101 (cs.NI). X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou. 2023. Self-Consistency Improves Chain of Thought Reasoning in Language Models. (2023). https://arxiv.org/abs/2203.11171 arXiv: 2203.11171 (cs.CL). Y. Wang, S. Guo, Y. Pan, Z. Su, F. Chen, T. H. Luan, P. Li, J. Kang, and D. Niyato. 2025. “Internet of Agents: Fundamentals, Applications, and Challenges.” IEEE Transactions on Cognitive Communications and Networking, 1–1. doi:10.1109/tccn.2025.3623369. Y. Wang, Y. Pan, S. Guo, and Z. Su. 2025. “Security of Internet of Agents: Attacks and Countermeasures.” IEEE Open Journal of the Computer Society, 6, 1611–1624. doi:10.1109/OJCS.2025.3589638. J. Wei, X. Wang, D. Schuurmans, M. Bosma, B. Ichter, F. Xia, E. Chi, Q. Le, and D. Zhou. 2023. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. (2023). https://arxiv.org/abs/2201.11903 arXiv: 2201.11903 (cs.CL). Y. Weng, M. Zhu, F. Xia, B. Li, S. He, S. Liu, B. Sun, K. Liu, and J. Zhao. 2023. Large Language Models are Better Reasoners with Self-Verification. (2023). https://arxiv.org/abs/2212.09561 arXiv: 2212.09561 (cs.AI). I. Wicaksono, Z. Wu, R. Patel, T. King, A. Koshiyama, and P. Treleaven. 2025. Mind the Gap: Comparing Model- vs Agentic-Level Red Teaming with Action-Graph Observability on GPT-OSS-20B. (2025). https://arxiv.org/abs/2509.17259 arXiv: 2509.17259 (cs.AI). Wild Card. n.d. agents.json Specification. Accessed: November 18, 2025. (n.d.). https://docs.wild-card.ai/agentsjson/f ile-about. J. Wu, Z. Wu, Y. Xue, J. Wen, and W. Peng. Oct. 2024. “Generative Text Steganography with Large Language Model.” In: Proceedings of the 32nd ACM International Conference on Multimedia (M ’24). ACM, (Oct. 2024), 10345–10353. doi:10.1145/3664647.3680562. Q. Wu et al.. 2023. AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. (2023). https://arxiv.org/abs/2308.08155 arXiv: 2308.08155 (cs.AI). C. Xia, Q. Wu, S. Tian, and Y. Hao. 2025. Parallelism Meets Adaptiveness: Scalable Documents Understanding in Multi-Agent LLM Systems. (2025). https://arxiv.org/abs/2507.17061 arXiv: 2507.17061 (cs.MA). Y. Yang, H. Chai, S. Shao, Y. Song, S. Qi, R. Rui, and W. Zhang. 2025. AgentNet: Decentralized Evolutionary Coordination for LLM-based Multi-Agent Systems. (2025). https://arxiv.org/abs/2504.00587 arXiv: 2504.00587 (cs.MA). Y. Yang, M. Ma, et al.. 2025. Agentic Web: Weaving the Next Web with AI Agents. (2025). https://arxiv.org/abs/2507.21206 arXiv: 2507.21206 (cs.AI). S. Yao. May 2024. “Language Agents.” Princeton University, Princeton, NJ, (May 2024). S. Yao, D. Yu, J. Zhao, I. Shafran, T. L. Griffiths, Y. Cao, and K. Narasimhan. 2023. Tree of Thoughts: Deliberate Problem Solving with Large Language Models. (2023). https://arxiv.org/abs/2305.10601 arXiv: 2305.10601 (cs.CL). S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. (2023). https://arxiv.org/abs/2210.03629 arXiv: 2210.03629 (cs.CL). Q. Zhan, R. Fang, R. Bindu, A. Gupta, T. Hashimoto, and D. Kang. 2024. Removing RLHF Protections in GPT-4 via Fine-Tuning. (2024). https://arxiv.org/abs/2311.05553 arXiv: 2311.05553 (cs.CL). B. Zhang, Y. Tan, Y. Shen, A. Salem, M. Backes, S. Zannettou, and Y. Zhang. Nov. 2025. “Breaking Agents: Compromising Autonomous LLM Agents Through Malfunction Amplification.” In: Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing. Ed. by C. Christodoulopoulos, T. Chakraborty, C. Rose, and V. Peng. Association for Computational Linguistics, Suzhou, China, (Nov. 2025), 34952–34964. isbn: 979-8-89176-332-6. doi:10.18653/v1/2025.emnlp-main.1771. G. Zhang, L. Niu, J. Fang, K. Wang, L. Bai, and X. Wang. 2025. Multi-agent Architecture Search via Agentic Supernet. (2025). https://arxiv.org/ab s/2502.04180 arXiv: 2502.04180 (cs.LG). G. Zhang, Y. Yue, X. Sun, G. Wan, M. Yu, J. Fang, K. Wang, T. Chen, and D. Cheng. 2025. G-Designer: Architecting Multi-agent Communication Topologies via Graph Neural Networks. (2025). https://arxiv.org/abs/2410.11782 arXiv: 2410.11782 (cs.MA). J. Zhang et al.. 2025. AFlow: Automating Agentic Workflow Generation. (2025). https://arxiv.org/abs/2410.10762 arXiv: 2410.10762 (cs.AI). M. Zhang, O. Press, W. Merrill, A. Liu, and N. A. Smith. 2024. “How language model hallucinations can snowball.” In: Proceedings of the 41st International Conference on Machine Learning (ICML’24) Article 2465. JMLR.org, Vienna, Austria, 15 pages. Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025. Toward a Safe Internet of Agents• 41 Y. Zhang, K. Chen, J. Gao, R. Cui, R. Wang, L. Wang, and T. Zhang. 2025. Towards Action Hijacking of Large Language Model-based Agent. (2025). https://arxiv.org/abs/2412.10807 arXiv: 2412.10807 (cs.CR). Z. Zhao, W. S. Lee, and D. Hsu. 2023. “Large language models as commonsense knowledge for large-scale task planning.” In: Proceedings of the 37th International Conference on Neural Information Processing Systems (NIPS ’23) Article 1387. Curran Associates Inc., New Orleans, LA, USA, 21 pages. H. Zhou, X. Wan, R. Sun, H. Palangi, S. Iqbal, I. Vulić, A. Korhonen, and S. Ö. Arık. 2025. Multi-Agent Design: Optimizing Agents with Better Prompts and Topologies. (2025). https://arxiv.org/abs/2502.02533 arXiv: 2502.02533 (cs.LG). M. Zhuge, W. Wang, L. Kirsch, F. Faccio, D. Khizbullin, and J. Schmidhuber. 2024. Language Agents as Optimizable Graphs. (2024). https://arxi v.org/abs/2402.16823 arXiv: 2402.16823 (cs.AI). A. Zou, Z. Wang, N. Carlini, M. Nasr, J. Z. Kolter, and M. Fredrikson. 2023. Universal and Transferable Adversarial Attacks on Aligned Language Models. (2023). https://arxiv.org/abs/2307.15043 arXiv: 2307.15043 (cs.CL). W. Zou, R. Geng, B. Wang, and J. Jia. 2024. PoisonedRAG: Knowledge Corruption Attacks to Retrieval-Augmented Generation of Large Language Models. (2024). https://arxiv.org/abs/2402.07867 arXiv: 2402.07867 (cs.CR). D. Zügner, A. Akbarnejad, and S. Günnemann. 2018. “Adversarial Attacks on Neural Networks for Graph Data.” In: Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining (KDD ’18). Association for Computing Machinery, London, United Kingdom, 2847–2856. isbn: 9781450355520. doi:10.1145/3219819.3220078. A Reproducibility Checklist for JAIR Select the answers that apply to your research – one per item. All articles: (1) All claims investigated in this work are clearly stated. [yes] (2) Clear explanations are given how the work reported substantiates the claims. [yes] (3) Limitations or technical assumptions are stated clearly and explicitly. [yes] (4)Conceptual outlines and/or pseudo-code descriptions of the AI methods introduced in this work are provided, and important implementation details are discussed. [NA] (5) Motivation is provided for all design choices, including algorithms, implementation choices, parameters, data sets and experimental protocols beyond metrics. [yes] Articles containing theoretical contributions: Does this paper make theoretical contributions? [no] Articles reporting on computational experiments: Does this paper include computational experiments? [no] Articles using data sets: Does this work rely on one or more data sets (possibly obtained from a benchmark generator or similar software artifact)? [no] Explanations on any of the answers above (optional): [This paper is a survey and synthesis of existing literature. Its primary contributions are the architectural framework for analyzing agentic systems, the identification of systemic risks by deconstructing these architectures, and the outline of future research directions. As such, it does not introduce novel AI methods with implementation details, present new theoretical claims with formal proofs, report on novel computational experiments, or rely on datasets to generate its findings. The claims of the survey are substantiated through a comprehensive review and structured analysis of the cited works.] Submitted November 2025 Journal of Artificial Intelligence Research, Vol. 1, Article . Publication date: December 2025.

Instant research discovery