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

Probieren Sie es in 30 Sekunden aus

pip install signet-auth

from 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-official in 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/signet und fügen Sie einen PostToolUse-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 signierte tools/call-Anfragen mit Belegen in params._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-demo

Siehe 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-ai

Schnellstart

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@signet

Jeder 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 install

Codex 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/signet

Fü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-tools

CLI

# 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 --chain

MCP-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-server

Verfügbare Tools:

inspect_current_request — überprüft den aktuellen MCP-Tool-Aufruf, wenn er params._meta._signet enthält
verify_receipt — überprüft einen rohen Signet-Beleg anhand eines öffentlichen Schlüssels
verify_request_payload — überprüft ein synthetisches MCP tools/call-Payload offline

Umgebungsvariablen:

SIGNET_TRUSTED_KEYS — durch Kommas getrennte ed25519:<base64> öffentliche Schlüssel
SIGNET_REQUIRE_SIGNATURE — true oder false (Standard false)
SIGNET_MAX_AGE — maximales Belegalter in Sekunden (Standard 300)
SIGNET_EXPECTED_TARGET — optionales erwartetes receipt.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-tools

Verfügbare Tools: signet_generate_keypair, signet_sign, signet_verify, signet_content_hash.

Python (LangChain / CrewAI / AutoGen + 6 weitere)

pip install signet-auth

from 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 AsyncSignetCallbackHandler

CrewAI-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 agent

Smolagents-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 receipt

Funktionsweise

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
`signet identity generate --name <n>`	Ed25519-Identität generieren (standardmäßig verschlüsselt)
`signet identity generate --unencrypted`	Ohne Verschlüsselung generieren (für CI)
`signet identity list`	Alle Identitäten auflisten
`signet identity export --name <n>`	Öffentlichen Schlüssel als JSON exportieren
`signet sign --key <n> --tool <t> --params <json> --target <uri>`	Eine Aktion signieren
`signet sign --hash-only`	Nur Parameter-Hash speichern (nicht die rohen Parameter)

signet