The decision API
Typed questions in, typed answers out, up to 400 in one call. Keys, prepaid credit with a ledger, rate limits and regions. The same request shape as Jev.
For investors · measured and early
The next useful AI decides, remembers and shows its work.
Language models write text for people. Software needs something else: a judgment it can act on, in milliseconds, that remembers the customer and can prove what it did. Jepela is that layer, as one API call. The API went live on 2026-09-24, every number about it is measured and dated, and we are early.
Measured
27 msthe engine's own time for a three-question decision, on the engine's server (median of 25, 2026-09-24)
0.20 → 0.82“escalate?” once two lines were in a customer's memory (2026-09-23)
$5.84per million decisions with memory, against $20.82 sending the history (arithmetic, a constructed test of 60 decisions, 2026-09-26)
805tests in a full run against the engine, 2026-09-30: “Ran 805 tests”, “OK (skipped=25)”
Sources and dates are on the home page and in the cookbooks.
The shift
From AI that writes to AI that decides
Most of what software asks an AI is not a paragraph. It is a judgment: route this ticket, flag this payment, escalate this customer, keep this message out. Those judgments happen millions of times a day, inside code, where text is the wrong answer.
Generative AI
Writes text for people
- Output is prose that code has to parse and trust
- Forgets everything between calls
- Priced by the text it generates
- Hard to check: no probabilities to gate on
Decision AI, with Jepela
Answers typed questions for software
- Choice, score or yes/no, with probabilities and a confidence
- A memory per customer, player, device or case, with what it changed
- $0.042 per million input tokens; output is free
- Measured limits, calibration on your own labels, verified forgetting
Why now
The category opened in September 2026
TypeSafe launched Jev, a "System One" decision model behind an API, on 2026-09-15. The attention was immediate. What its users asked for next is what Jepela built.
≈ 964YouTube videos about Jev from 749 channels, in its first eight days
≈ 275Hacker News stories in the same eight days
106,407members in TypeSafe's Discord, "the home of Jev"
Noneof the products in that material offered a memory per subject
Counted in Jepela's own market map of everything published about Jev, collected on 2026-09-23. The critics' main points were vendor-run benchmarks, calibration that does not hold on every dataset, a black box, and no memory. Jepela answers each one, and speaks Jev's request shape, so moving over is a new base URL and a model name.
- Jev launchesThe decision-model API category goes public.
- Jepela goes liveHosted API in the United States, with keys, prepaid billing and memory.
- Memory, fine-tuning, scalePinned lines, exclusions and names in memory; fine-tuning on a customer's own cases; requests sharing one forward pass.
- Public, with live demosA try-it box on the home page, seven games, a first-person game and twelve small apps.
- Accounts, payments, pilotsSelf-serve sign-up, a Europe region and the first pilots with organisations that have private data.
Built and running
Not a slide deck. A product that is built and deployed.
Everything below is in production or in the documentation, and tested.
Memory per subject
Recall by the state, the subject's names and the question; pinned lines; rules and exclusions checked in code; the answer without memory beside it; forgetting that is verified.
Quality you can check
Calibration fitted on a customer's own labels, golden sets, warnings in every answer about known traps, and a public page of what the engine gets wrong.
Fine-tuning as a service
A customer's cases train a model of its own, kept only when it beats the standard engine on cases it never saw and still listens to memory.
Built to scale
Requests that arrive together share one pass on the GPU: one engine answered 113 requests a second with 200 sent at once, each answer within 0.0001 of the answer to the same request sent alone; the median time per request was 1.8 s at that load (load test on a GPU test server, 2026-09-26). A pool can add engines as load grows.
Where developers are
A Python SDK, a TypeScript client, an MCP server with a Claude Code plugin, an agent skill, 31 documentation pages, 25 recorded examples and 11 cookbooks.
Proof, measured
Memory changes outcomes. We can show it.
In every live demo, two agents take the same decisions with the same engine, and only one has a Jepela memory. Measured on 2026-09-28 on a test setup.
☕The Usualchecks passed in a week of visits, four regulars; rules in code: no dairy for a regular who cannot have it, and decaf after the hour they gave
🚚Courier Townparcels delivered in three 5-day runs
🌱Green Thumbright care in a 14-day season
the same engine without memory the same engine with a Jepela memory · games you can play at arcade.jepela.com, measured on 2026-09-28 on a test setup through each game's own code; each game's page says how. “Rule in code” marks a win that comes from a rule Jepela checks in code, not from the engine.
Business model
Usage-based, from the first call
Customers prepay credit and pay for what the engine reads. Output is free. Every priced request is one line in their ledger.
Today
$0.042 per million input tokens, the same way and price as Jev, for business customers. Memory writes free; the passes that show what memory changed are free.
Grows with use
Memory makes each decision cheaper than sending the history (139 against 496 tokens in a constructed test of 60 decisions, 2026-09-26), so customers can put more decisions through Jepela.
Next
A price for fine-tuned models (free in the preview), a Europe region with the data kept there, and enterprise terms under the data processing agreement.
Why Jepela
Where we can win
The memory layer
Nobody in the category offered a memory per subject. Jepela's is not a bolt-on: rules checked in code, exclusions, pins, comparison with and without memory, and forgetting that is proven.
Trust as a product
Measured numbers only, a public page of failure modes, calibration on the customer's own labels, verified deletion, and a data processing agreement. That is what regulated buyers ask for.
No switching cost
The same request and answer shape as Jev: an existing integration moves with a new base URL and a model name, and gains memory.
Speed of execution
The API went live on 2026-09-24; memory upgrades, fine-tuning, a GPU pool and more than twenty demos followed within four days, with every change tested.
Where we are
Early, on purpose
The product is built and deployed: the API in the United States region since 2026-09-24, the documentation and the demos. When the API's health check can be read, the line at the top of this page shows whether the engine is answering right now. Accounts and card payments are open since 2026-10-15; next come the Europe region and the first pilots.
This is the moment to be early: the category is new, the product is real, and the terms are still being written.
What investment builds
- Capacity for more customers and the Europe region
- Self-serve sign-up and billing, from key to invoice
- Pilots with organisations that have private data and real decisions
- The team that turns a working engine into a company
Be early
We are talking with a small number of early investors and pilot partners.
Write to us for the deck, the numbers behind this page, and a live walkthrough of the engine and the memory.