The governance protocol for lights-out software factories
The future of AI software delivery won't be won by the smartest single agent. It will be won by the best-governed agent teams. AgentXchain turns independent AI agents into an accountable software organization — with structured turns, mandatory challenge, phase gates, and human sovereignty at the constitutional layer.
$ npx --yes -p agentxchain@latest -c "agentxchain demo"
✓ PM defined scope and raised 1 objection
$ npm install -g agentxchain
✓ Install once for repeated governed commands
$ agentxchain init --governed --goal "Ship a governed web app MVP"
✓ Scaffold with mission context before the first turn
$ agentxchain doctor
✓ Verify runtimes and repo health before you run
Writing code isn't the bottleneck. Coordination is.
Single models can already write code. The hard problem is what happens when multiple agents touch the same codebase over time.
Work overlaps
Two agents modify the same file, unaware of each other's changes. Merge conflicts are the symptom. Missing coordination is the disease.
Assumptions diverge
Agent A assumes an API shape. Agent B implements a different one. Nobody catches it until integration fails three turns later.
Quality drifts
Without mandatory review, agents agree with each other. Tests pass in isolation but the product doesn't work. Quality erodes silently.
No decision trail
Who decided to use that library? Why was that approach chosen? Without a ledger, there's no way to audit, learn, or roll back decisions.
Unclear what's shippable
Lots of agent activity, no clear answer to "is this done?" Without gates and evidence, release readiness is a guess.
Humans lose governance
You either micromanage every turn or let agents run unsupervised. There's no middle ground. Until now.
Trust from protocol, evidence, and governance
Trust in multi-agent systems doesn't come from model capability alone. It comes from how the system is governed.
Mandatory challenge
Every turn must identify at least one risk or objection about the previous agent's work. Blind agreement is a protocol violation. Adversarial robustness applied to software delivery.
Divergent agents, healthy friction
Agents are supposed to disagree. That tension surfaces risks early and produces better software than any single agent optimizing in isolation.
Long-horizon convergence
Phases, turn limits, mandatory verification, and human checkpoints. Constraints force convergence on a real product — optimized for convergence quality, not generation speed.
Five layers. One governed delivery system.
Each layer is independently replaceable. The protocol is the foundation — everything else plugs in.
Protocol
The constitutionRun state, roles, turn contracts, artifact schemas, validation rules, phase gates, decision ledger format, recovery semantics. Versioned independently. Model-agnostic. Runtime-agnostic.
Protocol v6 →Runners
The enforcement enginesRead config, manage state, assign turns, validate results, enforce gates. The Node.js CLI is the reference runner. Future runners: cloud services, GitHub Actions, CI pipelines, K8s operators.
Runner interface →Connectors
The bridge to agent runtimesThree modes: manual (human-in-the-loop), local_cli (Claude Code, Cursor, any CLI agent), api_proxy (direct LLM API calls). MCP support via stdio and streamable HTTP. ~200 lines to add a new connector.
Adapter reference →Workflow Kit
The opinionated operating modelPlanning framework (goal-first, scope-disciplined). Spec-driven development. Repo-native documentation. Test-driven quality. QA as governance proof. Escalation and recovery protocols.
Templates & workflows →Integrations
The organizational edgesLegacy IDE compatibility (VS Code, Cursor), governed status and approvals in-editor, step/run launch, restart recovery, report and dashboard access, notifications, export & verification, plugins, and multi-repo coordination.
Integration guides →Planning, specs, QA, and evidence — built into the protocol
AgentXchain doesn't just coordinate agents. It ships software through a structured lifecycle where every decision is traceable.
Goal-first planning
Every run starts with a goal, constraints, and acceptance criteria. Plans break down into small, shippable increments. Scope discipline is protocol-enforced, not suggested.
Spec-driven development
Explicit contracts between roles. Acceptance criteria defined before implementation begins. Agents implement against specs, not vibes. Divergence from spec triggers mandatory challenge.
Repo-native documentation
Plans, specs, decisions, QA evidence, and release notes live with the code. Not in a wiki. Not in Slack. In the repo, versioned and auditable alongside the implementation.
Evidence-driven quality
QA isn't a checkbox. Every quality claim requires evidence: test results, acceptance matrices, coverage reports. "It works" is not evidence. Proof is evidence.
Escalation & recovery
When agents get stuck, the protocol defines recovery paths. Operator escalation, blocked-state recovery, turn reassignment. No silent failures. No infinite loops.
Decision ledger
Every turn records decisions, objections, risks, and verification evidence in an append-only ledger. Full audit trail from first plan to final release.
Open-ended roles, not a fixed PM/Dev/QA template
The PM/Dev/QA example is just that — an example. Roles in AgentXchain are charter-driven and open-ended.
Charter-driven
Every role has a mandate, authority boundaries, governed artifacts, and structured workflow participation. Define the roles your project actually needs.
Any role shape
Security auditor. Performance engineer. API designer. Documentation writer. Compliance reviewer. The protocol doesn't prescribe roles — it governs how any role participates.
Turn structure
Each role gets structured turns with clear inputs and outputs. Turn results are validated against the role's charter. Out-of-scope work is flagged, not silently accepted.
"roles": [
{ "name": "architect", "mandate": "System design & API contracts" },
{ "name": "impl", "mandate": "Implementation against specs" },
{ "name": "security", "mandate": "Threat modeling & audit" },
{ "name": "qa", "mandate": "Evidence-driven verification" }
]
Lights-out operation without blind trust
The goal is agents that can run long-horizon workflows unattended. But unattended doesn't mean ungoverned.
Humans control
- Mission & project goals
- Constraints & non-negotiables
- Phase gate approvals
- Release authority (ship / no-ship)
- Escalation resolution
- Role & governance changes
Agents handle
- Planning within constraints
- Implementation against specs
- Mandatory challenge & review
- Test execution & evidence
- Documentation & decision logging
- Recovery within protocol bounds
Humans remain sovereign at the constitutional layer. Agents operate within granted authority. The protocol makes the boundary explicit.
Structured turns. Mandatory challenge. Human authority.
Optimized for convergence quality, not generation speed.
Init
Define roles, phases, adapters, and gates. Choose your team shape and workflow.
Plan
PM (or your planning role) produces specs with goals, constraints, and acceptance criteria.
Build & Challenge
Agents take structured turns. Every turn must challenge the previous work. Mandatory, not optional.
Gate & Ship
QA provides evidence. Human approves phase transitions. Decision ledger records everything.
IDE compatibility, dashboard, plugins, and multi-repo
AgentXchain meets you where you work. Not just a CLI — a full delivery platform.
Legacy IDE compatibility
VS Code and Cursor compatibility is available today for legacy lock-based coordination. In governed repos, the VS Code extension adds CLI-backed status, approvals, step/run launch, restart recovery, report and dashboard access, and state-change notifications. Reports, multi-repo operations, and the richer governance view still live in the browser dashboard and CLI.
Real-time dashboard
Web-based dashboard shows run state, turn history, decision ledgers, and governance reports. Monitor your agent teams in real time.
Plugin system
Extend the runner with custom plugins for your workflow. Hook into turn lifecycle events, add custom validation, integrate with your existing tools.
Multi-repo coordination
Coordinate agent teams across multiple repositories with a coordinator governance model. Workstreams, barriers, and cross-repo context sharing.
Multi-repo quickstart →Webhook notifications
Real-time notifications for turn completions, gate approvals, escalations, and run events. Integrate with Slack, PagerDuty, or any webhook consumer.
Export & verification
Export governed artifacts for compliance and audit. Verify exports against protocol schemas. Governance reports in text, JSON, or Markdown.
MCP connects tools. A2A connects agents. We govern delivery.
Three protocols for three different problems. They're complementary, not competing.
| MCP | A2A (Google) | AgentXchain | |
|---|---|---|---|
| Layer | Agent ↔ tools & data | Agent ↔ agent messages | Governance over shared work |
| Model | One agent, many tools | Delegation / RPC | Adversarial collaboration, turns |
| Authority | Single agent decides | Agents negotiate | Constitutional human sovereignty |
| Audit trail | Tool call logs | Message history | Structured decisions + objections |
| Horizon | Single task | Request-response | Long-running, multi-phase delivery |
| Best for | Agent uses tools | Agent calls another agent | AI team ships governed software |
Open protocol. Managed cloud. Same governance.
Two surfaces, one underlying protocol. Choose the deployment model that fits your team.
agentxchain.dev
Open-source core
- Full protocol specification (MIT)
- CLI runner — local enforcement engine
- All connectors: manual, local_cli, api_proxy, MCP
- Workflow templates & conformance kit
- Self-hosted dashboard
- Plugin system & multi-repo coordination
agentxchain.ai
Managed cloud experience
- Web dashboard — configure projects with UI, not JSON
- Installable apps for Cursor, Claude Code, Codex
- Cloud-managed coordination, state, and history
- Team workspaces with shared runs
- Compliance reporting & persistent audit trails
- No infrastructure to manage
Build in public with other AgentXchain operators
Product truth should not live only in release notes. Follow shipping work, challenge decisions, and watch the governed delivery model evolve in public.
Release callouts, product framing, and operator-facing updates from the company page.
Follow on LinkedIn →Fast release callouts, proof snapshots, and product changes as they ship.
Follow @agentxchaindev →Longer-form discussion, implementation feedback, and operator questions.
Join subreddit →AgentXchain has opinions
If you want a generic agent framework with no opinions about governance, this isn't it. Here's what AgentXchain intentionally is not.
Why teams adopt AgentXchain
The value is better product decisions and fewer expensive misses — not more agent activity.
Errors caught earlier
Mandatory challenge surfaces risks before they compound across agent turns.
Higher quality releases
QA evidence and acceptance matrices make release readiness explicit, not assumed.
Real accountability
Every turn is logged, validated, and attributable to an agent role with a charter.
Structured convergence
Phases, turn limits, and gates force the team toward a shippable result.
Complete audit trail
Append-only decision ledger records decisions, objections, risks, and evidence.
Lights-out capable
Automated adapters run governed workflows unattended. Humans intervene at gates, not every turn.
Dark software factories
Long-running. Multi-agent. Governed. Auditable. Evidence-backed. Interoperable across models, tools, and organizations. That's the future AgentXchain is building toward.
Five products. Five categories. Zero human code.
Each was built from scratch under AgentXchain governance with distinct team shapes, workflow phases, and governed artifacts.
Habit Board
Daily habit tracker with streaks, dark-theme UI, and JSON persistence.
4 roles · 4 phases · 29 tests
Trail Meals Mobile
React Native meal planner for hikers with offline-first AsyncStorage.
6 roles · 5 phases · 26 tests
Async Standup Bot
Team standup collector with reminders, summaries, and data retention.
5 roles · 5 phases · 15 tests
Decision Log Linter
CLI that validates markdown decision logs for structure and integrity.
5 roles · 5 phases · 8 tests
Schema Guard
Declarative schema-validation library with composable validators.
5 roles · 5 phases · 19 tests
Software is a team sport. Even when the team is AI.
One protocol. Define your roles. Route turns through real gates. Keep a decision trail you can inspect, audit, and trust.