Every figure on this page is a measured run
with committed artifacts.
Benchmarked on the JevBench public split — 231 items, run by the benchmark's own harness, scored by their rules, on a fanless-cheap CPU box. No cherry-picking, no training on the test set, and an adversarial audit of our own benchmark generator (see Integrity).
Where we win today
- Speed. The deterministic engine decides in a median of 2.0 ms per item — roughly 300× faster than a raw 4B LLM prompted for the same answers (651 ms), and the full escalation stack still medians under 150 ms because most items never reach the model.
- Cost. Modeled at $0.007 per 1M decisions on the third-party board's own pricing basis — ~125× under the cheapest row on that board (verdict-small, $0.87/1M) and ~4,600× under the hosted-Jev reference ($32/1M). On your own hardware the marginal cost is your electricity: CPU-only, offline, no accounts, no metered API.
- Open accuracy leadership. Our 4B-class model rung scores 76.6% on the public split — ahead of every purpose-built open model published on it (Kev-4B 73.7, Jev-Style-2B 73.6, decider-2b 71.0, Laya 58.4).
- Determinism. 231/231 bit-identical replay — predictions and probability vectors. Same input, same answer, forever, or it's a bug we track.
- Trustworthy confidence. ECE 0.070 on the split, with abstention and verify outcomes instead of confident nonsense.
Claims we refuse to make
- "Beats hosted Jev on accuracy." It doesn't — yet. Hosted Jev scores 86.6% on the split; our best rung is 76.6%. We beat it on latency, cost, privacy and determinism, and our full-system ladder re-run is queued. When we pass it, you'll see the run artifacts, not a vibe.
- One accuracy number for every benchmark. Our gate scores 93.3% on our internal audited suite and 89.2% on its held-out twin — and 76.6% on JevBench. Different suites, different numbers. One number per benchmark, always labeled, always with its source.
- "Confident" because softmax said so. Raw probability ≠ calibrated confidence. Ours is fitted per rung, versioned into every cache key, and audited.
Sensitivity warning from the field: the same model can score 0.77 on one benchmark and
~0.0-scaled intel on another. We publish the divergence table in
docs/RESEARCH.md §14 so nobody — including us — can hide behind a cherry-picked suite.
The escalation ladder: cheap mechanisms decide,
the model pays only for the hard stuff.
A decision cascades down the rungs until one of them is confident enough to accept — and stops there. Click a rung. Then run the three real scenarios below; the latencies shown are from the actual measurement runs.
relational proofs over extracted facts
versioned, byte-stable replay
provably-out candidates removed
hand-written scorer, gated accept
static-table semantic scoring
4B parallel readout, tail only
one gated shot on disagreement
Confidence you can automate against.
Raw softmax output is not calibrated confidence — so OpenCodifier never exposes it raw. Confidence is multi-dimensional (top probability, margin, entropy, out-of-distribution evidence, verifier agreement), fitted per rung, and versioned into every cache key. When confidence is low, the runtime abstains or escalates — and abstention is a successful outcome, never an error.
ECE, model rung
Expected calibration error on the 231-item public split — fitted with per-cardinality temperature buckets, because confidence on a 4-way board is a different animal than on a 20-way one.
ECE, full ladder
The fusion gate on the held-out twin of our internal suite — 120 items the gate never saw, from a generator it never saw, hardened by an adversarial audit first.
outcomes, not one
Accept (with calibrated confidence), verify (send it to the gated verifier), or abstain. Never silently discard a candidate on weak evidence, never fake a confident answer.
We audit our own benchmarks. Adversarially.
Before publishing a headline number, we released a tool whose only job is to disprove us: it re-derives every answer from the raw question text, hunts for keyword leaks, checks that the held-out suite is truly disjoint, re-runs the generator and demands byte-identical output, and proves no external dataset ever touches the pipeline.
- Zero hardcoded question/answer pairs. Every answer is re-derived from the question text by an independent reader.
- Zero dataset inflation. Holdout and main suites share no items and no contexts; distinct seeds, versioned and byte-locked.
- Payload honesty. The runner's wire payloads contain the question and the candidates — never the answer. Verified by reading the payload construction, not by trusting the README.
- Training contamination checks. The failure mode that inflates fine-tuned competitors' headline numbers (training on the benchmark's own split) is exactly what the audit hunts for — in our own suites, before we quote them.
Why this matters commercially
The alternatives market is young and loud: dozens of projects landed within two weeks, several won on the only benchmark they chose, and at least one headline number comes from a model fine-tuned on the benchmark's own training split.
In that market, auditable numbers are the moat. Every run on this page replays bit-for-bit from committed artifacts, and every claim links to its measurement. Steal our benchmarks and try to beat us — that's the point of publishing them.
Up and running in minutes.
Then it stays yours.
A Rust workspace with a canonical typed decision IR: machine-readable decisions in, machine-readable decisions out — over HTTP, MCP, CLI, or WASM. No accounts, no API keys, no telemetry. The base binary is useful with zero models installed.
1 · Run it — the fastest path
The whole toolchain is Rust 1.90+ with cargo. One build, one command:
git clone https://github.com/aliasfoxkde/OpenCodifier
cd OpenCodifier
cargo build --release -p opencodifier-cli
./target/release/opencodifier serve
The runtime is now on 127.0.0.1:8177 — loopback-only unless you explicitly say
otherwise. Prove it, then decide something:
curl -s http://127.0.0.1:8177/v1/healthz
curl -s http://127.0.0.1:8177/v1/decide \
-H 'content-type: application/json' \
-d @fixtures/native/request.json
Prefer a one-command install into ~/.cargo/bin?
cargo install --locked --path crates/opencodifier-cli — then opencodifier
is on your PATH. The committed fixture above is a real request (choice + score + boolean);
the response carries full distributions, calibrated confidence, and the execution trace.
2 · Keep it running — systemd daemon
One user service, survives reboots, restarts on crash:
mkdir -p ~/.local/bin ~/.config/systemd/user
cp target/release/opencodifier ~/.local/bin/
cat > ~/.config/systemd/user/opencodifier.service <<'EOF'
[Unit]
Description=OpenCodifier decision runtime
After=network-online.target
[Service]
ExecStart=%h/.local/bin/opencodifier serve
Restart=on-failure
RestartSec=2
NoNewPrivileges=yes
PrivateTmp=yes
[Install]
WantedBy=default.target
EOF
systemctl --user daemon-reload
systemctl --user enable --now opencodifier
systemctl --user status opencodifier
Logs: journalctl --user -u opencodifier -f. The service binds
127.0.0.1:8177 — expose it beyond loopback only deliberately
(serve --bind 0.0.0.0:8177) and behind a firewall; the local-first default is
the product, not a limitation.
3 · Embed it in your own site — WASM
The deterministic stack compiles to WebAssembly: decisions run client-side, offline, in your visitor's browser. Build the bundle once:
wasm-pack build crates/opencodifier-wasm \
--target web --out-dir ../site/wasm \
--out-name opencodifier_wasm
Then wire it into any page:
<script type="module">
import init, { WasmEngine } from "./wasm/opencodifier_wasm.js";
await init(); // resolves ./wasm/*_bg.wasm beside the JS
const engine = new WasmEngine();
const out = JSON.parse(engine.decide(JSON.stringify(request)));
</script>
The WASM build ships the zero-ML stack — rules, cache, metadata filters, lexical scoring — the same rungs that decide most items on the server, running in the browser. playground.html is the working example; its source is the integration guide. No network calls, ever.
4 · Pre-built binaries
Every release target is built by the pipeline with an attestation and a sha256 beside the
artifact (opencodifier-<version>-<target> +
.attestation.json). The matrix covers Linux (x86_64 gnu + musl static,
aarch64), macOS (x86_64 + aarch64), Windows (x86_64), Android, iOS, and WASM. The
v0.5.0 cut publishes them all in one place:
Until the cut lands, the build-from-source path above is the supported install — the same code the artifacts are cut from, and the attestation format is documented in the repo.
Interfaces
- HTTP /v1 API — localhost by default; exposure to the network is an explicit flag, never a default.
- MCP server — plug decisions into agent toolchains as a native tool.
- CLI —
opencodifier decidefor scripts and pipelines. - WASM — the core compiles for the browser; the deterministic stack runs client-side.
- Useful with zero models. The base binary decides with rules, filters and lexical scoring — no ML artifacts required. Add the model rung only if your workload earns it.
Design rules we don't break
- Deterministic-first: code gates run before any AI output is accepted.
- The cheapest reliable mechanism wins — never a bigger model when a cheaper rung is confident.
- Verification is confidence-gated: never two classifiers on every request.
- Sync core, no async runtime in the decision engine; heavyweight deps confined to one crate each.
- All input is hostile: input text can never modify policy, thresholds, or graph structure.
- Explainability = a deterministic execution trace. Never chain-of-thought.
Don't want to run it yourself?
Pay per decision, not per token.
The same engine that runs in your tab, hosted. No GPU, no warm-up, no model weights to babysit — decisions come back in milliseconds and cite the rung that answered them.
- Typed decisions — choice, boolean, score — with calibrated confidence
- Honest abstention: “not confident” is a response, never a guess
- Sub-10 ms at the cheap rungs; the model pays only for the hard tail
- Same canonical decision IR as the WASM module and the CLI
The waitlist is an email, not a form — signup flows land when the hosted endpoint ships. Self-hosting stays free and Apache-2.0 either way.
Hosted vs. self-hosted
| Hosted API | Self-hosted | |
|---|---|---|
| Price | $1 / 1M decisions | free, Apache-2.0 |
| Setup | an API key | one binary, no API keys |
| Hardware | ours (CPU) | yours (CPU-only) |
| Data leaves your machine | the request | never |
| Decision telemetry | dashboards, alerts, usage exports included | read it yourself — every response carries per-decision metrics + trace (no scrape endpoint) |
| Status | waitlist | shipping today |
One workshop. Many tools.
OpenCodifier is the decision rung of a wider platform built by the same people with the same discipline — deterministic-first, local-first, measured or it didn't happen. Grouped honestly below: what's open source, what's commercial, and what's still coming. Flip a card — the details and the link ride on the back.
Open source
Commercial
Coming soon
The machinery with no landing page
Some of the machinery stays private by design — it's infrastructure, not product, so it doesn't get brochures. The discipline it enforces does get advertised: every number on this page traces to a run that the platform's own pipelines verified.
Where the stack is heading
Convergence, not acquisition: a local decision runtime (this project), token savings (Amortyx), knowledge extraction and transfer (VIVERE), a knowledge fabric (BigData), fast CI (GitForge), early detection (Aegis) and MCP tooling control (MCPManage) — plus an AI-native commerce builder (FlexStack), an AI-first web desktop (OpenWebOS) and a light local AI stack that respects your GPU. Shared philosophy: cheapest reliable mechanism first, measured claims only, your hardware stays yours.
Where this goes next.
Questions people actually ask.
Is this a chatbot or an LLM wrapper?
No. It's a decision runtime. It produces typed, machine-readable decisions (choice / boolean / score) with calibrated confidence. LLMs appear only as an optional, expensive, last-resort rung — the architecture works with zero models installed.
Does it beat Jev?
On latency, cost, privacy, and determinism: yes, by wide margins — 2.0 ms vs hundreds of ms, a modeled $0.007 vs ~$32 per 1M decisions (the third-party board's pricing basis), fully local vs hosted. On raw accuracy against hosted Jev: not yet — 76.6% vs 86.6% on the public split. We publish both numbers because the divergence is the honest state of the field, and the full-system re-run is on the roadmap.
What hardware does it need?
The deterministic stack runs on anything — a laptop CPU, a router, a browser tab (WASM). The 4B model rung runs CPU-only on a desktop-class machine; most requests never reach it because cheaper rungs decide first.
Why not just call a big LLM?
Because most software decisions are small and repetitive: route this ticket, flag this message, pick this severity. Paying a frontier model to generate a sentence you immediately parse back into an if-statement is the wrong shape — slow, expensive, non-deterministic, and uncalibrated. (The category's popularity proves the point; our numbers prove the margins.)
Can I trust the accuracy claims?
Every number links to a committed run with deterministic replay (bit-identical predictions and probability vectors), an adversarial audit of the benchmark generator, and a held-out suite the system was never fitted on. The audit tool ships in the repo — run it against us.
What's the license? Can I self-host?
Apache-2.0. Self-hosting is the default posture — local, offline, no telemetry, no accounts, no API keys. That's not a paid tier restriction; it's the product.