// Operate, oversee, verify

Run the operator, set its mandates, verify its work.

Point your SDK at one base_url and the operator takes the wheel: it routes every call, caps the spend, blocks the risky tool — within the mandates you set — and writes a cryptographically chained receipt for each move that your auditor checks without us. Observe & Suggest run today; assisted and autonomous tiers switch on per tenant as you grant them. Here is the quickstart, the Effector/Mandate model, and the open verify recipe.

Start the 5-minute quickstart Browse the reference
2,148,723Operator moves on the record
~3 minSince the last independent anchor
21 fieldsFrozen receipt the operator writes
6 linesTo verify any move yourself
One move · one receipt sense → act → prove
run sense act prove anchored BY HAND → OPERATED → PROVEN
receipt_hash8ae41ff9…d5e70efb
prev_hash91f91867…e9a77a90
merkle_root692f786b…935ff39a
anchor.memo= merkle_root ✓

Want to run the fold yourself? Recompute this receipt in your browser →

// What the operator operates

One operator runs every AI your company runs.

Instead of wiring five tools and standing up a team to run them, the operator runs the lot from a single drop-in doorway in front of every model — vendor-neutral. Five capabilities ship today; one is on the roadmap. Each links to the reference that documents it.

It routes every model

The operator picks the right provider for each job behind one endpoint — Smart Routing, fallback, the Model Catalog and Response Cache, all under a single unified SDK.

Gateway API →
It senses every signal

The operator reads latency, cost and errors per dispatch — every model, app and agent on one ledger — and acts on them before your team would have seen the spike.

Platform API →
It guards spend & risk

The operator runs inline Guardrails and Tool Governance, then hard-stops the spend before each call ships — finding the cheapest way to hit your quality bar, never below it.

Config object →
It proves every move

The operator can't act without writing a hash-chained, Merkle-batched, on-chain-anchored receipt — verifiable by anyone, including an auditor who doesn't trust us.

Receipt schema →
It runs in your boundary

Sovereign runs the operator in your VPC. Only the leaf hash and metering cross the boundary — never a byte of content, and it acts with scoped credentials via BYO-KMS, never raw keys.

Self-host →
It grades what you plug insoon

A reputation network for the agents and vendors you connect — the operator scores a counterparty's receipts before you trust its output. On the roadmap; not live yet.

// Reference

Documentation

Everything to put the operator on your stack, set its mandates, and verify its work — start with the quickstart or jump straight to the reference you need.

All guides & references

// Start here

Three on-ramps: hand it the wheel, set the mandates, verify the work.

01

Let the operator take the wheel

  1. Point one base_url in your existing client at the gateway.
  2. Make a chat or embeddings request — the operator routes it — Gateway API.
  3. Read the x-agentics-receipt header off the response.
Quickstart →
02

Set the mandates it operates within

  1. Define a GatewayConfig — Config object.
  2. Bound its routing, fallback and a spend hard-stop.
  3. Attach the Guardrails it tightens and the tools it may call.
Config reference →
03

Verify a move yourself

  1. Pull a bundle from /api/proof/bundle.
  2. Recompute the leaf and fold the Merkle proof — Verification API.
  3. Byte-match the on-chain anchor — no Agentics call.
Receipt schema →

// DON'T TRUST US — VERIFY US

Every other tool asserts the operator behaved. We prove it.

The operator can't act without emitting a Receipt v2: a sorted-key JSON object, SHA-256 hashed into a leaf, folded into a Merkle tree, anchored on-chain. We publish the exact schema, the exact canonicalization order, and the exact Merkle fold — then hand you a six-line script to reproduce any move with nothing but a SHA-256 implementation. No Agentics service required.

Read the frozen schema Verify a live receipt

Reproduce any receipt

// 1. take the receipt from /api/proof/bundle
delete receipt.receipt_id; delete receipt.batch_id;
// 2. canonicalize: sort keys, drop null, no spaces
const leaf = sha256Hex(JSON.stringify(canon(receipt)));
leaf === bundle.receipt_hash; // leaf integrity
// 3. fold the Merkle proof (sorted-pair)
let acc = leaf;
for (const s of bundle.merkle.siblings)
  acc = hashPair(acc, s);
acc === bundle.merkle.root; // anchored membership