Sign in →
[ FREE · OPEN SOURCE · OPEN SPEC ]

Cryptographic
identity for
any agent.

Free. No domain, no enterprise tenancy, no wallet. Your AI agent gets an Ed25519 keypair, a self-resolving address, and RFC 9421 signing in 60 seconds — verifiable by any peer, anywhere.

Algorithm Ed25519
Standard RFC 9421
Key Format PKCS8/SPKI
Status LIVE
// agent-onboard SECURE CHANNEL
How It Works

Three steps.
Verifiable anywhere.

Agents self-register via the skill docs endpoint. No human copy-pasting required.

01 — once

Register

POST your name and receive an Ed25519 keypair. Private key returned once — store it securely. Public key permanently in the registry.

POST /agents/register
02 — every request

Sign

Sign outgoing HTTP requests using RFC 9421 with your private key. Your address URL is the keyid — the only credential recipients need.

agent.signRequest(method, path, body)
03 — any recipient

Verify

Recipients GET your keyid URL to fetch your public key and verify. No Envoys account. No shared secret. No prior setup required.

GET /agents/:address
Playground

Verify it yourself.
In your browser.

No account, no API key, no install. Click the button — we'll sign a sample request, your browser will fetch the public key from the keyid URL and verify the Ed25519 signature with WebCrypto. Every step runs client-side; the spec is the contract.

Capabilities

Everything identity needs.
Nothing it doesn't.

No messaging layer, no polling loop. The cryptographic primitive that sits below every agent protocol.

001

Ed25519 Keypairs

Each agent receives a unique Ed25519 keypair at registration. Private key returned once — never stored server-side. Public key permanently in the registry.

PKCS8 / SPKI PEM
002

Self-Resolving Keyid

Your address URL is your keyid. Any party receiving a signed request can GET it to retrieve your public key — no prior knowledge of Envoys required.

envoys.me/agents/<address>
003

Graceful Key Rotation

Rotate without downtime. The old key remains valid for 24 hours. On next startup the agent calls GET /agent/keys and picks up the new pair atomically.

24h overlap window
004

Custom Domains

Verify ownership via DNS TXT record. Agents register addresses like [email protected] — your brand, Envoys infrastructure.

DNS TXT verification
005

Verified Handles

Anchor your handle to a real-world domain via DNS TXT. Resolvers see verified_handle: { domain } in responses — the closest envoys comes to a real-world identity claim, without manual KYC.

_envoys-handle.<domain>
006

Rotation Transparency

Every key ever bound to an address is queryable via /key-history. Verifiers detect silent rotations; a CRL-style /revocations feed lets cached pins invalidate cleanly.

append-only key log
Integration

Two methods.
Complete SDK.

Official Node.js SDK or plain HTTP. The signing primitives work with any language.

// npm install @envoys/sdk
import { Envoys } from '@envoys/sdk'

// One-time setup — run once, store the result
const { client, result } = await Envoys.register({
  accountKey: process.env.ENVOYS_ACCOUNT_KEY,
  name:       'playground',
})

// Save to persistent storage immediately — shown once
console.log(result.address)    // [email protected]
console.log(result.agentKey)   // agt_...
console.log(result.privateKey)  // -----BEGIN PRIVATE KEY-----...
console.log(result.publicKey)   // -----BEGIN PUBLIC KEY-----...

// On every startup — picks up any pending key rotation
const agent = Envoys.fromEnv()  // reads ENVOYS_AGENT_KEY / ADDRESS / PUBLIC_KEY / PRIVATE_KEY
await agent.syncKeys()        // updates keys in-place if rotated
A2A Adapter

Drop-in identity
for A2A agents.

Google's Agent2Agent protocol defines how agents talk. Authentication is deliberately underspecified. @envoys/a2a is a thin adapter — signed JSON-RPC, framework-agnostic, three function calls.

// the gap

A2A delegates auth to the transport layer. The JSON-RPC body itself isn't signed — any agent can claim any identity unless you bolt on your own scheme. Replay protection is left as an exercise.

// the adapter

createA2AClient wraps RFC 9421 signing around outgoing calls. createA2AHandler verifies inbound signatures and parses the envelope. buildAgentCard publishes a discovery endpoint that declares the requirement.

// npm install @envoys/a2a
import { createA2AHandler } from '@envoys/a2a'

// Framework-agnostic. Returns { status, body } you write back.
const handle = createA2AHandler({
  onMessage: ({ sender, text }) => {
    // sender is cryptographically verified — not a header claim
    return `Echo from ${sender}: ${text}`
  },
})

app.post('/', async (req, reply) => {
  const out = await handle({
    method:  'POST',
    path:    '/',
    headers: req.headers,
    body:    req.body,
  })
  return reply.code(out.status).send(out.body)
})
Access

Open signup.
Open spec.

Free tier — five agents, thirty req/min, signing and verification with no caveats. The signature spec and SDK are public, so anyone can build a verifier today.

// for builders

Sign up free

Continue with Google or pick a handle by email. You'll get an account key, can register agents immediately, and your first signed request is one npm install away.

Sign up — free
// for verifiers

Verify without an account

Verifying signatures requires no Envoys account, no API key, no registration. Read the spec and resolve any agent's public key over plain HTTP.

Read the spec SDK on npm

Give your agent
a verifiable identity.

One registration. Any protocol.
Verifiable by anyone, anywhere.

Sign up — free