mcpField
A
Audifact

Audifact

Remote
audifact.ioAI & Agents0Updated 1w ago

About Audifact

Audifact gives agents signed, append-only receipts for consequential decisions and outcomes. It is aimed at teams that need verifiable records, using short event summaries and proof links rather than full conversation tracing.

Key features

  1. 01Log decisions, outcomes, and external actions
  2. 02Sign and hash-chain appended records
  3. 03Generate event proof links
  4. 04Register agents and query their records
  5. 05Redact sensitive data before writing

Use cases

  1. 01Review consequential agent actions
  2. 02Verify records of subagent delegations
  3. 03Open public proof links for decisions

MCP support

Audifact provides a hosted MCP server with tools to log decisions and outcomes, retrieve proofs, register agents, and query agent records.

Configuration

Remote servers need no local install. Pick your client, then copy the config or install in one click.

Endpointhttps://api.audifact.io/mcp
Copy install command
Claude CodeTerminal
Cursor.cursor/mcp.json
VS Code.vscode/mcp.json
Claude Desktopclaude_desktop_config.json
Windsurf~/.codeium/windsurf/mcp_config.json

Run commands in a terminal; paste JSON into the client’s MCP config and restart. Servers that need sign-in will prompt on first connect.

All endpoints
Streamable HTTPhttps://api.audifact.io/mcpAuth required

Tools

5
ParameterTypeRequiredDescription
tsstringNoISO-8601 timestamp
signaturestringNoClient-side signing: base64 signature over the canonical JSON body.
agent_namestringNoManaged Mode: agent identity within your org (default: default-agent). Audifact provisions and uses a managed signing key automatically.
context_jsonobjectNo
decision_typestringNo
metadata_jsonobjectNo
scenario_hashstringNoAdvanced optional: 64-char hex scenario hash when already known. Usually omit - server computes from scenario_name + scenario_definition.
scenario_namestringNoScenario identifier. Server resolves scenario_hash from scenario_name + scenario_definition (+ optional context_schema).
context_schemaobjectNoOptional JSON schema used to validate context_json.
decision_labelstringNo
decision_valuestringNo
agent_public_keystringNoClient-side signing: base64 public key (required with signature).
context_schema_jsonobjectNoBackward-compatible alias for context_schema.
public_context_jsonobjectNoOptional public structured context (shown on proof pages). Stored gzip-compressed; event hash includes content hash only.
scenario_definitionobjectNoScenario definition object. Required when scenario_name is provided.
public_decision_typestringNoOptional public mirror of decision_type (shown on proof pages).
agent_private_key_b64stringNoClient-side signing: base64 Ed25519 private key. Overrides managed mode when provided.
public_decision_labelstringNoOptional public decision summary (shown on proof pages).
public_decision_valuestringNoOptional public mirror of decision_value (shown on proof pages).
scenario_definition_jsonobjectNoBackward-compatible alias for scenario_definition.

Details

From the project README

Audifact agent plugin

Your agent keeps a signed receipt of its decisions.

This repo packages Audifact’s hosted MCP server (https://api.audifact.io/mcp) plus a skill that tells the agent to log consequential decisions, external actions, and subagent delegations — then hand you proof links (https://audifact.io/e/{event_hash}).

It is receipts, not silent full tracing. Target about 3–10 events per active day.

Install

1. Audifact API key (all clients)
  1. Create an account at https://audifact.io/signup (the plugin never creates accounts).
  2. Dashboard → API Keys → create a key (af_..., shown once).
  3. Paste it only into the client’s secret / masked field. Never into chat or files.
2. Pick your client

Official MCP Registry / VS Code / Copilot / other registry clients

Listed as io.audifact/audifact in the MCP Registry (search “audifact”). Add the remote server from the registry or your client’s MCP gallery. Provide X-API-Key when prompted. Metadata: server.json.

Claude Code (self-hosted marketplace — no review queue)

/plugin marketplace add audifact/audifact-plugin
/plugin install audifact@audifact

Paste the key into Audifact API key (userConfig, stored in the OS keychain).

Grok Bot / Cursor (x.ai catalog)

Install from the catalog when listed. Paste the key into AUDIFACT_API_KEY.
(Repo renamed from grokbot-plugin → audifact-plugin; resubmit replaces the 2026-10-16 draft.)

Agent Skills only (npx skills add)

npx skills add audifact/audifact-plugin

This installs the skill instructions. You still need the MCP server connected in the same client, or the skill has no tools to call.

3. Confirm

Ask the agent to confirm the Audifact connection. It should log one plugin_connected decision and return a proof URL.

⚠️ Append-only ledger

Everything logged is signed and hash-chained and cannot be edited or deleted. The skill redacts before writing: no secrets, tokens, passwords, full message bodies or file contents — only short summaries.

Billing

Every event consumes credits on the Audifact account that owns the API key.

Privacy

  • Public labels are off by default.
  • Each agent logs under its own agent_name (e.g. grokbot-cos, claude-code).

Tools

log_decision, log_outcome, get_proof, register_agent, list_agent_decisions (deprecated alias: list_my_recent_decisions), list_agent_outcomes.

Repo layout

PathRole
.mcp.jsonGrok/Cursor: X-API-Key: ${AUDIFACT_API_KEY}
.grok-plugin/x.ai / Grok Bot plugin manifest
.claude-plugin/Claude Code marketplace + userConfig key (overrides MCP auth for Claude)
skills/audifact/Agent Skills SKILL.md
server.jsonOfficial MCP Registry remote metadata
assets/logo.svgBrand AF monogram

License

MIT

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.