WYRD Protocol
What is it?

WYRD is an open standard that turns heterogeneous AI agents — different vendors, sizes, and context windows — into a system where no claim survives unexamined and every artifact carries its provenance.

Think of WYRD like a lie detector for multi-agent work. Where MCP standardizes how a model reaches tools, WYRD standardizes how a model’s claims become checkable — each witnessed, verified, recorded, and folded into a portable mathematical proof. No shared framework, no common vendor: a git repository, append-only text files, and discipline.

Quickstart

Three moves to your first proof. Verification is free and needs no account; proving needs a seat — claim a free one with a wallet.

1. Verify anything, free. POST /api/enclave/verify with a computed hash and the committed root.
2. Get a seat. Connect a wallet at the proof enclave — one free proof, no gas.
3. Attach your model. Add the MCP connector (below) and let it request proofs as tools.

The four beats

Every step runs the same cycle. The backronym and the ninth-century etymology of wyrd — “that which has been woven” — say the same sentence.

The covenant

Five commitments hold the protocol together. Each is a rule with a shape — how a well-behaved seat honors it, and the anti-pattern it rejects.

How it runs: a claim enters with its evidence and moves left to right. The gate can send it back.

The same five commitments, enforced in code — one WYRD step end to end:

# The covenant is not prose — it is executable. Here is a WYRD step in Python.

from wyrd import Claim, Ledger, parity_gate, sha256

ledger = Ledger("evidence/step_017.ndjson")   # SEP-3: one file, one writer

# 1. ASSERT, DON'T LAUNDER — a claim ships with its evidence or not at all.
run = run_tests("nested_arrays", seed=42)      # 12 cases
claim = Claim(
    statement = "parser handles nested arrays",
    evidence  = run,                            # the raw result, not a summary
)
assert claim.evidence.passed == claim.evidence.total, "no evidence, no claim"

# 2. GATES THAT CAN FAIL — prove the gate goes red before you trust it (SEP-4).
baseline = ledger.head_output()
assert parity_gate(baseline, baseline) is True          # honest input passes
assert parity_gate(corrupt(baseline), baseline) is False # sabotage is CAUGHT
# ...only now is parity_gate trusted for this step.

# 3. VERIFY, DON'T TRUST — a second hand rebuilds from a clean tree (SEP-2).
rebuilt = clean_build(claim.artifact)
assert parity_gate(rebuilt, baseline), "another seat could not reproduce it"

# 4. RECORD — append-only, hash-chained. The repository is the audit log.
receipt = ledger.append(claim, prev=ledger.tip_hash())   # SEP-6 receipt
print(receipt.root)        # 0x115a…  — anyone can now verify, trusting no one

# 5. THE OPERATOR'S HAND — the agent stages; the human ships (SEP-15).
stage_push(receipt)        # describes + stages the push
# git push is the operator's keystroke, never the agent's.

The Proof Kit

Sixteen proof types, each a real cryptographic primitive, each producing a portable artifact { root, proof, recipe, receipt } anyone can verify while trusting no one. Grouped by the beat each embodies — open any proof for its claim and the math beneath it.

Three surfaces

The same taxonomy is reachable however your model or app already lives — plain HTTP, an MCP connector, or the WEFT-API.

Connect your model

Attach WEFT to whatever you run — a local model in LM Studio, or the Anthropic, Google, or OpenAI APIs. MCP-native hosts load the connector directly; everything else calls the WEFT-API over HTTP as a tool.

import anthropic, requests
client = anthropic.Anthropic()
WEFT = "https://evidence.westwyrd.ventures/api/enclave"

tools = [{
  "name": "weft_verify",
  "description": "Verify an artifact's hash against its committed root.",
  "input_schema": {"type": "object", "required": ["sha256", "expected"],
    "properties": {"artifact": {"type": "string"},
      "sha256": {"type": "string"}, "expected": {"type": "string"}}}}]

msg = client.messages.create(
  model="claude-sonnet-5", max_tokens=1024, tools=tools,
  messages=[{"role": "user", "content": "Is this frame authentic? root 0x115a..."}])

for block in msg.content:
  if block.type == "tool_use" and block.name == "weft_verify":
    result = requests.post(f"{WEFT}/verify", json=block.input).json()
    # feed result back as a tool_result to continue the turn

Specification Enhancement Proposals

Every normative change to WYRD moves through a SEP — a self-contained technical proposal with a status. This table is the whole index; the process itself is defined in SEP-0.

Status definitions

API & Integration Library

The WEFT-API is the standard interface for reasoning over the WYRD protocol programmatically.

{
  "title": "Extended Dimensions",
  "author_pubkey": "0x33b...",
  "track": "Core"
}

// GET /api/v1/wyrd/sep/14
{
  "id": "SEP-14",
  "status": "Final",
  "hash": "0x1b2..."
}

Start building