# 10xGraph vs CrewAI: Graphs vs Role-Based Crews

> 10xGraph vs CrewAI compared with sources. Production server, auth, thread isolation, replay-safe tools and timeouts, plus where CrewAI is the better pick.

Source: https://10xgraph.com/docs/compare/agentflow-vs-crewai
Last updated: 2026-10-06

> **10xGraph vs CrewAI**
>
> CrewAI models work as role-based crews. 10xGraph models it as a typed graph and generates the secured production server around it.

This page is written by the 10xGraph team, so read it with that in mind. Claims about CrewAI link to CrewAI's documentation or package metadata, checked on 2026-10-06.

**CrewAI** is an MIT-licensed Python framework built around agents with roles and goals, tasks, and crews that run them under a process ([PyPI](https://pypi.org/project/crewai/)). It also has Flows for event-driven orchestration ([Flows docs](https://docs.crewai.com/en/concepts/flows)). **10xGraph** models a workflow as a typed state graph and ships the server layer (endpoints, auth, thread ownership, rate limits, deploy files) in the open-source install.

## Production layer compared

The first rows are where the two differ most. Orchestration basics are at the bottom.

| | 10xGraph | CrewAI |
|---|---|---|
| Production server (REST, SSE, WebSocket) in the open-source install | Yes. `10xgraph api` generates REST, SSE, WebSocket and realtime-audio endpoints from the compiled graph | Not documented for the open-source package. CrewAI AMP exposes deployed crews through REST endpoints ([AMP docs](https://docs-platform.crewai.com/platform/en/introduction)). AMP has a free Basic plan limited to 50 workflow executions per month, and a custom-priced Enterprise plan ([pricing](https://www.crewai.com/pricing)) |
| Auth (JWT or custom) | JWT (`"auth": "jwt"`) or a custom `BaseAuth` subclass | SSO and role-based access control are listed as Enterprise features ([pricing](https://www.crewai.com/pricing)). Not documented for the open-source package |
| Authorization | Role scopes (such as `graph:invoke`, `checkpointer:read`) or a custom `AuthorizationBackend` | Role-based access control is listed as an Enterprise feature ([pricing](https://www.crewai.com/pricing)) |
| Thread ownership isolation | Built-in `"authorization": "ownership"` backend, with a two-tier cached owner check | Not documented |
| Rate limiting | Memory or Redis sliding-window limits on the API, set in `10xgraph.json` | `max_rpm` on an agent limits requests per minute to avoid LLM rate limits ([agents docs](https://docs.crewai.com/en/concepts/agents)). That is outbound, not an API rate limit |
| Replay-safe tool calls after a crash | Tool ledger in the checkpointer: a tool that already ran is not executed again on resume. Needs a checkpointer | Flows can persist state with `@persist`. The Flows docs do not address tool call replay ([Flows docs](https://docs.crewai.com/en/concepts/flows)) |
| Versioned (compare-and-swap) state writes | Optimistic version check on durable writes in `PgCheckpointer` | Not documented |
| Node and tool timeouts | `node_timeout` and `tool_timeout`, with defaults of 900 s and 300 s | `max_execution_time` on an agent, optional with no default ([agents docs](https://docs.crewai.com/en/concepts/agents)) |
| Docker Compose and Kubernetes manifests | `10xgraph build --docker-compose --k8s` writes `Dockerfile`, `docker-compose.yml`, `k8s.yaml` | Not documented for the open-source package. AMP lists cloud, dedicated VPC and self-hosted options ([pricing](https://www.crewai.com/pricing)) |
| License | MIT, including API/CLI and client | MIT ([PyPI](https://pypi.org/project/crewai/)). AMP plans are commercial ([pricing](https://www.crewai.com/pricing)) |
| TypeScript client | Typed `10xgraph-client` | Not documented |
| Orchestration model | Typed `StateGraph` with nodes, conditional edges, sub-graphs | Crews run tasks under a sequential or hierarchical process. In hierarchical mode a manager agent delegates ([processes docs](https://docs.crewai.com/en/concepts/processes)) |
| State persistence | `InMemoryCheckpointer`, `PgCheckpointer` (Postgres plus Redis), SQLite, keyed by `thread_id` | Flows `@persist` with SQLite as the default backend and custom backends supported ([Flows docs](https://docs.crewai.com/en/concepts/flows)) |
| Python version | 3.12 or newer | 3.10 to 3.13 ([PyPI](https://pypi.org/project/crewai/)) |

## Why teams move from CrewAI to 10xGraph

1. **The server layer is part of the install.** With CrewAI, serving a crew over HTTP with managed auth goes through AMP. With 10xGraph, `10xgraph api` generates the endpoints and the auth, ownership and rate-limit settings live in `10xgraph.json`.
2. **Control flow is explicit.** Nodes and edges show where a run goes next. In CrewAI's hierarchical process, a manager agent decides at runtime ([processes docs](https://docs.crewai.com/en/concepts/processes)), which suits prototypes and is harder to audit.
3. **Side effects survive crashes.** If a worker dies after a tool returns, 10xGraph reads its tool ledger on resume and skips tools that already ran. See [replay-safe tools](/docs/concepts/replay-safe-tools).
4. **State is typed and inspectable.** `AgentState` carries a list of typed `Message` objects you can log and migrate.

## A two-agent flow in 10xGraph

A triage agent classifies a support ticket, then a resolver drafts the reply. The order is fixed by edges:

```python title="graph/support.py"
from tenxgraph.core.graph import Agent, StateGraph
from tenxgraph.core.state import AgentState
from tenxgraph.storage.checkpointer import InMemoryCheckpointer
from tenxgraph.utils import END

triage = Agent(
    model="google/gemini-2.5-flash",
    system_prompt=[{
        "role": "system",
        "content": "Classify the ticket as billing, shipping or other. Reply with the label and one sentence of reasoning.",
    }],
)

resolver = Agent(
    model="google/gemini-2.5-flash",
    system_prompt=[{
        "role": "system",
        "content": "Use the classification in context to draft a short, polite reply to the customer.",
    }],
)

graph = StateGraph(AgentState)
graph.add_node("TRIAGE", triage)
graph.add_node("RESOLVE", resolver)
graph.set_entry_point("TRIAGE")
graph.add_edge("TRIAGE", "RESOLVE")
graph.add_edge("RESOLVE", END)

app = graph.compile(checkpointer=InMemoryCheckpointer())
```

To add tools such as `lookup_order(order_id: str)` and `refund_order(order_id: str, amount: float)`, give the agent a `ToolNode`. See [add a tool](/docs/beginner/add-a-tool). For the CrewAI equivalent, see CrewAI's [Agents](https://docs.crewai.com/en/concepts/agents) and [Processes](https://docs.crewai.com/en/concepts/processes) docs.

## Hierarchical and delegated patterns

CrewAI's hierarchical process uses a manager agent that plans, delegates and reviews ([processes docs](https://docs.crewai.com/en/concepts/processes)). In 10xGraph, delegation is a router node plus handoff tools:

```python
from tenxgraph.core.graph import Agent, ToolNode
from tenxgraph.prebuilt.tools import create_handoff_tool

router_tools = ToolNode([
    create_handoff_tool("billing", "Send the ticket to the billing specialist"),
    create_handoff_tool("shipping", "Send the ticket to the shipping specialist"),
])

router = Agent(
    model="gemini-2.5-flash",
    provider="google",
    system_prompt=[{"role": "system", "content": "Route the ticket to the right specialist."}],
    tool_node="ROUTER_TOOLS",
)
```

Add `ROUTER`, `BILLING` and `SHIPPING` nodes to a `StateGraph` and let the router hand off control. The full pattern is in [the handoff how-to](/docs/how-to/python/handoff-between-agents). When routing is deterministic, use a plain Python function as the router and skip the extra model call.

## Serving as an API

```bash
pip install 10xgraph 10xgraph-api
10xgraph init --yes --template production --auth jwt --rate-limit redis
10xgraph api --host 0.0.0.0 --port 8000
10xgraph build --docker-compose --k8s
```

`10xgraph.json` points at your compiled graph:

```json
{"agent": "graph.support:app", "auth": "jwt", "authorization": "ownership"}
```

You get `POST /v1/graph/invoke`, `POST /v1/graph/stream` (SSE), a WebSocket endpoint and thread state endpoints, with JWT checks and owner-only threads in front of them.

## Migrating from CrewAI to 10xGraph

1. Each CrewAI `Agent(role=..., goal=..., backstory=...)` becomes a 10xGraph `Agent(model=..., system_prompt=[{"role": "system", "content": "<role, goal, backstory>"}])`.
2. Each `Task` becomes either a `Message` pushed into the graph state or a node that prepares the prompt for the next agent.
3. `Process.sequential` becomes a chain of `add_edge` calls. `Process.hierarchical` becomes a router node with handoff tools.
4. `crew.kickoff(inputs=...)` becomes `app.invoke({"messages": [...]}, config={"thread_id": "..."})`.
5. CrewAI memory maps onto a checkpointer, plus a vector retrieval tool if you need semantic recall.

## Where CrewAI is the better choice

- **Role-based prototypes.** If you want a researcher, writer and editor defined in a few declarative objects, CrewAI's model matches that directly.
- **You want a managed platform.** AMP offers a visual studio, tracing and hosted deployment, with a free Basic plan for small usage ([pricing](https://www.crewai.com/pricing)).
- **You prefer roles and tasks to nodes and edges.** That is a legitimate preference about how to think about the problem.
- **You need Python 3.10 or 3.11.** 10xGraph requires 3.12 or newer.
- **Community size.** CrewAI has a larger user base and more examples.

## Weak spots of 10xGraph

- Smaller community and fewer integrations.
- Pre-1.0: pin versions and read changelogs before upgrading.
- Renamed from Agentflow, so the 10xGraph name has little search history yet.
- No visual studio. The playground is a test chat, not a no-code builder.
- Code-first only, and Python 3.12 or newer.

## Sources

Verified on 2026-10-06.

- [crewai on PyPI](https://pypi.org/project/crewai/)
- [CrewAI pricing](https://www.crewai.com/pricing)
- [CrewAI AMP introduction](https://docs-platform.crewai.com/platform/en/introduction)
- [CrewAI Flows (persistence)](https://docs.crewai.com/en/concepts/flows)
- [CrewAI Agents (max_rpm, max_execution_time)](https://docs.crewai.com/en/concepts/agents)
- [CrewAI Processes](https://docs.crewai.com/en/concepts/processes)

## Next steps

- [Get started with 10xGraph](https://10xgraph.com/docs/get-started): Install, build an agent, expose an API, connect from TypeScript.
- [Multi-agent handoff patterns](https://10xgraph.com/docs/how-to/python/handoff-between-agents): Map CrewAI hierarchical flows to routers and handoff tools.
- [Persistence and threads](https://10xgraph.com/docs/concepts/checkpointing-and-threads): How state survives across calls.

## Frequently asked questions

### Can I run CrewAI tools inside a 10xGraph graph?

Any Python callable can be wrapped as a tool in a ToolNode. You typically rewrite the tool definition rather than re-using CrewAI's tool classes directly.

### Does 10xGraph support hierarchical agents like CrewAI's Process.hierarchical?

You can build the same delegate-at-runtime behavior with a router node and handoff tools (create_handoff_tool). The routing stays an explicit graph you can inspect, instead of a manager agent decision.

### How does 10xGraph handle long-term memory compared to CrewAI?

The 10xGraph checkpointer persists full graph state per thread_id, so chat history and intermediate state are durable. For semantic recall, pair it with a vector store such as Qdrant or Mem0, which 10xGraph supports as memory stores.

### Is 10xGraph good for non-chat workflows like research pipelines?

Yes. The graph runtime does not assume a chat surface, and you can run a compiled graph from any Python entry point, not just the API server.

### Is 10xGraph free for commercial use?

Yes. 10xGraph, including the API server, CLI and TypeScript client, is MIT-licensed. CrewAI's open-source framework is MIT-licensed too, and its AMP platform has its own plans.