the decision cache for Jev-class models

Compute the decision every time.
Remember it forever.

Jev returns a typed decision in milliseconds for a fraction of a cent. Ask it the same thing a million times and you pay every time — and you can't replay it offline. jevcache memoizes by (model, schema, state), so the same decision never runs — or bills — twice.

$ curl -fsSL jevcache.sh/install | sh copy

~2 MB binary · runs on your machine with your key and your bill · only a hash ever leaves it

0ms

a local hit — no round-trip, no inference

every repeat you don't pay for again

100%

deterministic — same input, same answer, in CI

why cache a model this fast?

The cost isn’t the model. It’s asking it the same thing twice.

Fast and cheap per call isn't free at volume — or reproducible. Three things a faster model can't give you:

01 / FREE AT VOLUME

Repeats are the norm

60–80% of an agent's decisions repeat — loops, retries, idempotent tools, heavy-tailed inputs. Every repeat is another bill. A cache hit costs $0.

02 / DETERMINISTIC

Same input, same answer

Pin the exact decision — replay it in CI, offline, with no network and no model-version drift. The reproducibility real systems demand.

03 / SHAREABLE

A model call can't be shared

A cache can. Publish one and anyone recalls against it — one team's decisions become everyone's, over a file or the hosted index.

Latency? A local hit returns in ~0ms, in-process, no round-trip at all. That's the bonus. The point is you stop re-deciding what you've already decided.

the math

What those repeats add up to

Pick your volume. This is what memoization keeps off the bill.

784,000

decisions/day served from cache, never re-run

$4,704

per month you don't spend re-deciding

assumes a 78% recurrence rate and ~$0.0004 / decision (Jev’s own benchmark) · your numbers, your ledger

how it works

private by designstate is redacted then canonicalized before it's hashed — emails, phones, and ids are masked by default, more via schema policy. Only a fingerprint and the answer ever leave your machine, never raw state. For sensitive schemas, a per-schema salt keeps outsiders from enumerating which states you've decided.

offline & exactreplay every fingerprint you've already seen — zero network, deterministic CI. recall() checks the ledger only, never a backend.

any backendyour own model, TypeSafe Jev, or OpenRouter. the Jev backend speaks the real /v1/systemone API; a miss routes to whichever you point at, then caches it forever.

key = sha256( model ⊕ schema ⊕ canonical( redact( state ) ) ) a hit returns in 0ms for $0 — the same decision never runs twice.

roadmap

now

Re-use your own cacheEvery decision is memoized locally. recall() returns a prior answer in 0ms for $0. Deterministic replay in CI.

now

Find, use & share cachesjevcache publish bundles your cache; jevcache add <url> merges someone else's. Files or gists — no server, no accounts.

beta

Global cache indexA hosted index is live — publish --remote pushes, use recalls, one commons keyed by fingerprint. Next: a decentralized index over the Hyperspace P2P network, and per-recall pricing so publishers can charge for a cache.

in your app

Run it once, call it from anywhere

The same binary runs as a local cache your app talks to over HTTP. No library to install, no per-call process to spawn, and it works from any language — you just POST a schema and some state.

# start the cache (points at your model via JEVCACHE_BACKEND)
$ jevcache serve
jevcache serving on http://127.0.0.1:9000

// then, from your app — schema is inline, nothing to pre-register
const res = await fetch("http://localhost:9000/decide", {
  method: "POST",
  body: JSON.stringify({ schema, state: ticket }),
})
const { answers, cached } = await res.json()
// first call routes to your model and caches it; every repeat comes back cached.

Prefer the command line? jevcache decide --schema … --state ticket.json --json does the same thing, and recall exits 3 on a miss for CI.

where it runs

A cache needs to live somewhere. Pick the shape that fits.

jevcache is one binary. Where you point your app at it depends on how your app is deployed.

A LONG-RUNNING APP

Sidecar on localhost

Your own server, a container, a worker? Run jevcache serve next to it and call http://localhost:9000. Nothing leaves the box.

SERVERLESS / EDGE

Point at a hosted instance

Vercel functions, Cloudflare, Lambda — there's no daemon to run in an ephemeral function. Host jevcache once (docker run, Fly, Railway) with a token, and your functions call it over HTTPS. Your state and model key stay on your instance.

SCRIPTS / CI

Call the binary

No server at all — jevcache decide / recall read and write the local ledger. recall exits 3 on a miss, so CI can branch on it.

# host it as a shared cache for your serverless functions
$ docker run -p 9000:9000 -e JEVCACHE_BACKEND=jev -e JEV_API_KEY=… \
    -e JEVCACHE_SERVE_TOKEN=secret jevcache

# then from a Vercel function — same call, remote host
await fetch("https://cache.yourapp.com/decide", { method:"POST",
  headers:{ authorization:"Bearer secret" }, body: JSON.stringify({ schema, state }) })

install

A single binary, about 2 MB