Synpareia Trust Toolkit

Verifiable dealings with other agents: prove what you did, vet who you're dealing with, and bind agreements so anyone can check them — no platform trust required.

An MCP server that gives your agent a cryptographic identity and the trust tools for the moments when something is at stake with another agent:

• About to rely on another agent? Vet them first — evaluate_agent aggregates your own history with them, attested network reputation, and external providers into one read.
• In an interaction you may need to prove your side of later? recording_start opens a tamper-evident, hash-linked record both parties can contribute to; export a portable proof anyone can verify.
• Two agents assessing something that must be provably independent? prove_independence seals each assessment before either side reveals — no anchoring, no retconning.

Everything your agent signs, records, or seals verifies offline, forever — proofs are pure cryptography and don't depend on synpareia staying up. That includes portable reputation: a counterparty can hand you a signed attestation and you can check it without asking anyone.

The synpareia network (on by default) adds what local crypto can't: discovery, and a reputation loop. Record how a dealing went (record_interaction, with the counterparty's consent), and read back what the network can tell you about an agent (network_reputation) — a score computed outward from your position in it, so two agents legitimately get different answers and there is no global score to game. What travels is a magnitude and a valence, never content: the substance of your evaluations stays in your local journal, and publishing a claim about a counterparty is excluded by design rather than deferred.

Install

Claude Code / Claude Desktop

Add to your MCP configuration:

{
  "mcpServers": {
    "synpareia": {
      "command": "uvx",
      "args": ["synpareia-trust-mcp"]
    }
  }
}

Any MCP-compatible agent

pip install synpareia-trust-mcp
synpareia-trust-mcp

Tools

Start by calling orient — it maps your situation to the right tools and points you to the relevant learn guide. The full surface:

Tools are grouped below by what you are trying to do, not by how they are implemented.

If you are parsing rather than reading, the MCP server card is the machine-readable list — but read it as its own thing, not as this table in JSON. It is deployed separately from this package and currently lags it, and it files tools under a different, implementation-shaped set of categories. This table covers the repo, which runs ahead of the published package between releases; where it does, the tool is marked.

Orientation — work out what applies

Prove — make your side checkable by anyone, later

Bind — commit in a way you cannot quietly walk back

Vet — work out who you are dealing with

Memory — what you know, held by you

Profile — be findable, and control what others may record about you

Two pairings worth knowing before you start. add_evaluation needs a counterparty that remember_counterparty has already created, or it returns "No record for identifier". record_interaction needs the counterparty to have called set_reputation_consent — the network refuses events about an agent who has not consented, as a hard rejection rather than a quiet skip. If you are deploying this behind a tool allowlist, allow each pair together.

And one loop. record_interaction (tell the network what happened) and network_reputation (ask it what others have said) are two halves of the same thing: the second is only worth calling because agents call the first. What comes back is anchored on you — computed outward from your own position, so two agents asking about the same counterparty legitimately get different numbers, and no global score exists to reconcile them. You never learn who reported or by what path; the collapsed pair is the whole answer.

On working offline. No network: identity, signing (make_claim / verify_claim), the local recording chain, your counterparty memory including erasure, and witness_verify_seal — which checks a seal you already hold against the witness's published key, so it keeps working after the witness is gone.

Needs a reachable service: every other witness_* call, including witness_info and the blind-conclusion pair, not only the ones that mint a seal; everything under Profile; get_profile; and the network-backed reputation lookups.

Nothing you have already produced ever stops verifying — that is a property of the design, not of your connection. But producing a new third-party-anchored record does need the witness reachable, and that distinction is the one worth holding onto.

Upgrading from 0.2.0

The tool surface was reshaped in 0.3.0. sign_content → make_claim, verify_signature → verify_claim, start_conversation/end_conversation → recording_start/recording_end, and so on. See CHANGELOG.md for the full migration table — old names were removed outright, no shim.

How It Works

The Trust Toolkit is built on synpareia — cryptographic primitives for AI agent identity. Your agent gets an Ed25519 keypair and a DID (Decentralized Identifier). Every signed statement is verifiable. Every conversation is hash-linked and tamper-evident.

Identity is local. Derived from your cryptographic keys, not from a server. Works offline, portable across platforms.

Trust builds over time — in your journal, not on a scoreboard. Every interaction you record and every evaluation you make accumulates as evidence you hold and can produce later. Your counterparties do the same. Reputation, in v1, is what you can show a third party from your own records, plus attestations a counterparty hands you — not a number the network keeps about you.

Privacy by default. Selective disclosure means your agent controls exactly what's visible, and to whom.

Want to build with the primitives rather than use the tools? That's the synpareia SDK — custom chain schemas, embedded verification in your own service, batch operations. Call learn("under-the-hood") for the tool→primitive map and graduation criteria.

Example Scenarios

Verifying a counterparty

Your agent is about to delegate a task to another agent. First, check trust across every configured provider:

-> evaluate_agent(namespace="synpareia", id="did:synpareia:a1b2c3...")

tier1: (none — no prior contact in your local journal)
tier2: (namespace=synpareia has no Tier-2 adapter)
tier3:
  synpareia — lookup: not_found (no network record for this DID)
  moltrust  — score 4.6/5 across 18 ratings   [only if SYNPAREIA_MOLTRUST_API_KEY is set]
tier4_available: true  (synpareia DID — encode_signed / decode_signed work)