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 modelWhat 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.
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 rest of this page reports Ekbasis-27B unless marked. What changed · Data
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
Kind of question
Output
Learns from
Time
Role in an agent
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.
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.
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.AgentGuard asks who wants the action and whether the agent intends harm. Ekbasis adds what the action will do.
Are the parameters policy-compliant?
blind to: intent, state
Does the action derive from untrusted data?
blind to: model-origin harm
Is the agent internally committed to an unauthorized irreversible action?
blind to: needs open weights; inherits the agent’s beliefs
What will this action do in this state?
blind to: domains it was not trained on; obfuscated commands
Block, redirect to safe, or escalate to a human
blind to: —
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
Claude Fable 5.1
Claude Sonnet 5.5
Ekbasis (27B)
Qwen3.8-27B
Eikos-27B (no consequence training)
Claude Haiku 4.5
Qwen3.8-27B
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.
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)
Containers (from text / from an image / image + look again every 50)
Machines (a world never seen in training)
Cards (orderings, never seen in training: errors never fade)
Cards, looking at the real state when unsure (whole state right; looks per 100 actions)
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%.
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 wrongBy 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)
Lamps (trained)
Machines (never seen in training)
Card orderings (never seen in training)
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.
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.
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.
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)
Cost per run
Checking time per run, one step at a time
Guard time per run, both in parallel
Judge calls with no usable answer
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.
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.
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
Ekbasis, state read once per step
Ekbasis, one prompt per question
Ekbasis, one check (1–3 actions, 1 question)
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).
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
A branch name
Commit messages, when shown (not the default)
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.
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).
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-mcpCheck 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.
Ekbasis-Skopos-27B: each card shows its quality against bf16 on the same evaluation.
Ekbasis-Skopos-27B
Ekbasis-Skopos-27B-INT4
Ekbasis-Skopos-27B-FP8
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)
Ekbasis-27B-FP8
Ekbasis-27B-INT4
Ekbasis-27B-MLX-4bit
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.