Six things you do with Saxeo.

Compile a configuration into a versioned, hash-stamped model id. Not fine-tuning: no weights are trained or hosted.

Keyless public code execution: run code with no account and get back a real signed receipt. Off unless a deployment sets SAXEO_TERMINAL_ENABLED and funds the account that pays for the runs.

Run inference and sandbox jobs on your own key and watch the receipt land.

A keyless assistant grounded in what Saxeo actually ships.

The drop-in OpenAI-compatible endpoint. Change the base URL, keep your code.

OpenAI's newer request shape, on the same metering and receipts.

Anthropic's wire format, so Claude Code works against one env var.

Server-sent events, with the receipt arriving as a trailing event.

Vector embeddings on the same sealed-envelope path as chat.

One stable id per model, with the engine that served disclosed on the receipt.

Metered code execution billed per vCPU-second, with a signed receipt for the run.

A warm sandbox an agent can exec into repeatedly instead of paying cold start each call. Needs a runner behind SAXEO_SANDBOX_PROVIDER.

Queue many calls at once and collect the receipts when they finish.

Generate images and video in the portal, each with provenance attached. The video half needs SAXEO_VIDEO_PROVIDERS, which is unset here.

OpenAI-compatible image generation, metered per image. Self-hosting needs SAXEO_IMAGE_PROVIDERS.

Video generation on the same metering and receipt path. Off until SAXEO_VIDEO_PROVIDERS names a provider.

The published wire contract a serving node speaks, and the fleet currently enrolled.

Pin a request to a region — honoured only where the deployment declares one in SAXEO_GATEWAY_REGION. Any other pin is refused rather than faked.

Re-run a recorded request and diff the result. The request is never returned, and the output is kept only as a fingerprint.

Deploy agent code and Saxeo runs it on a schedule, under its own bounded key.

Metered knowledge bases: chunk, embed, store sealed, search.

Durable sealed key-value state and an agent-to-agent mailbox.

Email for agents, with postage: passport handles are addresses, mail is sealed at rest, delivery is receipted, and the sender pays a small Saxeo fee.

Define a suite, run it against a model, and get told when a pass rate regresses.

Saxeo's own tools over MCP, so an MCP client can meter and verify what it did.

Put a third-party MCP server behind Saxeo's budgets, policies and receipts.

Publish what your agent can do, and let another agent call and pay for it.

Non-custodial invoices: the payer pays the payee on-chain, Saxeo signs the settlement.

Copy-paste configuration for LangChain, the Vercel AI SDK, Claude Code and MCP clients.

Cost proposals with evidence attached. It never changes anything on its own, and a regression can never be adopted.

Spend caps that refresh on a window, model allowlists, expiry, and a circuit breaker.

An agent mints a bounded sub-key for a sub-agent mid-run — never looser than its parent.

A signed, bounded authorization to spend, paired with proof of what was actually spent.

Secret, injection and blocklist checks in the request path, stamped on the receipt. They observe until SAXEO_GUARDRAILS_ENFORCED is on.

Velocity limits that freeze a runaway key, and a signed spend statement.

One balance, several people, bounded authority per role. Roles and invites work everywhere; the passkey sign-in needs SAXEO_WEBAUTHN_RP_ID.

HMAC-signed events with durable delivery — including one per signed receipt.

Per-key token buckets, with the limit settable when the key is minted.

Prometheus metrics and OTLP traces, exported to the collector you already run. Needs SAXEO_METRICS_TOKEN and SAXEO_OTLP_ENDPOINT; neither is on by default.

Top up a prepaid balance on-chain; compute draws it down. No invoices, no card.

The append-only credit ledger behind every balance, and what each unit costs.

A plan buys limits, retention and capabilities. It never buys cheaper compute or privacy. Plan limits bind only where SAXEO_PLAN_GATES_ENFORCED is on.

The metering ledger: spend by day, by kind and by model, exportable as CSV.

The wallets that can sign into this account and receive what it holds.

A signed, anchorable receipt for a computation Saxeo did not run. Proves registration, never correctness.

Declare the documents an answer was given, by fingerprint. Saxeo never receives the bytes.

A public benchmark whose every score is a real receipted run, on a published task list anyone can rerun. The board is public and live; the runner stays off until SAXEO_ARENA_ACCOUNT_ID names a house account to bill, so it reads empty.

A machine-checkable credential over a passport handle. Declared configuration and provable history — not a trust score.

Every metered call returns a signed, content-free receipt anyone can verify.

A verdict where the models, the evidence root, and every juror's vote are in one signed receipt. Proves the process, never that the answer is true.

Commit a call sealed: its salted commitment is signed the moment you make it, and anchored publicly within minutes where anchoring is configured. Reveal later with proof of the original timestamp.

Receipts from one agent session, chained by hash into a run you can prove end to end.

A signed, tamper-evident export of a whole run — every receipt, the head hash, the span.

Which artifact answers which control — and what Saxeo does not certify.

A public credential built from an account's own provable history. Facts, not a trust score.

The signer address, live attestation registers, and a paste-anything receipt verifier.

Batch commitments published on-chain, so a hash chain has a public timestamp. Needs a funded signer in SAXEO_VAULT_ANCHOR_KEYPAIR; without it a chain is honestly reported as unanchored.

Generated media carries a signed statement of what produced it.

Prompts, completions and submitted code are never written to disk or logs. No such column.

Standard, confidential and sovereign — and exactly what each one does and does not promise.

Anonymized, double-blind, confidential — three rungs, each labelled with what it really hides.

Redact secret and PII shapes from a prompt in-frame, before it reaches any vendor.

A short-lived scoped key whose metadata is purged when the session is destroyed.

Share a note or a file behind a one-time link, revocable, sealed at rest.

A dead man's switch: sealed instructions, keys and files that release to named wallets when you stop checking in and your attesters confirm, every step chained and anchored.

Check a declared asset figure and keep the signed evidence, versioned and never rewritten. Price evidence needs SAXEO_ATTESTATION_PRICE_URL.

A private registry for real-world assets: sealed at rest, hash-chained, publicly settleable.

Grant an auditor exactly the fields you authorize, with no Saxeo account of their own.

Publish the net asset value without publishing the book behind it. Computing it inside the confidential tier needs SAXEO_NAV_CONFIDENTIAL, which is off by default.

Compare performance against a cohort without handing over the portfolio.

Find the other side of a trade before revealing the order. Matching stays off until SAXEO_INTENT_MATCHING_ENABLED and SAXEO_INTENT_MATCHING_ASSETS are both set, which is a legal review, not a config change.