ChangeMesh

An enterprise agent fleet that rehearses, authorizes, executes, and proves complex changes with bounded autonomy and human-on-the-loop control.

Comment

Inspiration

Modern AI agents can write code quickly, but enterprise change is not just a coding problem. A seemingly small database or API change can cross repositories, schemas, event pipelines, billing services, ownership boundaries, security policies, and release processes.

The dangerous part is not generating a migration. The dangerous part is proving that the change is safe, reversible, authorized, recoverable, and backed by evidence before it reaches an irreversible boundary.

That is why I built ChangeMesh.

What it does

ChangeMesh is a proof-carrying enterprise change rehearsal and execution fleet.

Instead of treating an enterprise change as a chat session, ChangeMesh treats it as a long-lived, recoverable, policy-controlled distributed transaction:

Discover → Qualify → Rehearse → Ground → Authorize → Execute → Prove → Certify

A six-agent Google ADK fleet coordinates the workflow:

  • Change Orchestrator — routes and coordinates the end-to-end saga
  • Impact Scout — maps dependencies and blast radius
  • Policy Guardian — applies deterministic policy and privacy controls
  • Migration Engineer — produces bounded migration and rollback artifacts
  • Evidence Auditor — independently reconciles claims against deterministic evidence
  • Release Steward — prepares reversible release actions such as Draft Pull Requests

Before risky execution, ShadowLab rehearses failure, rollback, stale-approval, prompt-injection, compatibility, and recovery scenarios.

ChangeMesh also uses Approval Compression: reversible and policy-approved work continues autonomously, while only the smallest irreducible authority decision is escalated to a human.

Every completed workflow can be sealed into a tamper-evident Change Evidence Passport.

How we built it

ChangeMesh is built around Google's agent and cloud stack:

  • Gemini 3.6 Flash through Vertex AI
  • Google Agent Development Kit (ADK) for the multi-agent runtime
  • the official Google Gen AI SDK (google-genai)
  • Google Cloud Run for the deployed service
  • Google Cloud Firestore for durable, versioned saga state
  • Google Cloud Pub/Sub for event-driven coordination and causal event history
  • Python 3.13, Pydantic, HTML/CSS/JavaScript, pytest, Playwright, Ruff, and mypy

The architecture deliberately separates provider-neutral domain contracts from provider-specific adapters. Deterministic code owns execution facts; Gemini can provide semantic judgment, but it cannot rewrite deterministic facts or manufacture authority.

The deployed Cloud Run service is publicly reachable in europe-west3.

Real action vs. simulation

ChangeMesh explicitly distinguishes execution evidence modes.

The current Acme Billing demo workflow runs in SIMULATION mode and targets:

billing_accounts.payment_tier

The project also contains historical evidence of a bounded real action: ChangeMesh created a real GitHub Draft Pull Request in LIVE_WRITE mode against a controlled synthetic demo repository. That historical run targeted:

payment_accounts.payment_tier

The Draft PR was intentionally never merged. It is presented as historical evidence, not as the output of the current simulation.

This distinction is intentional: simulation is never presented as live execution, and historical evidence is never presented as current execution.

Challenges we ran into

The hardest part was not connecting an LLM to tools. It was defining strict authority and evidence boundaries.

Some of the biggest challenges were:

  • preventing semantic model output from overriding deterministic execution facts
  • separating execution mode from evidence state
  • enforcing idempotency and restart-safe saga behavior
  • preserving optimistic concurrency across durable state
  • preventing credentials from entering prompts, memory, evidence, or public UI
  • keeping historical LIVE_WRITE evidence clearly separated from current SIMULATION evidence
  • designing human authority as an exception rather than a routine approval bottleneck

Accomplishments that we're proud of

  • A working six-agent Google ADK fleet
  • Gemini 3.6 Flash integrated through a bounded Vertex AI model client
  • A deployed Google Cloud Run service
  • Firestore-backed durable state and Pub/Sub event coordination
  • ShadowLab rehearsal and autonomous correction flows
  • Approval Compression and explicit human-authority boundaries
  • Tamper-evident evidence/passport infrastructure
  • A real historical bounded GitHub Draft PR action
  • More than 1,800 automated tests across runtime, security, evidence, governance, and demo behavior
  • Explicit fixture, simulation, recorded-cloud, and live-write evidence boundaries

What we learned

The biggest lesson was that autonomy and authority are different things.

An agent can be highly autonomous while still being tightly bounded. The important question is not simply, “Can the model do this?” It is, “Which authority lane owns this fact or decision, is the action reversible, and what evidence proves what actually happened?”

We also learned that memory should not automatically become truth, model confidence should not become authorization, and a successful simulation should never overwrite or disguise a failed live action.

What's next

The next product step is to move from the competition demo toward customer-isolated enterprise deployments:

  • customer-hosted VPC runners
  • additional repository and infrastructure adapters
  • richer policy packs
  • more schema/API migration handlers
  • stronger enterprise identity and observability integrations
  • reusable Change Evidence Passports across long-running organizational change

The long-term goal is simple:

Autonomous agents should be able to move fast without requiring enterprises to trust them blindly.

Built With

Share this project:

Updates