Agentic AI Frameworks: Architectures, Protocols, and Design Challenges (2508.10146v1)
Abstract: The emergence of LLMs has ushered in a transformative paradigm in artificial intelligence, Agentic AI, where intelligent agents exhibit goal-directed autonomy, contextual reasoning, and dynamic multi-agent coordination. This paper provides a systematic review and comparative analysis of leading Agentic AI frameworks, including CrewAI, LangGraph, AutoGen, Semantic Kernel, Agno, Google ADK, and MetaGPT, evaluating their architectural principles, communication mechanisms, memory management, safety guardrails, and alignment with service-oriented computing paradigms. Furthermore, we identify key limitations, emerging trends, and open challenges in the field. To address the issue of agent communication, we conduct an in-depth analysis of protocols such as the Contract Net Protocol (CNP), Agent-to-Agent (A2A), Agent Network Protocol (ANP), and Agora. Our findings not only establish a foundational taxonomy for Agentic AI systems but also propose future research directions to enhance scalability, robustness, and interoperability. This work serves as a comprehensive reference for researchers and practitioners working to advance the next generation of autonomous AI systems.
Sponsor
Summary
- The paper identifies key challenges impeding scalability and interoperability in Agentic AI frameworks through comprehensive comparative analysis.
- It details how diverse memory systems and standardized communication protocols enable dynamic, context-aware behaviors in multi-agent systems.
- The study outlines future research directions, emphasizing the adoption of universal protocols to integrate Agentic AI within service computing environments.
Agentic AI Frameworks: Architectures, Protocols, and Design Challenges
Introduction
The paper "Agentic AI Frameworks: Architectures, Protocols, and Design Challenges" (2508.10146) offers a comprehensive analysis of Agentic AI frameworks, highlighting their architectural principles, communication protocols, memory management, and alignment with service-oriented computing paradigms. The paper critically evaluates leading frameworks like CrewAI, LangGraph, AutoGen, and others, identifying key limitations and proposing future research directions to enhance the scalability, robustness, and interoperability of autonomous AI systems.
Foundations of Intelligent Agents
The evolution of intelligent agents has been significantly influenced by the rise of LLMs and transformer-based architectures, which have endowed modern agents with dynamic and context-aware behaviors. Unlike traditional agents that operated based on fixed logic and deterministic rules, contemporary agent architectures, such as ReAct and PRACT, utilize LLMs to reason, act, and interact fluidly within human-centered contexts. These agents are capable of executing complex, long-term tasks through iterative loops of reasoning and acting, leveraging tools and external data sources efficiently.
Agent Communication Protocols
The paper explores the critical role of agent communication protocols in ensuring interoperability, security, and scalability within Multi-Agent Systems. Modern protocols, such as the Model Context Protocol (MCP) and Agent-to-Agent Protocol (A2A), facilitate seamless interaction between agents via standardized schemas like JSON-RPC and JSON-LD. These protocols eliminate the need for manual integration and are pivotal in forming modular, resilient agentic systems, though widespread adoption remains limited due to their nascent development.
Analysis of Agentic AI Frameworks
Comparative Overview
The paper categorizes major Agentic AI frameworks based on their shared principles and usage patterns. Frameworks like AutoGen and CrewAI emphasize structured orchestration, enabling role-based collaboration and team-oriented problem-solving. In contrast, lightweight frameworks like SmolAgents focus on simplicity and modularity, providing flexibility for prompt chaining and tool use with minimal overhead.
Figure 1: Agentic AI design taxonomy.
Memory in Frameworks
Memory systems in agentic frameworks are crucial for context-aware adaptive behavior, categorized primarily into short-term and long-term memories. LangGraph and OpenAI's SDK maintain session-based memories, while CrewAI integrates memory for specific dialogues and task coordination. These diverse implementations highlight the growing necessity for robust memory systems in handling dynamic, multi-turn interactions in complex environments.
Guardrails and Safety
Guardrails are provided in frameworks like AutoGen and LangGraph to ensure predictability and safety by validating agent outputs and maintaining operational integrity. While some frameworks offer native guardrail support, others rely on manual configurations, indicating an area where standardized, modular safety layers are needed to safeguard agentic AI systems effectively.
Applications and Challenges
Agentic AI frameworks have demonstrated utility across various domains, from automated travel planning to complex finance tasks. However, they face significant challenges, including architectural rigidity, limited interoperability, and dynamic collaboration constraints. Frameworks often lack standardized interfaces for cross-platform communication, hindering broader adoption and integration into service-computing ecosystems.
Agentic AI from a Service Computing Perspective
From a service computing standpoint, current frameworks showcase potential but require additional enhancements for seamless integration. The paper identifies gaps in runtime discovery, dynamic composition, and orchestration, suggesting that integrating W3C standards like WSDL and WS-Policy could elevate these frameworks into comprehensive service-computing solutions.
Figure 2: Unified class model for Agentic AI frameworks.
Conclusion
The paper presents a thorough exploration of Agentic AI frameworks, highlighting their design divergences and operational focuses. While these frameworks have made strides in specific areas like memory integration and task orchestration, they still face challenges in achieving full interoperability and scalability. The proposed directions for future research include establishing universal communication protocols and enhancing architectural flexibility to foster the development of more robust and adaptable agentic AI systems. These advancements will be crucial in realizing the potential of Agentic AI within diverse real-world applications.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What is this paper about?
This paper looks at a new kind of artificial intelligence called Agentic AI. Think of Agentic AI as smart digital helpers (“agents”) that can set goals, plan steps, use tools, talk to other agents, remember things, and work together—mostly powered by LLMs like GPT. The authors compare popular toolkits (“frameworks”) for building these agents and the “protocols” (rules) agents use to talk to each other. They explain how these systems are built, how they communicate, how they handle memory and safety, and how ready they are to be used like regular online services.
What questions did the authors ask?
The authors turn the technical topic into four big, simple questions:
- How did AI agents change from old-style rule-followers to modern LLM-powered problem-solvers?
- What frameworks exist to build Agentic AI, and how do they support teamwork, negotiation, and communication?
- How do these frameworks compare in key areas like talking to each other, using memory, coordinating tasks, and staying safe?
- Are today’s Agentic AI tools ready to plug into the same kind of service-based systems used on the web (like apps that discover and call each other)?
How did they paper it?
The paper is a careful, side‑by‑side review:
- They read documentation, research papers, and examples for leading frameworks (such as CrewAI, LangGraph, AutoGen, Semantic Kernel, Agno, Google ADK, MetaGPT).
- They analyzed agent communication protocols (the “languages” and rules agents use): MCP, ACP, A2A, ANP, and Agora.
- They compared how frameworks are designed (architecture), how agents store and recall information (memory), the safety checks (guardrails), and how well they fit into service computing (systems where apps discover, combine, and run other apps).
- They summarized patterns (a “taxonomy”), drew a unified model of what most agents share, and pointed out gaps and future directions.
To make technical terms simple:
- Framework: a toolkit or recipe for building agent teams.
- Protocol: a standard set of rules for agents to discover each other and exchange messages (like road rules for cars).
- Memory: what agents can remember now (short-term) and later (long-term).
- Guardrails: safety checks and rules to prevent bad or risky behavior.
- Service computing: designing software so different apps can find each other, talk, and work together automatically.
What did they find?
How modern agents differ from older ones
Older AI agents followed fixed rules in predictable environments. Modern agents, powered by LLMs, can:
- Understand flexible, changing contexts (like new instructions or messy real-world data).
- Plan steps, reflect on mistakes, try new tools, and adapt goals.
- Collaborate with other agents and humans using natural language.
In short, agents went from “scripted robots” to “autonomous teammates.”
How agents talk: the protocols
Agents need common “languages” to discover partners, share context, and coordinate tasks.
- MCP: simple tool calling and structured messages; good for connecting models to tools.
- A2A (by Google): more agent-focused; agents share capabilities, stream updates, and send “artifacts” (results).
- ANP: adds decentralized identity (DIDs) and semantic meaning (JSON‑LD), helpful for open networks.
- ACP: flexible, web-friendly messaging for goals and actions; works across organizations.
- Agora: a meta-layer that helps agents pick or build the right protocol using “Protocol Documents.”
Big picture: these protocols move toward service-style interoperability, but standards are fragmented, so seamless plug‑and‑play is still hard.
Frameworks at a glance
Different frameworks focus on different strengths:
- CrewAI and MetaGPT: role-based “teams” (like manager, researcher, coder) that coordinate tasks.
- AutoGen: multi-agent conversations with shared tools; great for collaborative workflows.
- LangGraph: graph-based orchestration (like a flowchart) for reliable, traceable agent processes.
- Semantic Kernel: enterprise-grade planning, memory, and tool integration.
- Agno: transparent, declarative agent definitions.
- Google ADK: experimental but aimed at scalable, multi-agent setups.
Many share core parts: an LLM for reasoning, tools for actions (APIs, code), memory for context, and guardrails for safety.
Memory and safety, in simple terms
Memory helps agents keep context and learn:
- Short-term memory: what’s happening now in the conversation or task.
- Long-term memory: things that persist, like preferences or past decisions.
- Some frameworks also track semantic (concepts), procedural (how-to steps), and episodic (specific past events) memory.
Guardrails are the “seatbelts”: validation checks, safe execution policies, and rules that prevent dangerous actions. Stronger support exists in AutoGen, LangGraph, Agno, and OpenAI’s SDK; others are still maturing.
Are these tools ready for service ecosystems?
Service computing wants apps that can:
- Be discovered like entries in a directory.
- Publish their capabilities.
- Be composed into bigger workflows.
The authors find partial readiness:
- Semantic Kernel, LangGraph, and Google ADK are closest to service-style composition.
- CrewAI, AutoGen, Agno, and MetaGPT often need extra infrastructure (registries, gateways) to work like full services.
- Standards inspired by older web specs (like WSDL for describing functions, BPEL for workflows) are starting to appear, but not consistently.
Current limits and open challenges
The authors highlight common pain points:
- Static roles: agents can’t easily change jobs mid-task.
- No runtime discovery: agents don’t easily find new teammates as they run.
- Code safety: running generated code can be risky without sandboxes.
- Interoperability gaps: frameworks don’t “just work” together; tool and task formats differ.
Why does this matter, and what’s next?
If Agentic AI becomes easier to build, safer to run, and more standardized, we could see:
- Smarter assistants for science, business, transportation, and education working in teams.
- Agents that plug into existing web services, discover resources automatically, and scale across companies.
- Safer, more reliable AI systems that remember well, coordinate smoothly, and respect rules.
The authors suggest future work on:
- Shared benchmarks to fairly compare frameworks.
- Stronger, universal communication protocols.
- Better support for classic multi-agent skills like negotiation and self-organization.
- Clearer service-style standards so agents can be discovered, composed, and orchestrated like any other web service.
In short: Agentic AI already helps teams of smart agents work together, but to make it truly reliable and widely usable, we still need better communication standards, safer execution, and service-friendly designs.
Glossary
- A2A (Agent-to-Agent Protocol): A communication standard for AI agents enabling discovery, task invocation, memory sharing, and capability coordination. "Google’s Agent2Agent Protocol (A2A) introduced a more agent-oriented architecture, enabling capabilities such as memory management, goal coordination, task invocation, and capability discovery."
- ACP (Agent Communication Protocol): A transport-agnostic protocol for agent messaging via structured JSON over RESTful APIs. "Agent Communication Protocol (ACP)\footnote{\url{https://agentcommunicationprotocol.dev/}, originally started at IBM, allows agents to communicate via RESTful APIs, using structured JSON messages to encode actions, goals, and intents."
- Agno: A declarative agent framework focused on transparent goal and tool definitions and controllable reasoning. "Agno, meanwhile, promotes a declarative and transparent approach to defining agent goals, tools, and reasoning logic, making it a strong candidate for automation workflows requiring explainability and control."
- Agora: A meta-coordination layer that integrates multiple agent protocols through machine-interpretable documents. "Agora\footnote{\url{https://agoraprotocol.org/}, accessed 10-05-2025} \cite{marro2024scalable} serves as a meta-coordination layer, integrating multiple protocols including MCP, ANP, and ACP."
- Agent Card: A standardized descriptor of an agent’s identity and capabilities used for discovery in A2A. "A2A formalizes communication through constructs like Agent Cards, Task Objects, and Artifacts (standardized outputs)."
- Agent Network Protocol (ANP): A protocol emphasizing decentralized identity and semantic interoperability for agent communication. "the Agent Network Protocol (ANP) \cite{anp2024} incorporates decentralized identifiers (DIDs) and JSON-LD semantics"
- Agentic AI: A paradigm of autonomous, goal-driven AI agents with contextual reasoning and coordination. "Agentic AI, where intelligent agents exhibit goal-directed autonomy, contextual reasoning, and dynamic multi-agent coordination."
- Agentic AI-as-a-Service: Delivering agent capabilities as services within computing ecosystems. "Agentic AI, LLMs, Agent protocols, Agentic AI-as-a-Service"
- Artifact: A standardized output object produced and delivered by agents under A2A. "A2A formalizes communication through constructs like Agent Cards, Task Objects, and Artifacts (standardized outputs)."
- AutoGen: A multi-agent framework enabling conversational collaboration among LLM agents with shared tools. "AutoGen \cite{wu2023autogen}, developed by Microsoft, enables rich multi-agent conversations with shared tools and modular LLM backends."
- Belief–Desire–Intention (BDI): A classical agent architecture modeling internal mental states for decision-making. "we believe that modern agents fundamentally differ from classical agents (e.g., Belief-Desire-Intention (BDI) agents)"
- BPEL: An XML-based language for orchestrating service workflows, adapted to multi-agent processes. "To support service-oriented Agentic AI, current frameworks have begun integrating W3C standards (e.g., WSDL, WS-Policy, BPEL)"
- Chain-of-thought: A prompting strategy that elicits step-by-step reasoning from LLMs. "the ReAct architecture combines Reasoning (chain-of-thought) and Acting (tool use) in an iterative loop."
- CrewAI: A framework for role-based multi-agent collaboration, coordination, and delegation. "CrewAI \cite{duan2024exploration} promotes role-based collaboration among agents, emphasizing coordination and delegation for team-based problem-solving."
- Declarative orchestration: Defining agent workflows via high-level specifications rather than imperative code. "Other frameworks lean toward graph-based or declarative orchestration."
- Decentralized Identifiers (DIDs): Cryptographically verifiable identifiers enabling decentralized agent identity. "incorporates decentralized identifiers (DIDs) and JSON-LD semantics"
- Episodic memory: Long-term memory that stores detailed contextual snapshots of past interactions. "episodic memory \cite{dechant2025episodic}, which encodes detailed contextual snapshots of specific past interactions or experiences"
- FIPA ACL: A standardized agent communication language specifying performatives for inter-agent messaging. "Agent communication protocols have evolved from early semantic standards such as FIPA ACL in the 1980sâ1990s"
- Google ADK: An experimental framework for scalable orchestration of multi-agent workflows. "Google ADK, still experimental and designed for scalability, allows orchestration of multi-agent workflows, making it suitable for adaptive AI assistants and enterprise automation."
- Goal-directed autonomy: The capability of agents to independently pursue and manage goals. "Agentic AI, where intelligent agents exhibit goal-directed autonomy, contextual reasoning, and dynamic multi-agent coordination."
- Guardrails: Safety and validation mechanisms that constrain agent actions and outputs. "guardrails to ensure safety, reliability, and validation of agent outputs and actions."
- In-context learning: LLM capability to learn from examples provided within the prompt context. "in-context learning (few-shot, one-shot, chain-of-thought prompting)"
- JSON-LD: A JSON-based format for linked data enabling semantic interoperability. "JSON-LD semantics, organizing communication around a lifecycle (creation, operation, update, termination)"
- JSON-RPC: A lightweight remote procedure call protocol using JSON for message encoding. "Model Context Protocol (MCP)\footnote{\url{https://modelcontextprotocol.io/introduction}, accessed 10-05-2025}, was initially designed for structured tool calls via JSON-RPC and secure schema validation."
- LangGraph: A graph-based orchestration framework for composing and sequencing LLM agent tasks. "LangGraph \cite{wang2024agent} introduces a novel graph-based model for sequencing tasks among LLM agents."
- LlamaIndex: A data-centric framework that equips agents with retrieval over structured and unstructured sources. "LlamaIndex empowers agents with capabilities for querying structured and unstructured data for knowledge-intensive applications."
- Long-horizon tasks: Complex tasks that require extended, multi-step planning and execution. "can reason, communicate, and coordinate to complete complex, long-horizon tasks."
- MCP (Model Context Protocol): A protocol for structured tool calls, schema validation, and secure context exchange. "Model Context Protocol (MCP)\footnote{\url{https://modelcontextprotocol.io/introduction}, accessed 10-05-2025}, was initially designed for structured tool calls via JSON-RPC and secure schema validation."
- MetaGPT: A multi-agent framework simulating software engineering teams via specialized roles. "Another framework, MetaGPT \cite{hong2023metagpt}, follows a comparable philosophy by simulating real-world software engineering teams"
- Multi-Agent Systems (MAS): Systems composed of multiple interacting agents coordinating to achieve goals. "This paradigm shift departs from traditional AI and Multi-Agent Systems (MAS) \cite{ferber1999multi}"
- PD (Protocol Documents): Machine-interpretable specifications guiding protocol selection and construction. "It introduces Protocol Documents (PDs), which are machine-interpretable specifications that guide agents in selecting or constructing communication protocols."
- Performative messaging: Communication using standardized speech acts (performatives) to express intent. "Emerging protocols (e.g., MCP, A2A, Agora) aim to bridge this gap through lightweight JSON-RPC schemas for context exchange, performative messaging, and discovery."
- Procedural memory: Memory of task procedures and strategies reused across interactions. "procedural memory, which recalls specific task flows or strategies previously used"
- PRACT: An LLM-agent architecture optimizing principled reasoning and acting. "Contemporary agent architectures, including ReAct \cite{yao2022react}, PRACT \cite{liu2024pract}, RAISE \cite{raise2024}, and Reflexion \cite{shinn2023reflexion}, are unified by their reliance on LLMs as reasoning engines"
- PydanticAI: A schema-first agent framework leveraging Pydantic for safety and reproducibility. "PydanticAI uses the Pydantic library to define agent schemas, enhancing reproducibility and safety, especially for debugging and deployment."
- RAISE: An LLM-agent architecture included among modern reasoning-centric designs. "Contemporary agent architectures, including ReAct \cite{yao2022react}, PRACT \cite{liu2024pract}, RAISE \cite{raise2024}, and Reflexion \cite{shinn2023reflexion}, are unified by their reliance on LLMs as reasoning engines"
- ReAct: An LLM agent pattern combining explicit reasoning with tool-using actions in a loop. "the ReAct architecture combines Reasoning (chain-of-thought) and Acting (tool use) in an iterative loop."
- Reflexion: An agent method that uses self-reflection to iteratively refine reasoning and actions. "Contemporary agent architectures, including ReAct \cite{yao2022react}, PRACT \cite{liu2024pract}, RAISE \cite{raise2024}, and Reflexion \cite{shinn2023reflexion}, are unified by their reliance on LLMs as reasoning engines"
- RESTful APIs: Web interfaces using HTTP methods and resources for agent communication. "allows agents to communicate via RESTful APIs, using structured JSON messages to encode actions, goals, and intents."
- Semantic Kernel: An enterprise-focused orchestration framework with planners, skills, and memory. "Semantic Kernel \cite{soh2024semantic} provides enterprise-grade orchestration with fine-grained control over planning, memory, and skill execution"
- Semantic memory: Memory storing meaning and past reasoning paths for reuse. "semantic memory \cite{sarthou2019ontologenius}, which stores and reuses past reasoning paths or decisions"
- Server-Sent Events (SSE): A unidirectional streaming protocol for sending real-time updates over HTTP. "JSON-RPC/HTTP/SSE"
- Service-oriented computing: A paradigm that structures software as discoverable, composable services. "alignment with service-oriented computing paradigms."
- State-machine logic: Deterministic workflow modeling where states and transitions control composition. "State-machine logic allows robust composition; discovery possible via extension hooks."
- Task Object: A structured representation of a task for execution under A2A. "A2A formalizes communication through constructs like Agent Cards, Task Objects, and Artifacts (standardized outputs)."
- Web3: Decentralized web technologies enabling identities and transactions in agent ecosystems. "compatible with Web3 environments"
- WS-Agreement: A specification for expressing and negotiating service-level guarantees among entities. "without formal constructs for WS-Coordination or WS-Agreement."
- WS-Coordination: A specification for managing shared context and coordination among distributed activities. "without formal constructs for WS-Coordination or WS-Agreement."
- WS-Policy: A framework for declaring and enforcing service policies and constraints. "W3C standards (e.g., WSDL, WS-Policy, BPEL)"
- WS-Security: A standard for securing SOAP messages with tokens, signatures, and encryption. "WS-Policy and WS-Security principles appear in Agno and SmolAgents via runtime settings and JWTs"
- WSDL: A language for describing web service interfaces and operations, analogous to agent function contracts. "To support service-oriented Agentic AI, current frameworks have begun integrating W3C standards (e.g., WSDL, WS-Policy, BPEL)"
Collections
Sign up for free to add this paper to one or more collections.