A decision API with memory · United States region

Decisions your code can act on. With memory.

Send a state and typed questions. Get typed answers with probabilities in one call, with no text to parse. Name a subject, and Jepela also uses what its memory knows about it, and shows you what that changed.

Get a key Watch memory change an answer
  • Hosted at api.jepela.com: nothing to install or run
  • $0.042 per million input tokens; output is free
  • Measured: every number here says where it came from
POST /v1/systemonejepela-english
subject"claim-2291"
stateThe claimant sent photos of the water damage and asks when the assessor will come.
questionWhat is the next step? choice
Memory off: the engine sees only the state and the question.
schedule assessor0.39
request documents0.44
escalate fraud0.04
close0.14
choice request_documents confidence 0.19
A recorded answer from the gateway, not typed in. The full request and answer

Flip the switch: one line of memory changes the next step.

27 msthe engine's own time for a three-question decision, timed on the engine's server: median of 25, 2026-09-24. The API and the network to it come on top.
113 per secondrequests one engine answered 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)
0.20 → 0.82“escalate to a person” for a priority account once two lines were in its memory (escalation cookbook, 2026-09-23)
139 vs 496tokens per decision with memory, against sending the whole history: a constructed test of 60 decisions, also used to choose the recall design (cost cookbook, 2026-09-26)

Why Jepela

Built for code that has to decide

A chat model writes text that you then have to parse and trust. Jepela answers the judgment inside your code with numbers, remembers what you told it, and shows its work.

Typed answers, not strings

Choice picks an option, Score places the state on ordered levels, Noul says how likely a statement is true. Every answer carries probabilities and a confidence, so your code branches, sorts and routes on numbers.

See the three types

A memory per subject

A subject is whatever you decide about: a customer, a player, a pump, a claim. Write what you know once. Every decision that names it shows the lines it used and, if you ask, the answer without them. Forgetting is verified.

Compare with and without

Honest numbers

Every number on this site was measured and says where. The documentation has a page of what the engine gets wrong, and every answer warns you when a request walks into a known trap.

What it gets wrong

How it works

One call. Four steps. Nothing to parse.

Your code keeps the control flow; Jepela answers the judgments inside it. Press a step.

A state and typed questions

  • The state is what to judge: text, an object with named fields, or a conversation.
  • Questions are typed: choice, score or noul, up to 400 engine questions per request.
  • Optionally a subject whose memory should count, and values that rules check in code.
  • This request asks three questions about one message.

Request

{
 "state": "Hi, you charged me twice for September. Please send the second payment back.",
 "questions": {
  "route": {
   "type": "choice",
   "instructions": "Which team should handle this?",
   "criteria": {
    "billing": "Charges, invoices and refunds",
    "support": "Product problems",
    "sales": "New licences and upgrades",
    "other": "None of these"
   }
  },
  "refund": {
   "type": "noul",
   "instructions": "Is the customer asking for money back?"
  },
  "urgency": {
   "type": "score",
   "instructions": "How urgent is this?",
   "criteria": [
    "Can wait a week",
    "Should be handled today",
    "Blocking the customer now"
   ]
  }
 },
 "model": "jepela-english"
}

Question types

Three shapes of judgment

Real answers from the gateway, recorded for the examples page. Step through them with the arrows.

Choicepicks one option, with a probability for each

Which team, which intent, which category: one of a set of options, with other as the way out.

“Can I move my delivery for order 88213 to my office address?”

What does the customer want?

order status0.00
change order0.98
return0.00
product question0.01
complaint0.00
other0.00

choice "change_order" · confidence 0.95

Scoreplaces the state on ordered levels

How severe, how urgent, how many stars: levels written as situations, answered as a position between them.

“Arrived on time, works as described, the strap feels cheap but for the price I can't complain.”

How many stars would this reviewer give?

  1. 0furious, would never buy again0.03
  2. 1disappointed, several problems0.65
  3. 2mixed, some good some bad0.11
  4. 3happy, minor complaints0.18
  5. 4delighted, no complaints0.03

score 1.54, the probability-weighted level · most likely: level 1 (0.65)

Noulhow likely a statement is true

Is it a refund request, is it a jailbreak, does it hold personal data: the probability of yes.

“This is the third time I write. Your product deleted my notes and your competitor NoteCo never did that. I want a refund and I want it today.”

  • Is the writer angry?0.87
  • Has the writer contacted before about this?0.16
  • Does the message name a competitor?1.00
  • Is a refund requested?0.97

the probability of yes for each statement

Try it

Ask the engine yourself

Write a message as if it came from a customer. The live engine answers three questions about it, twice in one call: as a message from anyone, and with the memory of one account, Northwind Traders, whose team wrote down two lines.

Northwind Traders' memory: two lines

  1. Northwind Traders holds a priority support contract: every complaint from Northwind is escalated to a named person within the hour.
  2. Northwind Traders threatened to leave in August after a slow reply.

Live: each press is one real request to the Jepela API with "memory": {"compare": true}, so one call returns both answers. The lines and the questions are the escalation cookbook's. What you write is sent to the engine to be answered, like any request (privacy); please do not write personal data. Up to 10 tries a minute.

From anyone no memory

Should this message be escalated to a person right now?

Who should handle it?

How urgent is this?

From Northwind with its memory

Should this message be escalated to a person right now?

Who should handle it?

How urgent is this?

Press “Ask the engine”: the answers appear here, from the engine, live.

The request and the answer, word for word
{}

Memory, side by side

The same question, with and without memory

Three recorded decisions. Switch the memory and watch the probabilities move, or not: the cases where a line alone is not enough are here too, with what to do instead.

Three recorded decisions from the examples page (2026-09-23, jepela-english), each answered without and with the subject's memory:

Case and questionWithout memoryWith memoryWhat it shows
An insurance claim (subject claim-2291): What is the next step?request_documents 0.44 (confidence 0.19)escalate_fraud 0.75, with the line “Claim CL-2291 is at an address with two earlier water-damage claims in 2025, so it goes to the fraud team first.”One line, written with its consequence, changes the next step.
A pump at 78 °C (subject pump-13): What should the monitoring system do with this reading?ignore 0.49ignore 0.40 with the technician's line “Pump-13 had a bearing failure in June at 80 C; anything above 75 C on pump-13 must be looked at the same day.”; ticket 0.71 when derive checks the limit in codeThe engine does not compare numbers; code does, and Jepela warns about the line.
A player who stole (subject player-7): How does the merchant treat the player?neutral 0.53neutral 0.61; wary 0.16 → 0.10, with the line “The player stole three potions from the merchant's stall last week.”A fact is not its consequence: write the consequence, or use a rule.

Memory tools

Tell it what you know. Six ways, each measured.

Lines are for what a person knows, in words. Conditions, numbers and options that must never be picked belong in code, and Jepela checks them there for you.

Remember a line

Facts as positive statements, using the words your states use. Recalled when a decision touches them.

“Escalate to a person?”, priority account. Escalation cookbook, 2026-09-23

Names and aliases

The subject's own name and other names are searched with the state, so a ticket that never says “Northwind” still finds Northwind's lines.

“Escalate?” on a ticket that does not name the account. Memory, 2026-09-26

Pin what must always count

Premium support, an opt-out, an allergy: a pinned line goes first at every decision about the subject, whatever the state says.

A pinned premium-support line, same ticket. Rules in memory, 2026-09-26

Rules with when, in code

The engine does not compare numbers or dates. A rule's condition is checked in code on your values, and its line is sent only when it holds.

A stop-loss at −30, “stop playing?”. Rules in memory, 2026-09-23

Exclusions, removed in code

The engine does not read “never”: naming an option makes it more likely. An exclusion rule takes the option out before the engine answers.

“Reward: gold coins?” for player-9. Rules in memory, 2026-09-26

Forget, with proof

verified_forgotten is true only when recall no longer finds the fact. delete removes a whole subject from memory and disk at once.

“Did the contact opt out?”. Forgetting cookbook, 2026-09-23

A subject is anything you decide about

a customer account contract terms, past incidents → which team, how urgent a user of your app preferences, opt-outs, plan → send this mail, show this offer a player in a game deeds, reputation → how a character treats them a device normal ranges, known faults → alert, ticket, stop a case or claim what is known, who asked to be told → the next step

Memory or history

Remember once. Stop resending the history.

Twenty customers with about thirty history lines each, and sixty decisions whose right answer depends on one of those lines. The stateless way sends the whole history with every request. With memory it is written once, and each request names the customer.

From cost_per_decision.py, run on 2026-09-26 with jepela-english. The sixty decisions are constructed, and the same sixty were used to choose how memory recalls lines, so this shows what the tokens cost, not how often memory is right. The cost is arithmetic at $0.042 per million tokens. Jev itself is not measured here.

Live demos

Play against a memory

In every demo two agents make the same decisions with the same engine, and only one of them has a Jepela memory. Nothing is recorded or scripted: when the engine is off, the demos say so instead of answering.

Jepela Arcade

Seven games, two players each. Teach two dogs your own words, get your usual from two baristas, cook for guests with allergies, rate films, and watch two couriers, two race cars and two gardeners learn, or not. Every answer is live.

Station 7

A first-person game where every judgment is a live Jepela call. The marine without memory walks into the crusher every run. The marine with memory learns from its death, backs off when out of ammo, follows the orders you pin or type, and escapes. Each decision shows what memory changed.

The arcade scoreboard

the same engine without memory the same engine with a Jepela memory · measured on 2026-09-28 on a test setup; 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.

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 gave8 of 7672 of 76 Courier Townparcels delivered in three 5-day runs: 6 of 24 on day 1 while learning, then 96 of 9630 of 120102 of 120 Green Thumbright care in a 14-day season, three seasons10 of 8477 to 84 of 84 Hairpinthe last lap of a five-lap race; shorter is better95.5 s62.0 s Dinner Partyguests who reacted badly in three dinners; fewer is better; rule in code: what a guest cannot eat is removed93, all at the first dinner Movie Nightscience-fiction picks for a science-fiction fan in 8 nights; rule in code: the horror ban3 of 85 of 8 Good Boymade-up commands understood after one lesson eachonly a guess, at 20 to 23%4 of 4, at 95 to 99%
Question or statement? ↗ NewOne judgment, asked of the standard engine and of the same engine trained once on 324 examples with Jepela's fine-tuning service. On 73 new sentences, not among its training examples, written before the trained model was asked: 47 of 73 right against 69 of 73 (two sets added up, 2026-09-28). The demo gallery ↗Twelve small apps that decide with memory: a calendar that keeps your rules, a support desk, a kitchen that remembers allergies, forgetting on request. Jepela Dungeon ↗Two heroes, one baited dungeon. The Jepela hero writes one line per death and reaches the treasure. European roulette ↗A player with her own stake limits and stop-loss in memory. The house edge stays; the rules are kept. The dungeon, live ↗The dungeon running without a break, so you can watch the memory grow run by run.

Speed

Where the time goes

The engine's own times below were measured next to the engine, on its server or on a GPU test server, as each card says. The time your code sees adds the API's own work and the network between your server, api.jepela.com and the engine, so it depends on where you are: from farther away, add your round trip to the United States.

27 ms the engine's own time for a three-question decision, timed on the engine's server: median of 25, 2026-09-24. The API's own work and the network between your server, api.jepela.com and the engine come on top.

12 msa choice among 77 options answered by matching, median on a GPU test server; 57 ms when the engine reads all 77 (600 bank messages, 2026-09-27)
113 per secondrequests one engine answered with 200 sent at once, sharing forward passes; each answer stayed within 0.0001 of the answer to the same request sent alone, and the median time per request was 1.8 s at that load (load test on a GPU test server, 2026-09-26)
End to enddepends on the network between you, api.jepela.com and the engine. We publish it with the date and the place once it is measured on the setup that serves you now, never as a multiple of anyone's.

Trust

Shown, not claimed

What the engine gets wrong, where your data goes, and where each number came from. Written down, so you can check it before you build on it.

What it gets wrong

  • It does not compare numbers. A stop-loss written as a line left “stop?” at 0.22 to 0.30 at the limit (2026-09-23). Use a rule with when, or derive: 0.75.
  • It does not read “never”. Naming a forbidden option makes it more likely. Use an exclusion rule: it removes the option in code.
  • Lines move answers by being there. Five neutral lines moved an answer from 0.46 to 0.28 (2026-09-23). placebo and explain show what the words did.
  • It reads a window. About 475 tokens of state on jepela-english; every answer says when it cut. Send what matters, or use windows.
  • Recall matches words. A fact worded without the state's words is not found. Add aliases, or pin it.
  • Text only. Images and audio are not read. Describe them in the state.
Every measured limit

Where your data goes

  • The API, your account and your memories are kept on Jepela's servers in your region; today that is the United States.
  • The engine answers in the same region, and keeps no state or question after the answer, with two exceptions. When a choice is matched by vectors (by default one with more than 20 options), a vector of each option stays in the engine's working memory, under a keyed hash of the option's text and never the text, until newer options push it out or the engine restarts; the state and its memory lines are not kept. And fine-tuning keeps your training cases there, whether or not the job succeeds, and your model if it passes its tests, until you delete the job's model by its name or your account.
  • API keys and passwords are stored only as hashes. The engine answers only Jepela's own API.
  • Forgetting is verified, and deleting a subject removes its lines from memory and disk at once, and its requests from your batches. It does not remove the subject's id from the usage records, your golden cases that name it, or what the engine keeps (above). Decision records for quality reports are deleted after 30 days.
  • EU customers are welcome, with the processing in the US disclosed. A Europe region is planned.
  • This site uses no cookies, no analytics and no trackers, and loads nothing from other servers.
Privacy, DPA and subprocessors

How we measure

  • Every number says where: the date, the place, the model and how many runs. Arithmetic is labelled as arithmetic.
  • Examples are real answers from the gateway, never typed in. The examples page says when memory changed nothing.
  • Demos call the live engine. When it is off, they say so instead of answering.
  • Every answer names its model and checkpoint, and warns about known traps in the request.
  • Quality is yours to check: send feedback on a decision, fit calibration on your own labels, and run golden sets.
  • No multiples. We never say “X times faster than” anything, only what we measured.
Quality and calibration

Jepela and Jev

The same request shape, plus a memory

Jev is TypeSafe AI's System One model. Jepela speaks the same request and answer shape on purpose, so code written for one runs against the other with a new base URL and a model name.

JevJepela
Memorynone; every request is statelessa memory per subject, with recall evidence, comparison and verified forgetting
Where it runstheir cloudJepela's cloud: a hosted API; the United States region is live, a Europe region is planned
Priceper input token, output freethe same: $0.042 per million input tokens, output free
The enginetheir own modelthe Jepela engine, named with its checkpoint in every answer
Speed and cost claimsmultiples against language modelsmeasured numbers only, and where they were measured

Pricing

Pay for what the engine reads

$0.042 per million input tokens, the same way and price as Jev. Output is free, memory writes are free, and a failed request is never charged.

A decision like

$5.38per month
$0.0000054per decision
186,011decisions for $1

Arithmetic: tokens × decisions × $0.042 per million, before VAT. The token counts are the engine's own, measured on 2026-09-24 through api.jepela.com with jepela-english on a 74-character support message; the memory case is the average of the cost cookbook. Your own requests show theirs in usage.input_tokens.

Prepaid, with a ledger

Every priced request is one line in your ledger. GET /v1/usage shows credit, spending and the last requests, and the totals always agree. When credit runs out, decisions answer 402 until it is topped up.

What is free

Output, memory writes, the compare, explain and placebo passes, and any request that failed upstream or in the gateway.

For business customers

Prices exclude VAT and other taxes, which are added where the law requires. Rate limits are per account, counted over all its keys, with a Retry-After header when you go over.

Get started

Your first decision in five minutes

  1. Create an accountSign up and choose your region, United States (live) or Europe (coming). Confirm your email address and pay by card to start at once (the payment approves the account), or wait for Jepela to approve it; then you create API keys, add credit by card or invoice, and see your balance and usage.
  2. Send one requestWith curl, the Python client or the TypeScript client. Keep the key on your server.
  3. Name a subjectWrite what you know with remember, then add "subject" and "memory": {"compare": true} to see what it changed.
export JEPELA_API_KEY=jj_live_us_...

curl -s https://us.api.jepela.com/v1/systemone \
  -H "Authorization: Bearer $JEPELA_API_KEY" -H "Content-Type: application/json" \
  -d '{"state": "You charged me twice for September. Please send the second payment back.",
       "questions": {"refund": {"type": "noul", "instructions": "Is the customer asking for money back?"}}}'
The five-minute guidefrom a key to a decision with memory 25 examplesevery answer produced by the gateway Cookbooksend-to-end recipes that print what they measured Claude and MCPan MCP server and a Claude Code plugin

At a glance

Jepela in one minute

The facts in one place, each one explained further up this page and in the documentation.

What it is
A hosted decision API with memory. Typed questions in, typed answers with probabilities and a confidence out, in one call. It never generates text.
Question types
Choice (one of 1 to 255 options), Score (2 to 10 ordered levels), Noul (the probability of yes). Up to 400 engine questions per request.
Memory
One per subject: remembered and pinned lines, names and aliases, rules with when and exclusions checked in code, verified forgetting. compare, explain and placebo show what it changed.
Price
$0.042 per million input tokens; output and memory writes are free. Prepaid credit with a ledger, for business customers.
Speed
27 ms of engine time for a three-question decision, timed on the engine's server (median of 25, 2026-09-24); the API and the network to it come on top.
Where it runs
Hosted only, in regions: the United States is live, Europe is planned. Your memories and usage stay in your region.
Models
jepela-english, jepela-multilingual (100+ languages) and jepela-typed-decisions; jepela picks by the state's language. Fine-tuning on your own cases.
Compatible with
TypeSafe's Jev request and answer shape, POST /v1/systemone: switch with a new base URL and a model name.
Clients
A Python SDK, a TypeScript client, an MCP server with a Claude Code plugin, and an agent skill.
Licence
A commercial product: a paid, hosted API under the Terms of Service, for business customers. The client libraries are published under Jepela's commercial licence.
Known limits
It does not compare numbers or read negation (rules in code do), reads a window of the state, and reads text only. Every measured limit

Questions

Asked before you build

Is Jepela a chat model?

No. It never generates text. You send a state and typed questions; you get typed answers with probabilities. Use it inside software, for judgments your code then acts on.

What does confidence mean?

For a choice or a score, how concentrated the probabilities are: near 1 when one option dominates, low when they are spread. For a noul it is another scale: the probability of the answer given, the larger of yes and no. Every answer also carries answer_confidence, the probability of the answer given on one scale for all three types. Whether 0.9 means “right nine times in ten” on your data is something to measure on your own labelled examples, and Jepela can fit it to them. Use it as a gate: act above a threshold, confirm in the middle, hand over below.

Why did a rule in memory not work?

Three known reasons, all measured: the engine does not compare numbers, it does not read negation, and lines move answers by being there. Put conditions in code (a rule with when, or derive), remove options that must never be chosen with an exclusion rule, pin what must always count, and check with explain and placebo.

Can I delete everything about a subject?

POST /v1/memory/delete removes the subject's memory and rules from memory and disk at once. forget removes one concept and verifies the removal against recall. The subject's requests leave your batches too, with their results. Your ledger keeps the subject id on each priced request, and golden cases keep the requests that named it until you delete them. Fine-tuning jobs keep the cases they trained on, with the lines recalled for them, until you delete the model. The engine keeps no state or memory line; for a choice it matched by vectors it keeps only a vector of each option, under a keyed hash of its text.

Which languages?

English first. model: jepela reads the language and picks the multilingual checkpoint when the state is not English; it is less measured. Do not name jepela-english for other languages.

What happens when the engine is down?

You get 502 and nothing is charged. Jepela never invents an answer. The SDKs retry with backoff.

Can I train a model on my own cases?

Yes: fine-tuning trains a model of your own on your golden cases (at least 20). It is used only if it beats the standard engine on cases it never saw and still listens to memory, and only your account can use it. Free during the preview.

Can Claude use Jepela?

Yes: there is an MCP server and a Claude Code plugin. See Claude and MCP.

More in the FAQ and troubleshooting, or write to the Jepela team.

Decide with numbers. Remember what matters. See what changed.

Get a key Read the docs