Skip to content

Tractum

Verifiable multi-agent consensus for Claude. A coordination layer built around signed, verifiable agreement.

Every agent framework can make one Claude answer. Most can run several in parallel. None of them ship a signed consensus receipt — agreement with the disagreement surfaced and the result cryptographically verifiable. That's Tractum.

Buzz coordinates agents via workflows. Goose gave one agent tools. LangGraph makes you wire coordination by hand. Tractum adds what none of them ship: signed multi-agent consensus with the disagreement surfaced.

The 30-second pitch

from tractum import AgentConfig, Swarm, SwarmConfig, Task

swarm = Swarm(SwarmConfig(
    name="ArchReview",
    agents=[
        AgentConfig("StrongConsistency", "Distributed Systems Engineer", "..."),
        AgentConfig("Operations", "SRE / Platform Lead", "..."),
        AgentConfig("Pragmatist", "Staff Engineer", "..."),
    ],
), api_key=...)

result = await swarm.process(Task(
    id="q1",
    description="Active-active Postgres, FoundationDB, or eventual consistency for payments?",
    input_data={},
))

print(result.result["final_answer"])
print(f"agreement: {result.result['agreement']:.0%}  disagreed: {result.result['disagreed']}")

Three specialists. One signed answer. Disagreement surfaced, not averaged away.

Why this exists

The agent-framework field is crowded but lopsided:

Tool What it solves The gap
LangGraph Production orchestration, manual graphs Coordination is DIY wiring
CrewAI DX, fast prototyping Coordination is shallow; +48% token cost
Goose (Block) Single-agent harness + MCP No multi-agent at all
Buzz (Block) The room agents talk in Coordination via workflows, no consensus primitive
Anthropic SDK Base Claude calls No coordination layer
MCP marketplaces Tool distribution No agreement primitive

The whitespace, plain: everyone built where agents act or where agents talk. Nobody shipped verifiable consensus — agreement with a tamper-evident receipt. Tractum fills exactly that.

What makes it defensible

Consensus results aren't text — they're signed, tamper-evident attestations anyone can verify. Since v0.4.0, every agent signs its own stance: a receipt is a k-of-n multi-sig over machine judgment, not one operator's claim about what the agents said.

from tractum import ConsensusReceipt, Ed25519Backend, verify_receipt_detailed

receipt = ConsensusReceipt.from_result(result, swarm_name="ArchReview", task_id="q1")
Ed25519Backend().sign_receipt(receipt, private_key)

# Anyone, anywhere, can verify this later — aggregate signature, every
# agent's individual statement signature, and the quorum count:
report = verify_receipt_detailed(receipt, expected_agent_pubkeys=agent_keys)
report.valid, report.valid_statements  # -> (True, 3)
# ...and tampering with any answer — or any agent's signature — is caught.
  • k-of-n quorum receipts — each agent's statement is individually signed; the quorum threshold is part of the signed payload.
  • Ed25519 by default — no new native deps, works everywhere.
  • Swappable signature backend — a post-quantum (ML-DSA) backend ships today; statements can mix algorithms and verify per statement.
  • Three transports — the same signed receipt renders as plain JSON, a W3C Verifiable Credential, or a Nostr NIP-78 event any Nostr client can read.

This is the layer that makes consensus worth acquiring rather than reimplementing in a weekend. See Transports for the tradeoffs and API Reference for the surface area.

Install

pip install tractum              # the SDK (4 deps, lean)
pip install tractum[mcp]         # + expose consensus as an MCP server
pip install tractum[nostr]       # + sign Nostr events for Buzz interop
pip install tractum[langgraph]   # + drop consensus into a LangGraph StateGraph

Use it three ways

1. As a Python SDK

from tractum import Swarm, WeightedVote, Debate

# Cheap default — one round, picks highest-confidence answer
swarm = Swarm(config, consensus=WeightedVote())

# For hard questions — agents see peers' answers and revise once
swarm = Swarm(config, consensus=Debate())

2. As an MCP server

tractum-mcp            # stdio — for Claude Code, Cursor
tractum-mcp --http     # HTTP/SSE — for remote agents

Any MCP-capable agent (Claude Code, Cursor, Goose) gains two tools: reach_consensus and verify_consensus. One tool call gets a signed agreement — no framework to learn, no graphs to wire.

Try it in 5 minutes: MCP demo — pip install to a verifiable decision, keyless-friendly.

3. As a coordinator (hierarchical decomposition)

from tractum import Coordinator, CoordinatorConfig

coord = Coordinator(CoordinatorConfig())
coord.add_sub_agent("Researcher", ...)
coord.add_sub_agent("Analyst", ...)
result = await coord.coordinate(task)

Next

  • Transports — JSON vs W3C VC vs Nostr NIP-78, and when to pick each.
  • Adapters — Buzz and LangGraph integration paths.
  • Benchmarks — Tractum vs single Claude vs CrewAI on a hard question.
  • API Reference — auto-generated from the source.
  • Changelog
NEWELL