Typed decisions inside AI agents

An agent makes small decisions all the time: should this action run, which tool fits, does the user want a person, is this allowed for this user. Asking a language model gives back text that has to be parsed. Jepela answers each check as a typed value with a probability, so the agent's code can branch on it. Use it instead of an LLM for these checks, and keep the control flow in your code.

Typed checks instead of free text

A noul is a yes/no statement, and the answer is the probability of yes. This request from the Noul page asks two of them about one message:

{"state": "I have asked three times now. Can I please just talk to a real person?",
 "questions": {"wants_human": {"type": "noul", "instructions": "Is the customer asking for a human agent?"},
               "repeat_contact": {"type": "noul", "instructions": "Has the customer contacted support about this before?",
                                  "criteria": {"true": "Mentions a prior attempt, ticket, or having asked before",
                                               "false": "No sign of any previous contact"}}}}

The number is both the answer and its certainty. Set the thresholds by the cost of each error, with a band for review:

YES, NO = 0.8, 0.2
if NO < value < YES:
    send_to_human_review()
elif value >= YES:
    take_yes_action()
else:
    take_no_action()

• Ask one thing per question, and combine the answers in code with weights you control.
• Gate each action on confidence: a cheap action can run at a lower confidence than one that moves money, and a middle band can ask the user to confirm.
• Below the gate, hand over to a person.

Picking a tool

A choice holds 1 to 255 options, so a tool list fits in one question. Above 20 options Jepela matches by default: the request and each tool's description become vectors, and the closest wins. Measured on public data on 2026-09-26: matching picked the right function among 672 on 60.0% of 150 questions, against 37.3% for the engine reading them. Matching finds the closest label; it does not judge whether a call is safe, so ask that as its own noul.

MCP server and Claude Code plugin

Jepela ships as an MCP server and a Claude Code plugin, so Claude can make typed decisions with memory as tool calls. With JEPELA_API_KEY set, the install from the Claude and MCP page is:

/plugin marketplace add jepelasweden/jepela
/plugin install jepela@jepela

The server speaks MCP over stdio, so other MCP clients can use it too. Without a key it still starts, and every tool call says how to get one. For coding agents that write software which calls Jepela, the agent skill gives the request shape and the rules on this page.

Memory per user

For an agent, the subject is usually the user. Write what you know once (preferences, opt-outs, plan) and name the user on each call. Jepela recalls the lines that touch the state and lists the ones it used. Subjects are separate per tenant: no request can name another tenant's subject. forget removes a concept and reports it gone only when recall no longer finds it; delete removes the user's whole memory and rules.

Limits go in code

The engine reads; it does not enforce. It does not read negation: a line that names a forbidden option makes it more likely. Measured on 2026-09-26: "Never give player-9 gold coins" as a memory line raised gold coins from 0.63 to 0.98; as an exclusion rule it was 0.00. An exclusion rule removes the option in code before the engine answers, as in this example from the Rules in memory page:

POST /v1/memory/rules
{"subject": "player-9", "text": "Gold coins are off for this player (coin bug).", "exclude": ["gold_coins"], "question": "reward"}

With "memory": {"compare": true} the answer shows what a rule took away, so the agent can refuse and say why instead of doing the runner-up. Measured on 2026-09-29 for the state "lock the screen" and a rule that excludes lock: with memory, none 0.68, sleep 0.32 and lock 0; without memory, lock 0.99.

The engine does not compare numbers or dates either. A rule with when is checked in code on the request's values and the state's fields, and the engine sees its line only when it holds. Measured through the gateway on 2026-09-23: with the stop-loss rule session_result <= -30, the stop answer was 0.11 at −10 (not fired) and 0.80 at −30 (fired).

Measure on your labels

Send the right answer with POST /v1/feedback, or the feedback tool, when you learn it. Then read GET /v1/quality for accuracy, calibration error and automate_at, which gives for the accuracy you need a threshold chosen on your labels and whether thresholds chosen that way reached that accuracy on labels they were not chosen on, with the share of decisions above them. Calibration is fitted on your own labels. Keep a golden set of cases with known answers, and run it before you change a question, a memory or a model.

Limits

• Jepela is not a chat model and does not write code or text: it answers typed questions.
• Answers near a threshold flip on small changes. For expensive actions, require a fired rule or two answers in a row.
• Recall matches words: a fact worded without the terms the state uses is not found. Pin what must always count.
• The MCP tools cover deciding, memory and feedback. Windows, rules, golden sets, batches and calibration are in the API and the SDKs.

Next steps

• Get a key: confirm your email address and pay by card to start at once, or wait for Jepela to approve the account; prepaid credit by card or invoice, $0.042 per million input tokens, output free.
• Claude and MCP and Agent skill: the plugin, the server and the skill.
• Rules in memory: exclusion rules, rules with when, pinned lines.
• Patterns and Cookbooks: how to build with it, with measured results.
• All use cases