Introduction

In short10xGraph (formerly Agentflow) is open-source, self-hosted infrastructure for AI apps: API server, auth and roles, tenant isolation, durable state, jobs and tracing.

  • 5 min read
  • 6 sections
  • Updated
  • v1.0.0
  • Markdown

10xGraph is open-source, self-hosted infrastructure for AI applications. You write the agents, tools and tasks; 10xGraph runs them behind an API server with authentication, role-based access, tenant isolation, durable state in Postgres and Redis, background jobs, metrics and tracing, and generates Docker and Kubernetes deploy files. MIT licensed, by 10xScale. Formerly Agentflow.

Agents stay the core workload. Write your AI logic; 10xGraph runs the infrastructure.

New here? Find your path on the docs map.

How you work with 10xGraph

The 10xgraph command comes with 10xgraph-api. Three commands take you from an empty folder to a running agent you can chat with, with no frontend to write.

  1. 10xgraph init scaffolds a project. It asks three questions: name, setup and provider.
  2. 10xgraph dev starts the API server on 127.0.0.1:8000 and opens the playground in your browser. Chat with your agent, and inspect its threads and runs.
  3. 10xgraph config opens a browser editor for every server setting in 10xgraph.json.

When you are ready to deploy, 10xgraph build writes the Dockerfile, and with flags a docker-compose.yml and a Kubernetes manifest. Pass --no-open to 10xgraph dev if you want the server without the browser tab. See Playground.

Your path

  1. Quickstart: build an agent and serve it over the API.
  2. Platform overview: what you get when you serve with 10xgraph-api, and what you still own.
  3. Security model: who can do what, and where each check runs.
  4. Control mapping: which SOC 2 and ISO 27001 controls the platform supports. Built for teams going through those audits; your deployment is what gets audited.
  5. Production checklist: the settings to confirm before you deploy.
  6. Build a production agent end to end: a support agent served with JWT auth, rate limits, Postgres memory, tests and Docker files.

The three packages

They work together or standalone.

  • Core library (10xgraph, import tenxgraph): StateGraph, ReactAgent and other prebuilt agents, tools as plain Python functions, state, checkpointing to memory, SQLite or Postgres, tool replay on failure, streaming, MCP and dependency injection. Add one provider extra such as 10xgraph[openai]. You can run an agent from Python with no server.
  • API server and CLI (10xgraph-api, import tenxgraph_api, command 10xgraph): you point 10xgraph.json at your compiled graph, and it serves REST and WebSocket endpoints with auth, authorization, rate limits, threads, memory, files and observability. 10xgraph dev runs it locally; production runs Gunicorn in the image from 10xgraph build.
  • TypeScript client (10xgraph-client): a typed SDK for Node.js and browsers covering invoke, stream, threads, memory and files. Plain HTTP or curl works too.

Get started

The fastest path depends on what you want to build.

What the docs cover

Navigate by the question you want to answer.

Get Started. Installation, your first agent, the Full setup, and how to migrate from Agentflow. Read this first.

Concepts. The mental model: graphs, state, messages, agents, tools, threads, checkpointers, memory, context, interrupts, streaming, serving and events. Understand how 10xGraph works.

Platform. What the server gives you and how it works: the security model, architecture, scaling and reliability, and what 10xGraph does not protect. Read this to decide whether to trust it.

Build Agents. How-to guides for building: custom graphs, prebuilt agents, tools, MCP, state, dependency injection, memory, context, multi-agent orchestration, streaming, media, authentication, interrupts, testing and observability. Each guide is a complete recipe with code.

API Server. Run and configure the server: the CLI, configuration file, authentication, authorization, rate limiting, REST and WebSocket endpoints, files and multimodal, observability, deployment to Docker and Kubernetes, and production checklist. Use this when you need to serve your agent over HTTP.

TypeScript Client. Call the server from a Node.js backend or browser frontend: create a client, invoke the graph, stream responses, manage threads, upload files, retrieve memory. Works with Next.js, React and plain TypeScript.

Testing and Evaluation. Unit test with mocked models, run eval sets against your agent, define criteria, simulate users, and generate reports. Verify your agent works before it ships.

Integrations. Connect to models (OpenAI, Google, Anthropic), frameworks (FastAPI, Next.js, CopilotKit), storage (Postgres, Redis), and coding assistants. Each integration shows how and when to use it.

Examples. Runnable code you can clone and modify: simple agents, custom state, tools, streaming, MCP, multi-agent, memory, media, production patterns. Build on these rather than from scratch.

Reference. Exact signatures, parameters and return types for the Python library, REST API, CLI, configuration and TypeScript client. Use this when you need to check an option or understand an error.

Troubleshooting. Symptoms, causes and fixes. Common errors with solutions. Error code reference. Start here if something is not working.

Glossary. Plain definitions of AI agent concepts: what is a ReAct agent, state graph, durable execution, idempotent tools, interrupts.

Compare. 10xGraph vs LangGraph, CrewAI, AutoGen, LlamaIndex and Google ADK. Honest side-by-sides, including where other frameworks are stronger.

Project. Roadmap, security policy, upgrade guides, support and how to contribute.

Frequently asked questions

Is 10xGraph production-ready?
The production layer ships today in the `10xgraph-api` package: an API server with JWT or custom auth, role-based access with own, tenant or all reach (own is the default), rate limits, durable checkpointing with Postgres or SQLite, replay-safe tools, and Docker and Kubernetes files from `10xgraph build`. Background jobs run on `10xgraph worker` and `10xgraph scheduler`. Some of it you must configure: with `auth` unset the server runs open, even with `MODE=production`. From 1.0 the public API is stable under a deprecation policy (breaking changes only in a major release, after at least one minor of deprecation). Pin exact versions and read the changelog before each upgrade. See the Platform overview for what is covered and what is not.
Do I need LangChain to use 10xGraph?
No. 10xGraph has no LangChain dependency. You build graphs with its own StateGraph and Agent classes and call model providers through its own interface.
Which models does 10xGraph support?
OpenAI, Google Gemini (including Vertex AI) and Anthropic (direct API, Vertex AI and Amazon Bedrock), plus any OpenAI-compatible endpoint such as Ollama or vLLM. Swapping the model string does not change your graph or tools.
Can I self-host 10xGraph?
Yes. 10xGraph is MIT licensed and self-hosted, with no hosted platform required. The `10xgraph build` command writes a Dockerfile and, with flags, a docker-compose.yml and a Kubernetes manifest so you can run it on your own infrastructure.
Last updated for v1.0.0Edit this page on GitHubReport an issue