Signet

Recibos de ações criptográficas para agentes de IA. Assina cada chamada de ferramenta MCP com Ed25519, log de auditoria encadeado por hash. 3 linhas de código para integrar.

GitHub

Experimente este MCPPatrocinado

Documentação

Signet

Não apenas registre as ações do agente. Prove-as.
_{Confiança criptográfica e evidência de autorização para cada ação de agente de IA — identidade, delegação, política, recibos: assinados, encadeados por hash, verificáveis offline. Independente de qualquer provedor.}

_{Pacotes TypeScript:
@signet-auth/core ·
@signet-auth/mcp ·
@signet-auth/mcp-server ·
@signet-auth/mcp-tools ·
@signet-auth/node ·
@signet-auth/vercel-ai}

▶ Experimente a demonstração ao vivo — assine uma chamada de ferramenta no seu navegador, altere um campo e veja a verificação falhar. _{(espelho: GitHub Pages)}

_{▶ Passo a passo: assinatura, trilha de auditoria e verificação · ▶ Demonstração: limite de execução e integração com MCP}

Pilot demo: identity → sign → bundle → restore on auditor's machine

_{Fluxo piloto de host único: assine cada chamada de ferramenta, entregue um pacote de evidências assinado, reverifique em qualquer máquina — sem necessidade de keystore do signet. Runbook do piloto →}

Seu agente de IA acabou de fazer um pedido, excluir uma linha, enviar um e-mail, mesclar um PR. Você consegue provar exatamente o que ele fez — para um auditor, um cliente ou para você mesmo após um incidente?

Signet é a camada de confiança independente para ações de agentes. Cada chamada de ferramenta recebe um recibo assinado que qualquer pessoa pode verificar offline, sem confiar na plataforma que hospedou o agente ou no fornecedor que armazenou os logs — e desde a versão 0.11, a autorização por trás de uma ação carrega sua própria prova: quem é o agente (principal), quem permitiu que ele agisse (delegação) e quem permitiu essa ação específica (decisão assinada pela autoridade).

Seus agentes rodam na infraestrutura deles. A prova pertence a você.

Por que não apenas logs?

Logs tradicionais dizem o que uma plataforma afirma que aconteceu. Eles são mutáveis, dependentes do provedor e não verificáveis sem confiar na parte que os escreveu.

Os recibos do Signet são diferentes. Modifique qualquer campo — nome da ferramenta, parâmetros, timestamp, assinante — e a assinatura Ed25519 quebra. Exclua ou reordene entradas e a cadeia de hash SHA-256 quebra. A verificação requer apenas a chave pública. Sem chamada de rede, sem API, sem login.

Logs comuns	Recibos do Signet
O provedor diz que aconteceu	Qualquer pessoa pode verificar, offline
Mutáveis depois do fato	A assinatura quebra com adulteração
Sem prova de ordenação	A cadeia de hash quebra com exclusão/reordenação
Confie no host do log	Verifique com a chave pública
Afirmação unilateral	Co-assinatura bilateral disponível

Use logs para observabilidade. Use o Signet quando precisar de evidência.

Para quem é isso?

Construtores de MCP — envolva qualquer servidor MCP com signet proxy, assine cada tools/call, sem alterações de código
Equipes de segurança / conformidade — trilha de auditoria à prova de adulteração que atende ao EU AI Act Art. 12, SOC 2 CC7.2, ISO 27001 A.8.15
Plataformas empresariais de agentes — prove o que o agente fez, quem autorizou, qual política estava em vigor
Usuários de frameworks — LangChain, CrewAI, Claude Code, Codex, OpenAI Agents, Vercel AI SDK — todos suportados
Implantações agente-a-agente — co-assinatura bilateral quando ambos os lados possuem chaves

Se uma chamada de ferramenta não puder ser verificada de forma independente, ela não deve ser confiada incondicionalmente. Isso importa quando um auditor pede prova, quando um incidente acontece em infraestrutura que você não controla, ou quando a pergunta não é "o que o console diz", mas "o que realmente aconteceu".

Cada agente recebe uma identidade Ed25519. Cada chamada de ferramenta pode ser assinada, anexada a uma trilha de auditoria encadeada por hash, verificada offline ou antes da execução, co-assinada pelo servidor, vinculada a uma cadeia de delegação e, opcionalmente, vinculada a uma decisão de política.

O vídeo acima mostra o fluxo completo. O SVG abaixo mostra os detalhes de assinatura da CLI, ou pule para Veja a rejeição de solicitações inválidas para assistir o servidor bloquear solicitações inválidas antes que elas sejam executadas.

Signet demo

_{Esta primeira demonstração mostra assinatura + recibos de auditoria. Veja também o diagrama de fluxo do MCP.}

O que o Signet adiciona

O Signet adiciona uma camada de confiança leve para ações de agentes:

Assine cada chamada de ferramenta com a chave criptográfica do agente
Verifique solicitações offline ou no limite de execução antes que sejam confiadas
Faça proxy de qualquer servidor MCP de forma transparente — assine solicitações sem tocar no código do agente ou do servidor, com co-assinatura de auditoria bilateral local no caminho do proxy
Co-assine respostas do servidor com recibos bilaterais quando você controla ambos os lados
Rastreie fluxos de trabalho de várias etapas vinculando recibos com trace_id e parent_receipt_id
Autorize agentes com cadeias de delegação com escopo que provam quem permitiu a ação
Ateste política incorporando um PolicyAttestation assinado quando uma política YAML é satisfeita
Inspecione localmente com uma trilha de auditoria somente de anexação e painel, sem necessidade de plano de controle hospedado

O que há de novo na versão 0.11

Principais canônicos: cada identidade pode carregar um URI de principal com escopo (agent://prismer/deploy-bot), assinado dentro de recibos e tokens de delegação; as declarações acting_for são corroboradas por máquina pela raiz da cadeia.
Decisões de autorização assinadas pela autoridade: signet authorize pré-aprova uma intenção; signet sign --decision produz um recibo respaldado por ela (ou --authority-key faz isso em uma única etapa). Uma decisão vincula-se à ação via intent_hash, então a reprodução em uma ação diferente é recusada.
Revogação: signet revoke invalida tokens de delegação e decisões com um registro assinado pelo emissor. A verificação relata um status explícito — revoked falha, unknown nunca é relatado como autorizado (--require-revocation-known para modo estrito). Pacotes de evidências carregam registros de revogação.
Condições e limites: regras de política carregam obrigações tipadas (require_approval, sandbox, …); escopos de delegação carregam restrições (--max-calls, --spend-limit). Caminhos de assinatura impõem orçamentos de contagem de chamadas e o invariante de estreitamento (uma concessão pode reduzir uma delegação, nunca ampliá-la).
Endurecimento: verify() agora verifica corretamente recibos v4; regras de política com limite de taxa falham de forma fechada quando nenhum estado é fornecido; a expiração da delegação vincula-se ao relógio de parede (retroceder o timestamp de um recibo não o contorna mais).

Conformidade

O Signet fornece os controles técnicos que os auditores procuram ao avaliar operações de agentes de IA. Veja o Mapeamento de Conformidade completo para detalhes.

Estrutura	O que o Signet aborda
SOC 2 Type II	Trilha de auditoria assinada (CC7.2), detecção de adulteração (CC7.3), escopo baseado em função (CC6.3), prova de autorização (CC8.1)
ISO 27001	Registro de eventos (A.8.15), controle de acesso (A.5.15), autenticação (A.5.17), gerenciamento de configuração (A.8.9)
EU AI Act	Manutenção de registros do Artigo 12: registro de eventos, rastreabilidade, identificação, integridade
DORA	Registro de incidentes de TIC (Art. 17), evidência de risco de terceiros (Art. 28-30), integridade da trilha de auditoria
NIST AI RMF	Governar (cadeias de delegação), Mapear (recibos assinados), Medir (consultas de auditoria), Gerenciar (mecanismo de política)

O Signet é uma ferramenta, não uma certificação. Ele fornece controles que apoiam a conformidade — sua implantação e configuração determinam a postura de conformidade.

Experimente em 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)

Por que dar estrela neste repositório?

O Signet está construindo uma nova categoria: recibos verificáveis de chamadas de ferramentas para agentes de IA. Dar estrela não é apenas um marcador — ajuda a impulsionar evidências criptográficas para ações de agentes no ecossistema, para que indústrias regulamentadas, plataformas empresariais e usuários de frameworks não precisem criar as suas próprias.

Trabalhando com o Microsoft Agent Governance Toolkit (exemplo mesclado no PR #1196)
Contribuidor nomeado no RFC ComplianceBackend do LangChain (#35691)
Trabalho de conformidade em direção à especificação IETF draft-farley-acta-signed-receipts
Mapeia para os quatro pilares do NIST NCCoE para identidade e autorização de agentes de IA (Perfil de Interoperabilidade Q4 2026)

Se você está construindo agentes que precisam sobreviver a uma auditoria, um incidente ou a um terceiro perguntando "prove" — dê estrela no repositório, experimente, abra uma issue.

Se você é novo, comece com um destes cinco caminhos:

Escolha seu caminho

Claude Code: Melhor para a primeira execução mais rápida em um agente de codificação. Execute /plugin install signet@claude-plugins-official no Claude Code. Em 5 minutos você terá chamadas de ferramentas assinadas e um log de auditoria local em ~/.signet/audit/.
Codex CLI: Melhor para assinar chamadas de ferramenta Bash no Codex. Copie plugins/codex/ para ~/.codex/plugins/signet e adicione um hook PostToolUse. Em 5 minutos você terá ações Bash assinadas no Codex usando a mesma trilha de auditoria.
Python SDK: Melhor se você quiser recibos dentro do LangGraph, LlamaIndex, OpenAI Agents, CrewAI ou seu próprio executor de ferramentas. Comece com SigningAgent.create(...) e adicione hooks de framework apenas onde precisar.
Clientes MCP: Melhor se você controla um cliente MCP ou transporte. Envolva seu transporte com new SigningTransport(inner, secretKey, "my-agent"). Em 5 minutos você terá solicitações tools/call assinadas com recibos em params._meta._signet.
Servidores MCP: Melhor se você quiser verificação antes da execução. Chame verifyRequest(request, {...}) no seu manipulador de ferramentas. Em 5 minutos você terá verificações de assinante, frescor, vinculação de destino e ferramenta/parâmetros no limite de execução.

Veja a rejeição de solicitações inválidas

Execute a demonstração mais curta de limite de execução:

cd examples/mcp-agent
npm run execution-boundary-demo

Execution-boundary demo showing invalid requests rejected before execution

_{Prefere movimento? Baixe o MP4 ou GIF.}

Veja examples/mcp-agent/demo-execution-boundary.mjs para o código-fonte da demonstração.

Cadeias de delegação: quem autorizou este agente?

Os recibos do Signet provam o que aconteceu. As cadeias de delegação provam quem permitiu.

Uma identidade raiz (humana ou organizacional) delega criptograficamente autoridade com escopo a um agente. As permissões só podem estreitar, nunca ampliar. O recibo v4 do agente carrega a prova completa de autorização.

Owner (alice) → Agent A (tools: [Bash, Read], max_depth: 0)
                    ↓
              v4 Receipt: tool=Bash, authorization.chain proves alice → Agent A

# Create a delegation token (expires in 24 hours)
signet delegate create --from alice --to deploy-bot --to-name deploy-bot \
    --tools Bash,Read --targets "mcp://github" --max-depth 0 --ttl 24h

# Sign with authorization proof (v4 receipt)
signet delegate sign --key deploy-bot --tool Bash \
    --params '{"cmd":"git pull"}' --target "mcp://github" --chain chain.json

# Verify: signature + chain + scope + root trust
signet delegate verify-auth receipt.json --trusted-roots alice

Melhor prática: Use delegações de curta duração (--ttl 1h, --ttl 24h) em vez de tokens de longa duração ou sem expiração. Se um agente for comprometido, a delegação expira automaticamente. Reemita tokens conforme necessário. Este é o mesmo padrão usado por JWTs de curta duração e certificados X.509.

Ou em Python:

from signet_auth import sign_delegation, sign_authorized, verify_authorized

# Delegation functions accept JSON strings for scope, chain, and receipts
token_json = sign_delegation(root_key_b64, "alice", agent_pubkey_b64, "bot", scope_json)
receipt_json = sign_authorized(agent_key_b64, action_json, "bot", f"[{token_json}]")
scope_json = verify_authorized(receipt_json, [root_pubkey_b64])

Delegation chain demo

Atestados de Política: Isso Foi Permitido?

O Signet pode aplicar uma política YAML antes de assinar. Quando uma ação é permitida, o recibo assinado carrega um PolicyAttestation provando qual hash de política, regra e decisão estavam em vigor.

version: 1
name: production-agents
default_action: deny
rules:
  - id: allow-read
    match:
      tool: Read
    action: allow
  - id: deny-rm-rf
    match:
      tool: Bash
      params:
        command:
          contains: "rm -rf"
    action: deny
    reason: destructive command

signet policy validate policy.yaml
signet policy check policy.yaml --tool Bash --params '{"command":"rm -rf /"}'

signet sign --key deploy-bot --tool Read \
    --params '{"path":"README.md"}' --target "mcp://github" --policy policy.yaml

Ações negadas falham antes que um recibo seja produzido. Ações permitidas produzem um recibo cujo payload assinado prova a decisão da política.

Quando as Equipes Usam o Signet

Você precisa de uma trilha de auditoria à prova de adulteração para agentes de codificação, ferramentas MCP ou automação de CI
Você quer provar qual agente solicitou uma ação e quem a autorizou após um incidente
Você precisa de recibos que possam ser verificados offline sem depender de um serviço hospedado
Você quer aplicação leve de políticas antes de assinar sem adicionar um proxy à sua stack

O Que o Signet É e Não É

O Signet é uma camada de confiança para ações de agentes: assinatura, auditoria, verificação, delegação e atestado de política
O Signet é projetado para se encaixar em stacks de agentes existentes com SDKs, plugins e middleware MCP
O Signet pode rejeitar solicitações MCP não assinadas, obsoletas, repetidas ou mal direcionadas antes da execução
O Signet pode negar ações antes de assinar quando você fornece um arquivo de política
O Signet não é um gateway hospedado, plano de controle sempre ativo ou substituto para sandboxing e design de privilégio mínimo

Instalação

# 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 (Node local audit/operator helpers)
npm install @signet-auth/node

# TypeScript (Vercel AI SDK middleware)
npm install @signet-auth/vercel-ai

# TypeScript (standalone MCP signing server)
npx @signet-auth/mcp-tools

Início Rápido

Plugin Claude Code

Assine automaticamente toda chamada de ferramenta no Claude Code com zero configuração:

# 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

Toda chamada de ferramenta é assinada com Ed25519 e registrada em uma trilha de auditoria com hash encadeado em ~/.signet/audit/.

Métodos de instalação alternativos:

# From Git
claude plugin add --from https://github.com/Prismer-AI/signet

# Via signet CLI
signet claude install

Plugin Codex

Assine automaticamente toda chamada de ferramenta Bash no Codex CLI:

git clone https://github.com/Prismer-AI/signet.git
cp -r signet/plugins/codex ~/.codex/plugins/signet

Em seguida, adicione o hook ao ~/.codex/hooks.json:

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": "node \"$HOME/.codex/plugins/signet/bin/sign.cjs\"",
        "timeout": 5
      }]
    }]
  }
}

Ou use o servidor MCP para ferramentas de assinatura sob 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

Integração com Cliente MCP (TypeScript)

Signet MCP bilateral flow demo

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!" },
});

Toda solicitação tools/call recebe um recibo assinado injetado em params._meta._signet.

Verificação do Servidor MCP

Se você também controla o servidor MCP, verifique as solicitações antes da execução:

import { FileNonceCache, verifyRequest } from "@signet-auth/mcp-server";

const nonceCache = new FileNonceCache(".signet/nonces.json");

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const verified = verifyRequest(request, {
    trustedKeys: ["ed25519:..."],
    maxAge: 300,
    nonceCache,
  });
  if (!verified.ok) return { content: [{ type: "text", text: verified.error }], isError: true };
  if (!verified.trusted) return { content: [{ type: "text", text: "untrusted signer" }], isError: true };
  console.log(`Verified: ${verified.signerName}`);
  // process tool call...
});

Integração com Vercel AI SDK

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
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-4o"),
  tools: { myTool },
  ...callbacks,
  prompt: "...",
});

// Every tool call is now signed
console.log(callbacks.receipts);

Servidor MCP de Referência

Este repositório também inclui um servidor MCP de referência mínimo que demonstra verificação no lado do servidor com @signet-auth/mcp-server.

cd examples/mcp-agent
npm ci
npm run verifier-server

Ferramentas disponíveis:

inspect_current_request — verifica a chamada de ferramenta MCP atual se ela incluir params._meta._signet
verify_receipt — verifica um recibo Signet bruto contra uma chave pública
verify_request_payload — verifica um payload MCP tools/call sintético offline

Variáveis de ambiente:

SIGNET_TRUSTED_KEYS — chaves públicas ed25519:<base64> separadas por vírgula
SIGNET_REQUIRE_SIGNATURE — true ou false (padrão true)
SIGNET_REQUIRE_TRUSTED_SIGNER — true ou false (padrão true)
SIGNET_MAX_AGE — idade máxima do recibo em segundos (padrão 300)
SIGNET_EXPECTED_TARGET — receipt.action.target esperado opcional

Servidor de Assinatura MCP Autônomo

@signet-auth/mcp-tools expõe assinatura, verificação e hash de conteúdo do Signet como ferramentas MCP — conecte-se a qualquer cliente compatível com MCP:

npx @signet-auth/mcp-tools

Ferramentas disponíveis: signet_generate_keypair, signet_sign, signet_verify, signet_content_hash.

SDK Python (LangChain / CrewAI / AutoGen + 6 mais)

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

Para ferramentas Python simples, o ponto de entrada de menor fricção é a camada de decorador:

from signet_auth import SigningAgent, signet_tool

agent = SigningAgent.create("tool-bot", owner="team")

@signet_tool(agent=agent, target="mcp://github.prod", audit_encrypt_params=True)
def create_issue(title: str, repo: str) -> str:
    return f"{repo}:{title}"

Se você executa um servidor MCP Python ou outro limite de execução, use verify_request() com um backend de nonce durável no formato piloto:

from signet_auth import FileNonceChecker, VerifyOptions, verify_request

nonce_checker = FileNonceChecker(".signet/nonces.json")
opts = VerifyOptions(
    trusted_keys=["ed25519:..."],
    expected_target="mcp://github.prod",
    nonce_checker=nonce_checker,
)

result = verify_request(request_params, opts)
if not result.ok:
    raise ValueError(result.error or "verification failed")
if not result.trusted:
    raise ValueError("untrusted signer")

Integração 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

Integração 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()

Integração 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)

Integração LangGraph

O LangGraph usa o sistema de callbacks do LangChain — o mesmo handler funciona diretamente:

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

Integração 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)

Integração 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}"

Integração 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

Integração 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])

Integração 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: Os argumentos de chamada de ferramenta ainda não estão disponíveis na API de hook (issue #939). Apenas o nome da ferramenta é assinado.

API de Baixo Nível

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-assinatura do 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

Como 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)

A assinatura no lado do cliente funciona sem alterar o servidor. Se você também controla o servidor, adicione verifyRequest() e signResponse() opcional para verificação no limite de execução e recibos bilaterais. signResponse() deve ser executado apenas após um verifyRequest() confiável bem-sucedido, e agora pode carregar estado final de resultado executed / failed / rejected / requires_approval dentro da assinatura bilateral.

Recibo de Ação

Toda chamada de ferramenta começa com um recibo assinado. Versões mais altas de recibo adicionam co-assinatura do servidor (v3) e cadeias de autorização (v4):

{
  "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..."
}

A assinatura cobre todo o corpo do recibo (ação + signatário + timestamp + nonce) usando JSON canônico RFC 8785 (JCS). Modificar qualquer campo invalida a assinatura.

Comandos CLI

Comando	Descrição
`signet identity generate --name <n>`	Gera identidade Ed25519 (criptografada por padrão)
`signet identity generate --unencrypted`	Gera sem criptografia (para CI)
`signet identity list`	Lista todas as identidades
`signet identity export --name <n>`	Exporta chave pública como JSON
`signet sign --key <n> --tool <t> --params <json> --target <uri>`	Assina uma ação
`signet sign --hash-only`	Armazena apenas o hash dos parâmetros (não os parâmetros brutos)
`signet sign --output <file>`	Escreve recibo em arquivo em vez de stdout
`signet sign --no-log`	Pula anexação ao log de auditoria
`signet sign --encrypt-params`	Criptografa `action.params` no log de auditoria mantendo a saída do recibo inalterada
`signet sign --policy <path>`	Aplica política antes de assinar e incorpora `PolicyAttestation`
`signet verify <receipt.json> --pubkey <name>`	Verifica assinatura de um recibo
`signet verify --chain`	Verifica integridade da cadeia de hash do log de auditoria
`signet audit`	Lista ações recentes
`signet audit --since <duration>`	Filtra por tempo (ex.: 24h, 7d)
`signet audit --tool <substring>`	Filtra por nome de ferramenta
`signet audit --verify`	Verifica todas as assinaturas de recibos
`signet audit --export <file>`	Exporta registros como JSON
`signet audit --bundle <dir>`	Constrói um pacote de evidências assinado portátil (records.jsonl + manifest.json + hash-summary.txt) para entrega de auditoria fora do host
`signet audit --bundle <dir> --include-trust-bundle <path>`	Incorpora um snapshot do pacote de confiança no pacote de evidências
`signet audit --restore <dir>`	Re-verifica um pacote de evidências produzido anteriormente (funciona em qualquer máquina, sem keystore do signet)
`signet audit --export <file> --decrypt-params`	Exporta registros de auditoria originais mais `materialized_receipt` com parâmetros descriptografados
`signet explore`	Navega pelos recibos interativamente (tabela, detalhe, estatísticas, verificação de cadeia)
`signet explore --show N`	Inspeciona o recibo #N com assinatura, política e informações de cadeia
`signet explore --show N --decrypt-params`	Materializa `action.params` criptografado para inspeção local
`signet explore --stats`	Estatísticas de recibos por ferramenta, signatário e versão
`signet delegate create ... --ttl 24h`	Cria um token de delegação com escopo (curta duração)
`signet delegate sign ... --chain <file>`	Assina com prova de delegação e produz um recibo v4
`signet delegate verify-auth <receipt> --trusted-roots <name>`	Verifica cadeia de autorização, escopo e raiz confiável
`signet policy validate <path>`	Valida sintaxe da política e imprime seu hash
`signet policy check <path> --tool <t> --params <json>`	Simula se uma ação seria permitida
`signet proxy --target <cmd> --key <name>`	Executa como proxy stdio MCP — assina todas as chamadas de ferramenta de forma transparente (chave de servidor efêmera)
`signet proxy ... --server-key <name>`	Usa uma identidade de assinatura de servidor persistente (necessário para pacotes de confiança ancorarem uma pubkey de servidor estável entre reinicializações)
`signet proxy ... --policy <path>`	Proxy com aplicação de política antes de assinar
`signet verify <bilateral.json> --trust-bundle <bundle> --nonce-store <path>`	Verifica recibos bilaterais v3 com proteção contra replay que sobrevive a reinicializações de processo
`signet claude install`	Instala plugin Claude Code (hook de assinatura PostToolUse)
`signet claude uninstall`	Remove plugin Claude Code
`signet dashboard`	Abre painel de auditoria local no navegador

Senha via prompt interativo ou variável de ambiente SIGNET_PASSPHRASE para CI.

Painel de Auditoria

Execute signet dashboard para abrir uma interface web local para seu log de auditoria — sem conta, sem rede, apenas seus recibos locais.

Signet audit dashboard — timeline view showing every signed tool call

_{Visão de linha do tempo: toda chamada de ferramenta registrada com signatário, nome da ferramenta, alvo e ID do recibo. Filtre por tempo, ferramenta ou signatário.}

A aba Integridade da Cadeia verifica a cadeia de hash SHA-256 em todo o seu log de auditoria — qualquer adulteração ou lacuna é apontada para o arquivo e linha exatos:

Signet chain integrity check — break point detected at line 189

_{Cadeia quebrada na linha 189: hash esperado vs. real exibido. É assim que "somente anexação" realmente parece na prática.}

Documentação

Documento	Descrição
Arquitetura	Design do sistema, visão geral dos componentes, fluxo de dados
Segurança	Primitivas criptográficas, modelo de ameaça, armazenamento de chaves
Runbook de Implantação Piloto	Runbook de ponta a ponta para um piloto assistido por fundador: identidades, pacote de confiança, proxy `--server-key`, replay durável, pacotes de evidências, captura de resultados, procedimentos pós-comprometimento
Guia de Integração MCP	Configuração MCP passo a passo com SigningTransport
Integração CI/CD	Exemplo de GitHub Actions, gerenciamento de chaves para CI
Guia do Log de Auditoria	Consulta, filtragem, verificação de cadeia de hash
Contribuindo	Instruções de build, fluxo de trabalho de desenvolvimento
Changelog	Histórico de versões

Estrutura do Projeto

signet/
├── crates/signet-core/       Rust core: identity, sign, verify, audit, keystore
├── signet-cli/               CLI tool (signet binary)
├── bindings/
│   ├── signet-ts/            WASM binding (wasm-bindgen)
│   └── signet-py/            Python binding (PyO3 + maturin)
├── plugins/
│   ├── claude-code/          Claude Code plugin (WASM signing + audit)
│   └── codex/                Codex CLI plugin (WASM signing + audit)
├── packages/
│   ├── signet-core/          @signet-auth/core — TypeScript wrapper
│   ├── signet-mcp/           @signet-auth/mcp — MCP SigningTransport middleware
│   ├── signet-mcp-server/    @signet-auth/mcp-server — Server verification
│   ├── signet-mcp-tools/     @signet-auth/mcp-tools — Standalone MCP signing server
│   ├── signet-node/          @signet-auth/node — Node local audit/operator helpers
│   └── signet-vercel-ai/     @signet-auth/vercel-ai — Vercel AI SDK middleware
├── examples/
│   ├── wasm-roundtrip/       WASM validation tests
│   └── mcp-agent/            MCP agent, echo server, and verifier server example
├── docs/                     Design docs, specs, plans
├── LICENSE-APACHE
└── LICENSE-MIT

Compilando a Partir do Código Fonte

Pré-requisitos

Rust (1.70+)
wasm-pack
Node.js (18+)
Python (3.10+) + maturin (para binding Python)

Build

# Rust core + CLI
cargo build --release -p signet-cli

# WASM binding
wasm-pack build bindings/signet-ts --target nodejs --out-dir ../../packages/signet-core/wasm

# TypeScript packages
cd packages/signet-core && npm run build
cd packages/signet-mcp && npm run build
cd packages/signet-mcp-server && npm run build
cd packages/signet-mcp-tools && npm run build
cd packages/signet-node && npm run build
cd packages/signet-vercel-ai && npm run build

# Python binding
cd bindings/signet-py
pip install maturin
maturin develop

Teste

# Rust tests
cargo test --workspace

# Python tests
cd bindings/signet-py && pytest tests/ -v

# WASM roundtrip
node examples/wasm-roundtrip/test.mjs

# TypeScript tests
cd packages/signet-core && npm test
cd packages/signet-mcp && npm test
cd packages/signet-mcp-server && npm test
cd packages/signet-mcp-tools && npm test
cd packages/signet-node && npm test

# Plugin tests
cd plugins/claude-code && npm test
cd plugins/codex && npm test

# Vercel AI SDK tests
cd packages/signet-vercel-ai && npm test

# Reference verifier server smoke test
cd examples/mcp-agent && npm run smoke

Segurança

Assinaturas Ed25519 (nível de segurança de 128 bits, ed25519-dalek)
Derivação de chave Argon2id (mínimo recomendado pela OWASP)
Criptografia de chave XChaCha20-Poly1305 com dados associados autenticados (AAD)
Cadeia de hash SHA-256 para log de auditoria à prova de adulteração
JSON canônico RFC 8785 (JCS) para assinaturas determinísticas

Chaves armazenadas em ~/.signet/keys/ com permissões 0600. Substitua com a variável de ambiente SIGNET_HOME.

O que o Signet prova

A chave X do agente assinou a intenção de chamar a ferramenta Y com parâmetros Z no tempo T

O que o Signet NÃO prova (ainda)

Que o servidor MCP executou a ação (use recibos bilaterais com signResponse() para co-assinatura do servidor — lançado na v0.4)
Que signer.owner realmente controla a chave (planejado: registro de identidade)

O Signet é primeiramente uma camada de evidência: ele prova o que aconteceu. Ele também pode aplicar verificações no limite de assinatura e no limite de execução, mas não substitui sandboxing, design de privilégio mínimo ou aprovação humana onde esses são necessários.

Projetos Relacionados

Prismer Cloud — Harness completo de agentes com mecanismo de evolução, camada de memória, comunidade e identidade Ed25519/DID integrada. Use o Prismer Cloud para a plataforma completa de agentes; use o Signet quando precisar apenas da camada de atestação autônoma.
Prismer.AI — A plataforma de pesquisa em IA de código aberto

Histórico de Estrelas

Se o Signet for útil para você, por favor, dê uma estrela neste repositório — isso ajuda mais equipes a encontrá-lo.

Licença

Licença dupla Apache-2.0 + MIT.