# 10xGraph vs Google ADK: Open-Source Alternative

> 10xGraph vs Google ADK compared with sources: API server, auth, thread isolation, replay-safe tools, sessions, and where ADK is the better pick.

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

> **10xGraph vs Google ADK**
>
> ADK is Google's agent framework with a path to Google Cloud. 10xGraph generates a secured server, with auth and owner-only threads, that runs on any infrastructure.

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](https://pypi.org/project/google-adk/)). It has Python, TypeScript, Java and Go variants, an `adk api_server` command and several deployment paths ([API server docs](https://adk.dev/runtime/api-server/), [deployment docs](https://adk.dev/deploy/)). **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.

| | 10xGraph | Google ADK |
|---|---|---|
| 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 | Yes, REST and SSE. `adk api_server` exposes session endpoints and `/run` and `/run_sse` ([API server docs](https://adk.dev/runtime/api-server/)) |
| Auth (JWT or custom) | JWT (`"auth": "jwt"`) or a custom `BaseAuth` subclass | Not documented on the API server page ([API server docs](https://adk.dev/runtime/api-server/)) |
| Authorization | Role scopes (such as `graph:invoke`, `checkpointer:read`) or a custom `AuthorizationBackend` | Not documented |
| 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` | Not documented |
| 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 | Not documented |
| Versioned (compare-and-swap) state writes | Optimistic version check on durable writes in `PgCheckpointer` | `DatabaseSessionService` uses in-process locking, and row-level locking on PostgreSQL and MySQL, to prevent races ([sessions docs](https://adk.dev/sessions/session/)) |
| Node and tool timeouts | `node_timeout` and `tool_timeout`, with defaults of 900 s and 300 s | Not documented |
| Docker Compose and Kubernetes manifests | `10xgraph build --docker-compose --k8s` writes `Dockerfile`, `docker-compose.yml`, `k8s.yaml` | Documented deployment targets are Agent Runtime, Cloud Run, GKE and any container host ([deployment docs](https://adk.dev/deploy/)) |
| License | MIT, including API/CLI and client | Apache-2.0 ([PyPI](https://pypi.org/project/google-adk/)) |
| TypeScript | Typed `10xgraph-client` for the 10xGraph API | ADK for TypeScript, an agent framework for Node.js and browsers, Apache-2.0 ([adk-js](https://github.com/google/adk-js)). It is a framework, not a client for a Python server |
| Model providers | OpenAI, Anthropic (direct, Vertex AI, Bedrock), Google (Gemini, Vertex AI), OpenAI-compatible endpoints | Gemini first-party, plus OpenAI, Anthropic and others through LiteLLM ([LiteLLM docs](https://adk.dev/agents/models/litellm/)) |
| Orchestration | Typed `StateGraph` with conditional edges and sub-graphs | `SequentialAgent`, `ParallelAgent` and `LoopAgent` workflow agents ([workflow agents docs](https://adk.dev/agents/workflow-agents/)) |
| Sessions and persistence | `InMemoryCheckpointer`, `PgCheckpointer` (Postgres plus Redis), SQLite, keyed by `thread_id` | `InMemorySessionService`, `VertexAiSessionService`, `DatabaseSessionService` for PostgreSQL, MySQL and SQLite ([sessions docs](https://adk.dev/sessions/session/)) |
| Python version | 3.12 or newer | 3.10 or newer ([PyPI](https://pypi.org/project/google-adk/)) |

## 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](https://adk.dev/runtime/api-server/)). 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](/docs/concepts/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

```python title="graph/agent.py"
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](/docs/providers/google) for Vertex AI configuration. For the ADK version, see ADK's [documentation](https://adk.dev/).

## Workflow patterns

ADK's workflow agents run sub-agents in sequence, in parallel or in a loop ([docs](https://adk.dev/agents/workflow-agents/)). The 10xGraph equivalents use graph primitives:

| ADK pattern | 10xGraph equivalent |
|---|---|
| `SequentialAgent` | `add_edge("A", "B"); add_edge("B", "C")` |
| `ParallelAgent` | Two nodes that both write to state, joined by a fan-in node |
| `LoopAgent` | A self-looping node plus `recursion_limit` in the invoke config |
| Sub-agents and transfer | Router node plus `create_handoff_tool` |

## Sessions and threads

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

```python
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

```bash
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

```typescript
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](https://adk.dev/deploy/), [sessions docs](https://adk.dev/sessions/session/)). 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](https://adk.dev/deploy/)).
- **You want the same framework in several languages.** ADK documents Python, TypeScript, Java and Go variants ([API server docs](https://adk.dev/runtime/api-server/)). 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](https://pypi.org/project/google-adk/) (license, Python version)
- [ADK API server](https://adk.dev/runtime/api-server/)
- [ADK deployment](https://adk.dev/deploy/)
- [ADK sessions](https://adk.dev/sessions/session/)
- [ADK workflow agents](https://adk.dev/agents/workflow-agents/)
- [ADK with LiteLLM](https://adk.dev/agents/models/litellm/)
- [ADK for TypeScript](https://github.com/google/adk-js)

## Next steps

- [Get started with 10xGraph](https://10xgraph.com/docs/get-started): Install, build an agent, expose an API, connect from TypeScript.
- [Google provider configuration](https://10xgraph.com/docs/providers/google): Gemini API and Vertex AI.
- [Deployment guide](https://10xgraph.com/docs/how-to/production/deployment): Run 10xGraph in production on any cloud.

## Frequently asked questions

### Does 10xGraph support Vertex AI as well as Google AI Studio?

Yes. The 10xGraph Google provider supports both the Gemini API and Vertex AI. Switch with use_vertex_ai=True on the Agent or the GOOGLE_GENAI_USE_VERTEXAI environment variable. See the providers/google docs for the configuration.

### Can I run 10xGraph on Google Cloud Run or GKE?

Yes. The API server is a standard Python ASGI app, and 10xGraph build generates a Dockerfile, a Docker Compose file and a Kubernetes manifest. Package it and deploy it on Cloud Run, GKE or any Kubernetes cluster.

### Does 10xGraph have anything like ADK's SequentialAgent, ParallelAgent and LoopAgent?

These patterns are graph primitives in 10xGraph. Sequential is a chain of edges, parallel is a fan-out and fan-in, and a loop is a self-edge capped by recursion_limit.

### Is ADK limited to Gemini?

No. ADK documents LiteLLM integration for models from other providers such as OpenAI and Anthropic, alongside first-party Gemini support. 10xGraph also supports several providers behind one model string.

### Is 10xGraph free for commercial use?

Yes. 10xGraph, including the API server, CLI and TypeScript client, is MIT-licensed. ADK is Apache-2.0 licensed per its PyPI metadata.