Causallayer MCP Server

The io.github.smq9sn5jck-coder/causallayer Model Context Protocol (MCP) server provides deterministic AI liability attribution, using Bitcoin-anchored proof certificates. Its purpose and scope are reflected in its focus on causal attribution, legal-tech workflows, and compliance-oriented AI safety and governance topics.

🛠️ Key Features

Deterministic AI liability attribution
Bitcoin-anchored proof certificates
Causal attribution for accountability evidence
Toolset: 10 tools

🚀 Use Cases

AI audit and ai-governance workflows
Compliance support related to EU AI Act / EU AI Liability Directive topics
Legal-tech evidence chains for responsible-ai and insurtech contexts

⚡ Developer Benefits

Integrates with Model Context Protocol (mcp) tooling
Supports developer needs around ai-safety, compliance, and ai-risk
Uses ed25519, deterministic, and ai-audit-oriented design themes

⚠️ Limitations

Readme excerpt is truncated in provided data, so exact tool behaviors and interfaces beyond the high-level description are not specified.

FaultKey · CausalLayer MCP Server

OpenSSF Scorecard

FaultKey CausalLayer MCP — terminal demo showing liability attribution

Deterministic fault math for multi-party AI incidents. When an AI causes harm and three parties argue over who pays, FaultKey returns a signed, Bitcoin-anchored certificate of fault allocation in under 200 ms — no LLM, no probabilistic scoring, no vendor cooperation needed for a third party to verify.

This is the official Model Context Protocol (MCP) server for the CausalLayer engine, packaged as a Cloudflare Worker. It lets AI agents (Claude Desktop, Cursor, Cline, Continue, Windsurf) call the four core liability-attribution tools without writing a single line of integration code.

If this saves you time, give it a star — it helps others find it and tells us people care.

Live demo

🎮 Try the Interactive Demo — No setup required. Pick a scenario, click "Run Analysis", see real-time liability attribution.

The public Worker is deployed on Cloudflare's global edge network and is fully functional in standalone demo mode (deterministic responses, watermarked, rate-limited 5 calls / IP / day):

Endpoint: https://mcp.faultkey.com/mcp (live, custom domain)
Mirror: https://causallayer-mcp-demo.zykm9qkk7j.workers.dev/mcp
Healthcheck: /healthz
Demand telemetry: /stats (public, aggregated, no PII)

Quick start

Claude Desktop

Add this to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

json

{
  "mcpServers": {
    "faultkey": {
      "command": "npx",
      "args": ["-y", "causallayer-mcp"]
    }
  }
}

Restart Claude. Type "List the FaultKey tools."

Cursor

Settings → MCP Servers → Add new:

Name: faultkey
Command: npx -y causallayer-mcp

Cline / Continue / Windsurf

json

{
  "name": "faultkey",
  "command": "npx",
  "args": ["-y", "causallayer-mcp"]
}

Direct HTTP (no CLI)

bash

curl -X POST https://causallayer-mcp-demo.zykm9qkk7j.workers.dev/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"0"}}}'

The response includes a Mcp-Session-Id header that you reuse for subsequent calls.

Tools

Tool	Description	Demo limit	Paid cost
`submit_incident`	Submit an AI incident for deterministic liability attribution. Returns a signed `CausalCertificateV1` with per-agent fault allocation, evidence-chain completeness, and Bitcoin-anchored proof.	5 / IP / day	50 credits
`verify_certificate`	Independently verify a certificate (signature, Merkle integrity, issuer status) without calling FaultKey.	50 / IP / day	1 credit
`get_anchor_status`	Return the index of all Tessera anchor batches or one batch's full JSON (signed Merkle root, OpenTimestamps proof reference).	Unlimited	Free
`query_issuer_registry`	List all trusted CausalLayer issuer public-key fingerprints, status, and validity windows.	Unlimited	Free

Why deterministic?

Insurers, banks, and APRA-regulated entities cannot accept LLM-based fault attribution because the same prompt produces different answers on different days. FaultKey uses a closed-form causal scoring algorithm (graph-theoretic, version-pinned, byte-identical reproducible across runs) so two adversarial parties get the same number — that's the whole point.

The math is published as an Australian Standards-aligned paper. The signed certificate, issuer registry, and Merkle anchor log are all independently verifiable by a third party using only Node's built-in crypto and the causallayer-verifier tool — no network calls back to the vendor.

Guardrails (enforced at the Cloudflare edge)

NO-PII — Payloads are regex-scanned for emails, Tax File Numbers, Medicare numbers, SSNs, and credit cards. Rejected unless the caller sets pii_acknowledged: true (which is logged in the certificate as a compliance acknowledgement).
DETERMINISTIC-ONLY — The engine rejects any request lacking deterministic_only: true. This is the agent's binding acknowledgement that FaultKey output is closed-form, not probabilistic.
EVIDENCE-REQ — At least one identified agent and one timestamped event with description must be supplied or the request is rejected with 400 evidence_insufficient.

Self-hosting

You can deploy your own copy to your own Cloudflare account if you want to enforce a corporate firewall, custom rate limits, or bring your own KV namespace:

bash

git clone https://github.com/smq9sn5jck-coder/causallayer-mcp.git
cd causallayer-mcp
pnpm install
pnpm wrangler kv namespace create LEDGER
# paste the returned id into wrangler.jsonc
pnpm wrangler deploy

The CausalLayer engine itself (the closed-form fault math) runs upstream and is available via API key. For self-hosted demos without an upstream, set STANDALONE_DEMO=true in wrangler.jsonc to short-circuit upstream calls and return deterministic, watermarked responses.

Architecture

code

[Claude/Cursor/Cline]  ←→  [npx causallayer-mcp]  ←→  [Cloudflare Worker]  ←→  [CausalLayer engine]
                              (mcp-remote proxy)         (this repo)            (Fly.io Sydney)
                                                              ↓
                                                    [KV: credit ledger]
                                                    [DO: per-session state]
                                                    [KV: telemetry buffer]

Transport: Streamable HTTP (per the 2024-11-05 MCP spec — SSE is deprecated)
Session state: Cloudflare Durable Object (CausalLayerMCP), SQLite-backed
Billing: Cloudflare KV ledger, Stripe Checkout webhook, optional x402 USDC fallback
Demo: Per-IP daily counter in KV, deterministic fixture responses with [DEMO] watermark
Latency: p50 ≈ 60 ms (cold), 25 ms (warm) on Cloudflare's 300+ POPs

Pricing

Tier	Credits	$AUD	Notes
Demo	5 incidents / IP / day	Free	Watermarked responses
Starter	1,000	$99	Stripe Checkout, no SLA
Growth	10,000	$749	+ 50 verify, 99.5% SLA
Enterprise	Unmetered	Contact	+ dedicated namespace, 99.95% SLA, audit log access

For enterprise tenants email sales@faultkey.com (or open a GitHub issue with subject "enterprise inquiry").

Interactive Tools

Score any AI incident in seconds — faultkey.com/score — describe what happened, get a deterministic liability split with dollar exposure, jurisdiction analysis, and a shareable verdict card.

Compare vendor liability profiles — faultkey.com/compare — side-by-side comparison of AI vendors (OpenAI vs Anthropic vs Google etc.) across incident types.

Public accuracy ledger — faultkey.com/track-record — 7/7 direction match on backtested cases, 3 pending predictions on active litigation.

License

Apache 2.0. See LICENSE.

Support the Project

If FaultKey helped you understand AI liability, saved you research time, or you just think deterministic fault attribution should exist:

⭐ Star this repo — github.com/smq9sn5jck-coder/causallayer-mcp (takes 2 seconds, helps others find it)
Share it — post on LinkedIn, X, or your team Slack
Score an incident — faultkey.com/score
Compare vendors — faultkey.com/compare
Join the discussion — GitHub Discussions

Built in Brisbane

FaultKey is built in Brisbane, Australia, with data residency in Sydney for APRA-regulated buyers. The team can be reached at hello@faultkey.com.

title	string	required
description	string	optional
category	string	optional
severity	string	optional
jurisdiction	string	optional
financial_impact_cents	any	optional
currency	string	optional
agents	array	required
events	array	required
deterministic_only	boolean	required	G2: Must be true. Acknowledges CausalLayer is deterministic and not LLM-based.
pii_acknowledged	boolean	optional	G1: Set to true ONLY if caller has confirmed PII handling is permitted by their data agreement. False payloads with detected PII will be rejected.

certificate	object	required	The CausalCertificate object claimed by the issuer.
canonicalInput	object	required	The original incident body that produced the certificate — the same JSON originally posted to submit_incident or submit_otel_trace.

title	string	required
otlp	object	required	OTLP JSON payload with resourceSpans[]. See https://opentelemetry.io/docs/specs/otlp/#json-protobuf-encoding
category	string	optional
jurisdiction	string	optional
financial_impact_cents	any	optional
currency	string	optional
deterministic_only	boolean	required	G2: Must be true. Acknowledges CausalLayer is deterministic.
pii_acknowledged	boolean	optional	G1: Set to true ONLY if PII handling is permitted by your data agreement. OTLP traces frequently leak user/session ids in attributes.

verdict	object	required	The verdict block from the CausalCertificate.
fourFactorScoring	object	required	The fourFactorScoring block from the CausalCertificate.
agents	array	required	Agent registry (id + type) so the simulator can map remediation targetType to specific party ids.
remediations	array	required	List of remediation IDs from the catalog (e.g. vendor_adversarial_eval_suite, deployer_human_in_loop). Each may optionally pin appliedToParty to a specific agent id.

attributable	object	required	Canonical pre-overlay apportionment as { party_id: share }. Sum should approximate 1.0; the function renormalises within tolerance.
actors	array	required	All actors with the union of jurisdiction-specific role tags. EU and AU tags coexist on the same actor record.
flags	object	required	Union of jurisdiction-specific flags. AI Act / PLD flags drive the EU overlay; ACL / CPS 230 / VAISS flags drive the AU overlay.
jurisdictions	array	optional	Optional subset to compute. Defaults to all five.
primaryJurisdiction	string	optional	Engine-level jurisdiction string (e.g. 'EU', 'DE', 'AU'). Used by the EU gate to decide engagement.

CausalLayer MCP

Causallayer MCP Server

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

Topics

submit_incident

verify_certificate

verify_certificate_recompute

submit_otel_trace

simulate_remediation

query_jurisdiction_overlay

evaluate_prospective_response

get_anchor_status

query_issuer_registry

extract_incident