MetreceptΩMetrecept

Product

What is Metrecept

The black box for autonomous AI agents: every call crossing the pipe becomes a signed, independently verifiable receipt of what happened and what it cost — built on plumbing that rents the pipe, not the model, and stops mechanical agent loops from re-paying prefill.

Create AccountWaste demoArchitecture deep dive

Three mechanisms. One crossing.

Every call crosses the same pipe. What you get out the other side depends on which mechanism you’re looking at — the black box is the point; the other two make it fast and accountable at scale.

  1. 01 — Black box

    Every crossing is witnessed

    Cache hit, upstream miss, or a third-party API call an agent made mid-session — each mints an Ed25519-signed JWS receipt: kind-tagged, independently verifiable, byte-identical to what a court or auditor could check without trusting Metrecept at all.

    How receipts work

  2. 02 — The pipe

    The substrate every receipt is minted from

    One OpenAI-compatible base URL, BYOK on the wire, exact-match replay caching, and provider-native cache breakpoints. Identical prompts answer from Redis — the lab gets paid once, not on every retry.

    The pipe, in depth

  3. 03 — The black box at scale

    The same two mechanisms, at organizational scale

    SSO, tenant-scoped spend caps, and a ledger that reconciles to Stripe — so a hundred agents produce one auditable trail instead of a hundred unaccountable ones. Still a recorder, not a governor: it doesn't stop a call, it guarantees the call survives.

    Enterprise chaos

One crossing. Two layers of truth.

Clients hit one OpenAI-compatible ingress. Replay lives in the ephemeral layer; money, policy, and compliance live in the pipeline. They meet at HIT or MISS — always metered.

Ephemeral layer

Exact-replay inventory

  • Edge Redis GET
  • Content-addressed blobs
  • Cache trees / tips
  • BYOK on the wire — never stored

Optimized for latency and mechanical repeat. Can TTL or tear down without losing the durable ledger.

Pipeline governance

Who may cross

  • Email account + tenant keys
  • Meters → ledger → Stripe
  • Compliance ingest
  • Provider route honesty

Durable governance: tenancy, spend caps, audit, FinOps. Billing truth always lives here — even when the edge serves a HIT.

What this architecture enables

This design turns traditionally wasteful AI operations — re-paying identical agent and CI prompts, mixing preview pollution into production HIT inventory — into inventory and metadata operations.

  • Signed, verifiable receipts

    Every HIT, MISS, and API call mints an Ed25519 JWS receipt — proof, not a promise.

  • Zero-upstream replay

    Identical requests answer from Redis. The lab is not paid twice.

  • Tree-scoped isolation

    PR and agent inventories diverge without cloning tenants or databases.

  • Promote as index work

    Bring new digests to main without rewriting history as a bulk export.

  • Compose with a DB preview

    State branch + replay tip in one CI job — complementary peers.

  • Governed browse

    Public web through robots / PII / SSRF before model contact.

  • Compliance-grade ledger

    Tenant spend, SSO, and audit trail feed one meter — no side channel.

  • HITRedis replay. Labs silent. Pipe rent on the crossing.
  • MISSBYOK upstream. Completion stored. Pipe rent still ticks.
  • ReceiptEither way, a signed JWS mints — HIT, MISS, or API call, all independently verifiable.
  • AccountEmail + password login. Intermediate key bound to your profile.
  • InventoryTenant-scoped exact-replay tips — never a training corpus.

The black box for autonomous AI agents

Agent products scale context across turns. Naive routing re-pays prefill on every call. Compaction helps — it does not remove waste from identical or near-mechanical repeats (retries, loops, CI prompt suites). Underneath that inefficiency sits a sharper problem: nobody reviews what an unattended agent called, how many times, against which live endpoints, or what it would have cost to reproduce.

Metrecept rents the plumbing that makes that traffic economically survivable — and turns every call crossing it into a signed, independently verifiable receipt.

The gem

LayerRole
LabsGeneration + model billing (BYOK or managed pool)
ClientCockpit (Agent Shell, apps, Cursor/VS Code, …)
MetreceptSees every call → receipts it; metering (replay, compliant ingest, ledger) is the substrate, not the sale

We do not sell bigger context windows or wholesale tokens on Intermediate. We sell the receipt.

Stack ownership

Zoom out to the whole toolchain and every layer already has an owner. Metrecept's is the one that turns every call, mechanical repeat or not, into a signed, addressable, queryable record instead of an unwitnessed one:

LayerOwner
Hardware / model weightsLabs (OpenAI, Anthropic, …)
Postgres / durable app dataNeon
Interface / IDECursor
CataloguingGitHub
DistributionAWS
Systems language (edge)Rust
In-memory databaseRedis
Verifiable record of an AI dev's spend and agent activityMetrecept

Promise

Point any OpenAI-compatible client (or the Agent Shell) at one base URL. Keep your keys or use a managed pool. Gain a signed record of what happened and what it cost — and, as that same metering's original byproduct, exact-replay, compliant web context, and a clean ledger. Log in with email and password — Intermediate keys stay bound to your account profile.

Non-goals

No semantic cache. No Intermediate token wholesale. No overclaiming real-time control over what an agent does — the receipt proves what happened, it never stops what happens. Replay inventory is never a training corpus. Start with The black box, the Waste demo, Architecture, or Quickstart.

Go deeper