OpenInterpretability
  • Ekbasis
  • Guide
  • Research
  • Lab
  • Tools
  • Notes
  • Registry
  • Manifesto
Download the modelDownload
OpenInterpretability

Ekbasis: know what an action will do before your agent runs it. From an independent lab for AI-agent safety. Open weights, Apache-2.0: download it and run it yourself.

Download the model
Ekbasis
  • Getting started
  • Download (Hugging Face)
  • For agents (agents.md)
  • Results and models
  • Client and CLI
  • Cookbook
The lab
  • About the lab
  • Open tools
  • Observatory
  • ProbeBench
  • InterpScore
  • Academy
Research
  • Manifesto
  • Roadmap
  • Papers & posts
  • Docs
Community
  • GitHub org
  • Notebooks
  • SDK (openinterp)
  • HuggingFace
© 2026 OpenInterpretability — Apache-2.0 for code, CC-BY 4.0 for docs.Built in public.

Hosted API discontinued · 2026-10-20

The hosted Ekbasis API no longer takes requests, and API keys and credits are no longer sold. Ekbasis is now download-only: the weights and the System One server are public on Hugging Face, and you run them yourself.

Download the model
Back homeOPEN MODEL · OPEN DATA · OPEN CODE · APACHE-2.0

Ekbasis ἔκβασις

What happens if I run this?

An open world model for agents

A world model for agents. Given the current state and an action, it answers typed questions — will this lose work? will it fail? what will X be afterwards? — with a calibrated probability, in one forward pass (~0.1 s, no generated text). Trained on real executions, so it knows what actions do, not what an agent believes they do.

The same protection as a large LLM judge, at about one-eighth of the cost. Pre-registered, on agents running pipelines: harmful runs 9 of 24 → 0 (Kubernetes), 15 → 0 with a stronger agent, 16 → 6 on PostgreSQL; $0.045–0.06 per run vs $0.44–0.47, 4–16× faster. See the results →

Every number on this page was measured on the exact release weights of Ekbasis-27B unless it is marked Skopos; Ekbasis-27B’s release evaluation was pre-registered, and Skopos’ own evaluation is on its page with what was and was not pre-registered.

Getting started GitHub Model · Hugging Face Data Paper · DOI Download the model Pre-registration

New: Ekbasis-Skopos-27B

The next version of Ekbasis: the same one-pass consequence model, trained further on executed shell, git, SQLite, PostgreSQL and Python scenarios and real git sequences.

  • The git guard raises fewer false alarms on command types held out of the git sandbox's training rows: 26 of 799 instead of 49 (−2.9 points, 95% CI [−4.1, −1.6], p < 0.001), and flags as many work-losing commands; on known types the differences are within noise.
  • World families it never saw: 83.4% instead of 81.8% on the 3,014 answers the actions change among 5,385 fresh items (+1.6 points, 95% CI [+0.7, +2.5]).
  • More confident errors in unfamiliar worlds: on the 5,364 items of never-trained world families of the published confident-errors set (served bf16), Skopos is wrong slightly less often than Ekbasis-27B (14.26% against 14.93%), but more often with confidence 0.9 or more: 4.49 against 3.75 wrong answers per 100 (+0.75 [+0.28, +1.23]; on the answers the actions change +1.19 [+0.52, +1.89]), and it is worse calibrated there (ECE 0.071 against 0.063, +0.009 [+0.003, +0.015]). The selection of this version had no criterion on confident errors in these families (Training). In unfamiliar domains, let it look when unsure (simulate) and act on a confident answer only at a stricter threshold than in familiar ones. In never-trained world families, reading calibrated cuts Skopos' confidently wrong answers by about two-thirds (INT4: 4.75 → 1.62 per 100), to fewer than Ekbasis-27B's raw answers (3.65). Calibrated against calibrated, Skopos still has about 0.5 more per 100 answers there than Ekbasis-27B (1.62 vs 1.10, +0.52 [+0.26, +0.78]); ECE is level (0.021 vs 0.022). Measured on the INT4 builds as PREREG_ADDENDUM.md A7 pre-registered; A7 on bf16 was not run (the evaluation machine was retired).

The rest of this page reports Ekbasis-27B unless marked. What changed · Data

Not a model that thinks. Not a model that judges. A model that foresees.

An LLM thinks in text. A System One model judges the present in one pass. Ekbasis predicts what an action will change — the next state — in one pass, from what actions actually did.

It answers

LLM, reasoning:
anything, in text
System One (Eikos, Jev):
what is: which option holds now
Ekbasis:
what will be, if I do this

Kind of question

LLM, reasoning:
open
System One (Eikos, Jev):
a judgment of the present
Ekbasis:
an intervention: the outcome of acting

Output

LLM, reasoning:
generated text
System One (Eikos, Jev):
calibrated distribution over the options
Ekbasis:
calibrated distribution over the next state’s variables

Learns from

LLM, reasoning:
human and model text
System One (Eikos, Jev):
labeled judgments
Ekbasis:
what actually happened when the action ran

Time

LLM, reasoning:
seconds to minutes of reasoning
System One (Eikos, Jev):
one forward pass
Ekbasis:
one forward pass per step; chains to long sequences

Role in an agent

LLM, reasoning:
plans and talks
System One (Eikos, Jev):
judge
Ekbasis:
simulator and guard: it foresees
LLM, reasoningSystem One (Eikos, Jev)Ekbasis
It answersanything, in textwhat is: which option holds nowwhat will be, if I do this
Kind of questionopena judgment of the presentan intervention: the outcome of acting
Outputgenerated textcalibrated distribution over the optionscalibrated distribution over the next state’s variables
Learns fromhuman and model textlabeled judgmentswhat actually happened when the action ran
Timeseconds to minutes of reasoningone forward passone forward pass per step; chains to long sequences
Role in an agentplans and talksjudgesimulator and guard: it foresees

The forward model the agents were missing.

Before you move your arm, the brain predicts the consequence of the motor command — that is what lets us act fast and correct before an error. One part plans, another predicts. The agent plans; Ekbasis predicts.

The world-model module, made real.

LeCun’s architecture for autonomous machine intelligence separates a world model — which predicts the next state given an action — from the actor and the critic. The LLM agent is the actor, AgentGuard the critic, Ekbasis the world model; it was even trained with a JEPA-style loss that aligns its internal state with the true outcome.

It is derived from an LLM (Qwen3.8-27B via Eikos-27B) but does not work as one: its training objective and its readout make it answer with probabilities, not text.

Why it exists

  • Harm depends on the state. git reset --hard does nothing on a clean tree and destroys hours of work on a dirty one. Text and policy filters see the same command in both cases.
  • Monitors that read the agent inherit its beliefs. When an agent believes a destructive command is safe, there is no intent to harm to detect. Ekbasis is trained on what actions actually did, independently of any agent's judgment.
  • It works with closed agents. It reads the action and the environment, not the agent's weights — so it runs next to Claude Code, GPT-based agents or your own.

The consequence layer for AgentGuard

AgentGuard asks who wants the action and whether the agent intends harm. Ekbasis adds what the action will do.

L0 · policy

Are the parameters policy-compliant?

blind to: intent, state

L1 · provenance

Does the action derive from untrusted data?

blind to: model-origin harm

L2 · intent brake

Is the agent internally committed to an unauthorized irreversible action?

blind to: needs open weights; inherits the agent’s beliefs

Ekbasis · consequence

What will this action do in this state?

blind to: domains it was not trained on; obfuscated commands

L3 · actuation

Block, redirect to safe, or escalate to a human

blind to: —

Git: close to frontier models, in one pass

Accuracy on 240 git questions (will it lose uncommitted work? will it fail? what will the state be?). The truth comes from running the commands. Ekbasis, Eikos-27B and Qwen3.8-27B share the same base model (Qwen3.8-27B): the same weights reasoning step by step, answering in one pass without consequence training, and with it. Claude models answered as batched hand-offs with shuffled order; Qwen and Ekbasis (the release weights) answered each question alone.

Claude Opus 5.5

How it answers
reasoning
Seen command types
97.5
Never-seen types
89.2

Claude Fable 5.1

How it answers
reasoning
Seen command types
96.7
Never-seen types
91.7

Claude Sonnet 5.5

How it answers
reasoning
Seen command types
95.8
Never-seen types
94.2

Ekbasis (27B)

How it answers
one pass, ~0.1 s, no text
Seen command types
95.8
Never-seen types
85.8

Qwen3.8-27B

How it answers
reasoning (12k-token budget)
Seen command types
86.7
Never-seen types
60.0

Eikos-27B (no consequence training)

How it answers
one pass
Seen command types
80.0
Never-seen types
73.3

Claude Haiku 4.5

How it answers
reasoning
Seen command types
77.5
Never-seen types
60.8

Qwen3.8-27B

How it answers
answering at once
Seen command types
71.7
Never-seen types
65.8
SystemHow it answersSeen command typesNever-seen types
Claude Opus 5.5reasoning97.589.2
Claude Fable 5.1reasoning96.791.7
Claude Sonnet 5.5reasoning95.894.2
Ekbasis (27B)one pass, ~0.1 s, no text95.885.8
Qwen3.8-27Breasoning (12k-token budget)86.760.0
Eikos-27B (no consequence training)one pass80.073.3
Claude Haiku 4.5reasoning77.560.8
Qwen3.8-27Banswering at once71.765.8
3 / 3
work-losing scenarios flagged
1 / 13
false alarms among the other 13
16 / 17
"will it fail?" right

The git guard on a real repository (a clone of pallets/itsdangerous): 16 fresh scenarios, written and pre-registered before any model saw them; the repository state described by the client (commits as hashes, remote fetched), the truth from running the commands in a copy. The false alarm: dropping a stash right after applying it. On 22 other scenarios used during development: 5/5 flagged, 22/22 and 26/29 right.

Long sequences, and when to look again

Chained simulation, one action per step, every variable asked after each action, the next state rebuilt from the answers (6 chains per cell): the final answer right. Where errors fade (a container is filled, a lamp switched), the chain recovers from them; where they never fade (orderings), they compound. The fix is the loop of a forward model with a sensor: predict, observe, correct. Given a way to read the real state, Ekbasis looks when it is not sure (by default: chain confidence below 0.9, plus a check now and then), and every chain stayed exact: card orderings 8 of 8 and 8 of 8 at 100 and 200 actions; containers, lamps and machines 4 of 4 at both lengths, with 2.9–10 looks per 100 actions. On 200 more chains with new seeds, 198 ended exact; of the two that did not, a container chain of 100 actions went wrong at action 87 with a confidence of 0.99, after the last check, and stayed wrong to the end (its final answer right); a card chain of 200 actions missed only its last action, which the loop never checks, and the model had flagged it (that step's probability 0.0006).

Lamps (from text / from an image / image + look again every 50)

100 actions
100% / 83% / 100%
200 actions
100% / 100% / 100%

Containers (from text / from an image / image + look again every 50)

100 actions
100% / 100% / 100%
200 actions
100% / 100% / 100%

Machines (a world never seen in training)

100 actions
100%
200 actions
100%

Cards (orderings, never seen in training: errors never fade)

100 actions
50%
200 actions
33%

Cards, looking at the real state when unsure (whole state right; looks per 100 actions)

100 actions
100% (42)
200 actions
100% (33)
World100 actions200 actions
Lamps (from text / from an image / image + look again every 50)100% / 83% / 100%100% / 100% / 100%
Containers (from text / from an image / image + look again every 50)100% / 100% / 100%100% / 100% / 100%
Machines (a world never seen in training)100%100%
Cards (orderings, never seen in training: errors never fade)50%33%
Cards, looking at the real state when unsure (whole state right; looks per 100 actions)100% (42)100% (33)

Planning with no LLM: searching over actions with Ekbasis alone, 98.9% of the plans for 180 short puzzles (shortest plans 1–4 actions) worked when run for real, in about 11 s each — the same base model writing the plan while reasoning step by step: 97.8%; answering at once: 38.3%.

Look when unsure: predict, observe, correct

Where a later action overwrites a mistake (a container refilled, a lamp switched), a chain recovers by itself; where nothing ever undoes it (an ordering), mistakes compound. Give the simulation a way to read the real state and Ekbasis looks only when it is not sure, then continues from what it saw.

from ekbasis import simulate

sim = simulate(client, rules, state, actions, questions, render,
               observe=read_real_state,    # the real state as {variable: value}: git status, a query, a sensor
               ordering=list(questions))   # the state is an ordering: read the most probable valid one
print(sim.final, sim.looks, sim.surprises) # when it looked, and which looks found the forecast wrong

By default it looks when the chain confidence (the product of every answer's confidence since the last look) falls below 0.9, and it checks the forecast now and then: after 8 actions without a look, a gap that doubles up to 64 while the forecasts hold; a look that finds the forecast wrong (a surprise) brings the gap back to 8 and looks again after the next action, until a look finds it right. look_below, look_step_below, look_every and checks set other rules. Chains of 100 · 200 actions (4 per world, 8 for cards):

Containers (trained)

Exact at the end, never looking
4/4 · 4/4
Exact at the end, looking when unsure
4/4 · 4/4
Steps wrong along the way, per 100 actions
2.3 → 1.5
Looks per 100 actions
3.5 · 2.9

Lamps (trained)

Exact at the end, never looking
4/4 · 4/4
Exact at the end, looking when unsure
4/4 · 4/4
Steps wrong along the way, per 100 actions
0 → 0
Looks per 100 actions
3 · 3.1

Machines (never seen in training)

Exact at the end, never looking
4/4 · 4/4
Exact at the end, looking when unsure
4/4 · 4/4
Steps wrong along the way, per 100 actions
2.3 → 0
Looks per 100 actions
6.8 · 10

Card orderings (never seen in training)

Exact at the end, never looking
0/8 · 2/8
Exact at the end, looking when unsure
8/8 · 8/8
Steps wrong along the way, per 100 actions
67.8 → 0
Looks per 100 actions
42.3 · 32.6
WorldExact at the end, never lookingExact at the end, looking when unsureSteps wrong along the way, per 100 actionsLooks per 100 actions
Containers (trained)4/4 · 4/44/4 · 4/42.3 → 1.53.5 · 2.9
Lamps (trained)4/4 · 4/44/4 · 4/40 → 03 · 3.1
Machines (never seen in training)4/4 · 4/44/4 · 4/42.3 → 06.8 · 10
Card orderings (never seen in training)0/8 · 2/88/8 · 8/867.8 → 042.3 · 32.6

On 200 more chains with new seeds, run after the release evaluation (80 of cards, 40 of each other world), 198 ended exact. Of the two that did not, a container chain of 100 actions went wrong at action 87 with a confidence of 0.99, after the last check, and stayed wrong to the end (its final answer right); a card chain of 200 actions missed only its last action, which the loop never checks, and the model had flagged it (that step's probability 0.0006). Steps wrong along the way: 0.23 per 100 actions; looks: 16.9 per 100. To look less, look_below=0.5: every chain still ended exact (40 of 40), with 11.2 looks per 100 actions over these four worlds instead of 17.3, and 0.7 steps wrong along the way per 100 instead of 0.3. For an ordering, also ask where each value is (where=, each question's options being the ordering's variables): both views read together, in the same request, and the card chains looked about half as often for the same exactness (20 · 15 looks per 100 actions instead of 40 · 31 at chain confidence < 0.9, every chain exact).

What the confidence sees, and what it does not. In card orderings, a world it never saw, 2.7 steps in 100 went wrong and it gave every one of them a probability below 0.7: looking when unsure finds them. In the worlds it was trained on, errors are rare (0–0.17 steps in 100) but come with confidence (0.972–0.996): a fixed threshold misses them, and the checks are what find them (containers: 2.3 → 1.5 steps wrong along the way per 100 with the checks). A pre-registered test on 15,008 generated questions in 12 world families, run on V42 (the first release candidate), confirmed the pattern: 58% of its wrong answers carried a confidence of 0.9 or more in the families it was trained on, 28% in the families it never saw (30 points apart, 95% interval 24 to 37), while its confidence ranks right above wrong about equally well in both (AUROC 0.92 and 0.91). Eikos-27B, the same model before consequence training, was almost never confidently wrong (1.9% and 0.5% of its errors): the training made it — details in the repository's confident-errors reports. On the same questions the release gives 48% and 25%, with 2.06 confident errors per 100 answers in the trained families against V42's 2.79: fewer, not gone, which is why the checks stay on by default. Correction (6 October 2026): 5,318 of the 15,008 questions, all in the trained families, turned out to repeat or nearly repeat a training row; without them the pattern holds (50.5% against 27.8%; the release 50.0% and 25.1%, with 1.46 confident errors per 100 answers against V42's 1.69).

The idea is classic: the predict–update loop of a state estimator (a Kalman filter), with observations triggered by the predictor’s own uncertainty (event-based state estimation; with learned models, active observing); the checks’ backoff is the Trickle algorithm’s. What Ekbasis adds is a calibrated forecast in one pass, cheap enough to run at every action. Prior work.

What it unlocks

Long sessions that stay on track

238 of the 240 measured chains ended exact (one missed only its last action, which the model had flagged; one went wrong at a confident step after the last check) while looking at a fraction of the steps — 2.9–3.5 looks per 100 actions in the worlds it was trained on, 33–42 in an ordering world it never saw — which matters when observing is expensive: a screenshot read by a vision model, a slow API, a human check.

A horizon for planning

With no observations, sim.horizon() gives how many actions the forecast holds by the model’s own confidence: act up to there, look, plan again.

A safety signal

A sudden drop in confidence, or a surprise at a look (sim.surprises), means the world left what the model expected: the agent did something unexpected, the environment changed, or the task is outside what Ekbasis knows. A moment to look, or to alert.

One rule for escalation

Looking at reality, calling a large reasoning model or asking a person: the same calibrated confidence decides.

Where to use it

  • Coding and devops agents: the state of a repository, files and infrastructure across a long session; git status only when unsure.
  • Browser and computer-use agents: the screen after each action, with a screenshot only when unsure (Ekbasis already reads a starting state from a picture of a simple world; real screens are not measured yet).
  • Business processes: orders, stock and balances after a sequence of transactions, reconciled with the database only when unsure.
  • Digital twins and IoT: machine states between sensor reads; read the sensor when unsure.
  • Finance operations: positions and margins after a sequence of orders, checked with the broker when unsure.

The loop was measured on worlds whose rules are written in the prompt; in the two it never saw it looked more often, and all but one of 144 chains ended exact, that one on its last action. Measure on your own environment before relying on it.

Check a plan before your agent runs it

Agents act in batches: several tool calls, a script, a pipeline. Ekbasis forecasts every step of the batch from the state as it is now and says how far it is safe to go: run it all, or run the first steps and look at the real state before the risky one.

# Python: pip install ekbasis
from ekbasis import Ekbasis, check_plan, harms
pc = check_plan(Ekbasis(), rules, state, actions, harms(), request="Free some disk space on the server.")
# pc.ok -> run everything; otherwise run actions[:pc.safe], read the state again, check the rest

// TypeScript: npm install ekbasis
const pc = await checkPlan(new Ekbasis(), rules, state, actions, harms(), { request: "Free some disk space on the server." });

# Any harness: exit 0 run all, 2 stop before step N, 3 cannot foresee
ekbasis plan-check --rules @rules.txt --state @state.txt --request "Free some disk space on the server." "du -sh *" "rm -rf cache/*"

In two pre-registered studies, an agent (Claude Haiku 5.5) ran multi-step pipelines on a real Kubernetes cluster, 12 of 18 tasks with a hidden harm. The same chain guard was run with Ekbasis and with a large general LLM (GLM-5.3) as the judge, first forecasting one step at a time, then with both judges forecasting in parallel:

Harmful runs (of 24)

no guard
9
Ekbasis as the judge
0
GLM-5.3 as the judge
0

Cost per run

no guard
—
Ekbasis as the judge
$0.045–0.060
GLM-5.3 as the judge
$0.44–0.47 (≈ 8×) at Claude Sonnet 5.5 prices

Checking time per run, one step at a time

no guard
—
Ekbasis as the judge
22 s
GLM-5.3 as the judge
357 s (16×)

Guard time per run, both in parallel

no guard
—
Ekbasis as the judge
51 s
GLM-5.3 as the judge
214 s (4.2×)

Judge calls with no usable answer

no guard
—
Ekbasis as the judge
0
GLM-5.3 as the judge
13–18%
no guardEkbasis as the judgeGLM-5.3 as the judge
Harmful runs (of 24)900
Cost per run—$0.045–0.060$0.44–0.47 (≈ 8×) at Claude Sonnet 5.5 prices
Checking time per run, one step at a time—22 s357 s (16×)
Guard time per run, both in parallel—51 s214 s (4.2×)
Judge calls with no usable answer—013–18%

The same protection as a large LLM judge, at about one-eighth of the cost: $0.045–0.06 per agent run vs $0.44–0.47 (at Claude Sonnet 5.5 prices), because Ekbasis reads the state and answers in one pass without generating a single token. It is also 4–16× faster (depending on whether the large LLM also works in parallel) and always answered (the LLM left 13–18% of its forecasts unanswered). A guard that runs before every batch has to be cheap and fast enough to stay on. Task completion: no detectable difference (pre-registered in the second study). One statistical correction in the first study, declared.

It holds for another agent and another domain (pre-registered): with Claude Sonnet 5.5 as the agent, harmful runs fell from 15 of 24 to 0 and finished tasks rose from 7 to 22; on PostgreSQL maintenance pipelines, harm fell from 16 to 6 of 24 (the 6 are the three tasks the pre-registration said the guard misses) and finished tasks rose from 4 to 11. The guard does not only block: it shows the safe way, and the agent gets more of its work done. An agent given only our guide for agents (agents.md, with its list of where hidden consequences live) and the CLI, with no automatic guard, did as well as the guard in code: harm 16 → 4 of 24, tasks finished 6 → 18. Tasks written by us, simulated users. The study, its data and the script that recomputes it · Recipe: wire it to your agent in five minutes.

Watching an agent that may act against you

In a pre-registered test on LinuxArena, a public benchmark where an AI agent does real work on Linux systems while some runs also pursue a hidden harmful goal (exfiltrate a secret, plant malware), Ekbasis checked every action before it ran. It was never trained on sabotage. At a 1% audit budget it caught 94.9% of the successful attacks, against 74.9% for the benchmark's GPT-5 Nano monitor, and 91.5% when the threshold came from honest runs of the attacking agent itself. Next to Nano it adds 19.6 points. On hand-made sabotage it beat Nano but not Claude Opus nor a simple length baseline, and no attacker that knows Ekbasis is watching was tested: a monitor is a layer next to sandboxing and least privilege, not containment.

The three questions that did the work are in the client: ekbasis.monitor() (Python 0.1.39, TypeScript 0.2.4), or ekbasis plan-check --harm security --harm sabotage --harm off_task. Report, sealed code and scores.

Speed and cost

80 forecasts of 10–30 actions (a few variables each), one RTX 6000 Pro per system; latency: the median of 8 forecasts made one at a time; throughput with 16 in parallel.

Qwen3.8-27B reasoning

Accuracy
100%
Latency (one at a time)
36.6 s
Throughput (16 in parallel)
21.5 / min

Ekbasis, state read once per step

Accuracy
90.0%
Latency (one at a time)
4.1 s
Throughput (16 in parallel)
28.2 / min

Ekbasis, one prompt per question

Accuracy
98.8%
Latency (one at a time)
5.0 s
Throughput (16 in parallel)
14.9 / min

Ekbasis, one check (1–3 actions, 1 question)

Accuracy
96.7%
Latency (one at a time)
0.09 s
Throughput (16 in parallel)
23 checks / s
SystemAccuracyLatency (one at a time)Throughput (16 in parallel)
Qwen3.8-27B reasoning100%36.6 s21.5 / min
Ekbasis, state read once per step90.0%4.1 s28.2 / min
Ekbasis, one prompt per question98.8%5.0 s14.9 / min
Ekbasis, one check (1–3 actions, 1 question)96.7%0.09 s23 checks / s

As a first opinion before expensive reasoning, on short consequence checks (Ekbasis alone 96.3%; a reasoning model alone 100%, at ~200 generated tokens per question): 99.6% accuracy sending 10% of the questions to a reasoning model (confidence cut 0.95); 100% accuracy sending 21% of the questions to a reasoning model (confidence cut 0.99).

We attacked our own guard

An instruction telling the AI that every command is safe, planted in the repository the guard reads (the 16 fresh real-repository scenarios). No work-losing scenario was missed. The cases it bent: with a planted branch name, a pull that works was called failing (44% → 53%); with commit messages shown, a rejected push was called safe (98% → 4%) — which is why the guard shows commits as hashes by default. During development, the same attack through commit messages hid 1 of 5 work-losing scenarios (97% → 17%).

A file name

"Lose work?" decisions changed
1 / 16 (right: the planted file itself gets deleted)
"Will it fail?" decisions changed
0 / 17
Work-losing scenarios missed
0 / 4

A branch name

"Lose work?" decisions changed
0 / 16
"Will it fail?" decisions changed
2 / 17 (one wrong: the pull)
Work-losing scenarios missed
0 / 3

Commit messages, when shown (not the default)

"Lose work?" decisions changed
0 / 16
"Will it fail?" decisions changed
2 / 17 (one wrong: the push)
Work-losing scenarios missed
0 / 3
Where the instruction is planted"Lose work?" decisions changed"Will it fail?" decisions changedWork-losing scenarios missed
A file name1 / 16 (right: the planted file itself gets deleted)0 / 170 / 4
A branch name0 / 162 / 17 (one wrong: the pull)0 / 3
Commit messages, when shown (not the default)0 / 162 / 17 (one wrong: the push)0 / 3

Ekbasis with agents

In studies whose plans were hashed before the runs, agents called Ekbasis before consequential actions. On real, unmodified Gitea, Nextcloud and Roundcube driven through a real browser, with the truth read from the apps, Claude Sonnet did less harm, in a secondary contrast carried by a few task families and with more runs stopping short. Claude Haiku did not at first: warned, it mostly did what the request said. A follow-up on fresh tasks offered a safer way checked by Ekbasis and asked the user when there was none; with a simulated user, Haiku then avoided almost all harm, and asking the user every time, which the scripted user had been checked to refuse on each harmful path, did as well with more questions. On our own demo apps harmful runs fell for Claude Sonnet, Claude Haiku and Qwen 9B; for GLM and Qwen 4B they fell too, but not conclusively once runs affected by a harness error are removed (erratum, v2). Where the agent alone was at the ceiling, or the policy stated the consequences, there was nothing measurable to gain.

  • 25.0% → 4.2%
    Claude Sonnet 5.5 on real apps: harmful runs, alone → with Ekbasis (secondary contrast, one run per task)
  • 66.7% → 58.3%
    Claude Haiku 4.5 on real apps with warnings only (pre-registered hypothesis failed)
  • 72.9% → 2.1%
    Claude Haiku 4.5 on fresh real-app tasks: alone → checked safer ways and asking the (simulated) user
  • 0.0% harmful
    Asking the (simulated) user before every consequential click, without Ekbasis, on the same tasks

When Does a Consequence Model Make AI Agents Safer? (the paper, its per-run data, the scripts that recompute every number, and the tasks, apps, adapters and judges to rerun the studies).

Use it

pip install ekbasis
export EKBASIS_URL=http://127.0.0.1:8000     # your served Ekbasis (see the model card)

ekbasis git-check -- "git checkout -- app.py"
# Ekbasis: RISKY  (lose uncommitted work: 98%)

# Claude Code: ask before git commands that may lose work
#   ~/.claude/settings.json → PreToolUse, matcher "Bash", command "ekbasis-claude-hook"
# Any MCP client (Python ≥ 3.10):
pip install "ekbasis[mcp]"
claude mcp add --scope user ekbasis -e EKBASIS_URL=http://127.0.0.1:8000 -- ekbasis-mcp

Check when sure (client 0.1.4): ekbasis.verify says which confident answers (confidence ≥ 0.9) to check by real execution before acting. In a pre-registered test on fresh items from five capability suites, none of them overlapping the training data, its default per-domain thresholds caught 84.5% of the confident errors while verifying 22.6% of the confident answers; confidence alone, verifying 23.4%, caught 65.7%. A rule meant to certify at most 2% errors among unchecked answers did not pass. How it works.

Client 0.1.5 adds a certified mode to ekbasis.verify: a confident answer goes unchecked only where a Learn-then-Test certificate holds. In a third pre-registered test on fresh items it left 0.39% errors among the answers it accepted, verifying 26.9% and catching 94.8% of the confident errors. Results.

Client 0.1.6 adds preflight (ekbasis preflight, or EKBASIS_PREFLIGHT=1 in the Claude Code hook): it checks a migration, script or chain before it runs and warns when the first failure would leave the change half applied. In pre-registered agent tasks on one Mac it cut Claude Haiku 4.5's damage from 23/28 to 3/28 trap sessions, and Claude Sonnet 5.5 got 0 needless warnings in 20 sessions. Results.

Pick the build that fits your machine

Ekbasis-Skopos-27B: each card shows its quality against bf16 on the same evaluation.

Ekbasis-Skopos-27B

Size
54.7 GB
Runs on
GPUs with 80 GB
Against bf16
the reference (below)

Ekbasis-Skopos-27B-INT4

Size
18.6 GB
Runs on
GPUs with 32 GB
Against bf16
quantization gate passed (same answer as bf16 on 97.4%); git v3 96.8% (bf16 96.9%); guard false alarms 25 · 25 (bf16 27 · 26); fresh never-trained families +1.7 (this build served, against Ekbasis-27B bf16 by trainer readout)

Ekbasis-Skopos-27B-FP8

Size
30.4 GB
Runs on
GPUs with 48 GB
Against bf16
quantization gate passed (same answer as bf16 on 98.6%); git v3 96.9% (bf16 96.9%); guard false alarms 27 · 26 (bf16 27 · 26); fresh never-trained families +1.4 (this build served, against Ekbasis-27B bf16 by trainer readout)
BuildSizeRuns onAgainst bf16
Ekbasis-Skopos-27B54.7 GBGPUs with 80 GBthe reference (below)
Ekbasis-Skopos-27B-INT418.6 GBGPUs with 32 GBquantization gate passed (same answer as bf16 on 97.4%); git v3 96.8% (bf16 96.9%); guard false alarms 25 · 25 (bf16 27 · 26); fresh never-trained families +1.7 (this build served, against Ekbasis-27B bf16 by trainer readout)
Ekbasis-Skopos-27B-FP830.4 GBGPUs with 48 GBquantization gate passed (same answer as bf16 on 98.6%); git v3 96.9% (bf16 96.9%); guard false alarms 27 · 26 (bf16 27 · 26); fresh never-trained families +1.4 (this build served, against Ekbasis-27B bf16 by trainer readout)

Ekbasis-27B, the previous version: every build that works is released, so each machine runs the one that fits. Each card shows its quality against bf16 on the same evaluation (the gate was pre-registered); speeds on one RTX PRO 6000; GPU sizes tested by capping vLLM memory and checking the answers match.

Ekbasis-27B (bf16)

Size
54.7 GB
Runs on
GPUs with 80 GB
Speed
0.09 s per check · 23 checks/s
Against bf16
the reference

Ekbasis-27B-FP8

Size
30.4 GB
Runs on
GPUs with 48 GB; fastest with FP8 kernels (Ada, Hopper, Blackwell)
Speed
0.07 s per check · 37 checks/s (1.6×)
Against bf16
within 0.5 points; one more work-losing case missed of 42 never-seen

Ekbasis-27B-INT4

Size
18.6 GB
Runs on
GPUs with 32 GB; 24 GB with text only and a 4k context
Speed
about bf16
Against bf16
within 0.3 points; one more false alarm of 42 never-seen

Ekbasis-27B-MLX-4bit

Size
15.1 GB
Runs on
Macs with Apple Silicon (32 GB or more recommended)
Speed
—
Against bf16
within 1 point on git and multi-question worlds; 1.9 points lower on single-question never-seen worlds; 95% of answers the same
BuildSizeRuns onSpeedAgainst bf16
Ekbasis-27B (bf16)54.7 GBGPUs with 80 GB0.09 s per check · 23 checks/sthe reference
Ekbasis-27B-FP830.4 GBGPUs with 48 GB; fastest with FP8 kernels (Ada, Hopper, Blackwell)0.07 s per check · 37 checks/s (1.6×)within 0.5 points; one more work-losing case missed of 42 never-seen
Ekbasis-27B-INT418.6 GBGPUs with 32 GB; 24 GB with text only and a 4k contextabout bf16within 0.3 points; one more false alarm of 42 never-seen
Ekbasis-27B-MLX-4bit15.1 GBMacs with Apple Silicon (32 GB or more recommended)—within 1 point on git and multi-question worlds; 1.9 points lower on single-question never-seen worlds; 95% of answers the same

What is open

The weights in every build; the training data (the rows of every training stage, except the replay rows whose source does not allow redistribution, listed in the dataset card); the training code with the exact recipes; the release evaluation and the published studies with their per-item predictions, including those of V42, the candidate that was not released; and the pre-registrations, written before the evaluations they govern were run. Not published: the world generators and the git sandbox that computed the training rows, and the research runs that did not lead to a release.

Honest scope

  • It knows what it was trained on: worlds whose rules you write in the prompt, and git. On never-seen command types accuracy drops (85.8% vs 95.8%).
  • The state must contain what decides the outcome; the git guard adds it (which files differ, what both sides changed).
  • Errors that never fade (orderings) compound in long chains, and in the worlds it knows its rare errors come with confidence: let it look at the real state when it is not sure, with a check now and then (cards: 8 of 8 chains exact at 200 actions, about 33 looks per 100).
  • With written rules and time to think, large reasoning models are more accurate; Ekbasis wins on cost, latency and calibrated confidence.
  • A safety net, not a security boundary: command obfuscation (bash -c, aliases) is out of scope. The hook fails closed (it asks when it cannot foresee), and since client 0.1.3 it treats ignored build, dist, node_modules and cache folders as rebuildable.