Log inSubmit server
FaultKey · CausalLayer logo

FaultKey · CausalLayer

Deterministically attributes AI-incident fault among parties and returns signed, independently verifiable certificates.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install FaultKey · CausalLayer

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "faultkey-causallayer": {
      "command": "npx",
      "args": [
        "-y",
        "causallayer-mcp"
      ]
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

We couldn’t confirm it starts correctly

We ran the install command but it didn't respond within our test window — this can mean a slow first-time install rather than a real problem.

npx -y causallayer-mcp

No response to initialize.

This is an experimental automated check and can have false negatives — missing environment variables, a slow cold install, etc. It doesn’t necessarily mean something’s wrong. Last checked 7d ago.

Overview

FaultKey · CausalLayer MCP server exposes deterministic AI-liability attribution through four MCP tools. It submits incidents to the CausalLayer engine, produces signed fault-allocation certificates, and supports independent checks of signatures, Merkle data, issuer status, and Bitcoin anchoring. The service runs as a Cloudflare Worker with Streamable HTTP support and can also be launched through the npm package with npx. Reach for it when incident evidence needs a repeatable vendor, deployer, and user allocation rather than an LLM-generated judgment.

Use cases

  • Attribute fault across AI vendors, deployers, and users
  • Submit timestamped incident evidence for deterministic scoring
  • Verify signed liability certificates without contacting the issuer
  • Inspect Bitcoin-anchored Tessera batches
  • Audit trusted CausalLayer issuer keys and validity windows

Key features

  • Deterministic per-agent fault allocation
  • Signed CausalCertificateV1 output
  • Independent certificate verification
  • Bitcoin and OpenTimestamps anchor references
  • Issuer registry inspection
  • Evidence and PII guardrails

Tools4

What FaultKey · CausalLayer lets your agent do. Expand a tool for its parameters.

Self-reported~146 tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 1d ago

Recent health check succeeded.

5/5 checks healthy over the last 46d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 10d ago via OSV.dev · causallayer-mcp (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars2Stargazers on the source repository.
npm downloads135Package downloads in the last 30 days.
Last commit1mo agoMost recent push to the default branch.
Install checkInconclusiveDidn't respond in our test window — often a slow first install.
Tools exposed4Callable tools this server registers over MCP.
Directory activity2 viewsConfig copies, upvotes, and views on AllMCPs.

How FaultKey · CausalLayer works

What FaultKey · CausalLayer does

FaultKey · CausalLayer provides an MCP interface to the CausalLayer engine for deterministic attribution of fault in multi-party AI incidents. An incident can identify agents and timestamped events, after which the service returns a signed CausalCertificateV1 containing per-agent allocation, evidence-chain completeness, and an anchored proof reference.

The intended parties include vendors, deployers, and users involved in an AI-related event. The calculation is closed-form and version-pinned, so the same input is intended to produce byte-identical results across runs. This makes the server relevant to workflows that need an auditable allocation rather than probabilistic model output.

How it works

The repository packages the MCP server as a Cloudflare Worker. Clients communicate using Streamable HTTP according to the 2024-11-05 MCP specification; the README identifies SSE as deprecated for this deployment. The Worker maintains session state through a Cloudflare Durable Object backed by SQLite and uses Cloudflare KV for the credit ledger and telemetry buffer.

The public deployment is available at https://mcp.faultkey.com/mcp, with a Worker mirror also documented. A local MCP client can invoke the npm package through npx -y causallayer-mcp, while direct HTTP callers must retain the Mcp-Session-Id returned during initialization.

FaultKey · CausalLayer applies three documented request checks. Incident payloads are scanned for several categories of personal information and normally require pii_acknowledged: true when detected. Requests must also set deterministic_only: true, and an incident needs at least one identified agent plus one timestamped event with a description.

Tools and capabilities

  • submit_incident sends an incident for attribution and returns a signed certificate with fault allocation and evidence information.
  • verify_certificate checks a certificate’s signature, Merkle integrity, and issuer status without calling FaultKey.
  • get_anchor_status returns either the available Tessera anchor-batch index or the full JSON for one batch, including its signed Merkle root and OpenTimestamps proof reference.
  • query_issuer_registry lists trusted CausalLayer issuer fingerprints, status values, and validity windows.

Certificates, the issuer registry, and the Merkle anchor log are described as independently verifiable by third parties. The repository points to Node built-in cryptography and the separate causallayer-verifier tool for that verification path.

Setup and configuration

For Claude Desktop, add an MCP entry that runs npx with -y causallayer-mcp, then restart the client. Cursor uses the same command through its MCP server settings. Cline, Continue, and Windsurf can use the equivalent JSON command configuration.

Self-hosting requires cloning the repository, installing dependencies with pnpm, creating a Cloudflare KV namespace named LEDGER, placing its returned identifier in wrangler.jsonc, and deploying with Wrangler. The upstream CausalLayer engine is accessed through an API key. For a self-hosted demonstration without that upstream, set STANDALONE_DEMO=true; responses then use deterministic, watermarked fixtures.

Limitations and notes

The public demo is rate-limited and returns watermarked responses. Its documented limit is five incident calls per IP per day; certificate verification has a separate daily limit, while anchor-status and issuer-registry queries are listed as unlimited.

FaultKey · CausalLayer does not replace legal or regulatory judgment. Its documented role is to calculate and package a deterministic allocation with verification material. Requests that fail the evidence, deterministic-mode, or personal-information safeguards are rejected.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about FaultKey · CausalLayer

FaultKey · CausalLayer is an MCP server that connects AI agents to the CausalLayer liability-attribution engine. Its main tools submit incidents, verify certificates, inspect Tessera anchor batches, and query trusted issuers. It returns signed, deterministic fault allocations with evidence-chain information and Bitcoin-anchored proof references for independent checking.

Install it by configuring your MCP client to run `npx -y causallayer-mcp`. Claude Desktop uses an entry in its JSON configuration, while Cursor adds the same command through MCP settings. Cline, Continue, and Windsurf can use the documented command-based JSON configuration.

Yes, FaultKey · CausalLayer works with Cursor. In Cursor’s MCP server settings, add a server named `faultkey` and use `npx -y causallayer-mcp` as the command.

Yes, use `verify_certificate` to check the certificate independently. The tool verifies the signature, Merkle integrity, and issuer status without calling FaultKey, and the README also identifies Node’s built-in cryptography and the `causallayer-verifier` tool as verification options.

Self-host it by cloning the repository, installing dependencies with pnpm, creating a Cloudflare KV namespace named `LEDGER`, adding its identifier to `wrangler.jsonc`, and deploying with Wrangler. The upstream engine requires an API key; `STANDALONE_DEMO=true` enables deterministic watermarked fixtures without that upstream.

Related MCP servers

All in Legal All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewFaultKey · CausalLayer AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/faultkey-causallayer?style=directory)](https://allmcps.com/mcp/faultkey-causallayer)
HTML Embed
<a href="https://allmcps.com/mcp/faultkey-causallayer"><img src="https://allmcps.com/api/badge/faultkey-causallayer?style=directory" alt="FaultKey · CausalLayer on AllMCPs" /></a>