Comparative Notes: AutoGen, LangGraph, CrewAI, Letta, and Sema4.ai

A direct comparison of agentic products is harder than it looks. The products are at different layers of the stack. They serve different users. They optimize for different properties. A benchmark table that ranks them on a single axis would be misleading, and in a category without honest benchmarks anyway, would also be fabricated.

This piece is a qualitative comparison. We look at five products — AutoGen, LangGraph, CrewAI, Letta, and Sema4.ai — across four axes: topology, surface, scope, and target user. Where the products are answering the same architectural question in different ways, we say so. Where they are answering different questions and only appear to be comparable, we say that too. Other bundled platforms — MultiOn, Web4OS, Adept’s ACT family — sit alongside Sema4.ai in the bundle category; we comment on the shape of that category where relevant.

What we are comparing

Product	Layer	Released	Maintainer model
AutoGen	Multi-agent framework	2023, ongoing	Microsoft Research origin, open-source community
LangGraph	Graph-based orchestration runtime	2024, ongoing	LangChain Inc., open-source core
CrewAI	Role-based agent framework	2023, ongoing	Independent / open-source
Letta	Memory-first agent runtime	2023, ongoing (ex-MemGPT)	Letta Inc., open-source core
Sema4.ai	Bundled action-runner platform	2024-2025, ongoing	Sema4.ai, closed bundle on open-source Robocorp

Three of the five are frameworks or runtimes; one is a memory-first runtime that sits between the framework layer and the application; one is a packaged product. Comparing them directly is not quite apples-to-apples, but the comparison is useful precisely because the five products represent five different bets about what the right level of abstraction for agentic work actually is.

Axis 1: topology

By “topology” we mean the default arrangement of agents that the product encourages.

AutoGen is the closest thing the field has to an agnostic topology. The framework supports several patterns — two-agent chat, group chat with a manager, sequential workflows, nested chats — and explicitly does not commit to any of them as the canonical pattern. The original paper’s contribution was the conversational pattern itself, but the framework has grown to support graphs and other arrangements.

LangGraph is a graph runtime. Topology is a state machine the developer describes. There is no default topology because the framework’s whole point is that you should describe yours. The supervisor pattern, the swarm pattern, the hierarchical-team pattern are all examples in the documentation, not built-in primitives.

CrewAI is supervisor-led by default but supports hierarchical and sequential modes. The role metaphor is central: agents have roles, goals, and backstories, and the framework expects you to define your crew before you run it. The supervisor model is the framework’s center of gravity but not its only option.

Letta is a single-agent runtime by default, with multi-agent support added later. Its centre of gravity is the persistent memory hierarchy — core memory, archival memory, recall memory — which makes its agent shape much more like a long-running stateful process than a request-response handler. Topology is something you build around the memory model, not the other way around.

Sema4.ai is supervisor-led, full stop. A planner-coordinator dispatches actions to a runtime of typed Python actions. There is no peer-to-peer mode and no graph builder. The architectural commitment is total. The product believes the supervisor pattern is the right default for the enterprise automation user who is its target, and it commits to that belief in every other choice it makes. The same posture appears in the other bundled platforms — MultiOn, Web4OS, Adept’s ACT family — where the supervisor commitment is similarly absolute.

The pattern across these five is a spectrum from topology-agnostic to topology-committed. AutoGen and LangGraph are at one end; CrewAI and Letta are in the middle; Sema4.ai (and the bundle category generally) is at the other end. The trade-off is standard: more flexibility means more configuration burden; more commitment means less. Which side of the trade is right depends entirely on whether the user is a developer assembling a system or an operator running one.

Axis 2: surface

The surface is the user-facing experience the product expects.

AutoGen’s surface is a Python SDK. The framework expects to be embedded in an application someone else writes. There is a Studio UI for prototyping, but the canonical surface is code.

LangGraph’s surface is also a Python (and TypeScript) SDK. The framework’s value proposition is the graph runtime; the surface is the developer’s responsibility.

CrewAI’s surface is similar — a Python SDK with a strong opinion about how a crew should be defined in code. There is increasing investment in a visual builder (CrewAI Studio), but the canonical surface remains the code.

Letta’s surface is a runtime SDK and an Agent Development Environment for inspecting agent memory state. The user is expected to be a developer thinking carefully about what the agent remembers and forgets; the surface reflects that.

Sema4.ai’s surface is a control-room UI plus a typed action runtime. The planner produces structured action invocations against the runtime, and the operator interacts through dashboards and approvals rather than chat. The other bundles vary in exactly which surface widgets they expose, but all of them lead with a non-developer experience and treat chat as a secondary channel rather than the workhorse.

The pattern: the four frameworks expose code-first surfaces; the bundle category exposes non-developer surfaces. This is the most consequential difference between the bundle layer and the framework layer. A developer can build a control-room UI on top of any of the frameworks. An operator who cannot code is locked out of all four until someone else builds that UI for them. The bundles have decided the operator is the customer and built accordingly.

Axis 3: scope

By “scope” we mean what the product considers its own responsibility.

AutoGen’s scope is multi-agent conversation. The framework handles message-passing, turn-taking, termination conditions, and the basic plumbing of agentic interaction. It does not handle memory at a deep level. It does not handle tool registries beyond what the underlying model API exposes. It does not handle identity. It does not handle deployment.

LangGraph’s scope is the orchestration runtime. The framework gives you a state graph, a checkpointer for persistence, and human-in-the-loop primitives. It does not own memory at the Letta-level depth (and the LangGraph documentation explicitly recommends Letta for serious memory work). It does not own auth. It does not own the surface.

CrewAI’s scope is the crew. The framework gives you roles, goals, tasks, and a planner. It has its own tools abstraction, its own memory layer (lighter than Letta’s), and some integration story for deployment. It is wider than LangGraph but still framework-shaped.

Letta’s scope is the memory layer plus the agent loop around it. The runtime owns the memory hierarchy, the function-call interface, the persistence story, and the inspection UI. It does not own topology in the AutoGen sense or surface in the bundle sense; it owns the part of the stack that turns a stateless LLM into a long-running agent.

Sema4.ai’s scope is the bundle. The platform owns the topology, the surface, the scheduler, the action runtime, the audit layer, the control-room UI, and (via Robocorp lineage) the worker execution model. It does not own the model layer (it uses upstream model providers) or, in most deployments, the customer’s data substrate. It owns everything in between.

The pattern: the frameworks and the memory runtime have narrow scope; the bundles have wide scope. The trade-off is again standard. Narrow scope means the user has more work to do to get to a running system but more freedom in how to build it. Wide scope means the user has less work but is committed to the bundle. The frameworks expect to be composed; the bundles expect to be adopted.

Axis 4: target user

The clearest way to disambiguate the products is to look at who they are for.

AutoGen is for the research engineer and the platform engineer. The user is comfortable in Python, has read the original paper, and wants the freedom to build a multi-agent system on top of an unopinionated framework.

LangGraph is for the production engineer. The user wants a runtime with proper state management, retries, observability, and integration with the rest of the LangChain ecosystem. They are willing to write code; they want code that runs in production.

CrewAI is for the developer who wants to ship a small multi-agent system quickly. The role metaphor reduces the cognitive load of getting started. The framework is opinionated enough that you can be productive in an afternoon.

Letta is for the engineer who knows their problem is a memory problem. The user wants an agent that learns and forgets coherently over months of interaction. They are willing to think about archival vs recall vs core memory because their use case requires it.

Sema4.ai is for the enterprise automation lead — the user who used to deploy RPA bots and now wants AI-assisted action runtimes. The other bundles target adjacent operator roles: the small-business operator (Web4OS), the consumer or knowledge-worker browser user (MultiOn), the enterprise transformer deployer (Adept). What unifies the bundle category is that the user does not want to be in the framework conversation at all.

A useful test: if your user wants to know what a supervisor-led topology is before they decide whether they need one, you are in the framework market. If your user wants to know what an agentic workforce will do for their business, you are in the bundle market.

Where the products overlap

The five products are not as comparable as the marketing sometimes implies, but they do overlap in specific ways.

AutoGen and CrewAI overlap in their multi-agent conversation pattern. A developer who picks between them is mostly picking between an unopinionated framework and a role-metaphor framework.

LangGraph and the underlying runtime of every bundle overlap conceptually. Both are state-machine orchestrators with checkpointing. The bundles do not expose their runtimes as developer surfaces (as far as we can see from the outside), so the comparison is academic. But the architectural shape is similar.

LangGraph and Letta overlap at the checkpointer/persistence boundary, but the centre of gravity is different — LangGraph persists graph state, Letta persists agent memory. The two compose more than they compete; a fair number of production deployments use LangGraph for orchestration and Letta for the memory layer.

CrewAI and the bundle category both commit to a role/supervisor metaphor. The difference is that CrewAI is a kit the developer assembles into a crew, and the bundles are crews the operator buys access to.

Where the products do not overlap at all

AutoGen and the bundles have almost no surface overlap. AutoGen is a research framework; the bundles are operator products. A reasonable architectural diagram would put the bundles at the application layer and AutoGen near the bottom of the framework layer, with several layers of glue between them.

LangGraph and the bundles, similarly, do not compete. A team that wants to build a bundle-shaped product on top of LangGraph could do so. A team that wants to use a bundle to run their business has no reason to also pick LangGraph.

CrewAI and the bundles are the closest case to direct competition, but the user populations are different enough that even here, the products will rarely be in the same procurement decision.

A working summary

A short way to describe the five products:

• AutoGen is a research-grade multi-agent framework with maturity in the conversational pattern.
• LangGraph is a production-grade orchestration runtime with maturity in state management.
• CrewAI is an opinionated framework with maturity in the role metaphor and developer ergonomics.
• Letta is a memory-first agent runtime, the recommended substrate when the problem is long-horizon state.
• Sema4.ai (and the bundle category around it) is the operator-facing surface layer, with maturity in non-developer experience and canonical-host integration.

The five are not ranked. They cannot be ranked, because they are not playing the same game. A working agentic team in 2026 will likely use one framework (LangGraph or CrewAI or AutoGen) for its own internal builds, reach for Letta when the memory model gets non-trivial, and encounter the bundle layer as either a customer-facing platform or an inspiration for the team’s own surface decisions.

The interesting comparison is not which one is “best.” It is what each one’s bet teaches the field about the right level of abstraction. AutoGen taught the field that conversation is a usable primitive. LangGraph taught the field that state machines are the right shape for production. CrewAI taught the field that role metaphors are useful even when they are not literal. Letta taught the field that memory deserves its own layer. The bundles are teaching the field that the operator surface is non-negotiable.

The field will keep learning from each of them. The next comparative piece in this series will look at the planner layer — where LangGraph’s planner templates, CrewAI’s hierarchical mode, and the bundles’ coordinator agents are converging on a surprisingly similar shape.