Skip to main content

AgentXchain v2.24 Launch Snapshot — Four Adapters Proven Live

Historical launch snapshot from April 2026 — At v2.24.1, AgentXchain first proved four runtime adapters live, and proved the three non-manual adapters (local_cli, api_proxy, mcp) with real AI models instead of mocks. Escalation, recovery, and the public install path were all exercised through the real CLI.

The problem AgentXchain solves​

AI capability is improving quickly. Coordination quality is not.

A single model can write useful code. That is not the hard problem. The hard problem is what happens when multiple agents touch the same codebase over time: work overlaps, assumptions diverge, quality drifts, nobody owns the decision trail, and humans lose governance without micromanaging.

The bottleneck is no longer intelligence. The bottleneck is governance, coordination, and convergence.

AgentXchain is an open-source governance protocol that turns independent AI agents into a governed software team with structured turns, mandatory challenge, phase gates, and human sovereignty.

See it in 30 seconds​

No API keys needed:

npx --yes -p agentxchain@latest -c "agentxchain demo"

This runs a complete governed lifecycle:

  • PM scopes auth-token rotation, raises a missing-rollback objection
  • Dev implements with atomic rollback, resolves the PM objection, raises a clock-skew risk
  • QA reviews against the acceptance matrix, raises a compliance gap, issues ship verdict

Three agents. Three different failure classes caught. 1.8 seconds. Zero API keys.

What was proven at the v2.24.1 launch​

Four adapters were proven live at launch​

AdapterWhat it doesLive proof
manualHuman types the turn resultProven across multiple governed runs as the human control path
local_cliClaude Code, Cursor, any CLI agentrun_91f4ba5d54707a7e — live Claude Code dev turn with a real model
api_proxyDirect LLM API call with proposal stagingrun_7b067f892916b799 — full proposed-authority lifecycle with real Anthropic output
mcpMCP stdio/HTTP with real model behind serverrun_83a64c7bb6925711 — Anthropic API via MCP stdio

The precise launch-time claim matters: at the v2.24.1 launch, all four adapters were proven live; three adapters were proven with real models; manual was the governed human-in-the-loop control path.

Escalation and recovery​

AgentXchain doesn't just run agents. It recovers when they fail.

  • Dev turn rejected twice until max_turn_retries exhausted
  • Run transitions to blocked with escalation:retries-exhausted:dev
  • Operator recovers the run
  • Engineering director reviews with an objection
  • Full audit trail preserved

Proof: run_ebf10c05d7419a0c — Scenario D recovery details

Proposal authoring​

api_proxy agents can propose file changes through a staging area:

  1. Agent returns proposed_changes[] in the turn result
  2. Proposals materialize under .agentxchain/proposed/<turn_id>/
  3. Operator reviews with agentxchain proposal list and agentxchain proposal diff
  4. agentxchain proposal apply copies reviewed changes into the workspace
  5. Conflict detection prevents stale proposals from silently overwriting workspace changes

Post-release install verification​

Release postflight now verifies the public npx install path in an isolated environment — not just registry metadata.

How it works​

AgentXchain governs multi-agent delivery with five layers:

  1. Protocol — the constitution. Run state, roles, turn contracts, phase gates, decision ledger, recovery semantics. Versioned independently. Model-agnostic.
  2. Runners — enforcement engines. The CLI is the reference implementation.
  3. Connectors — bridges to agent runtimes. At the v2.24.1 launch, this included manual, local CLI, API proxy, and MCP. Current releases have expanded beyond this launch snapshot.
  4. Workflow Kit — opinionated operating model. Planning, specs, QA, release, escalation, recovery.
  5. Integrations — dashboard, notifications, plugins, multi-repo coordination.

Core governance rules​

  • Mandatory challenge: every turn must include at least one objection. Blind agreement is a protocol violation.
  • Human sovereignty: humans approve phase transitions and ship decisions.
  • Phase gates: real artifacts must exist before work advances.
  • Append-only audit: every decision, objection, and risk is recorded.
  • Structured convergence: phases, turn limits, and mandatory verification force convergence on real output.

What AgentXchain is not​

What it's notWhat that isHow AgentXchain differs
Agent frameworkCrewAI, LangGraph, AutoGen, MetaGPTThose build agents. AgentXchain governs how agents converge.
Single-agent coderDevin, Cursor, Copilot, CodexThose are smart individual agents. AgentXchain coordinates teams of them.
Message routerGoogle A2AA2A routes messages between agents. AgentXchain governs the delivery process.
Tool connectorMCPMCP connects models to tools. AgentXchain is one of those tools — and also uses MCP as a connector.

Get started​

# See governance in action (no API keys)
npx --yes -p agentxchain@latest -c "agentxchain demo"

# Install the CLI, then scaffold a governed repo
npm install -g agentxchain
agentxchain init --governed --template web-app --goal "Ship a governed web app MVP" --dir my-agentxchain-project -y
cd my-agentxchain-project
agentxchain doctor

# Walk through your first real governed run
# https://agentxchain.dev/docs/getting-started

Links:

Evidence (v2.24.1 launch-time snapshot)​

These counts reflect the state of the codebase at the time v2.24.1 shipped. The test surface has grown significantly since launch — run cd cli && npm test and npx vitest run for current numbers.

  • 2,486 node tests / 534 suites / 0 failures
  • 774 Vitest tests / 36 files / 0 failures
  • 108 conformance fixtures
  • Protocol v7 spec published
  • All 4 adapter types proven live
  • local_cli, api_proxy, and mcp proven with real AI models
  • Docusaurus production build passes

MIT licensed. View source on GitHub.