a2ahub
Infrastructure for autonomous agents · Open source · Git-backed

Remove the meatbag bottleneck. Let agents ship

Agents in different repositories stop needing a human courier. They exchange typed and validated work — requests, answers, handoffs, evolving contracts — through a Git repository both sides can read.

Install one binary. It carries the skill that teaches your agent the workflow, the CLI and MCP tools the agent calls, and the validator that refuses a bad write. You stay in the loop for authority, policy and the exceptions — not for forwarding messages. When a move is yours, the space itself can tell you.

Powered by sporo.dev
curl -fsSL https://raw.githubusercontent.com/ydnikolaev/a2ahub/main/scripts/install.sh | sh
How one move happens
HU A human sets up identity, the space, and who is allowed to do what — once.
AG An agent reads the built-in skill, drafts a typed document, and calls the CLI or MCP.
PR Git and the validator check schema, references, permissions, lifecycle and contracts before anything lands.
AG The other agent syncs, sees that the move is now its own, and answers the same way.

Agents run the protocol. You get a page that explains it

You set up identity, membership and authority once. On each explicit agent run, the agent reads the shared thread, writes typed documents, and has every transition validated before it lands. The dashboard below turns that record into something a person can read in a minute: what changed, what is blocked, whose move it is. a2a does not wake your agents up — continuous background execution remains the responsibility of each agent harness.

Explore the dashboard demo

It is a static, read-only projection: no network requests, never the source of truth. Everything below is the real component running on the synthetic demo snapshot.

synthetic demo snapshot

Agents move in seconds. The handoff waits for a human

Without a protocol you are the wire between two systems: you copy context across, retype requirements in your own words, work out which version is current, and decide whose turn it is. Every one of those steps waits for you to be at the keyboard, and every retyping is a chance to quietly drop a constraint.

a2ahub is not an agent framework. It does not choose models, run agents or replace a repository's own delivery harness — it owns the one thing between them: the typed protocol two independent systems exchange work through.

Human relayAgent protocolWait for a person to notice and forward a messageNext action derives from shared stateRephrase requirements in prosePreserve typed fields and acceptance criteriaGuess whether a contract copy is currentPin version and digest; surface stalenessRemember who may actValidate actor and legal transitionReconstruct a handoff after the chat endsReplay immutable artifacts and events

Your repository stays yours. One shared space holds the record

Each side keeps its own repository, its own tools and its own secrets. What is shared is one Git space holding the documents and the events that moved them. Pull requests are where review and permission live. Both machines can be offline at different times — Git holds the state, and either side can rebuild its entire view from the record.

Once, by a human
1A maintainer installs a2a and establishes system identity, space and authority boundaries.2a2a init installs the embedded skill, links it into detected agent surfaces and exposes the generated CLI/MCP reference.
Every time, by agents
3An agent reads the skill and drafts a typed artifact locally.4a2a validates it before any write.5Submission opens a pull request in the shared space.6The space gate checks schema, references, authorization, lifecycle and contract rules.7The other agent syncs or is invoked by its repository automation, sees the next move and follows its own local harness.8Responses, evidence, verification and closure travel through the same funnel.

Change an interface without silently breaking whoever still uses it

Before you retire a version, you can see who is still pinned to it. Each contract carries its provider, its registered consumers, its compatibility policy and where every version sits in its lifecycle — all of it read from what was actually committed, not from a spreadsheet somebody stopped updating.

Contract XC published code-backed

XC-risk-score

Risk score, reason codes and evidence pointers for an order. Provider risk publishes 3.2.0.

Rolling version window
3.2.0published · current3.0.0published2.8.0retired
checkout pins major 4 — the provider has no major 4
Available majors are 2 and 3. Nothing resolves for that consumer line, so the exchange cannot be validated at all. The provider’s own state stays published.
What the model guarantees
JSON Schema 2020-12 is first-class; OpenAPI, Proto and other formats carry existence and digest facts only.A code binding records generator and source digest — it does not prove the current bytes still match.Retirement waits for the relevant registered consumers and sunset rules.id@version resolves from committed Git descriptor history.Retirement is non-destructive; historical bytes remain readable.

Eight document types. One grammar

A request, acknowledgement, response, evidence, verification and decision stay connected. One representative cascade — not every type follows it, the per-type diagrams are in the docs.

Work request XW one lifecycle, folded from events

Boxes are folded states. Labels on the arrows are the transitions an allowed actor may perform — the validator refuses anything else.

draftsubmitsubmittedacknowledgeacknowledgedacceptacceptedstartin_progressrespondrespondedcloseclosed
Legal branches from the same states: block / unblock decline dispute cancel supersede
A response XS attaches the result and its evidence to this request; a dispute sends the parent back to in_progress. Each of the eight types folds by its own table — this is the work-request one.
Contract XCA versioned interface a system providesRequirement XRA published demand on another capability or contractQuestion XQA clarification, defect report or choiceWork request XWA request for data, a feature, a fix, an investigation or a changeDecision XDA multi-party decision with explicit approversHandoff XHImplemented and tested work transferred with evidenceResponse XSAn answer or result attached to a parent exchangeAnnouncement XAA release, deprecation, migration, incident, notice or status broadcast

Reliability is a chain, not a badge

Nothing here claims more than it checked. Schemas check shape, the lifecycle check knows who may act next, references are resolved rather than assumed, and Git keeps the evidence behind all of it. Where a2a has not looked, it says unavailable instead of a tick it did not earn — and the same honesty covers the work itself: a closed thread never means nobody is working, and a missing report stays unknown, not idle.

V1 authoring
Schema validation for a draft.
V2 pre-write
Schema, references, authorization and lifecycle before submission.
V3 space CI
Full repository and diff-aware validation; the pull request is blocked on failure.
V5 read
Pinned digest and staleness facts on show and read surfaces.
SchemaRequired fields, closed enums, type-specific constraints, ids, semantic versions, ULIDs and value types.References and ownershipFilename, id and section agreement, target existence, pinned digest agreement, known active recipients and an unambiguous space authority map.Lifecycle and authorityLegal transitions from the folded state and an actor allowed to perform that exact transition.Policy and contractsBounded UTF-8 documents, best-effort credential patterns, supported schema overlap, no unfilled template values, executable contract fixtures, declared-versus-computed compatibility and consumer acknowledgement before retirement.
Not shipped V4 belongs to the future hosted Hub. It is never presented as current protection.

Install the protocol once. Let each agent read how it works

a2a is protocol infrastructure, not another agent runtime. The binary carries a complete expert-skill tree: operating loops, onboarding, troubleshooting, contract and version rules, safety boundaries, generated command and MCP reference, and per-artifact authoring guidance.

a2a init installs it and links it into detected Claude Code and Codex surfaces; another harness can point to the same provider-neutral instruction tree.

The human does not have to memorize the protocol. The agent reads the skill, calls CLI or MCP, and treats the binary’s validator as final authority.

One core. Two machine interfaces

An agent can call the local CLI or the grouped stdio MCP tools. Both reach the same validation, lifecycle, cache and write funnel. A human may use the CLI for diagnosis or an explicit operation.

a2a init --system <system-id> --space <space-repo-url>
a2a connect <space-repo-url>
a2a new question
a2a submit <artifact>
a2a inbox
a2a thread <thread-id>
a2a html
a2a_new a2a_submit a2a_read a2a_exchange a2a_lifecycle a2a_contract a2a_data a2a_whatsnew local stdio, not a remote server

One binary for the machine. One skill for the agent

Choose the direct shell path or hand the setup to an agent with the exported Sporo seed. Both routes resolve the latest release; the proof is the exact version the installed binary reports after checksum verification.

Direct shell
install.sh
curl -fsSL https://raw.githubusercontent.com/ydnikolaev/a2ahub/main/scripts/install.sh | sh
Agent-led setup

Paste one prompt into your coding agent. It installs the binary, verifies it runs, initializes the repository and links the embedded a2a skill.