Agentic AI Frameworks: Architectures & Protocols Guide

The Rise of Agentic AI: From Rule-Based to Autonomous

The landscape of artificial intelligence is undergoing a fundamental transformation. What began as rigid, rule-based expert systems in the 1980s has evolved through decades of incremental progress into something qualitatively different: autonomous AI agents capable of reasoning, planning, and collaborating in ways that closely mirror human cognitive processes. A comprehensive new research paper by Hana Derouiche, Zaki Brahmi, and Haithem Mazeni from universities in Tunisia provides one of the most thorough systematic reviews of this transformation, analyzing eleven major agentic AI frameworks, five communication protocols, and the critical design challenges that remain unsolved.

This evolution matters because agentic AI represents the bridge between today’s impressive but limited AI tools and tomorrow’s truly autonomous systems. Current large language models can generate remarkable text, analyze complex documents, and answer sophisticated questions. But they operate in isolation, responding to individual prompts without the ability to plan multi-step strategies, coordinate with other AI systems, or learn from their own experiences over time. Agentic frameworks are the missing infrastructure layer that transforms these powerful but passive models into active participants in complex workflows.

The research addresses four critical questions that every technology leader and AI practitioner needs to answer: How have intelligent agents evolved from traditional systems to modern LLM-powered architectures? What frameworks exist for building these systems? How do they compare across critical dimensions like communication, memory, and safety? And most urgently, how ready are these frameworks for integration into enterprise service computing ecosystems? Understanding the answers, as explored in surveys of LLM agent methodologies, is essential for making informed infrastructure decisions.

Redefining the Modern AI Agent

The paper’s most significant conceptual contribution is its proposed redefinition of what constitutes a modern AI agent. Traditional definitions from classical AI literature emphasized fixed sensing and acting loops, where agents operated within predetermined behavioral boundaries. The researchers propose a fundamentally expanded definition:

An autonomous and collaborative entity, equipped with reasoning and communication capabilities, capable of dynamically interpreting structured contexts, orchestrating tools, and adapting behavior through memory and interaction across distributed systems.

This definition captures twelve dimensions of transformation from traditional to modern agents. Where traditional agents had limited autonomy dependent on human input, modern agents independently perform complex and extended tasks. Where traditional agents managed single, static goals, modern agents handle multiple, evolving, and nested goals managed adaptively. Where traditional architectures were monolithic and rule-based, modern agents use modular architectures centered on LLMs with integrated memory, tools, context injection, and role assignment.

Perhaps the most consequential shift is in decision-making. Traditional agents used deterministic or rule-based symbolic reasoning, producing predictable but inflexible behavior. Modern LLM-based agents employ context-sensitive, probabilistic reasoning with adaptive planning and self-reflection capabilities. This means they can handle ambiguity, adjust strategies based on new information, and even critique and improve their own outputs through frameworks like ReAct, PRACT, RAISE, and Reflexion.

The practical implication is that organizations can no longer evaluate AI agents using the criteria developed for traditional automation systems. The evaluation framework must expand to encompass autonomy levels, adaptability to novel situations, quality of reasoning under uncertainty, and the ability to learn and improve over time. This represents a paradigm shift in how enterprises assess and deploy AI capabilities.

Agent Communication Protocols Explained

One of the research paper’s most valuable contributions is its systematic analysis of five agent communication protocols that are shaping how AI agents discover, interact, and collaborate with each other. Understanding these protocols is essential for anyone building multi-agent systems or planning enterprise AI infrastructure.

Model Context Protocol (MCP)

MCP uses JSON-RPC message formatting with HTTP, Stdio, and SSE transport layers. It operates on a client-server model specifically designed for LLM-tool integration, allowing language models to invoke external tools and services through structured interfaces. MCP supports inter-agent delegation with strict hierarchical roles, making it suitable for systems where one primary agent coordinates specialized tool-using sub-agents. It is already integrated into frameworks like LangChain, OpenAgents, and Agno.

Agent Communication Protocol (ACP)

Originated at IBM Research, ACP takes a different approach by using JSON-LD message formatting with goal-oriented semantics. Rather than simple request-response patterns, ACP messages express goals and intended actions, enabling richer collaboration between agents. Its transport-agnostic design makes it compatible with Web3 environments, and it uses agent metadata files and registries for discovery. ACP is supported by AutoGen, LangGraph, and CrewAI.

Agent-to-Agent Protocol (A2A)

Developed by Google, A2A introduces three key constructs: Agent Cards for capability advertisement, Task Objects for work coordination, and Artifacts as standardized outputs. This protocol is specifically designed for enterprise agent orchestration scenarios where multiple sophisticated agents must discover each other’s capabilities, negotiate task assignments, and exchange structured results. A2A’s memory management and goal coordination features make it the most enterprise-ready protocol currently available.

Agent Network Protocol (ANP) and Agora

ANP targets decentralized agent markets, incorporating Decentralized Identifiers (DIDs) for agent identity management and lifecycle management capabilities spanning creation, operation, update, and termination of agents. Agora operates as a meta-coordination layer that integrates multiple protocols through natural-language Protocol Documents, enabling agents to negotiate which communication protocol to use for specific interactions. Together, these protocols point toward a future where AI agents can autonomously form and dissolve collaborative relationships across organizational boundaries.

A critical finding from the protocol analysis is that while HTTP dominates as the transport layer, semantic heterogeneity between protocols, ranging from custom performatives to goal-oriented messages to natural-language protocol documents, limits seamless integration. Standardized service contracts similar to WSDL for agents remain nascent, creating a significant barrier to large-scale Agent-as-a-Service adoption.

Eleven Agentic AI Frameworks Compared

The research provides the most comprehensive side-by-side comparison of agentic AI frameworks published to date, analyzing eleven distinct platforms across multiple dimensions. These frameworks fall into four natural categories based on their primary design philosophy.

Structured Orchestration and Multi-Agent Workflows

AutoGen from Microsoft leads this category, offering rich multi-agent conversations with shared tools and modular LLM backends. CrewAI focuses on role-based collaboration and delegation for team-based problem-solving, while MetaGPT takes the unique approach of simulating real-world software engineering teams where agents adopt specialized roles like project manager or developer throughout the product lifecycle pipeline.

Lightweight and Transparent Agent Composition

SmolAgents emphasizes simplicity and modularity through prompt chaining and tool use with minimal overhead. PydanticAI leverages the Pydantic library for agent schemas, enhancing reproducibility and safety for debugging and deployment scenarios. These frameworks are ideal for teams that need transparent, inspectable agent behavior without the complexity of full orchestration platforms.

Graph-Based and Declarative Orchestration

LangGraph provides a graph-based model for sequencing tasks with compositional flows and stateful operations, making it highly traceable and scalable for enterprise applications. Semantic Kernel offers enterprise-grade orchestration with fine-grained control over planning, memory, and skill execution. Agno takes a declarative approach to defining agent goals, tools, and reasoning logic, making it particularly suitable for automation requiring explainability. For organizations already evaluating these tools through the lens of cloud computing trends, framework choice often depends on existing infrastructure commitments.

Data-Centric and Distributed Ecosystems

LlamaIndex specializes in querying structured and unstructured data for knowledge-intensive applications. Google ADK, still experimental, focuses on multi-agent workflow orchestration suitable for adaptive AI assistants and enterprise automation. OpenAI Agents SDK provides a high-level interface that encapsulates tool use, memory, and instruction-following behavior for developers who want maximum productivity with minimum architectural complexity.

All eleven frameworks share a unified class model built around five core components: the LLM as reasoning engine with in-context learning capabilities, Tools for external actions, Memory for persistence, Guardrails for safety, and Prompts and Tasks as structural elements. This convergence suggests that despite their different approaches, the industry is coalescing around a common understanding of what an agentic system requires at its foundation.

Memory Architectures in Multi-Agent Systems

Memory architecture emerges from the research as perhaps the most critical differentiator between frameworks for production deployments. The paper analyzes five distinct memory types and maps their support across all eleven frameworks, revealing significant disparities that should inform framework selection decisions.

Short-term memory handles immediate conversational and task context, analogous to a human’s working memory during a conversation. Long-term memory persists data across sessions, storing user preferences, task history, and learned knowledge. Semantic memory stores and reuses past reasoning paths or decisions, enabling agents to apply lessons learned from previous interactions to new situations. Procedural memory recalls specific task flows or strategies, effectively teaching agents how to perform complex operations. Episodic memory captures detailed contextual snapshots of specific past interactions, providing rich experiential context for future decision-making.

The research reveals that only three frameworks, Semantic Kernel, CrewAI, and MetaGPT, support four out of five memory types, making them the most cognitively complete options available. Semantic Kernel stands alone in supporting procedural memory alongside short-term, long-term, and semantic memory, making it uniquely suited for enterprise workflows where agents must learn and replicate complex operational procedures. CrewAI’s episodic memory support makes it particularly valuable for customer-facing applications where remembering the context and outcomes of previous interactions drives relationship quality.

At the other end of the spectrum, SmolAgents and PydanticAI offer no built-in memory support whatsoever. While this design choice reduces complexity and overhead, it means that every interaction starts from zero, eliminating the possibility of learning, personalization, or context carryover. For applications where stateless simplicity is acceptable, this is a reasonable tradeoff. For enterprise applications requiring persistent intelligence, these frameworks would need significant external memory infrastructure.

The memory analysis has direct implications for organizations evaluating agentic frameworks for deep research systems and knowledge-intensive applications. A research agent that cannot remember what it has already found, what strategies worked, and what the user’s evolving interests are will deliver fundamentally inferior results compared to one with comprehensive memory capabilities.

Safety Guardrails and Trust Layers

The research paper’s analysis of safety guardrails across frameworks reveals a concerning landscape where most platforms require external logic or manual setup for robust safety enforcement. This finding is particularly significant given the increasing deployment of agentic systems in high-stakes enterprise environments.

AutoGen provides the strongest native guardrail support through built-in validators and retry logic that catch and handle errors during agent execution. LangGraph offers advanced flow-level checks via node validation, allowing developers to insert safety gates at specific points in the workflow graph. Agno includes an early-stage trust layer, while the OpenAI Agents SDK provides schema validation with developer-defined safeguards.

CrewAI, MetaGPT, and Google ADK offer partial guardrail support, typically limited to specific interaction patterns or output validation stages. LlamaIndex and Semantic Kernel provide validation only at specific stages of their pipelines, requiring developers to supplement with custom safety logic for comprehensive coverage. Most notably, SmolAgents explicitly prioritizes developer control over built-in safety mechanisms, placing the full burden of safety assurance on the implementing team.

The research team identifies a critical need for standardized, modular safety layers that can be applied consistently across frameworks. Current approaches are fragmented and framework-specific, meaning that organizations using multiple frameworks must implement different safety strategies for each one. This fragmentation increases both the complexity and the risk of safety gaps in multi-framework deployments. For organizations concerned with cybersecurity threats, the guardrail maturity of chosen frameworks should be a primary selection criterion.

The code safety dimension deserves particular attention. Frameworks like MetaGPT and AutoGen that generate and execute code as part of their agent workflows introduce severe safety risks including unauthorized file system access, shell command execution, and unsafe library imports. The paper recommends Docker containers with strict capability limitations and restriction to pre-approved pure functions as mitigation strategies, but acknowledges that these solutions add significant architectural complexity.

Service Computing Readiness Assessment

One of the most forward-looking aspects of the research is its assessment of how ready current agentic AI frameworks are for integration into service-oriented computing ecosystems. This analysis evaluates frameworks across three critical service computing capabilities: discovery (can agents find each other?), publishing (can agents advertise their capabilities?), and composition (can agents be combined into larger workflows?).

The results reveal that most frameworks are only partially ready for enterprise service computing. Semantic Kernel offers the most complete service-oriented architecture, with dynamic composition via planners and partial support for both discovery and publishing, though external implementation is still required for full capability. Google ADK provides comparable readiness but requires Google Cloud services including API Gateway and Service Directory for discovery and publishing functionality.

LangGraph supports composition through its state-machine logic and offers discovery through catalog adapter extensions, but lacks native publishing capability. AutoGen supports sequential tool invocation with limited planning logic but requires external registries for both discovery and publishing. CrewAI supports composition but requires external registries for all other service computing functions. Agno and SmolAgents are the least service-computing ready, requiring external logic for virtually all service-oriented capabilities.

The paper also maps current framework capabilities against six W3C specifications that could serve as a foundation for standardized agent services. WSDL-equivalent functionality for describing agent function contracts exists only in limited form in CrewAI and OpenAI SDK. BPEL-equivalent workflow orchestration appears in AutoGen’s multi-agent workflows. WS-Policy-equivalent runtime configuration control exists in Agno and OpenAI SDK. WS-Security-equivalent communication security appears in SmolAgents through JWTs and encryption. These W3C-inspired features are emerging but remain far from the standardized, interoperable adoption level needed for true Agent-as-a-Service ecosystems.

Critical Challenges and Limitations

The research identifies five critical challenges that limit the current generation of agentic AI frameworks and provide a roadmap for future development priorities.

Rigid Architectures

Most frameworks enforce static agent roles where once an agent is assigned as a planner, executor, or coder, it cannot easily change behavior during execution. In MetaGPT or CrewAI, role assignments are effectively permanent for the duration of a workflow. This rigidity prevents the kind of dynamic role adaptation that human teams perform naturally when circumstances change or unexpected challenges emerge.

No Runtime Discovery

Current frameworks cannot dynamically discover or collaborate with new agents during runtime. All interactions must be statically defined before execution begins, fundamentally limiting the scalability and emergent cooperation potential of multi-agent systems. The paper proposes agent or skill registries as central directories where agents could publish and query capabilities, enabling dynamic collaboration that mirrors how human professionals find and engage specialists as needs arise.

Code Safety Vulnerabilities

Generated code execution, a common pattern in MetaGPT and AutoGen, poses severe security risks. Agents that generate and execute code can potentially access file systems, execute shell commands, and import unsafe libraries. While Docker containerization and function whitelisting offer mitigation strategies, the fundamental tension between agent capability and code safety remains unresolved. This challenge aligns with broader concerns identified in zero trust architecture approaches to AI system security.

Interoperability Gaps

Frameworks operate in silos with fundamentally incompatible abstractions. CrewAI’s task model cannot be interpreted by AutoGen. SmolAgent’s planner cannot invoke a LangGraph workflow without significant translation middleware. This siloing prevents the kind of cross-framework composition that would allow organizations to leverage the best capabilities of multiple frameworks simultaneously. The paper recommends adopting SOA principles by wrapping AI agents as services via RESTful APIs and using communication protocols inspired by FIPA-ACL or modern standards.

Absence of Standardized Benchmarks

There are currently no standardized benchmarks for objectively comparing agentic AI frameworks. This makes it impossible to perform apples-to-apples evaluations of framework performance, reliability, or resource efficiency. Without such benchmarks, framework selection remains largely subjective, based on team familiarity, documentation quality, and anecdotal reports rather than rigorous, reproducible measurements. Approaches used in evaluating generative AI impact could provide methodological foundations for developing these needed benchmarks.

Future Directions for Agentic AI Research

The paper identifies six priority areas for future research that will shape the next generation of agentic AI capabilities. First, standardized benchmarks must be developed to enable objective comparison and reproducibility across frameworks. Without these benchmarks, the field cannot progress from subjective framework evaluation to evidence-based architecture decisions.

Second, universal agent communication protocols are needed to enhance interoperability and scalability. While MCP, ACP, A2A, ANP, and Agora represent important progress, the semantic heterogeneity between these protocols creates friction that limits large-scale multi-agent deployments. A convergence on shared semantic standards, potentially building on the W3C specifications analyzed in the paper, would dramatically accelerate enterprise adoption.

Third, established multi-agent system paradigms including negotiation, coordination, and self-organization need to be more deeply incorporated into existing frameworks. Current frameworks implement only a fraction of the theoretical MAS capabilities developed over decades of distributed AI research. Bringing this rich academic foundation into production frameworks would unlock significantly more sophisticated agent collaboration patterns.

Fourth, modular safety layers should be developed as standardized components that can be applied across frameworks rather than implemented as framework-specific custom logic. This standardization would reduce the safety engineering burden on individual development teams and improve the overall trustworthiness of deployed agent systems.

Fifth, service-oriented agent architectures with full discovery, publishing, and composition capabilities must mature to enable true Agent-as-a-Service deployment models. The paper envisions a future where agents are deployed, discovered, and composed as naturally as web services are today, but acknowledges that significant architectural and standards work remains.

Sixth, the researchers point toward neuro-symbolic or quantum-secure communication architectures as longer-term research directions. Neuro-symbolic approaches would combine the reasoning flexibility of neural networks with the logical rigor of symbolic systems, potentially resolving the reliability concerns that currently limit agent autonomy in high-stakes applications. Quantum-secure communication would future-proof agent networks against emerging cryptographic threats.

Practical Implementation Guidance

Drawing from the comprehensive analysis presented in this research, several practical recommendations emerge for organizations planning agentic AI implementations.

For framework selection, the decision should be driven primarily by the specific use case rather than general popularity. AutoGen and CrewAI are strongest for multi-agent conversations and team-based collaboration. LangGraph provides the best foundation for complex, stateful enterprise workflows requiring auditability and reliability. Semantic Kernel is the optimal choice for organizations with significant existing Microsoft ecosystem investments seeking to incrementally add AI capabilities. For rapid prototyping with minimal overhead, SmolAgents or the OpenAI Agents SDK provide the fastest path to working implementations.

Memory architecture should be a primary selection criterion, not an afterthought. Organizations building customer-facing applications should prioritize frameworks with episodic memory support like CrewAI and AutoGen. Those building operational automation should look at procedural memory capabilities, where Semantic Kernel and MetaGPT lead. For knowledge-intensive applications, semantic memory support from Semantic Kernel, CrewAI, MetaGPT, or LlamaIndex is essential.

Communication protocol selection should anticipate future interoperability needs. Organizations planning single-framework deployments can use framework-native communication. Those anticipating multi-framework environments should evaluate ACP or A2A compatibility early, as retrofitting protocol support is significantly more difficult than building it in from the start.

Safety must be addressed architecturally rather than bolted on. Given that most frameworks provide incomplete guardrail support, organizations should plan for external safety layers from the beginning of their architecture design. This includes code sandboxing for frameworks that execute generated code, output validation for all agent responses that affect downstream systems, and access control for agent interactions with sensitive data and services.

Finally, organizations should treat framework investment as a portfolio rather than a bet. Given the rapid evolution of the agentic AI ecosystem, investing in understanding multiple frameworks and maintaining the ability to adopt new ones as they mature provides more strategic flexibility than deep commitment to a single platform.