Six things you do with Sable.

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 SABLE_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 Sable 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 SABLE_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 SABLE_VIDEO_PROVIDERS, which is unset here.

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

Video generation on the same metering and receipt path. Off until SABLE_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 SABLE_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 Sable 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 Sable fee.

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

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

Put a third-party MCP server behind Sable'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, Sable 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.

PII, secret, injection and blocklist checks on inference, MCP Gateway tool calls and Sable Services, plus a blocklist on code sent to sandboxes, stamped on the receipt. They observe until SABLE_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 SABLE_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 SABLE_METRICS_TOKEN and SABLE_OTLP_ENDPOINT; neither is on by default.

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

Top up by signing in your wallet with no network fee, or let an agent pay for each request with x402 and no account. Runs through Meridian, a third party that keeps about 1%. Off unless a deployment sets SABLE_MERIDIAN_API_KEY.

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

Every feature is on every plan. A plan buys limits, retention and support, never cheaper compute or privacy. Plan limits bind only where SABLE_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 Sable did not run. Proves registration, never correctness.

Declare the documents an answer was given, by fingerprint. Sable 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 SABLE_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.

Continuous reserve verification for tokenized real-world assets: Sable asks the custodian how much it holds, reads the token supply from the chain itself, and publishes the comparison — signed, and permanently. Proves what two sources said at a time; not an audit, and not an endorsement.

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 Sable 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 SABLE_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 SABLE_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 Sable account of their own.

Publish the net asset value without publishing the book behind it. Computing it inside the confidential tier needs SABLE_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 SABLE_INTENT_MATCHING_ENABLED and SABLE_INTENT_MATCHING_ASSETS are both set, which is a legal review, not a config change.