signet
Ihr KI-Agent hat gerade ein Tool aufgerufen. Können Sie beweisen, was er getan hat?
Die meisten Agenten-Stacks protokollieren Aktionen im Nachhinein, überprüfen aber nie, was tatsächlich gesendet wurde. Wenn eine Anfrage wiederholt, manipuliert oder gefälscht wird, hat die Ausführungsseite keine Möglichkeit, dies zu erkennen.
Signet behebt dies: Jeder Agent erhält eine Ed25519-Identität, jeder Tool-Aufruf wird signiert, ein Hash-verkettetes Audit-Log zeichnet auf, was passiert ist, und Clients oder Server können die Anfrage überprüfen, bevor sie ihr vertrauen. 3 Zeilen zum Signieren. 3 Zeilen zum Überprüfen. Open Source.
Wenn Signet für Sie nützlich ist, geben Sie diesem Repo einen Stern, damit mehr Teams es finden können.
Beginnen Sie mit dem CLI-Ablauf unten, um das Signieren in Aktion zu sehen, und springen Sie dann zu Siehe, wie fehlerhafte Anfragen abgelehnt werden, um zu beobachten, wie der Server unsignierte, manipulierte, veraltete oder falsch adressierte Anfragen blockiert, bevor sie ausgeführt werden.
Warum Signet
Signet fügt eine leichtgewichtige Vertrauensebene für Agenten-Aktionen hinzu:
Signieren Sie jeden Tool-Aufruf mit dem kryptografischen Schlüssel des Agenten
Auditieren Sie, was passiert ist, mit einem nur anhängbaren, Hash-verketteten lokalen Log
Überprüfen Sie jeden Aktionsbeleg offline, kein Netzwerk erforderlich
Integrieren Sie es mit Claude Code, Codex CLI, MCP-Clients und -Servern, Python-Frameworks und dem Vercel AI SDK
Related MCP server: touchstone-mcp
Probieren Sie es in 30 Sekunden aus
pip install signet-authfrom signet_auth import SigningAgent
agent = SigningAgent.create("my-agent", owner="team")
receipt = agent.sign("github_create_issue", params={"title": "fix bug"})
assert agent.verify(receipt)
print(receipt.id)Wenn Sie neu sind, beginnen Sie mit einem dieser vier Pfade:
Wählen Sie Ihren Pfad
Claude Code: Am besten für den schnellsten ersten Lauf in einem Coding-Agenten. Führen Sie
/plugin install signet@claude-plugins-officialin Claude Code aus. In 5 Minuten haben Sie signierte Tool-Aufrufe und ein lokales Audit-Log unter~/.signet/audit/.Codex CLI: Am besten zum Signieren von Bash-Tool-Aufrufen in Codex. Kopieren Sie
plugins/codex/nach~/.codex/plugins/signetund fügen Sie einenPostToolUse-Hook hinzu. In 5 Minuten haben Sie signierte Bash-Aktionen in Codex unter Verwendung desselben Audit-Pfads.MCP-Clients: Am besten, wenn Sie einen MCP-Client oder Transport kontrollieren. Umschließen Sie Ihren Transport mit
new SigningTransport(inner, secretKey, "my-agent"). In 5 Minuten haben Sie signiertetools/call-Anfragen mit Belegen inparams._meta._signet.MCP-Server: Am besten, wenn Sie eine Überprüfung vor der Ausführung wünschen. Rufen Sie
verifyRequest(request, {...})in Ihrem Tool-Handler auf. In 5 Minuten haben Sie Signierer-, Aktualitäts-, Zielbindungs- sowie Tool-/Parameter-Prüfungen an der Ausführungsgrenze.
Siehe, wie fehlerhafte Anfragen abgelehnt werden
Führen Sie die kürzeste Demo zur Ausführungsgrenze aus:
cd examples/mcp-agent
npm run execution-boundary-demoSiehe examples/mcp-agent/demo-execution-boundary.mjs für den Demo-Quellcode.
Wann Teams zu Signet greifen
Sie benötigen einen Audit-Pfad für Coding-Agenten, MCP-Tools oder CI-Automatisierung
Sie möchten nach einem Vorfall beweisen, welcher Agent eine Aktion angefordert hat
Sie benötigen Belege, die offline überprüft werden können, ohne von einem gehosteten Dienst abhängig zu sein
Sie möchten Beweise für signierte Tool-Aufrufe, ohne einen Proxy oder ein Gateway zu Ihrem Stack hinzuzufügen
Was Signet ist und was nicht
Signet ist eine Attestierungsebene für Agenten-Aktionen: signieren, auditieren und verifizieren
Signet ist darauf ausgelegt, mit SDKs, Plugins und MCP-Middleware in bestehende Agenten-Stacks zu passen
Signet ist kein Policy-Engine, Firewall oder Aktionsblocker
Signet ist kein Ersatz für Gateways; es ergänzt Präventions- und Durchsetzungstools
Installation
# CLI
cargo install signet-cli
# Python
pip install signet-auth
# TypeScript (MCP middleware)
npm install @signet-auth/core @signet-auth/mcp
# TypeScript (MCP server verification)
npm install @signet-auth/mcp-server
# TypeScript (Vercel AI SDK middleware)
npm install @signet-auth/vercel-aiSchnellstart
Claude Code Plugin
Signieren Sie jeden Tool-Aufruf in Claude Code automatisch ohne Konfiguration:
# Option A: From the official Anthropic plugin marketplace
/plugin install signet@claude-plugins-official
# Option B: Add Signet as a marketplace source, then install
/plugin marketplace add Prismer-AI/signet
/plugin install signet@signetJeder Tool-Aufruf wird mit Ed25519 signiert und in einem Hash-verketteten Audit-Pfad unter ~/.signet/audit/ protokolliert.
Alternative Installationsmethoden:
# From Git
claude plugin add --from https://github.com/Prismer-AI/signet
# Via signet CLI
signet claude installCodex Plugin
Signieren Sie jeden Bash-Tool-Aufruf in der Codex CLI automatisch:
git clone https://github.com/Prismer-AI/signet.git
cp -r signet/plugins/codex ~/.codex/plugins/signetFügen Sie dann den Hook zu ~/.codex/hooks.json hinzu:
{
"hooks": {
"PostToolUse": [{
"matcher": "Bash",
"hooks": [{
"type": "command",
"command": "node \"$HOME/.codex/plugins/signet/bin/sign.cjs\"",
"timeout": 5
}]
}]
}
}Oder verwenden Sie den MCP-Server für On-Demand-Signier-Tools:
codex mcp add signet -- npx @signet-auth/mcp-toolsCLI
# Generate an agent identity
signet identity generate --name my-agent
# Sign an action
signet sign --key my-agent --tool "github_create_issue" \
--params '{"title":"fix bug"}' --target mcp://github.local
# Verify a receipt
signet verify receipt.json --pubkey my-agent
# Audit recent actions
signet audit --since 24h
# Verify log integrity
signet verify --chainMCP-Client-Integration (TypeScript)
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
import { generateKeypair } from "@signet-auth/core";
import { SigningTransport } from "@signet-auth/mcp";
// Generate an agent identity
const { secretKey } = generateKeypair();
// Wrap any MCP transport -- all tool calls are now signed
const inner = new StdioClientTransport({ command: "my-mcp-server" });
const transport = new SigningTransport(inner, secretKey, "my-agent");
const client = new Client({ name: "my-agent", version: "1.0" }, {});
await client.connect(transport);
// Every callTool() is now cryptographically signed
const result = await client.callTool({
name: "echo",
arguments: { message: "Hello!" },
});Jede tools/call-Anfrage erhält einen signierten Beleg, der in params._meta._signet eingefügt wird.
MCP-Server-Überprüfung
Wenn Sie auch den MCP-Server kontrollieren, überprüfen Sie Anfragen vor der Ausführung:
import { verifyRequest } from "@signet-auth/mcp-server";
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const verified = verifyRequest(request, {
trustedKeys: ["ed25519:..."],
maxAge: 300,
});
if (!verified.ok) return { content: [{ type: "text", text: verified.error }], isError: true };
console.log(`Verified: ${verified.signerName}`);
// process tool call...
});Vercel AI SDK-Integration
import { generateText } from "ai";
import { generateKeypair } from "@signet-auth/core";
import { createSignetCallbacks } from "@signet-auth/vercel-ai";
const { secretKey } = generateKeypair();
const callbacks = createSignetCallbacks(secretKey, "my-agent");
const result = await generateText({
model: openai("gpt-4"),
tools: { myTool },
...callbacks,
prompt: "...",
});
// Every tool call is now signed
console.log(callbacks.receipts);Referenz-MCP-Server
Dieses Repo enthält auch einen minimalen MCP-Referenzserver, der die serverseitige Überprüfung mit @signet-auth/mcp-server demonstriert.
cd examples/mcp-agent
npm ci
npm run verifier-serverVerfügbare Tools:
inspect_current_request— überprüft den aktuellen MCP-Tool-Aufruf, wenn erparams._meta._signetenthältverify_receipt— überprüft einen rohen Signet-Beleg anhand eines öffentlichen Schlüsselsverify_request_payload— überprüft ein synthetisches MCPtools/call-Payload offline
Umgebungsvariablen:
SIGNET_TRUSTED_KEYS— durch Kommas getrennteed25519:<base64>öffentliche SchlüsselSIGNET_REQUIRE_SIGNATURE—trueoderfalse(Standardfalse)SIGNET_MAX_AGE— maximales Belegalter in Sekunden (Standard300)SIGNET_EXPECTED_TARGET— optionales erwartetesreceipt.action.target
Eigenständiger MCP-Signierserver
@signet-auth/mcp-tools stellt Signet-Signierung, -Überprüfung und -Inhalts-Hashing als MCP-Tools bereit – einbindbar in jeden MCP-kompatiblen Client:
npx @signet-auth/mcp-toolsVerfügbare Tools: signet_generate_keypair, signet_sign, signet_verify, signet_content_hash.
Python (LangChain / CrewAI / AutoGen + 6 weitere)
pip install signet-authfrom signet_auth import SigningAgent
# Create an agent identity (saved to ~/.signet/keys/)
agent = SigningAgent.create("my-agent", owner="willamhou")
# Sign any tool call -- receipt is auto-appended to audit log
receipt = agent.sign("github_create_issue", params={"title": "fix bug"})
# Verify
assert agent.verify(receipt)
# Query audit log
for record in agent.audit_query(since="24h"):
print(f"{record.receipt.ts} {record.receipt.action.tool}")LangChain-Integration
from signet_auth import SigningAgent
from signet_auth.langchain import SignetCallbackHandler
agent = SigningAgent("my-agent")
handler = SignetCallbackHandler(agent)
# Every tool call is now signed + audited
chain.invoke(input, config={"callbacks": [handler]})
# Async chains supported too
from signet_auth.langchain import AsyncSignetCallbackHandlerCrewAI-Integration
from signet_auth import SigningAgent
from signet_auth.crewai import install_hooks
agent = SigningAgent("my-agent")
install_hooks(agent)
# All CrewAI tool calls are now globally signed
crew.kickoff()AutoGen-Integration
from signet_auth import SigningAgent
from signet_auth.autogen import signed_tool, sign_tools
agent = SigningAgent("my-agent")
# Wrap a single tool
wrapped = signed_tool(tool, agent)
# Or wrap all tools at once
wrapped_tools = sign_tools([tool1, tool2], agent)LangGraph-Integration
LangGraph verwendet das Callback-System von LangChain – derselbe Handler funktioniert direkt:
from signet_auth import SigningAgent
from signet_auth.langgraph import SignetCallbackHandler
agent = SigningAgent("my-agent")
handler = SignetCallbackHandler(agent)
result = graph.invoke(input, config={"callbacks": [handler]})LlamaIndex-Integration
from signet_auth import SigningAgent
from signet_auth.llamaindex import install_handler
agent = SigningAgent("my-agent")
handler = install_handler(agent)
# All tool call events are now signed
index = ... # your LlamaIndex setup
response = index.as_query_engine().query("What is Signet?")
# Access receipts
print(handler.receipts)Pydantic AI-Integration
from signet_auth import SigningAgent
from signet_auth.pydantic_ai_integration import SignetMiddleware
agent = SigningAgent("my-agent")
middleware = SignetMiddleware(agent)
@middleware.wrap
def my_tool(query: str) -> str:
return f"result: {query}"Google ADK-Integration
from signet_auth import SigningAgent
from signet_auth.google_adk import SignetPlugin
agent = SigningAgent("my-agent")
plugin = SignetPlugin(agent)
# Pass as callback to ADK agentSmolagents-Integration
from signet_auth import SigningAgent
from signet_auth.smolagents import signet_step_callback
agent = SigningAgent("my-agent")
callback = signet_step_callback(agent)
bot = CodeAgent(tools=[...], model=model, step_callbacks=[callback])OpenAI Agents SDK-Integration
from signet_auth import SigningAgent
from signet_auth.openai_agents import SignetAgentHooks
agent = SigningAgent("my-agent")
oai_agent = Agent(
name="assistant",
hooks=SignetAgentHooks(agent),
tools=[...],
)Hinweis: Tool-Aufruf-Argumente sind in der Hook-API noch nicht verfügbar (Issue #939). Nur der Tool-Name wird signiert.
Low-Level-API
from signet_auth import generate_keypair, sign, verify, Action
kp = generate_keypair()
action = Action("github_create_issue", params={"title": "fix bug"})
receipt = sign(kp.secret_key, action, "my-agent", "willamhou")
assert verify(receipt, kp.public_key)Bilateraler Beleg (Server-Co-Signierung)
from signet_auth import generate_keypair, sign, sign_bilateral, verify_bilateral, Action
# Agent signs the tool call
agent_kp = generate_keypair()
action = Action("github_create_issue", params={"title": "fix bug"})
agent_receipt = sign(agent_kp.secret_key, action, "my-agent")
# Server co-signs with the response
server_kp = generate_keypair()
bilateral = sign_bilateral(
server_kp.secret_key, agent_receipt,
{"content": [{"type": "text", "text": "issue #42 created"}]},
"github-server",
)
assert verify_bilateral(bilateral, server_kp.public_key)
assert bilateral.v == 3 # v3 = bilateral receiptFunktionsweise
Your Agent
|
v
SigningTransport (wraps any MCP transport)
|
+---> Signs each tool call (Ed25519)
+---> Appends Action Receipt to local audit log (hash-chained)
+---> Forwards request to MCP server (unchanged)Nur agentenseitig. MCP-Server müssen sich nicht ändern.
Aktionsbeleg
Jeder Tool-Aufruf erzeugt einen signierten Beleg:
{
"v": 1,
"id": "rec_e7039e7e7714e84f...",
"action": {
"tool": "github_create_issue",
"params": {"title": "fix bug"},
"params_hash": "sha256:b878192252cb...",
"target": "mcp://github.local",
"transport": "stdio"
},
"signer": {
"pubkey": "ed25519:0CRkURt/tc6r...",
"name": "demo-bot",
"owner": "willamhou"
},
"ts": "2026-03-29T23:24:03.309Z",
"nonce": "rnd_dcd4e135799393...",
"sig": "ed25519:6KUohbnSmehP..."
}Die Signatur deckt den gesamten Belegkörper (Aktion + Signierer + Zeitstempel + Nonce) unter Verwendung von RFC 8785 (JCS) kanonischem JSON ab. Das Ändern eines beliebigen Feldes macht die Signatur ungültig.
CLI-Befehle
Befehl | Beschreibung |
| Ed25519-Identität generieren (standardmäßig verschlüsselt) |
| Ohne Verschlüsselung generieren (für CI) |
| Alle Identitäten auflisten |
| Öffentlichen Schlüssel als JSON exportieren |
| Eine Aktion signieren |
| Nur Parameter-Hash speichern (nicht die rohen Parameter) |
Available Tools
4 toolssignet_content_hashA
Compute SHA-256 hash of canonical JSON (RFC 8785 JCS). Accepts any JSON value.
Inputs: content (required).
signet_generate_keypairA
Generate a new Ed25519 keypair. Returns only the public key. Use Signet CLI to manage secret keys securely.
Inputs: no named parameters.
signet_signA
Sign an action (tool call) with an Ed25519 key, producing a cryptographic receipt. Uses SIGNET_SECRET_KEY env var if set, otherwise requires secret_key argument.
Inputs: tool (required), signer_name (required), params, target, +2 more.
signet_verifyA
Verify a Signet receipt signature. Returns {valid: true/false}. Accepts both bare base64 and ed25519:-prefixed public keys.
Inputs: public_key (required), receipt_json (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool performs a distinct cryptographic operation: hashing, key generation, signing, and verification. No overlap in purpose reduces ambiguity.
Tools follow a 'signet_' prefix pattern. Most use verb_noun (generate_keypair, sign, verify), but 'content_hash' is noun_noun. Minor inconsistency but still clear.
Four tools is well-scoped for a cryptographic signing server. Each tool is essential, covering the core workflow without bloat.
The tool set covers the full signing lifecycle: input representation (hash), key generation, signing, and verification. No obvious gaps for the stated purpose.
Maintenance
Related MCP Connectors
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
Tamper-evident proof creation and verification for AI agents via MCP, A2A, and REST.
Production-grade cryptography toolkit with 31 MCP tools for classical, PQC, and KMS workflows.
Self-hosted MCP server: 26 deterministic dev, security, and EVM tools.
Related MCP Servers
- AlicenseAqualityDmaintenanceMCP server for AI agent identity — verify agents with Ed25519 signatures, check trust scores, sign and verify content, exchange encrypted messages. Built on the Agent Identity Protocol (AIP).81MIT

touchstone-mcpofficial
AlicenseNot gradedqualityCmaintenanceLocal MCP server that signs and records agent actions into a tamper-evident log using Ed25519 keys for frictionless integration with Touchstone.63 npmApache 2.0- AlicenseNot gradedqualityCmaintenanceA sovereign, MIT-licensed MCP server for professional-service workflows, providing offline-capable, Ed25519-signed tools for autonomous agents and human developers.MIT
- AlicenseNot gradedqualityCmaintenanceA sovereign, MIT-licensed MCP server for professional-service workflow tools that runs on your infrastructure with Ed25519 signing, enabling autonomous agents to discover and invoke tools securely.MIT