Six things you do with Sable.

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.

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

Generate images and video in the portal, each with provenance attached.

OpenAI-compatible image generation, metered per image.

Video generation on the same metering and receipt path.

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

Pin a request to a region — honoured only where the deployment actually declares one.

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.

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.

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.

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

One balance, several people, bounded authority per role.

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.

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.

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.

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

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.

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.

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

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.

Compare performance against a cohort without handing over the portfolio.

Find the other side of a trade before revealing the order.