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

Pruébalo en 30 segundos

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)

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-official en 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/signet y añade un hook PostToolUse. 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 solicitudes tools/call firmadas con recibos en params._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-demo

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

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

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

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

Luego 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-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

Integració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-server

Herramientas disponibles:

inspect_current_request — verifica la llamada a herramienta MCP actual si incluye params._meta._signet
verify_receipt — verifica un recibo de Signet sin procesar contra una clave pública
verify_request_payload — verifica una carga útil de tools/call de MCP sintética sin conexión

Variables de entorno:

SIGNET_TRUSTED_KEYS — claves públicas ed25519:<base64> separadas por comas
SIGNET_REQUIRE_SIGNATURE — true o false (predeterminado false)
SIGNET_MAX_AGE — edad máxima del recibo en segundos (predeterminado 300)
SIGNET_EXPECTED_TARGET — receipt.action.target esperado 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-tools

Herramientas disponibles: signet_generate_keypair, signet_sign, signet_verify, signet_content_hash.

Python (LangChain / CrewAI / AutoGen + 6 más)

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}")

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 AsyncSignetCallbackHandler

Integració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 agent

Integració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 receipt

Có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
`signet identity generate --name <n>`	Generar identidad Ed25519 (cifrada por defecto)
`signet identity generate --unencrypted`	Generar sin cifrado (para CI)
`signet identity list`	Listar todas las identidades
`signet identity export --name <n>`	Exportar clave pública como JSON
`signet sign --key <n> --tool <t> --params <json> --target <uri>`	Firmar una acción
`signet sign --hash-only`	Almacenar solo hash de parámetros (no parámetros sin procesar)
`signet sign --output <file>`	Escribir recibo en archivo en lugar de stdout
`signet sign --no-log`	Omitir adición al registro de auditoría
`signet verify <receipt.json> --pubkey <name>`	Verificar una firma de recibo
`signet verify --chain`	Verificar la integridad de la cadena de hash del registro de auditoría
`signet audit`	Listar acciones recientes
`signet audit --since <duration>`	Filtrar por tiempo (ej. 24h, 7d)
`signet audit --tool <substring>`	Filtrar por nombre de herramienta
`signet audit --verify`	Verificar todas las firmas de recibos
`signet audit --export <file>`	Exportar registros como JSON
`signet claude install`	Instalar plugin de Claude Code (hook de firma Post

signet