signet
Tu agente de IA acaba de llamar a una herramienta. ¿Puedes probar lo que hizo?
La mayoría de las pilas de agentes registran las acciones después del hecho, pero nunca verifican lo que realmente se envió. Si una solicitud se reproduce, se manipula o se falsifica, el lado de ejecución no tiene forma de saberlo.
Signet soluciona esto: cada agente obtiene una identidad Ed25519, cada llamada a herramienta se firma, un registro de auditoría encadenado por hash registra lo que sucedió, y los clientes o servidores pueden verificar la solicitud antes de confiar en ella. 3 líneas para firmar. 3 líneas para verificar. Código abierto.
Si Signet te resulta útil, dale una estrella a este repositorio para ayudar a que más equipos lo encuentren.
Comienza con el flujo de CLI a continuación para ver la firma en acción, luego salta a Ver cómo rechaza solicitudes incorrectas para ver cómo el servidor bloquea solicitudes sin firmar, manipuladas, obsoletas o mal dirigidas antes de que se ejecuten.
Por qué Signet
Signet añade una capa de confianza ligera para las acciones de los agentes:
Firma cada llamada a herramienta con la clave criptográfica del agente
Audita lo que sucedió con un registro local de solo adición y encadenado por hash
Verifica cualquier recibo de acción sin conexión, sin necesidad de red
Integra con Claude Code, Codex CLI, clientes y servidores MCP, marcos de trabajo de Python y Vercel AI SDK
Related MCP server: touchstone-mcp
Pruébalo en 30 segundos
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)Si eres nuevo, comienza con uno de estos cuatro caminos:
Elige tu camino
Claude Code: Ideal para la ejecución inicial más rápida en un agente de codificación. Ejecuta
/plugin install signet@claude-plugins-officialen Claude Code. En 5 minutos tendrás llamadas a herramientas firmadas y un registro de auditoría local en~/.signet/audit/.Codex CLI: Ideal para firmar llamadas a herramientas Bash en Codex. Copia
plugins/codex/en~/.codex/plugins/signety añade un hookPostToolUse. En 5 minutos tendrás acciones de Bash firmadas en Codex usando el mismo rastro de auditoría.Clientes MCP: Ideal si controlas un cliente o transporte MCP. Envuelve tu transporte con
new SigningTransport(inner, secretKey, "my-agent"). En 5 minutos tendrás solicitudestools/callfirmadas con recibos enparams._meta._signet.Servidores MCP: Ideal si quieres verificación antes de la ejecución. Llama a
verifyRequest(request, {...})en tu manejador de herramientas. En 5 minutos tendrás comprobaciones de firmante, frescura, vinculación de destino y herramienta/parámetros en el límite de ejecución.
Ver cómo rechaza solicitudes incorrectas
Ejecuta la demostración de límite de ejecución más corta:
cd examples/mcp-agent
npm run execution-boundary-demoConsulta examples/mcp-agent/demo-execution-boundary.mjs para ver el código fuente de la demostración.
Cuándo recurren los equipos a Signet
Necesitas un rastro de auditoría para agentes de codificación, herramientas MCP o automatización de CI
Quieres probar qué agente solicitó una acción después de un incidente
Necesitas recibos que puedan verificarse sin conexión sin depender de un servicio alojado
Quieres evidencia de llamadas a herramientas firmadas sin añadir un proxy o puerta de enlace a tu pila
Qué es y qué no es Signet
Signet es una capa de atestación para acciones de agentes: firmar, auditar y verificar
Signet está diseñado para encajar en pilas de agentes existentes con SDKs, plugins y middleware MCP
Signet no es un motor de políticas, firewall o bloqueador de acciones
Signet no es un reemplazo para puertas de enlace; complementa las herramientas de prevención y cumplimiento
Instalación
# 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-aiInicio rápido
Plugin de Claude Code
Auto-firma cada llamada a herramienta en Claude Code sin configuración:
# 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@signetCada llamada a herramienta se firma con Ed25519 y se registra en un rastro de auditoría encadenado por hash en ~/.signet/audit/.
Métodos de instalación alternativos:
# From Git
claude plugin add --from https://github.com/Prismer-AI/signet
# Via signet CLI
signet claude installPlugin de Codex
Auto-firma cada llamada a herramienta Bash en Codex CLI:
git clone https://github.com/Prismer-AI/signet.git
cp -r signet/plugins/codex ~/.codex/plugins/signetLuego añade el hook a ~/.codex/hooks.json:
{
"hooks": {
"PostToolUse": [{
"matcher": "Bash",
"hooks": [{
"type": "command",
"command": "node \"$HOME/.codex/plugins/signet/bin/sign.cjs\"",
"timeout": 5
}]
}]
}
}O usa el servidor MCP para herramientas de firma bajo demanda:
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 --chainIntegración de cliente MCP (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!" },
});Cada solicitud tools/call obtiene un recibo firmado inyectado en params._meta._signet.
Verificación de servidor MCP
Si también controlas el servidor MCP, verifica las solicitudes antes de la ejecución:
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...
});Integración con Vercel AI SDK
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);Servidor MCP de referencia
Este repositorio también incluye un servidor de referencia MCP mínimo que demuestra la verificación del lado del servidor con @signet-auth/mcp-server.
cd examples/mcp-agent
npm ci
npm run verifier-serverHerramientas disponibles:
inspect_current_request— verifica la llamada a herramienta MCP actual si incluyeparams._meta._signetverify_receipt— verifica un recibo de Signet sin procesar contra una clave públicaverify_request_payload— verifica una carga útil detools/callde MCP sintética sin conexión
Variables de entorno:
SIGNET_TRUSTED_KEYS— claves públicased25519:<base64>separadas por comasSIGNET_REQUIRE_SIGNATURE—trueofalse(predeterminadofalse)SIGNET_MAX_AGE— edad máxima del recibo en segundos (predeterminado300)SIGNET_EXPECTED_TARGET—receipt.action.targetesperado opcional
Servidor de firma MCP independiente
@signet-auth/mcp-tools expone la firma, verificación y hash de contenido de Signet como herramientas MCP: conéctalo a cualquier cliente compatible con MCP:
npx @signet-auth/mcp-toolsHerramientas disponibles: signet_generate_keypair, signet_sign, signet_verify, signet_content_hash.
Python (LangChain / CrewAI / AutoGen + 6 más)
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}")Integración con LangChain
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 AsyncSignetCallbackHandlerIntegración con CrewAI
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()Integración con AutoGen
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)Integración con LangGraph
LangGraph utiliza el sistema de callbacks de LangChain: el mismo manejador funciona directamente:
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]})Integración con LlamaIndex
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)Integración con Pydantic AI
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}"Integración con Google ADK
from signet_auth import SigningAgent
from signet_auth.google_adk import SignetPlugin
agent = SigningAgent("my-agent")
plugin = SignetPlugin(agent)
# Pass as callback to ADK agentIntegración con Smolagents
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])Integración con OpenAI Agents SDK
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=[...],
)Nota: Los argumentos de llamada a herramienta aún no están disponibles en la API de hooks (issue #939). Solo se firma el nombre de la herramienta.
API de bajo nivel
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)Recibo bilateral (Co-firma del servidor)
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 receiptCómo funciona
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)Solo del lado del agente. Los servidores MCP no necesitan cambiar.
Recibo de acción
Cada llamada a herramienta produce un recibo firmado:
{
"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..."
}La firma cubre todo el cuerpo del recibo (acción + firmante + marca de tiempo + nonce) usando JSON canónico RFC 8785 (JCS). Modificar cualquier campo invalida la firma.
Comandos de CLI
Comando | Descripción |
| Generar identidad Ed25519 (cifrada por defecto) |
| Generar sin cifrado (para CI) |
| Listar todas las identidades |
| Exportar clave pública como JSON |
| Firmar una acción |
| Almacenar solo hash de parámetros (no parámetros sin procesar) |
| Escribir recibo en archivo en lugar de stdout |
| Omitir adición al registro de auditoría |
| Verificar una firma de recibo |
| Verificar la integridad de la cadena de hash del registro de auditoría |
| Listar acciones recientes |
| Filtrar por tiempo (ej. 24h, 7d) |
| Filtrar por nombre de herramienta |
| Verificar todas las firmas de recibos |
| Exportar registros como JSON |
| Instalar plugin de Claude Code (hook de firma Post |
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