How Google’s New Open‑Source Projects Make AI Agents Production‑Ready

Scion: Coordinating Multiple Agents

⭐ 1.6k+ · Go · Apache 2.0 · Created 2026‑03 · Updated 2026‑07

If three Claude Code agents edit the same repository simultaneously, they will read the same file, commit to the same branch, and overwrite each other’s changes. While local workspaces can be separated with git worktrees, the problem becomes an engineering challenge in CI, remote VMs, or Kubernetes clusters.

Scion solves this by abstracting multi‑agent collaboration into two core mechanisms:

One isolated container per agent (full process isolation)

One git worktree per agent (optional file‑system isolation)

Container isolation separates processes; worktree isolation separates files. Using both, agents rarely collide.

Unlike many frameworks that enforce a rigid "A → B → C" workflow, Scion lets agents coordinate via a CLI tool, allowing the model itself to decide when and how to interact with other agents.

The project includes a visual replay tool (Relics of Athenaeum) that records every message and file access during a multi‑agent task, demonstrating a self‑organizing pattern applicable to software engineering, data research, and platform engineering.

How to Use Scion

Install via Homebrew:

brew tap homebrew-scion/scion
brew install homebrew-scion/scion/scion
scion server start

After starting the server, open 127.0.0.1:8080/onboarding in a browser to complete runtime detection, identity configuration, image pull, and workspace creation.

Start an agent with a single command: scion start my-agent "Help me debug this error" Check status and interact using scion list and scion attach <name>, which opens a tmux session.

Real‑World Scion Use Cases

Software migration : Parallel refactoring of a large codebase across multiple agents.

Market research : A fleet of agents crawls different data sources and aggregates results.

Product testing : Agents simulate multiple user roles to explore edge‑case scenarios.

Notably, the Scion Films project let agents write a script, plan shooting, and produce a documentary entirely through coordinated agent work.

Scion Limitations

Currently this project is early and experimental. Most concepts are settled, but many features may not be fully implemented; anything might break or change and the future is not set. Local use is relatively stable, Hub‑based workflows are highly usable, Kubernetes runtime support still has rough edges.

Usability is rated as medium: users need familiarity with containers, git worktrees, and the CLI, but the codebase is a single Go binary.

AX: Resumable Single‑Agent Runtime

⭐ 1.9k+ · Go · Apache 2.0 · Created 2026‑03 · Updated 2026‑07

While Scion tackles horizontal scaling, AX (Agent Executor) addresses the opposite extreme: ensuring a long‑running single agent can survive network jitter, process crashes, or machine restarts without losing state.

AX assumes agents are "long‑run workers" that may execute for hours across multiple machines and can be interrupted mid‑task.

Three core capabilities:

Single‑Writer architecture : a single controller manages all state changes, avoiding concurrent conflicts.

Event Log persistence : each operation is appended to an event log, enabling recovery after crashes.

Advanced Resumption : on compatible platforms (e.g., Kubernetes), the actor state can be restored from the compute layer.

Traditional agent frameworks assume tasks finish in minutes and can be retried; AX’s design assumes tasks may run for hours, fail many times, and require the user to resume where they left off.

AX Architecture

AX separates responsibilities into two layers:

Server layer (multitenant) AX Server: receives client requests and manages sessions. Event Log: stores all state‑changing events. Control API: provides suspend/resume operations for actors. Snapshot Service: offers snapshot creation for recovery.

Actor layer (stateful session tenant) AX Harness Server: runs the actual agent code and integrates with MCP Server, Harness Service, and model services.

Clients connect to the server via a resumable stream; the server writes to the event log using scan/append. If an actor crashes, the Control API can restore it from a snapshot, preserving the session.

How to Use AX

Install the CLI: go install github.com/google/ax/cmd/ax@latest Execute a simple task: ax exec --input "Can you list this directory?" To resume after a disconnection, add --last-seq 12 --resume (or the equivalent flags) so the execution continues from the last sequence number.

For production, the recommended deployment is Kubernetes + Agent Substrate, with detailed manifests provided in the manifests/ directory.

AX Status

🚧 AX is in active early development. We are actively refining our core, resumption protocols, and runtime specifications, which will introduce major breaking changes prior to a stable release. Temporary Policy: We are temporarily pausing the acceptance of external Pull Requests while we stabilize the core architecture.

The project is labeled as early and experimental; major breaking changes are expected before a stable release, and external contributions are currently limited to issues.

Usability is rated as hard: users need knowledge of Kubernetes, distributed systems, and agent runtimes, but a local go install can get the binary running.

Combined Implications

Together, Scion and AX illustrate Google Cloud’s two‑pronged strategy for AI agents in production:

Horizontal scaling (Scion): enabling many agents to collaborate without conflict.

Vertical reliability (AX): ensuring a single long‑running agent can survive failures and resume.

These are not competing choices but complementary pieces of the infrastructure needed to move agents from experimental prototypes to reliable production workers.

GitHub Repositories

Scion: github.com/GoogleCloudPlatform/scion AX:

github.com/google/ax