Get started

10xGraph is an open-source Python framework for building and deploying multi-agent LLM systems. You write the agent graph in Python. 10xGraph generates the REST, WebSocket and realtime audio server around it, enforces thread ownership and access control, stores state durably, and generates Docker files. A tool that finished before a crash is not run twice on replay.

What you get

10xGraph consists of three parts that work together: a Python library for building agents, an API server that turns agents into services, and a TypeScript client for integrating those services into applications.

The Python library

The core library (10xgraph, imported as tenxgraph) is the orchestration engine. Nodes are computation (an agent that calls an LLM, or a plain function), edges control the flow, and state moves through the graph as it runs.

Start with the prebuilt ReactAgent, which loops between the model and its tools. Build a custom StateGraph when you need non-linear routing, custom state or multi-agent handoffs. Tools run in parallel by default, memory has three layers (working state, durable checkpoints, long-term vector stores), MCP tools load dynamically, and OpenAI, Google GenAI and Anthropic are supported through one interface.

The example below is a support agent that looks up orders and issues refunds. Run it with your provider key set, for example GEMINI_API_KEY.

pip install "10xgraph[google-genai]"

# A support agent with two plain Python functions as tools
from tenxgraph.prebuilt.agent import ReactAgent
from tenxgraph.storage.checkpointer import InMemoryCheckpointer


def lookup_order(order_id: str) -> dict:
    """Look up an order by id and return its status and total."""
    return {"order_id": order_id, "status": "delivered", "total": 59.0}


def refund_order(order_id: str, amount: float) -> str:
    """Refund an order. This moves money, so it must run exactly once."""
    return f"Refunded {amount:.2f} for order {order_id}"


app = ReactAgent(
    model="google/gemini-2.5-flash",
    provider="google",
    system_prompt=[{"role": "system", "content": "You are a support agent for an online shop."}],
    tools=[lookup_order, refund_order],
).compile(checkpointer=InMemoryCheckpointer())

The API server and CLI

The API server (10xgraph-api, imported as tenxgraph_api) serves your compiled graph with no extra code. A config file points at the agent, and the server exposes REST and WebSocket endpoints, access control, rate limiting, thread management and a long-term memory store. The 10xgraph CLI scaffolds projects, runs the server and generates Docker and Kubernetes files.

Install it with pip install 10xgraph-api. Then create a 10xgraph.json file that points at the app object in agent.py:

{
  "agent": "agent:app",
  "env": ".env"
}

Start the API server from the folder that holds both files:

# Starts on http://127.0.0.1:8000
10xgraph api

The server listens on http://127.0.0.1:8000 with a Swagger UI at /docs. Requests pass through authentication (JWT or custom), authorization (thread ownership and role scopes) and rate limiting when you configure them. POST /v1/graph/invoke runs the agent and returns the result, POST /v1/graph/stream streams chunks as NDJSON, and /v1/graph/ws is a WebSocket for bidirectional streaming. The /v1/threads routes expose a thread’s state and messages.

Test the server with curl:

curl -X POST "http://localhost:8000/v1/graph/invoke" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": [{"type": "text", "text": "Where is order 1042?"}]}],
    "config": {"thread_id": "test-001"}
  }'

Or open the interactive playground:

10xgraph play

The TypeScript client

The TypeScript client (10xgraph-client, class TenxGraphClient) is a typed interface to the API. It sends the bearer token, parses the NDJSON stream into typed chunks, and covers invoke, stream, threads, memory and files. It does not ship React hooks.

import { TenxGraphClient, Message } from "10xgraph-client";

// Omit authToken when the server runs without auth
const client = new TenxGraphClient({
  baseUrl: "http://localhost:8000",
  authToken: "your-jwt-token",
});

// Invoke the agent and read the final messages
const result = await client.invoke(
  [Message.text_message("Where is order 1042?")],
  { config: { thread_id: "test-001" } },
);
console.log(result.messages);

// Or stream chunks as they arrive
for await (const chunk of client.stream(
  [Message.text_message("Refund order 1042 for $50")],
  { config: { thread_id: "test-001" } },
)) {
  console.log(chunk.event, chunk.message);
}

What’s included

The framework comes with production-ready features out of the box, no configuration needed unless you want to customize them:

Prerequisites

To get started, you need:

• Python 3.12 or newer
• An API key for one LLM provider: OPENAI_API_KEY, GEMINI_API_KEY (or GOOGLE_API_KEY), or ANTHROPIC_API_KEY
• Node 18 or newer and npm (optional, for the TypeScript client)

Reading order

Follow this path to go from zero to a deployed agent:

The tutorial builds on one agent across its steps, so follow it in order. Skip it if you only want a running server: the quickstart is enough.

The next major section, Concepts, explains how everything works under the hood. Guides covers task-oriented recipes (add memory, use MCP, deploy to Kubernetes), and API reference documents every class, function, and route.

Rename note

10xGraph was published under the name “Agentflow” until 2026. The Python library now imports from tenxgraph (for example from tenxgraph.core.graph import StateGraph), the PyPI package is 10xgraph, and the command is 10xgraph. The old agentflow imports still work as a deprecated alias until version 2.0. The old package name 10xscale-agentflow is no longer updated; install 10xgraph instead.