Every call, routed by the operator — and proven.
The operator picks the right model for each job and records the choice. Instead of wiring your apps to one provider and hand-tuning the rest, you point them at one endpoint and change one base_url — the operator routes, governs and budgets each call inline, then writes a receipt you can verify yourself.
The operator sits in the data path, not off to the side
Instead of a logger that watches after the fact, the gateway is where the operator acts. Your apps call one OpenAI-wire-compatible endpoint; the operator runs in-path, so it enforces your policy before a call reaches the model — and hashes every dispatch on the way out, so no move it made can be quietly rewritten later.
Change one base_url and your existing SDK keeps working. Behind that change, the operator resolves the provider, picks the model for the job, applies your routing and guardrail config, checks the budget, calls upstream, and writes a prev_hash-chained receipt. You decide how much it runs — per domain, dialed up or down, reversible in one click. Observe & Suggest is available now; assisted and autonomous tiers roll out per tenant as you grant them.
- One integration, every provider. The operator resolves a bare model id or an @slug across Anthropic, OpenAI, Gemini, Bedrock and more — you wire one endpoint, not five.
- It enforces before the call. Guardrail and budget checks run in-line — the operator blocks, redacts or hard-stops before a token reaches the provider.
- A receipt on every dispatch. Each response carries an x-agentics-receipt hash. Every other tool asserts what it did; the operator proves it on a record you can't edit.
An operator that logs is common. One whose log you can prove is not.
Instead of asking you to trust a console, the operator can't act without writing a receipt: hash-chained to the one before it, folded into a Merkle batch, and anchored on a public chain — tamper-evident by construction, checkable without us.
The receipt the operator wrote for this call
As the request leaves the gateway, the operator's canonical receipt is SHA-256 hashed into a leaf, linked to the previous receipt by prev_hash, and queued for the next Merkle batch. Recompute the leaf yourself — the bytes match, or the chain is broken.
This is the same client-side verification shipped on the Trust portal. SHA-256 runs via Web Crypto. No Agentics call.
- •Recompute leaf
- •Chain integrity
- •Fold Merkle proof
- •Anchor memo == root
SHA-256 runs in your browser via Web Crypto. No Agentics call.
You change one base_url. Then the operator takes the wheel.
Instead of rewriting your apps, keep your SDK, your prompts, your retries. Change the base URL, add your gateway key, and the operator routes, governs, budgets and proves every call from there.
curl https://agentics.you/api/v1/chat/completions \
-H "Authorization: Bearer ak_…" \
-H "Content-Type: application/json" \
-d '{"model":"@anthropic/claude-opus-4-8",
"messages":[{"role":"user","content":"hi"}]}'
# ← x-agentics-receipt: <receipt_hash>from openai import OpenAI
client = OpenAI(base_url="https://agentics.you/api/v1", api_key="ak_…")
resp = client.chat.completions.create(
model="@anthropic/claude-opus-4-8",
messages=[{"role": "user", "content": "hi"}],
)
print(resp.headers["x-agentics-receipt"])Watch the operator work, call by call
Instead of grepping provider dashboards, you supervise one feed. The console streams every move the operator makes — provider, model choice, latency, cost, outcome and the receipt hash for each call.
Trust Gateway console
A live table of the operator's dispatches — provider, model choice, latency, outcome and the verifiable receipt hash for each call.
Open Trust Gateway →