Deterministic
Same inputs, same decision — on any machine, under every 1.x release. The hot path is integer-only, so there is no floating-point drift to explain away.
catalog + policy + request → decision00Live
The window beside this runs the published calybris-core compiled to WebAssembly. It weighs three suppliers, records the decision and replays it. Every few seconds it edits one digit of its own record — and refuses it.
explain()returns a verdict for every candidateverify()rebuilds the decision from its inputs- one changed digit and the replay no longer matches
Replacement part for the linebudget $65,000min. quality 65%
| Candidate | Price | Verdict |
|---|---|---|
| Contracted supplier | $61,000 | |
| Second source | $47,500 | |
| Spot market | $39,000 |
Audit record
- action
- …
- selected_candidate_id
- …
- estimated_cost_microunits
- …
- policy_digest
- …
- decision_digest
- …
·Loading the engine…
01Product
Calybris does not guess and does not learn on the fly. It applies the rules you wrote, in a fixed order, and keeps exactly enough to prove that it did.
Explainable
Every candidate gets a verdict: the gate that stopped it, what was measured and against which limit. explain() runs the same evaluation as the decision, so it cannot disagree with it.
explain() → one row per candidateTamper-evident
Decisions are hash-chained and Ed25519-signed; from 1.3.0 they are also dated by an RFC 3161 authority and a Bitcoin block. Change one record and verification fails — even if the operator made the change.
verify() → valid | refused02How it works
Every candidate meets the same gates in the same order, cheapest check first. The first one it fails is the reason on record — with what was measured and the limit it was measured against.
- 01
Inputs
A frozen catalog, a policy snapshot and a typed request. Nothing else reaches the kernel.
- 02
Gates
Seven hard limits in a fixed order. A candidate that fails one is out, with the reason recorded.
- 03
Rank
Survivors are priced, checked against the budget and ranked on a single utility number.
- 04
Seal
One action plus an audit bundle: policy, input and decision digests and a replay result.
- 01Disabled
enabled == 0the policy turned it off - 02Quality
quality_bps < minimum_quality_bpsbelow the quality floor - 03Latency
p95 > max_p95_latency_mstoo slow for this request - 04Capability
caps & required ≠ requiredmissing a required capability - 05Provider
provider ∉ allowed_maska provider this request may not use - 06Region
regions & required = 0not available where the data must stay - 07RiskCeiling
risk > risk_ceilingmore risk than the candidate accepts
Survivors are ranked on
utility = quality_adjusted − risk_penalty − cost − latency_penaltyOver budget → OverBudget · utility ≤ 0 → NonPositiveUtility · the rest → Eligible, ranked. Nothing clears? The status is "rejected" and the candidate is None — never a fictitious zero.
03Trust layer · new in 1.3.0
Calybris 1.3.0 lets someone who trusts nobody — including whoever runs the system — check which decisions were written, and when. With standard tools, offline.
The public checkpoint, as served
Origin, tree size and root hash of the 1,000-decision demo log, then the log’s Ed25519 signature line.
- 1
Signed
The log signs a checkpoint over every decision, in the C2SP signed-note format used by Go’s checksum database.
- 2
Witnessed
A witness cosigns only if the new checkpoint extends everything it signed before, so two different histories cannot both be cosigned.
- 3
Timestamped
Each checkpoint is dated by an RFC 3161 authority and by an OpenTimestamps proof in a Bitcoin block. Nobody can backdate it.
- 4
Verified
The verifier reports exactly how far it got — signature only, witnessed, timestamped or full. It never rounds up.
Verify 1,000 decisions in your browser
A public log, a witness, FreeTSA and a Bitcoin block — checked in this tab by calybris-core compiled to WebAssembly.
Preview features, outside the 1.x stability promise until reviewed. Today the only witness is run by the maintainer. Calybris proves the integrity of the trail — not that your inputs were true or that your policy was good.
04Use cases
The kernel does not know what a candidate is. You bring the catalog — these are reference mappings onto one API, not separate products.
AI agent budgets
One shared budget across paid calls. Reserve before, commit or release after; remaining + reserved + committed always equals what you started with.
python examples/agent_budget.pyModel routing
Pick a model or provider under quality, latency, risk, provider and budget ceilings.
cargo run --example llm_routingSupplier selection
Which quote clears budget, deadline, quality and capabilities — and why, months later.
python examples/supplier_decision.pyPre-trade admission
Each child order clears a policy gate and an exposure gate before it reaches a venue.
cargo run --example pretrade_guardFulfilment at volume
10,000 orders across 8 courier networks with distinct SLAs, coverage and risk tolerances.
python bindings/python/examples/orion_market.pyPolicy change review
Replay history under two rule sets and count what moved. A replay, not a forecast.
compare_policies(engine, stricter, history)05Developers
A library, not a service. No account, no API key, no network calls — it runs in your process, and your data stays there.
verify()rebuilds the result from what you persist; it never trusts a self-declared flag- Checked APIs validate untrusted input before it reaches the kernel
calybris-verifyaudits a decision log offline, with no access to your system- The proof format is specified byte by byte and pinned by conformance vectors
Surfaces and their promise
calybris-core Rust | stable |
calybris Python | stable API |
calybris-ffi C ABI | stable ABI · build from source |
calybris_commerce Python | experimental |
pip install calybrisfrom calybris import (Candidate, DecisionEngine,
DecisionRequest, EngineConfig)
day = 86_400_000
catalog = [
Candidate(candidate_id=1, provider_id=0,
quality_bps=9000, risk_ceiling_bps=8000,
lead_time_ms=8 * day, region_mask=1,
quoted_cost_microunits=80_000_000),
Candidate(candidate_id=2, provider_id=1,
quality_bps=9500, risk_ceiling_bps=8000,
lead_time_ms=3 * day, region_mask=1,
quoted_cost_microunits=100_000_000),
]
engine = DecisionEngine(catalog, config=EngineConfig(
latency_penalty_microunits_per_ms=0))
request = DecisionRequest(
request_sequence=1,
budget_microunits=120_000_000,
business_value_microunits=200_000_000,
maximum_lead_time_ms=5 * day,
)
result = engine.decide(request)
result.status # "selected"
result.selected_candidate_id # 2: the cheaper quote is late
engine.verify(request, result) # rebuilt from the inputs
06Engineering
- ~115 ns
- per decision on CodSpeed CI, Linux x86_64. Hardware- and workload-dependent; reproduce it with
cargo bench. - 7
- hard gates, always evaluated in the same order
- 0
- lines of
unsafecode in the kernel, enforced by#![forbid(unsafe_code)] - 1.x
- no breaking changes to the API, digests or replay since 1.0.0
- Loom + Miri on the budget ledger
- Fuzzing and property tests
- Semgrep, cargo-audit, cargo-deny in CI
- Golden and conformance vectors
- Apache-2.0
07KRYNARIS
KRYNARIS reads what happened after decisions and looks for readable relations — one measurement, one cut, the counts behind it. The ones that survive validation are compiled into bounds Calybris enforces, and signed.
proofframeproves the data
KRYNARISfinds, compiles and signs rules
Calybris 1.xenforces them, with proof
How a rule earns its place
- History is split in time order into discovery, validation and holdout.
- Cuts found on discovery are re-measured unchanged on validation; those are the numbers reported.
- A rule must beat what shuffled outcomes produce, or it is discarded.
- Rules tighten automatically and loosen only with approval. Protected attributes are reported, never compiled.
Measured — caveats included
UCI credit default · 30k rows3 rules · 78.7% approved at 14.1% defaultLogistic regression at the same approval rate: 14.2% · AUC 0.702 vs 0.730
Telco churnRules were weaker than a model51.9% vs 64.1% at a 25.6% flag rate
75.3M US flights, streaming12 two-column rules, most replicateSome carriers’ rules matched no test flights: rules need expiry
Measured in KRYNARIS runs, September 2026. Association, never causation. KRYNARIS is not open source.
08See it run
Every demo runs the published calybris-core in your tab — compiled to WebAssembly or WASI. Requests, outcomes and non-AI costs are simulated, and each page says so.
One engine, four domains: AI routing across 184 real endpoints, freight, grid dispatch and credit — every decision written to one chain you can watch break.
Verify
Check a real log yourself
1,000 decisions, a signed checkpoint, a witness, an RFC 3161 timestamp and a Bitcoin block. Change one decision and watch it fail.
Open RouterLive model router
19 models on 50 hosts with real prices and regions. Start an incident, tamper with the log, edit a signed receipt.
Open LabCalybris lab
The decision step by step, a million jittered trials with a digest over every one, and the research lab.
Open TryPreview features
What would flip a decision, Merkle inclusion proofs and keyed exploration on the same kernel.
Open09Fit
Use Calybris when
- decisions must be deterministic and replay-auditable
- you need hard gates — budget, risk, latency, region, capability — in your control plane
- post-mortems and compliance need proof bundles, not log grep
- you want to see what a policy change would have done before shipping it
Look elsewhere for
- inventory, WMS or carrier booking
- a hosted routing API or a managed decision service
- live market data, order matching or exchange connectivity
- deciding what the policy should be — that is your judgement
10FAQ
What is Calybris?
Calybris Core is a deterministic decision engine. Given a frozen catalog, a policy snapshot and a typed request, it rejects candidates at hard limits, ranks the survivors on one utility number, and returns one action with an audit bundle that replays to the same answer.
Is Calybris an LLM gateway or an order management system?
No. It is a decision kernel. Model routing, carrier selection, supplier choice and pre-trade admission are reference mappings onto one API; inventory, booking, market data and order matching stay outside it.
What exactly does Calybris prove?
The integrity of the decision trail: policy, input and decision digests plus a replay result, a hash-chained WAL with anchors, and Ed25519-signed receipts and policies. It does not prove that your inputs were true or that your policy was good.
How is KRYNARIS different from a machine-learning model?
KRYNARIS produces readable rules, one measurement and one cut at a time, validated on newer data and against shuffled outcomes, then compiles them into bounds Calybris enforces. On UCI credit default its 3 rules matched logistic regression’s default rate at the same approval rate (14.1% vs 14.2%); on Telco churn a model was stronger.
Is it open source, and what does it cost?
Calybris Core is open source under Apache-2.0 and free to use: cargo add calybris-core for Rust, pip install calybris for Python, and a stable C ABI. KRYNARIS is not open source.
Will a 1.x update change my decisions?
No. From 1.0.0 the API, decision semantics, digest formats and replay behaviour are specified and pinned by tests; a decision made under 1.0.0 replays identically under every later 1.x.
What is new in 1.3.0?
A trust layer, so a reader no longer has to take the operator’s word: C2SP signed checkpoints over the decision log, witness cosignatures that catch a log showing two histories, RFC 3161 and Bitcoin (OpenTimestamps) time evidence, a verifier that reports exactly what it established, and exact propensities for off-policy estimates. It ships behind the preview flags, outside the stability promise until reviewed, and decides exactly as 1.2.0 did.
Open source under Apache-2.0. Install it in a minute; verify a real log in ten seconds.
cargo add calybris-core · pip install calybris