Skip to main content
Glama

signafAIde SDK

signafAIde records the decisions AI agents make. Each record is signed with the agent's own key and chained on the machine that wrote it. Once a person opts in, a witness (the signafAIde service, or one you host) co-signs it and timestamps it publicly, so neither side can forge or edit a record alone. It attests integrity and timing, never whether a decision was right.

  • Free on its own: the SDK and the verifiers are Apache-2.0 and need no account. On their own they give you a signed, chained, offline-verifiable record of every tool call, on your machine. The service adds what one party cannot give itself: an independent second signature, two public time bounds, and a check that no record is missing.

  • Local first: with no API key, records are signed, chained and verified in .signafaide/, and nothing is sent. Sending starts only when a person runs signafaide init (a sandbox: no account, email or card) or sets SIGNAFAIDE_API_KEY.

  • Hashes, not content: after the opt-in, each record sends its content hash with its tool name, agent name and time (and its chain links), never its inputs or outputs, unless you turn on stored content. Tool and agent names are sent as you write them, so don't put personal data in them. Each content hash is salted with 16 random bytes that stay on your machine with the content, so the hash alone cannot be used to guess the content, even when it has only a few possible values.

  • Your environment: the default witness is the hosted service (https://api.signafaide.co.uk). A self-hosted witness, under an Enterprise contract, is set with SIGNAFAIDE_URL (self-host guide). Running in production: production guide.

  • Independent checks: the protocol is a public spec with test vectors, and the verifier checks a verification pack without our service.

What is here

path

what

spec/SPEC.md

the protocol: records, batches, receipts, anchors, the HTTP API, verification packs, local state

spec/vectors.json

test vectors every implementation reproduces byte for byte

python/

the Python SDK and CLI (signafaide on PyPI)

python-langchain/

langchain-signafaide: a LangChain agent middleware that records every tool call the agent makes

js/

the TypeScript SDK, CLI and agent setup for coding agents (signafaide on npm), and the MCP server (signafaide-mcp, in js/mcp)

scripts/release-check.mjs

run before a release: the default witness is the hosted service, every version agrees and was bumped since the last tag, CHANGELOG.md has its entry, the verifier binary is built from this source, and the npm and PyPI names are claimed

CHANGELOG.md

what changed in each release; every release is a git tag (v0.3.2)

verifier/

signafaide-verify, the standalone Rust verifier of a pack (also builds to WebAssembly)

core/

the Rust protocol core shared by the verifier and the service

plugin/

the Claude Code plugin: the MCP server and the skill

gemini-extension.json, .cursor-plugin/, mcp.json, glama.json

listing files for the Gemini CLI gallery, the Cursor marketplace and Glama

Related MCP server: mcp-audit-gateway

Quick start

uv add signafaide                 # Python, in a uv project; or: python3 -m venv .venv && .venv/bin/python -m pip install signafaide
npm install signafaide            # TypeScript or JavaScript

Wrap the tools that act, run the agent, then signafaide verify (npx signafaide verify for TypeScript). See the Python and TypeScript READMEs.

Add the MCP server to a coding agent

The MCP server (signafaide-mcp, Node.js 20 or later) lets a coding agent preview the setup, verify records and show status. It sends nothing until a person agrees to create a sandbox. In a project, npx signafaide agent setup writes this for each coding agent it finds. To add it by hand, put this in the agent's MCP configuration (Cline, Cursor, Windsurf, Kiro, Zed and others use the same shape):

{
  "mcpServers": {
    "signafaide": { "command": "npx", "args": ["-y", "signafaide-mcp@0.3.2"] }
  }
}
  • Claude Code: claude mcp add signafaide -- npx -y signafaide-mcp@0.3.2

  • Gemini CLI: gemini extensions install https://github.com/AIME-TECH-UK-LIMITED/signafaide-sdk

  • Kiro: Add to Kiro

There are no API keys or other settings. To check it works, ask the agent to call signafaide_status.

Recording everything an agent can call

Wrapping records the tools a developer wraps. Two things cover the rest.

  • MCP tools: signafaide gateway -- <the MCP server's command> (in the signafaide npm package) runs an MCP server behind a recording proxy. The agent's MCP client starts the gateway in place of the server, for example npx -y signafaide gateway --agent support-bot -- npx -y @modelcontextprotocol/server-filesystem /data. Every tool call that passes through is recorded, a decision before the call is forwarded and an outcome when the answer arrives, and a call that cannot be recorded is not forwarded. A remote (HTTP) server goes behind a stdio bridge: npx -y signafaide gateway -- npx -y mcp-remote https://mcp.example.com/mcp.

  • Framework tools: wrap_tools / wrapTools declare the tools they wrap as recorded, and declare_tools([...]) / declareTools([...]) takes the agent's full tool list, so the tools that are not wrapped are declared as not recorded. The declaration is a signed note per tool in the agent's chain (ordinary records, counted like any other), and every verifier reports it per agent, for example all 4 declared tools are recorded or 1 declared tool is not recorded: web_search. It is a note, never a failure.

What this shows, and what it does not: the gateway records every call that goes through it; a call the application makes around it is still not recorded, so the deployment has to make the gateway the only route to those tools. A declaration is the program's own signed statement of its tools: evidence of what it said it had, not proof that the list is complete. A tool list is as fresh as its last declaration: a source that stops (a gateway that is removed, a program that ends) leaves the list at its clean exit, or within 24 hours after a crash. Details: TypeScript, Python, spec §2.6, §7 and §8.

Verify without our service

cargo run --manifest-path verifier/Cargo.toml -- pack.json --keys keys.json --agent-keys agent-keys.json --head head.json --offline

The service keys come from the witness's /.well-known/signafaide-keys.json (or a file). The agent keys, agent-keys.json, come from the customer, who runs signafaide keys export and hands the file over with the pack. --head is optional: the customer's newest signed head (.signafaide/head.json), which proves no record was dropped from the end. --offline skips the public timestamp lookup, so that check is reported as not checked, never as passed. The result line says how many of the 12 checks passed, are pending (a public timestamp that has not confirmed yet) and were not checked, for example PASS: 11 of 12 checks passed, 1 pending (public timestamp). The Python and TypeScript SDKs run the same checks (signafaide verify pack.json). Every verifier gives the same check ids, statuses and result for the same inputs (spec §7).

Privacy and support

License

Apache-2.0, see LICENSE.

Available Tools

7 tools
signafaide_explain_errorExplain a signafAIde error codeA

What a signafAIde error code means and how to fix it, e.g. chain_conflict, quota_exceeded, invalid_key, network, not_recorded.

Inputs: code (required).

signafaide_initCreate an external signafAIde sandbox (ask the user first)A

Creates an external sandbox project on the signafAIde service (or the SIGNAFAIDE_URL witness), saves its API key to .env and returns the claim link, what claiming gives and when an unclaimed sandbox is deleted. From then on record hashes (never content) are sent there, and records written earlier ship with their original times. This is an external side effect: ask the user and call it only after they agree. Without it, records stay local and still verify. Creating a sandbox means the user agrees to the signafAIde Terms and Privacy notice (/legal/terms and /legal/privacy, where is SIGNAFAIDE_URL or the signafAIde service): show them both links when you ask, and pass on the notice this tool returns. It creates nothing unless confirm_user_agreed is true and user_words holds what the user wrote when they agreed.

Inputs: directory, user_words, confirm_user_agreed.

signafaide_quickstartsignafAIde snippet for a language and frameworkA

Returns the install command, the canonical code to record an agent's tool calls with signafAIde, and the verify command, for one language and framework.

Inputs: language (required), framework.

signafaide_setupPreview signafAIde setup for this project (changes nothing)A

Signed, tamper-evident records of what an AI agent decided and did, kept on this machine; nothing is sent until a person opts in. Use when the user asks to audit, log or trace AI or agent decisions, needs an audit trail, tamper-evidence or compliance evidence, or builds an agent whose tools pay, send, approve, delete or change real things. A preview: it changes no file, creates nothing and sends nothing. Returns the detected language, package manager and framework, the exact install command, the code edit for this framework, the functions that look like actions, and what a sandbox would send. Make the edit yourself, run the agent, then call signafaide_verify.

Inputs: directory.

signafaide_statussignafAIde statusB

API key and env, the service URL, each agent chain with its record count and last receipt, records waiting in the outbox, the quota, and the claim link with how long an unclaimed sandbox has left.

Inputs: directory.

signafaide_verifyVerify the local signafAIde recordsA

Checks every record in the project's .signafaide/ folder (or a verification pack): schema, hashes, agent signatures, chain links and content hashes, and, for records a witness has co-signed, Merkle proofs, the service's batch and head signatures, drand and anchors. With an API key it first ships waiting records; without one nothing is sent. Returns one line per check, what still needs the witness, and PASS or FAIL.

Inputs: pack, directory.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 7 tools

    Disambiguation3/5

    signafaide_setup and signafaide_quickstart overlap heavily: both return an install command plus framework-specific integration code, differing mainly in that setup also detects the stack and previews actions. The claim link is surfaced by three tools (claim_link, status, and init's return), creating further boundary blur. init vs setup is at least clarified by descriptions (init is the real side-effecting call, setup is a read-only preview).

    Naming Consistency4/5

    Every tool uses the signafaide_ prefix with snake_case, which is predictable and easy to scan. Minor deviation: some names are verbs (verify, setup, init) while others are nouns (status, claim_link), but the meaning stays clear.

    Tool Count5/5

    Seven tools is well-matched to the scope: preview, initialize, quickstart, status, claim link, verify, and error explanation. Nothing feels padded, and no obvious operation is crammed into an overloaded tool.

    Completeness3/5

    The lifecycle of onboarding and verification is covered, but there is no tool to read, list, or search the actual recorded events, and no explicit way to ship pending outbox records (it happens implicitly inside verify). Rekey/rotate, unclaim/revoke, and cleanup of local .signafaide state are also absent, leaving a few dead ends.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Tamper-evident audit logging for AI agents. Append-only, hash-chained, optionally Ed25519-signed log. The MCP server lets an agent keep and verify a record of what it actually did.
      8
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Tamper-evident audit trail for AI agent tool calls. Cryptographically signed, hash-chained records that prove what your agents did.
      3
      29 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Captures AI agent runs and turns them into tamper-evident execution records showing tool use, timing, failures, recoveries, and human interventions. Records can be inspected, exported, and verified offline.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables capturing a tamper-evident, hash-chained local record of every AI agent tool call — both the decision before a tool runs and its outcome — so you can review what the agent actually did in order, detect edits, deletions, or reordering at the exact index, and export a signed evidence pack any third party can verify with no installs.
      2
      MIT