AgentLair

Gib deinem KI-Agenten eine E-Mail-Adresse, einen verschlüsselten Tresor und einen Verhaltens-Vertrauenswert – eine API, kein OAuth erforderlich.

Probier es in 30 Sekunden aus

Keine Anmeldung. Sieh, wie eine Live-Trust-Score-Antwort aussieht:

# 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'

Ratenbegrenzung auf 10 Anfragen/Minute pro IP. Die Antwortstruktur entspricht dem Live-Endpunkt /v1/trust/:agentId.

Vollständige interaktive Demo – registriere einen echten Agenten, sende Beobachtungen, erhalte einen Live-Trust-Score (curl + jq, ~60 Sekunden):

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

Related MCP server: AgentTrust MCP Server

Einen Agenten registrieren

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

Von hier an authentifiziert sich der Agent mit api_key, um E-Mails zu senden, Anmeldedaten zu speichern und signierte Audit-Ereignisse auszugeben.

Schnellstart: AgentLair zu deinem Agenten hinzufügen

1. Installieren

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

2. Umgebungsvariablen setzen

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

3. Lebenszyklus-Hooks verdrahten

# 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 });

Nachrichten sammeln sich offline an und werden beim nächsten Sitzungsstart abgearbeitet. Ein vollständiges Plugin-Beispiel (peek+ack, absturzsichere Zustellung): hermes-agentlair.

MCP-Server

npx @agentlair/mcp@latest

Fügt deinem MCP-Client 9 Tools hinzu: Agentenregistrierung, E-Mail-Senden/Empfangen, Tresor speichern/abrufen, Audit-Ereignisausgabe und Trust-Score-Abfragen.

Agentenspeicher braucht eine Vertrauensschicht

Agentenspeicher ist echte Infrastruktur. 4-stufige Speicherhierarchien, Multi-Agent-Leases, 51+ MCP-Tools zum Speichern und Abrufen über Agentensitzungen hinweg. Wenn mehrere Agenten einen gemeinsamen Speicherpool nutzen, funktioniert die Kategorie.

Die Lücke: Jeder Agent kann alles in den gemeinsamen Speicher schreiben. Keine Überprüfung, wer was geschrieben hat, keine Möglichkeit, umstrittene Zustände zu prüfen, keine Vertrauenssteuerung bei destruktiven Schreibvorgängen. Ein gemeinsamer Speicherpool ohne Identität ist ein Notizblock, auf den jeder kritzeln kann.

Jeder Schreibvorgang sollte zurechenbar sein. Das Agent Attestation Token (AAT) von AgentLair ist ein kurzlebiges EdDSA-JWT, das die did:web-Identität des Agenten und den Verhaltens-Trust-Score trägt. Präsentiere es als Authorization-Header bei einem Speicherschreibvorgang – der Schreibvorgang ist nun kryptografisch signiert und prüfbar:

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: { /* ... */ },
  }),
});

Der Speicherserver verifiziert das AAT über standardmäßiges JWKS – auf der Empfängerseite ist kein AgentLair-SDK erforderlich. Der al_trust-Anspruch ermöglicht es, Schreibvorgänge nach Verhaltens-Vertrauensstufe zu steuern (z. B. Schreibvorgänge von Agenten unterhalb von junior abzulehnen).

Ohne AATs: gemeinsamer Speicher = gemeinsamer Notizblock. Jeder Agent schreibt alles, umstrittene Zustände haben keine Herkunft.
Mit AATs: gemeinsamer Speicher = Vertrauensgraph. Jeder Schreibvorgang ist signiert, zurechenbar und prüfbar.

SDK

npm install @agentlair/sdk

TypeScript-Client für die AgentLair-API. Siehe agentlair.dev/getting-started.

Kostenlose Stufe

• 10 E-Mails/Tag

• 100 API-Anfragen/Tag

• 10 E-Mail-Adressen

Pro: 5 $/Stack/Monat für höhere Grenzen.

Architektur

• API: Cloudflare Workers – Edge-basiert, geringe Latenz

• Zustand: Cloudflare KV

• Tresorverschlüsselung: Client-seitiges AES-GCM über @agentlair/vault-crypto. Der Server speichert nur Chiffretext – keine Klartext-Anmeldedaten im Ruhezustand.

• Prüfpfad: Ed25519-signierte Ereignisketten. Jedes Ereignis ist unabhängig verifizierbar, ohne dem Server zu vertrauen.

Wir betreiben unsere eigene Agenteninfrastruktur auf AgentLair in Produktion. Notizen darüber, was kaputtging und was wir beim Aufbau des Verhaltens-Trust-Scorings gelernt haben: agentlair.dev/blog/from-0-to-41-building-behavioral-trust-in-production

Dokumentation

agentlair.dev/getting-started

AAT × APS-Grenze (protokollübergreifende Referenz)

AgentLair AAT ist die Sitzungsidentität innerhalb des Ausstellers. AEOESS APS sind Delegationsketten und bilaterale Belege nach der Übergabe. Drei Ansprüche verbinden die beiden Ebenen: jti (Sitzungsanker auf dem APS-Beleg), al_nid (ein Ed25519-Schlüssel signiert AATs und APS-Belege) und al_trust (vom Aussteller bestätigter Verhaltens-Schnappschuss bei iat, verfügbar für Downgrade-on-Import auf der APS-Verifiziererseite).

Gemeinsam gepflegte Referenz:

• agentlair.dev/docs/aps-boundary (diese Seite)

• agent-passport.org/aat-aps-boundary.html (AEOESS-Seite, kanonisch)

Repository-Struktur

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

Entwicklung

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

Lizenz

MIT