Decisions,
not paragraphs.

Apache-2.0 local-first no API keys CPU-only

OpenCodifier turns unstructured state into typed, machine-actionable decisions — choice, boolean, score — with calibrated confidence and honest abstention, on hardware you already own. A large language model is the expensive last resort here, not the default.

runtime · decide p50 2.0 ms
{
  type:        "choice",
  id:         "vendor-select",
  choice:     "rule.exit",
  confidence: 0.94,
  gate:       { outcome: "accept", top_probability: 0.94 },
  rung:       "exact-rule"  ← relational proof, no model
}
typed · calibrated · bit-for-bit replayable

Illustrative output — the real envelope, in the API docs.

Try it in the Playground See the measured numbers How the ladder works Hosted API — $1/1M decisions
2.0 ms
engine p50 per decision
JevBench public split, CPU-only
76.6%
best published open decision model
on the 231-item public split
$0.007
modeled cost per 1M decisions
engine rung, board pricing basis
231/231
deterministic replay — every item,
every time, bit-for-bit
0.070
calibration error (ECE)
of our model rung on the split
The numbers

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.

How it works

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.

1
Exact rule
relational proofs over extracted facts
~0 ms
2
Cached decision
versioned, byte-stable replay
~0 ms
3
Metadata filter
provably-out candidates removed
sub-ms
4
Lexical / BM25
hand-written scorer, gated accept
0.4 ms
5
Embedding
static-table semantic scoring
7.9 ms
6
Decision model
4B parallel readout, tail only
0.3–2.3 s
7
Verifier
one gated shot on disagreement
on demand
Pick a scenario to watch a request ride the ladder.
Calibration

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.

0.070

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.

0.103

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.

3

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.

Integrity

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.

Build with it

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:

Releases ↗

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 decide for 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.
Hosted API — coming soon

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.

Coming soon
$1per million decisions
  • 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
Join the waitlist

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 APISelf-hosted
Price$1 / 1M decisionsfree, Apache-2.0
Setupan API keyone binary, no API keys
Hardwareours (CPU)yours (CPU-only)
Data leaves your machinethe requestnever
Decision telemetrydashboards, alerts, usage exports includedread it yourself — every response carries per-decision metrics + trace (no scrape endpoint)
Statuswaitlistshipping today
Ecosystem

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.

Commercial

Amortyx commercial · free to use More work from every token — compression, routing, request optimization for LLM workloads. ↻ details Amortyx Lossless-first compression before context is spent, provider routing with circuit breakers, and savings you can audit in your own logs. Spend less, keep the output. amortyx.com ↗ MCPManage commercial · community Control plane for the MCP tooling layer your agents use. ↻ details MCPManage Manage, secure and audit the MCP servers your agents rely on from one place. A commercial product with community roots, being reworked. mcpmanage.com ↗ VIVERE research lab Knowledge extraction & transfer — labels, not weights. ↻ details VIVERE The research lab behind the training corpora our compact decision models learn from: extraction and transfer machinery that turns raw text into supervised signal. Public site; the machinery stays in the lab. vivere-5we.pages.dev ↗
BigData commercial · private The knowledge fabric — vector store, embeddings, semantic retrieval. ↻ details BigData Fast knowledge access across the stack — the fabric every sibling product reads from. Private infrastructure, so no landing page: it's plumbing, not product. private repository
The Harness commercial · private The agent harness that builds all of this — hooks, skills, rules, MCP registry. ↻ details The Harness Disciplined engineering as software: code-based quality gates run before AI output is accepted, hooks that enforce them, skills that compose. It wrote the page you're reading. private
TaskWizer Stack commercial Chat, CLI, VS Code integration and the TaskWizer command center — one stack. ↻ details TaskWizer Stack The TaskWizer product stack — AI assistance from chat to editor to command line, under one roof. Chat · soon CLI · soon VS Code · soon more · soon taskwizer.com ↗

Coming soon

CodeReview open source · soon Deterministic-first code review, pointed at pull requests. ↻ details CodeReview The quality-gate instinct of this workshop as a review product: prove it before it merges, and say what stayed unverified. In development; lands open source. in development
FlexStack commercial · soon AI-powered eCommerce platform and website builder. ↻ details FlexStack Storefronts, catalog and checkout where AI does the heavy lifting — generation, enrichment, merchandising — under the same deterministic-first discipline. In development. in development
OpenWebOS open source · soon An AI-first productivity WebOS — one monolithic, modern platform. ↻ details OpenWebOS A monolithic open-source project: an AI-first productivity operating system for the browser, built on modern web standards with deep integrations between apps, agents and your files. In design. repository to follow

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.

Roadmap

Where this goes next.

Adversarial benchmark audit — shipped. Independent re-derivation of every suite answer; hardened holdout re-measured.
Held-out validation — shipped. Full-system ladder: 0.892 out-of-sample with zero gate drift, +9.2 pp over the previous gate on identical hardware.
Full-system JevBench re-run — the fusion gate on the official public split, run by the benchmark's own harness.
Official third-party board submission — 1,500-decision self-hosted run, artifacts published, independently checkable.
Smaller, faster model rung — and open weights. Our distillation program is training a compact decision model on VIVERE-extracted corpora. It ships publicly only if it clears its pre-registered gates (beat the untuned base and the best community checkpoint on both of our suites) — if it passes, the weights land on Hugging Face.
Sub-100 ms ONNX encoder rungs — a middle rung between lexical and the 4B model, CPU-only.
Release engineering — binaries for Linux, macOS, Windows, ARM and WASM, with release attestation like everything else we ship.
FAQ

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.