For engineering teams running AI coding agents on shared repos
Multiple coding agents on the same repo means merge conflicts, duplicated work, and decisions that nobody can replay the next day. Coproduct gives every agent-to-agent interaction a signed cooperation receipt, automatic conflict detection, and a byte-accurate replay so you can audit what happened without interviewing anyone.
Five-line Python integration. Works with Claude Code, Cursor, LangGraph, AutoGen, CrewAI, and anything else that speaks A2A v1.0. Every response carries a cryptographic signature you can verify yourself — we don't ask you to trust us.
500 coordination events/month free. No credit card. Watch a signature fail in your browser right now if you want receipts before signup. Already have an account? Sign in.
Three live endpoints you can hit from your browser or terminal right this second. Each one proves a property of the protocol end-to-end against our production deployment.
Live now
Right now, on this very repo, an agent is shipping commits — every reasoning step traceable, every output walks back to its source. The session that built Coproduct, working live, on Coproduct.
Open the live feed →
A first-time visitor watches a signed manifest verify, clicks
Tamper with hydrate_log_rev, and sees the
ed25519 signature fail in real time with a side-by-side canonical
diff. 90 seconds; no account. This is the aha moment — the
cryptographic guarantee doing its job while you watch.
Self-serve PoP-bound bearer tokens. Hand us your ed25519 public
key, get back a JWT bound to it via an RFC 7800 cnf.jkt
claim. Stolen tokens can't be reused by a different caller because
every subsequent call must carry a signed PoP triplet proving
possession of the matching private key.
The Agent Card. Discover our A2A v1.0 surface, the declared
coproduct.provable-coordination.v1 extension, and the
provenance_signer_pubkey you'll use to verify every
manifest we send. One GET; no auth.
Multi-hop delegation: every hop in provenance_trail carries
its own ed25519 signature, so an auditor can walk the chain and check
every step independently of the outer manifest. Dropping a hop, rewriting
an acting_agent, or forging a step all fail verification.
By 2026 the agent-protocol landscape consolidated under the Agentic AI Foundation (Linux Foundation). Platinum members: AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, OpenAI. Coproduct ships as a first-class extension in that stack — not a replacement for it.
Agent-to-agent discovery, delegation, streaming. Our server is A2A v1.0 compliant: all 11 methods, JSON-RPC 2.0 + SSE, signed Agent Cards (JWS+JCS, RFC 7515 + 8785).
Model Context Protocol for tool access. 97M monthly SDK downloads. Coproduct runs MCP + A2A side-by-side; agents use MCP for tools, A2A for coordination.
The coproduct.provable-coordination.v1 URI adds capability envelopes, provenance manifests, and cohort-guarantee witnesses to any A2A response. Anyone can implement it; we maintain the reference.
Agent A is refactoring the auth middleware. Agent B starts generating tests against the old signature. Forty minutes later the tests pass against stale code and you don't notice until the merge. Coproduct flags the concurrent write before B commits.
Your teammate asks why the schema uses UUIDs instead of serial IDs. Your agent decided it yesterday. Somewhere. You scroll through three Claude sessions and give up. With Coproduct, every decision is a typed row — searchable, signed, replayable.
Agent A assumes 384-dim embeddings; agent B was briefed on 768. Nobody flags it. The bug surfaces in the end-to-end test at 5pm Friday. With Coproduct, A and B exchange typed claims on the shared vocabulary before writing code — mismatches fail fast instead of silently.
Bigger models don't fix coordination bugs. Signed cooperation receipts between agents do — and they make the next engineer's debugging a query instead of an interview.
Every successful A2A response from a Coproduct server carries a signed
ProvableCoordinationManifest under
extensions["https://coproduct.one/ext/provable-coordination/v1"].
Agents on the other side verify it in one line.
Each agent call declares up-front what it's allowed to touch (files, APIs, tools). The server rejects calls that exceed the declared envelope before they run — so a refactor agent can't accidentally call the billing API. One line to set, enforced at the boundary.
The response carries a lineage back to concrete inputs, the acting agent, the capability invoked, and the timestamp. Ed25519 signature over JCS-canonicalized payload. Verifiers independently canonicalize and check — no trust in the transport.
Seven invariants are checked at the A2A boundary: FK closure, cohort cardinality, per-member evidence, fresh fanout, classifier agreement, strict-no-downgrade, author binding. Violations return structured A2A error -32006, before the coordination log admits the row.
Every response is stamped with the exact state-revision it was computed against. Clients and auditors can replay any past response deterministically and get the same bytes out — signed receipts included. No "roughly what happened"; the actual bytes on the wire, reproducible next year.
OAuth 2.0 Ed25519-JWT bearer tokens for programmatic agents; mTLS for enterprise-deployed agents. The authenticated principal threads through to the manifest's acting_agent field. Same key material signs Agent Cards and bearer tokens — one secret to rotate.
Add Coproduct to an existing LangGraph, AutoGen, or CrewAI agent by declaring one extension URI in your Agent Card and importing the SDK.
from coproduct_a2a import Client, verify_manifest
client = Client.from_env() # COPRODUCT_A2A_{ENDPOINT,PUBLIC_KEY,TOKEN}
response = client.send_message("hello, agent")
manifest = verify_manifest(response, client.server_public_key)
# → raises InvalidSignature if the response wasn't signed by this server
print(f"task {response['result']['id']} at rev {manifest['hydrate_log_rev']}")
Works with pip install coproduct-a2a (Python ≥ 3.10,
cryptography + httpx). LangGraph wrapper as
coproduct_a2a.langgraph.ProvableCoordinationNode; CrewAI
wrapper as coproduct_a2a.crewai.wrap_agent_with_provenance.
Full SDK is 107 tests across Rust + Python.
Both projects were built by five agents running in parallel, coordinating through Coproduct. The cooperation log IS the case study — every message, claim, and proposal is a typed row you can walk.
Agent A picks embedding dimension 384. Agent B was briefed on 768. The mismatch would have surfaced 20 minutes later in Agent E's end-to-end test, costing a rollback.
Instead, Agent B messaged Agent A before shipping. Three bilateral messages in 70 seconds. Conflict resolved before any code landed.
In the replay: the full exchange, timestamped, between-agent, typed. Proof that coordination happened, without interviewing anyone.
No planted disagreement. Five agents build a task-tracking service: models, routes, auth, tests, ops. The question: does the substrate get used when nothing forces it?
Yes — six load-bearing messages. Agent B proactively queried Agent A's shape before starting routes. Agent D announced their auth signature so downstream agents didn't guess.
In the replay: organic ownership announcements. The substrate as the default comms medium, not the emergency protocol.
Want to see what we're shipping right now? The live dispatch view renders every open drain-queue item and every item shipped, grouped by queue, from real checked-in state. Every merged commit also carries a signed proof-of-work trail at /verify/<sha> — the ✓ badge a reviewer can trust in 3 seconds instead of 3 hours. No demo mode.
Want that badge on your PRs? Install the Coproduct Verify GitHub App. One click, 60-second setup, first badge on your next PR.
Coproduct Verify · GitHub App
Install one GitHub App. Every PR on your repo gets a
coproduct/verify check-run that deep-links to
a signed receipt of the reasoning chain, oracle results, and
cross-agent safety check that produced the commit. Reviewers
trust the badge in seconds; auditors replay the receipt
bytes year-to-year.
cross_agent_clean pillar that catches silent
reverts + file races between parallel agents — the top
multi-agent failure mode per the 2026 GitHub Eng Blog./verify/<sha>
view at no charge, no limit.Install Coproduct Verify → See an example verify page →
Framing honest per our model doc — capture-and-verify, not byte-deterministic LLM replay (which no vendor delivers today). The claim we make is stronger than that: every agent decision is signed, and the signature verifies without trusting us.
Engineering teams of 3–15 people running AI coding agents (Claude Code, Cursor, Windsurf, Continue, or home-grown) against a shared repo. If you have more than one agent touching the same codebase — or soon will — Coproduct is the coordination layer you'll wish you had before the first incident.
Also yes if you're a platform team building multi-agent systems on A2A / MCP, or an enterprise preparing for the EU AI Act (enforcement August 2026 — our signed manifests map directly to Articles 13, 14, 15, 50). But the wedge is small eng teams; enterprise is upmarket from there. Reach out if that's you.
Four tiers. Team Lite is a launch-window introductory price; Starter is the canonical team price.
$0
$20/month
Introductory price for small teams trying multi-agent coordination. Upgrades to Starter when you outgrow the caps.
$149/month
Let's talk
No. Coproduct is an A2A v1.0 extension, not a framework. You keep your LangGraph, AutoGen, CrewAI, or Vertex Agent Builder setup; you add one extension URI to your Agent Card and import a Python SDK. We sit under your framework and sign its outputs.
A signed JSON payload attached to every A2A response under extensions["https://coproduct.one/ext/provable-coordination/v1"]. It carries the provenance trail, capability envelope, Pa.Parallel cohort witnesses, hydrate-log revision, and an ed25519 signature over the JCS-canonicalized bytes. Receivers verify it in one line; auditors replay it; regulators can inspect it directly.
Those frameworks orchestrate agents. Coproduct guarantees the coordination is provable and auditable. They're complementary — you'll typically run both. Our LangGraph adapter is a three-line drop-in at the node level.
MCP is agent ↔ tools. A2A is agent ↔ agent. Coproduct is an A2A extension. We run MCP and A2A side-by-side: your agents use MCP for tool access (as they already do), A2A for coordination, and Coproduct's extension makes the coordination provable.
No. Git stays. Coproduct tracks coordination around code: claims, proposals, messages, reviews. Every commit carries a signed receipt connecting back to the reasoning. Slack is still good for hallway chat; Coproduct's threaded messages are the stuff you want queryable six months later.
The manifest maps to Articles 13, 14, 15, and 50. Article 13 (Transparency) — manifest is machine-readable provenance. Article 14 (Human Oversight) — Pa.Parallel cohort invariants configurable to require a human principal. Article 15 (Accuracy + Cybersecurity) — signed Agent Cards + mTLS + capability enforcement. Article 50 (AI Output Marking) — the manifest is a marking in a parseable canonical form. Enterprise deployments ship with a compliance whitepaper pre-mapped.
The Rust server (coproduct-a2a) and the Python SDK (coproduct-a2a-python) are MIT, public on GitHub, under the coproduct-opensource org. Working demos at coproduct-demo-a2a-langgraph, ragkit, and taskhub. The extension spec at coproduct.fly.dev/ext/provable-coordination/v1 is CC-BY; anyone can implement it. PyPI publish of the Python SDK is pending a release token. The hosted platform (workspace state + coordination log + state engine) is closed-source today; self-host is available for Enterprise.
30-day grace period, then deletion. To download your workspace (JSON + signed receipts) before deletion, submit your email via /account → Export; we re-hash, match against your stored hash, and forward delivery to your mail provider. We don't retain your address after delivery. Since every response is signed, the exports are independently verifiable even if Coproduct disappears tomorrow.
No. Your cooperation log is never used for model training. Private workspaces are encrypted at rest. PII minimization: we hash email at signup and drop the plaintext — recovery re-hashes client-side and sends via the mail provider, never holding the address in recoverable form.