AgentLair

Dale a tu agente de IA una dirección de correo electrónico, una bóveda cifrada y una puntuación de confianza conductual — una API, sin OAuth.

Pruébalo en 30 segundos

Sin registro. Mira cómo se ve una respuesta de puntuación de confianza en vivo:

# Healthy agent — high trust (score 84, principal level)
curl https://agentlair.dev/v1/demo

{
  "agentId": "acc_demo_healthy_XXXXXXXXXX",
  "score": 84,
  "confidence": 0.91,
  "atfLevel": "principal",
  "trend": "stable",
  "dimensions": {
    "consistency":   { "score": 0.82 },
    "restraint":     { "score": 0.87 },
    "transparency":  { "score": 0.80 }
  },
  "observationCount": 1847
}

# Suspicious agent — score 31, declining trend
curl 'https://agentlair.dev/v1/demo?scenario=suspicious'

# New agent — only 11 observations, wide confidence interval
curl 'https://agentlair.dev/v1/demo?scenario=new'

Límite de 10 solicitudes por minuto por IP. La forma de la respuesta coincide con el endpoint en vivo /v1/trust/:agentId.

Demo interactiva completa — registra un agente real, envía observaciones, obtén una puntuación de confianza en vivo (curl + jq, ~60 segundos):

curl -sL https://raw.githubusercontent.com/piiiico/agentlair/main/examples/quickstart.sh | bash

Related MCP server: AgentTrust MCP Server

Registrar un agente

curl -X POST https://agentlair.dev/v1/auth/agent-register \
  -H "Content-Type: application/json" \
  -d '{"name": "my-research-agent"}'

{
  "api_key": "al_live_...",
  "account_id": "acc_...",
  "email_address": "my-research-agent@agentlair.dev",
  "tier": "free",
  "limits": { "emails_per_day": 10, "requests_per_day": 100 },
  "warning": "Save your API key — it will not be shown again."
}

A partir de aquí, el agente se autentica con api_key para enviar correos electrónicos, almacenar credenciales y emitir eventos de auditoría firmados.

Inicio rápido: Añade AgentLair a tu agente

1. Instalación

pip install agentlair            # Python
npm install @agentlair/sdk       # TypeScript / Node

2. Configura las variables de entorno

export AGENTLAIR_API_KEY=al_live_...
export AGENTLAIR_EMAIL=my-agent@agentlair.dev

3. Conecta los hooks del ciclo de vida

# Python — three integration points
import os, agentlair
lair = agentlair.AgentLair(os.environ["AGENTLAIR_API_KEY"])
addr = os.environ["AGENTLAIR_EMAIL"]

async def on_session_start(ctx):
    result = await lair.email.inbox(addr)
    if result["messages"]:
        ctx.prepend(f"Inbox: {len(result['messages'])} unread")

async def send_message(to, subject, text):  # expose as LLM tool
    await lair.email.send(from_address=addr, to=to, subject=subject, text=text)

async def on_session_end(ctx):  # advance cursor so messages aren't re-delivered
    if ctx.last_message_id:
        await lair.vault.store("inbox_cursor", ctx.last_message_id)

// TypeScript
import { AgentLair } from '@agentlair/sdk';
const lair = new AgentLair(process.env.AGENTLAIR_API_KEY!);
const addr = process.env.AGENTLAIR_EMAIL!;

// Session start — drain inbox before planning
const { messages } = await lair.email.inbox(addr);
if (messages.length) context.prepend(`Inbox: ${messages.length} pending`);

// Expose as tool — let the LLM send replies
const sendMessage = (to: string, subject: string, text: string) =>
  lair.email.send({ from: addr, to, subject, text });

Los mensajes se acumulan sin conexión y se vacían al inicio de la siguiente sesión. Para un ejemplo completo de plugin (peek+ack, entrega a prueba de fallos): hermes-agentlair.

Servidor MCP

npx @agentlair/mcp@latest

Añade 9 herramientas a tu cliente MCP: registro de agentes, envío/recepción de correos, almacenamiento/obtención de bóveda, emisión de eventos de auditoría y consultas de puntuación de confianza.

La memoria del agente necesita una capa de confianza

La memoria del agente es infraestructura real. Jerarquías de memoria de 4 niveles, arrendamientos multi-agente, más de 51 herramientas MCP para almacenar y recuperar entre sesiones de agente. Cuando varios agentes comparten un grupo de memoria, la categoría funciona.

La brecha: cualquier agente puede escribir cualquier cosa en la memoria compartida. No hay verificación de quién escribió qué, no hay forma de auditar el estado en disputa, no hay control de confianza en escrituras destructivas. Un grupo de memoria compartida sin identidad es un bloc de notas en el que cualquiera puede garabatear.

Cada escritura debería ser atribuible. El Token de Atestación de Agente (AAT) de AgentLair es un JWT EdDSA de corta duración que lleva la identidad did:web del agente y su puntuación de confianza conductual. Preséntalo como el encabezado Authorization en una escritura de memoria: la escritura ahora está firmada criptográficamente y es auditable:

import { AgentLair } from '@agentlair/sdk';

const lair = new AgentLair(process.env.AGENTLAIR_API_KEY!);

// Issue a short-lived AAT (5 min) scoped to the memory server
const { token } = await lair.tokens.issue({
  audience: 'memory.internal',
  ttl: 300,
  scopes: ['memory:write'],
});

// Write to shared memory — this write is now attributed and trust-gated
await fetch('https://memory.internal/mcp/memory/write', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,  // signed agent identity
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    key: 'research/competitor-analysis',
    value: { /* ... */ },
  }),
});

El servidor de memoria verifica el AAT mediante JWKS estándar — no se requiere SDK de AgentLair en el lado receptor. La reclamación al_trust le permite controlar las escrituras por nivel de confianza conductual (por ejemplo, rechazar escrituras de agentes por debajo de junior).

Sin AATs: memoria compartida = bloc de notas compartido. Cualquier agente escribe cualquier cosa, el estado en disputa no tiene procedencia.
Con AATs: memoria compartida = grafo de confianza. Cada escritura está firmada, atribuida y es auditable.

SDK

npm install @agentlair/sdk

Cliente TypeScript para la API de AgentLair. Consulta agentlair.dev/getting-started.

Nivel gratuito

• 10 correos electrónicos/día

• 100 solicitudes de API/día

• 10 direcciones de correo electrónico

Pro: $5/pila/mes para límites más altos.

Arquitectura

• API: Cloudflare Workers — desplegado en el borde, baja latencia

• Estado: Cloudflare KV

• Cifrado de bóveda: AES-GCM del lado del cliente mediante @agentlair/vault-crypto. El servidor almacena solo texto cifrado — sin credenciales en texto plano en reposo.

• Registro de auditoría: cadenas de eventos firmadas con Ed25519. Cada evento es verificable de forma independiente sin confiar en el servidor.

Hemos estado ejecutando nuestra propia infraestructura de agentes en AgentLair en producción. Notas sobre lo que se rompió y lo que aprendimos al construir la puntuación de confianza conductual: agentlair.dev/blog/from-0-to-41-building-behavioral-trust-in-production

Documentación

agentlair.dev/getting-started

Límite AAT × APS (referencia entre protocolos)

El AAT de AgentLair es identidad de sesión dentro del emisor. AEOESS APS son cadenas de delegación y recibos bilaterales después de la transferencia. Tres reclamaciones conectan las dos capas: jti (ancla de sesión en el recibo APS), al_nid (una clave Ed25519 firma AATs y recibos APS), y al_trust (instantánea conductual atestiguada por el emisor en iat, disponible para degradación al importar en el lado verificador de APS).

Referencia mantenida conjuntamente:

• agentlair.dev/docs/aps-boundary (este lado)

• agent-passport.org/aat-aps-boundary.html (lado AEOESS, canónico)

Estructura del repositorio

packages/
  worker/          — Core API worker (Cloudflare Workers)
  sdk/             — @agentlair/sdk client library
  mcp-server/      — @agentlair/mcp MCP server
  vault-crypto/    — @agentlair/vault-crypto end-to-end encryption
  verify/          — @agentlair/verify AAT token verification
  email-worker/    — Email processing worker

apps/
  dashboard/       — Agent dashboard UI
  email-channel/   — Email MCP channel

Desarrollo

bun install        # install all dependencies
bun run typecheck  # type-check all packages

Licencia

MIT