Open source · MIT · Python 3.12+
Write the Python agent. 10xGraph builds the production server around it.
Authentication (JWT or your own), authorization with owner-only threads, prompt-injection validators, rate limits, two-tier memory, replay-safe tools, and Docker and Kubernetes manifests come generated with your graph. MIT licensed and self-hosted, so the production layer is in the box.
Star on GitHubAn editor types a short agent.py and a 10xgraph.json with JWT auth, ownership authorization and a Redis rate limit. The editor tilts into an isometric base, and the generated server rises on top of it in layers: input validators for prompt injection and jailbreaks, rate limits, authorization with RBAC and owner-only threads, authentication with JWT or a custom backend, and the API server on port 8000. Redis, PostgreSQL and Kubernetes pods slide in beside it. Requests from a TypeScript client travel down through the layers and a request log lists each one: an expired token gets 401 EXPIRED_TOKEN, another user's thread gets 403, a burst gets 429 with a retry-after, and an "ignore all previous instructions" message gets 422 prompt injection blocked. When a pod fails mid-refund, a new pod rises and the resumed run skips the refund because it is already in the ledger.
Works withOpenAI, Anthropic, Google Gemini, Vertex AI, Amazon Bedrock and any MCP server
- Production layerIn the boxAuth, permissions, rate limits and deploy files, generated.
- ReliabilityReplay-safe toolsA crash and resume never runs a finished tool twice.
- ScaleTwo-tier memoryHot data in a Redis cache, cold data in PostgreSQL.
- Full stackPython to TypeScriptTyped client, browser tools, realtime audio.
- OwnershipYours to runMIT, self-hosted, any model, no LangChain.
What is 10xGraph?
10xGraph is an open-source Python framework for production multi-agent AI. You write the agent, and 10xGraph generates the production server around it: authentication, scoped access control, owner-only threads, rate limits, and Docker and Kubernetes deployment. Memory has two tiers, with hot data in a Redis cache and cold data in PostgreSQL. MIT licensed, made by 10xScale.
Updated October 2026 · v0.10.0 · Read the concepts
- License
- MIT, including the API server and CLI. Use it commercially, self-host it, fork it.
- Runtime
- Python 3.12+. Core 0.10.0, API and CLI 0.7.0, TypeScript client 0.6.0.
- Memory
- Hot: active thread state cached in Redis and read first. Cold: full history in PostgreSQL with versioned writes.
- Dependencies
- No LangChain. Dependency injection through InjectQ.
The production server ships with the framework
Most agent frameworks stop at the graph. Serving it, securing it and deploying it becomes your project or a paid platform. 10xGraph generates that layer from your project config, under the same MIT license.
- One install, one config file
pip install 10xgraph 10xgraph-api, then10xgraph.jsondrives the server. - Secure defaultsThe production template turns on JWT auth, owner-only threads and a prompt-injection validator.
- Built for many usersOwner checks are cached in process and in Redis, so authorization does not cost a database round trip per request.
"auth": "jwt""authorization": "ownership""rate_limit": { "backend": "redis" }build --docker-compose --k8sPOST /v1/graph/streamCrash mid-run. Resume without charging the card twice.
A process can die between two tool calls. When the run resumes, 10xGraph replays the interrupted step but checks a tool ledger first, so tools that already finished are skipped instead of executed again.
lookup_orderran · recordedcharge_cardran · recordedsend_receiptprocess killedlookup_orderskipped · in ledgercharge_cardskipped · in ledgersend_receiptran · recorded- Tool ledgerEach completed tool call is recorded as soon as it returns. Keys include the issuing message, so models that reuse ids like
call_1never collide across turns. - Versioned state writesDurable writes use an optimistic version check, so two runs on the same thread cannot overwrite each other. The Redis cache is version-guarded too.
- Real timeouts
node_timeoutandtool_timeoutstop a hung tool from holding a worker forever.
Two-tier memory that scales with your users
Active conversations need fast reads. History needs to be durable. 10xGraph keeps each kind of data in the store built for it.
Active thread state
- Written on every step of a run and read first.
- Expires after 24 hours by default, configurable.
- Version-guarded writes, so a stale run cannot move state backwards.
Durable history
- Full thread history with versioned writes.
- Recent state snapshots kept per thread (20 by default).
- Threads resume after restarts and after the cache expires.
Also included:SQLite for local workQdrant and Mem0 for long-term memoryevents to Kafka, Redis Pub/Sub, RabbitMQ, OpenTelemetry
One stack, Python backend to TypeScript frontend
- Typed TypeScript clientInvoke, stream, threads, memory and files. Works in Next.js, Vite and Node.
- Tools that run in the browserRemote tools execute on the client, for things only the user's device can do, with validated schemas.
- Realtime audioA WebSocket endpoint at
/v1/graph/livefor voice agents. - Playground
10xgraph playstarts the server and a React UI to chat with your agent.
import { TenxGraphClient, Message } from '10xgraph-client';
const client = new TenxGraphClient({
baseUrl: 'https://agents.example.com',
authToken: userJwt, // same JWT the API checks
});
const question = Message.text_message('Where is order A-1042?', 'user');
for await (const chunk of client.stream([question])) {
if (chunk.event === 'message') render(chunk.message?.content);
}Yours to run, on any model
MIT licensed, self-hosted, no LangChain dependency. Pick the provider with one model string; the graph, tools and endpoints stay the same. 10xScale runs its own production AI products on 10xGraph.
agent = ReactAgent(
model="google/gemini-2.5-flash", system_prompt=[{"role": "system", "content": "You are a support agent."}],
tools=[lookup_order],
)When 10xGraph is not the right choice
- You need a large plugin marketplace today. The community is smaller than LangGraph's or CrewAI's.
- You need a 1.0 API guarantee. The core is at 0.10.0. Pin versions and read the changelog.
- You want visual tooling first. LangGraph Studio and LangSmith are stronger for visual debugging.
- You are on Python older than 3.12, or you want a no-code builder.
"Quote from a named engineer or team, with permission."
Name, role, companyFrequently asked questions
What is 10xGraph?
10xGraph is an open-source Python framework for building production multi-agent AI systems. You write agents as typed StateGraphs or with the prebuilt ReactAgent, and 10xGraph generates the production server around them: REST and streaming endpoints, JWT auth, owner-only threads, scoped access control, rate limits, and Docker and Kubernetes manifests. It is MIT licensed and made by 10xScale.
What happens if a run crashes mid-way?
With a checkpointer configured, 10xGraph records the current node before running it and keeps a ledger of every completed tool call. When the run resumes, the interrupted node runs again, but any tool call already in the ledger is skipped instead of executed. A payment tool that finished before the crash does not charge the card a second time.
How does 10xGraph handle authentication and multi-user isolation?
The API server supports JWT or a custom auth class. The production template sets authorization to ownership, so a thread is accessible only to the user who created it, and owner checks are cached in process and in Redis. You can also restrict individual tools by role and add rate limits backed by memory or Redis.
How is 10xGraph different from LangGraph?
Both model agents as graphs. With 10xGraph, the API server, authentication, rate limits and Docker and Kubernetes manifests come from the same MIT-licensed install, and you host them yourself. LangGraph offers its managed server through LangSmith Deployment. LangGraph also requires langchain-core, while 10xGraph has no LangChain dependency.
Which LLM providers does 10xGraph support?
10xGraph picks the provider from the model string. It supports OpenAI, Google Gemini including Vertex AI, and Anthropic through the direct API, Vertex AI or Amazon Bedrock. Any OpenAI-compatible endpoint also works. Changing the model string does not change your graph, your tools or your API endpoints.
Is 10xGraph free and open source?
Yes. 10xGraph is released under the MIT license, including the API server and the CLI. You can use it in commercial products, self-host it on your own infrastructure and modify it. There is no hosted platform you have to buy and no account to create before you start building.
Is 10xGraph production-ready?
10xScale runs its own AI products on 10xGraph in production. It includes replay-safe tool calls, versioned state writes, node and tool timeouts, JWT auth, owner-only threads, rate limiting and Kubernetes manifests. The core is at version 0.10.0, before 1.0, so pin your versions and read the changelog when you upgrade.
How do I install 10xGraph?
Run pip install 10xgraph 10xgraph-api on Python 3.12 or newer. Then run 10xgraph init --yes --template production to scaffold a project with auth, validators, tests and config, 10xgraph api to serve it on port 8000, and 10xgraph build --docker-compose --k8s to generate deployment files. The TypeScript client installs with npm install 10xgraph-client.
Was 10xGraph previously called Agentflow?
Yes. 10xGraph was published as Agentflow, under the PyPI name 10xscale-agentflow, until 2026. The project was renamed because many unrelated tools share the Agentflow name. The Python package is now imported as tenxgraph. The old agentflow import path remains as a deprecated alias until 2.0, so existing code keeps working while you switch to the new package names.
Ship your first agent with auth, memory and deployment already done.
- MIT licensed
- Runs on your machine
- No account needed
- Self-hosted in production