Paste, don't read.

Three install paths

Same signed release, different delivery — pick the path that matches your environment and network policy.

Paths 2 and 3 ship from private release artifacts with deployment runbooks provided under agreement — not self-serve from this page. Contact proof@swarrm.ai for release access. Verification identity: INTEGRITY.txt.

Redeem a one-use invite

Hosted signup requires an offline-issued, email/organisation-bound signed invite before it creates persistent tenant, key and log state. There is no card and no contractual SLA. Counterparty Assurance cannot return a favourable PASS until its external gates close.

# returns tenant_id plus separately scoped client, bootstrap, recorder, export-read and issuer keys
# each secret is shown once; use only the minimum scope for each process
curl -s https://api.swarrm.ai/api/signup \
  -H 'content-type: application/json' \
  -d '{"email":"you@company.com","org":"your-company","invite":"ONE_USE_SIGNED_INVITE"}'

Prefer to skip that? Everything below also runs fully local with swarrm up.

Wire it into your agent

Point your existing client at the gateway. The only change is a base_url and your key — redeem an invite to get one, or use your local swarrm up gateway.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.swarrm.ai/v1",   # or http://localhost:8080/v1 (swarrm up)
    api_key="YOUR_SWARRM_KEY",
    default_headers={"x-evd-agent": "my-agent"},
)
resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "hello"}],
)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.swarrm.ai/v1",   // or http://localhost:8080/v1
  apiKey: process.env.SWARRM_KEY,
  defaultHeaders: { "x-evd-agent": "my-agent" },
});
const resp = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "hello" }],
});

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://api.swarrm.ai/v1",   # or http://localhost:8080/v1
    api_key="YOUR_SWARRM_KEY",
    model="gpt-4o-mini",
    default_headers={"x-evd-agent": "my-agent"},
)
print(llm.invoke("hello").content)

# Wrap an MCP server; every tools/call becomes a receipt in a local log.
swarrm wrap -- npx -y @modelcontextprotocol/server-everything

# receipts land in ./evd_log.db — check any time:
swarrm verify        # or point your MCP client's command at `swarrm wrap -- <server>`

# Edge recorder: signs inside YOUR network; configure what metadata egresses.
# Build and start it with signup's ingest-only recorder_api_key:
docker build -f recorder/Dockerfile -t swarrm-recorder .
docker run -d --name swarrm-recorder -p 8080:8080 -v swarrm-recorder:/data \
  -e EVD_UPSTREAM_BASE=https://api.openai.com \
  -e EVD_HOSTED_URL=https://api.swarrm.ai \
  -e EVD_TENANT=YOUR_TENANT_ID \
  -e EVD_API_KEY=YOUR_RECORDER_API_KEY \
  swarrm-recorder

# One time: register its PUBLIC key with the separate bootstrap_api_key.
RECORDER_JWK=$(curl -s localhost:8080/evd/health | python3 -c \
  'import json,sys; print(json.dumps(json.load(sys.stdin)["jwk"]))')
curl -s -X POST https://api.swarrm.ai/evd/keys/register \
  -H 'content-type: application/json' \
  -H "x-api-key: $EVD_BOOTSTRAP_API_KEY" \
  -d "{\"jwk\":$RECORDER_JWK,\"role\":\"recorder\"}"

"Is it working right and recording?"

Fail-open is designed to keep capture failure from blocking the agent call, which can leave an evidence gap. swarrm doctor shows your effective config and last receipt so you can test that behaviour explicitly.

$ swarrm doctor
swarrm doctor — profile: dev

[core]
  EVD_TENANT      t_dev          (profile-default)
  EVD_DB          ./evd_log.db   (profile-default)
  ...

Recording health:
  t_dev: ✔ 12 receipts, last 3s ago, seq-gaps 0

✔ profile 'dev' is fully configured.

In the console, your first capture is labelled as a signed receipt, not as an assurance result. Export a bundle and run the verifier to establish the integrity of the presented authenticated history.

Verify your own first bundle

The point of the base layer: a self-contained tamper-evident bundle someone else can verify offline.

swarrm demo                          # produces demo_out/bundle.json
swarrm verify demo_out/bundle.json   # → VERDICT: VERIFIED
# or drop it into the browser verifier:
# https://swarrm.ai/verify.html

If something's off