10xGraph vs Google ADK: Open-Source Alternative

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

Google Agent Development Kit (ADK) is an Apache-2.0 licensed, code-first framework for building, evaluating and deploying agents (PyPI). It has Python, TypeScript, Java and Go variants, an adk api_server command and several deployment paths (API server docs, deployment docs). 10xGraph is a graph runtime that also generates a secured production server, in the open-source install, under the MIT license.

Production layer compared

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

Why teams choose 10xGraph over ADK

1. Auth and isolation are generated. The adk api_server page documents session and run endpoints but no authentication (API server docs). 10xGraph’s production template turns on JWT auth, owner-only threads and a Redis rate limit in 10xgraph.json.
2. Side effects survive crashes. 10xGraph’s tool ledger skips tools that already ran when a run resumes. See replay-safe tools.
3. Compare-and-swap on durable writes. PgCheckpointer checks a state version on write and guards the Redis cache write by version, so a stale run cannot overwrite a newer one.
4. Deploy files for two targets. 10xgraph build --docker-compose --k8s writes the files you would otherwise write by hand.

A support agent in 10xGraph on Gemini

from tenxgraph.prebuilt.agent import ReactAgent
from tenxgraph.storage.checkpointer import InMemoryCheckpointer


def lookup_order(order_id: str) -> dict:
    """Return status and total for an order."""
    return {"order_id": order_id, "status": "delivered", "total": 59.0}


def refund_order(order_id: str, amount: float) -> str:
    """Refund part or all of an order."""
    return f"Refunded {amount} on {order_id}"


agent = ReactAgent(
    model="google/gemini-2.5-flash",  # add use_vertex_ai=True to route through Vertex AI
    provider="google",
    system_prompt=[{"role": "system", "content": "You are a support agent. Confirm the order before refunding."}],
    tools=[lookup_order, refund_order],
)

app = agent.compile(checkpointer=InMemoryCheckpointer())

The model string selects the provider, so the same graph and tools can run on another provider by changing the string and installing its extra. See the Google provider docs for Vertex AI configuration. For the ADK version, see ADK’s documentation.

Workflow patterns

ADK’s workflow agents run sub-agents in sequence, in parallel or in a loop (docs). The 10xGraph equivalents use graph primitives:

Sessions and threads

ADK keys conversations by session. 10xGraph keys them by thread_id with a checkpointer:

from tenxgraph.core.state import Message
from tenxgraph.storage.checkpointer import PgCheckpointer

checkpointer = PgCheckpointer(
    postgres_dsn="postgresql://user:password@localhost:5432/agents",
    redis_url="redis://localhost:6379/0",
)
checkpointer.setup()

app = agent.compile(checkpointer=checkpointer)
app.invoke(
    {"messages": [Message.text_message("Where is my refund for order A-1042?")]},
    config={"thread_id": "user-42"},
)

Serving as an API

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

Endpoints include POST /v1/graph/invoke, POST /v1/graph/stream (SSE), a WebSocket endpoint and thread state endpoints. The server is a container you can run on Cloud Run, GKE or any other host.

TypeScript client

import { AgentFlowClient, Message, StreamEventType, bearerAuth } from "10xgraph-client";

const client = new AgentFlowClient({
  baseUrl: "http://127.0.0.1:8000",
  auth: bearerAuth(token),
});

for await (const chunk of client.stream(
  [Message.text_message("Where is order A-1042?")],
  { config: { thread_id: "ts-stream-1" } },
)) {
  if (chunk.event === StreamEventType.MESSAGE && chunk.message) {
    process.stdout.write(chunk.message.text());
  }
}

Migrating from Google ADK

1. LlmAgent(model=..., instruction=..., tools=[...]) becomes Agent(model="google/gemini-2.5-flash", system_prompt=[{"role": "system", "content": ...}], tool_node="TOOL"), or ReactAgent for a tool-calling loop.
2. Tool functions go into ToolNode([fn]).
3. SequentialAgent becomes a chain of add_edge calls, ParallelAgent becomes fan-out and fan-in nodes, and LoopAgent becomes a self-loop with recursion_limit.
4. A session service becomes a checkpointer (PgCheckpointer, or InMemoryCheckpointer for development) plus thread_id in the config.
5. Deployment becomes 10xgraph api or the generated container files. Keep the Google provider configuration and route it through Vertex AI with use_vertex_ai=True.

Where Google ADK is the better choice

• You are invested in Google Cloud. ADK documents Agent Runtime, Cloud Run and GKE deployment, and a Vertex AI session service (deployment docs, sessions docs). 10xGraph has no managed Google runtime.
• You want a managed agent runtime. Agent Runtime is a managed, auto-scaling service for ADK agents (deployment docs).
• You want the same framework in several languages. ADK documents Python, TypeScript, Java and Go variants (API server docs). 10xGraph’s core is Python only.
• You need Python 3.10 or 3.11. 10xGraph requires 3.12 or newer.

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 Google-managed runtime or visual tooling. The playground is a test chat.
• Code-first only, and Python 3.12 or newer.

Sources

Verified on 2026-10-06.

• google-adk on PyPI (license, Python version)
• ADK API server
• ADK deployment
• ADK sessions
• ADK workflow agents
• ADK with LiteLLM
• ADK for TypeScript

Next steps