Top 4 Open-Source Frameworks for Building Agentic Systems

I have reviewed several of the most popular open-source AI agent frameworks. In this article, I break down each framework’s multi-agent orchestration capabilities, agent and function definitions, memory capabilities, and human-in-the-loop support—exploring how each one functions and how easy it is to get started.

Of note, LangGraph is proprietary software, but it provides an open-source library for agent development.

Compare agentic frameworks

Agentic frameworks vary across several key dimensions, and understanding these differences is essential for making meaningful comparisons. Here are the most important factors that distinguish one framework from another:

Multi-agent orchestration

LangGraph

LangGraph is a relatively well-known framework and stands out as a key option for developers building agent systems.

Explicit multi-agent coordination: You can model multiple agents as individual nodes or groups, each with its own logic, memory, and role in the system.

It creates AI workflows across APIs and tools. Thus, it is a good fit for RAG and custom pipelines.

That said, it is complex/challenging to debug and the learning curve is steep.

AutoGen

Free-form agent collaboration: AutoGen allows multiple agents to communicate by passing messages in a loop. Each agent can respond, reflect, or call tools based on its internal logic.

It has an asynchronous agent collaboration, making it particularly useful for research and prototyping scenarios where agent behavior requires experimentation or iterative refinement.

CrewAI

CrewAI offers a high-level abstraction that simplifies building agent systems by handling most of the low-level logic for you. However, CrewAI’s multi-agent orchestration is limited:

• There’s no built-in execution graph or flow control — agents self-organize based on responses.
• Multi-agent flows are linear or loop-based, not hierarchical or DAG-based.

With multiple agents sending messages, it could become difficult to trace, monitor, or debug agent decisions and coordination.

OpenAI Swarm

OpenAI has described Swarm as a multi-agent framework. However, based on what’s been shared so far:

Swarm currently operates via a single-agent control loop, with:

• Natural language routines in the system prompt
• Tool usage via docstring parsing
• An agent iteratively planning and executing tasks

Thus, it has no agent-to-agent communication (single-agent execution). Unlike frameworks like AutoGen (which supports message passing between agents) or CrewAI (which uses role-based team setups), Swarm has no built-in mechanism for agents to interact with each other.

This makes Swarm a good fit for prototyping, single-agent, step-by-step reasoning workflows using tools or routines (a natural language description of a tasks or workflows).

This approach makes routines in Swarm more flexible and generalizable than traditional scripts or rule-based flows rather than hard-coding logic.

Agent and function definition

LangGraph

LangGraph takes a graph-based approach to agent design, where each agent is represented as a node that maintains its own state. These nodes are connected through a directed graph, enabling conditional logic, multi-team coordination, and hierarchical control. This enables you build and visualize multi-agent graphs with supervisor nodes for scalable orchestration.

LangGraph uses annotated, structured functions that attach tools to agents—you can build out nodes, connect them to various supervisors, and visualize how different teams interact. Think of it like giving each team member a detailed job description. This makes it easier to build and test agents that work together.

AutoGen

AutoGen defines agents as adaptive units capable of flexible routing and asynchronous communication. Agents interact with each other (and optionally with humans) by exchanging messages, allowing for collaborative problem-solving. Like LangGraph uses annotated, structured functions.

CrewAI

CrewAI takes a role-based design approach. Each agent is assigned a role (e.g., Researcher, Developer) and a set of skills—functions or tools it can access. Function definition is through structured annotations.

OpenAI Swarm

OpenAI Swarm uses a routine-based model where agents are defined through prompts and function docstrings. It doesn’t have formal orchestration or state models, relying instead on manually structured workflows. Functions behavior is inferred by the LLM through docstrings (Swarm identifies what a function does by reading its description) making this setup flexible but less precise.

Memory

Memory capabilities:

• Stateful: Whether the framework supports persistent memory across executions.
• Contextual: Whether it supports short-term memory via message history or context passing.

Memory features is a key part of building agentic systems to remember context and adapt over time:

• Short-term memory: Keeps track of recent interactions, enabling agents to handle multi-turn conversations or step-by-step workflows.
• Long-term memory: Stores persistent information across sessions, such as user preferences or task history.
• Entity memory: Tracks and updates knowledge about specific objects, people, or concepts mentioned during interactions (e.g., remembering a company name or project ID mentioned earlier).

LangGraph

LangGraph uses two types of memory: in-thread memory, which stores information during a single task or conversation, and cross-thread memory, which saves data across sessions. Developers can use MemorySaver to save the flow of a task and link it to a specific thread_id. For long-term storage, LangGraph supports tools like InMemoryStore or other databases. This provides flexible control over how memory is scoped and retained across executions.

AutoGen

AutoGen uses a contextual memory model. Each agent maintains short-term context through a context_variables object, which stores interaction history. It doesn’t have built-in persistent memory.

CrewAI

CrewAI provides layered memory out of the box. It stores short-term memory in a ChromaDB vector store, recent task results in SQLite, and long-term memory in a separate SQLite table (based on task descriptions). Additionally, it supports entity memory using vector embeddings. This memory setup is automatically configured when memory=True is enabled,

OpenAI Swarm

Swarm is stateless and does not manage memory natively. Developers can pass short-term memory through context_variables manually, and optionally integrate external tools or third-party memory layers (e.g., mem0) to store longer-term context. I

Human-in-the-loop

LangGraph

LangGraph supports custom breakpoints (interrupt_before) to pause the graph and wait for user input mid-execution.

AutoGen

AutoGen natively supports human agents via UserProxyAgent, allowing humans to review, approve, or modify steps during agent collaboration.

CrewAI:

CrewAI enables feedback after each task by setting human_input=True; the agent pauses to collect natural language input from the user.

OpenAI Swarm

OpenAI Swarm offers no built-in HITL.

Agentic frameworks: Real life use cases

LangGraph – Multi-agent travel planner

A production project built with LangGraph demonstrates a stateful, multi-agent travel assistant that pulls flight and hotel data (using Google Flights & Hotels APIs) and generates travel recommendations.⁵

CrewAI – Agentic content creator

CrewAI’s official examples repository includes flows like trip planning, marketing strategy, stock analysis, and recruitment assistants, where role-specific agents (e.g., “Researcher”, “Writer”) collaborate on tasks.⁶

CrewAI turns a high-level content brief into a complete article using Groq.⁷

Core features of agentic frameworks

Model support:

• Most are model-agnostic, supporting multiple LLM providers (e.g., OpenAI, Anthropic, open-source models).
• However, system prompt structures vary by framework and may perform better with some models than others.
• Access to and customization of system prompts is often essential for optimal results.

Tooling:

• All frameworks support tool use, a core part of enabling agent actions.
• Offer simple abstractions to define custom tools.
• Most support Model-Context-Protocol (MCP), either natively or through community extensions.

Memory / State:

• Use state tracking to maintain short-term memory across steps or LLM calls.
• Some helps agents retain prior interactions or context within a session.

RAG (Retrieval-Augmented Generation):

• Most include easy setup options for RAG, integrating vector databases or document stores.
• This allows agents to reference external knowledge during execution.

Other common features

• Support for asynchronous execution, enabling concurrent agent or tool calls.
• Built-in handling for structured outputs (e.g., JSON).
• Support for streaming outputs where the model generates results incrementally.
• Basic observability features for monitoring and debugging agent runs.

External Links

• 1. A Guide to Building Agentic RAG Systems with LangGraph. Analytics Vidhya
• 2. Top 5 Frameworks for Building AI Agents in 2024 (Plus 1 Bonus) - DEV Community. DEV Community
• 3. Top 5 Frameworks for Building AI Agents in 2024 (Plus 1 Bonus) - DEV Community. DEV Community
• 4. How OpenAI Swarm Enhances Multi-Agent Collaboration?. Analytics Vidhya
• 5. https://medium.com/@jalajagr/automate-your-travel-plans-with-multi-agent-ai-langgraph-14d688baed66
• 6. https://docs.crewai.com/getting-started/examples
• 7. https://medium.com/analytics-vidhya/groq-powered-content-creator-agent-using-crewai-langchain-2e5eaad738ac