Business overview

Helixor is the embedded decision runtime for software and AI agents that cannot guess. Encode policy, constraints and optimization once. Helixor returns a provable action, or abstains, and the data you decide on never leaves your environment.

“Provable” means checkable, not a cryptographic proof. Each action comes with the invariants that passed or failed, the rules that fired and a receipt hash you can recompute. What a pack's rules do not settle goes to a declared refer action, or to hosted reasoning Preview, which abstains to a person instead of guessing. The data stays in your environment when the runtime runs in your process or next to it; the hosted parts below see only what you send them.

The rest of the platform supports that runtime: solvers for optimization, a learning loop that improves packs from outcomes under a regression gate, reasoning for the ambiguous remainder, and digital workers and governed execution for agents that act.

See a business decision from policy to outcome#

These source-integration walkthroughs include illustrative policies, downloadable drafts and checked structured-input outcomes. Use them to choose a pilot; they are not customer case studies or claims of measured savings.

Pilot: your policy, next to your current process#

Bring a written policy and a handful of past cases. We'll turn it into a pack and run it next to your current process.

1. You send the policy and the cases

   The written policy for one decision, and a handful of past cases with the decision each one got. Synthetic or redacted cases are fine.

2. We build the pack

   Helixor writes the policy as facts, invariants and a closed set of actions in the playbook format, compiles it, and checks it against your past cases.

3. Shadow run next to your current process

   The pack decides the same cases your current process decides, in your environment. Your current decision stays the one that acts, so nothing your users see changes.

4. Report: agreements and disagreements, with receipts

   You get every case where the pack and your current process agree or differ, with the rules that fired and the receipt for each decision, so each one can be checked.

To start, email hello@helixor.ai with the subject “Pilot request”: say which decision, and attach the policy if you can share it. A person replies with a scope and a quote. To run a longer pilot yourself, including the learning loop, follow the pilot plan in Evaluating fit.

The problem it solves#

Most organizations make the same decisions thousands or millions of times a day: approve or refer, route or hold, allocate or defer, release or withhold. Today those decisions live in one of three places, and each has a cost:

• Hand-written code is exact but opaque, slow to change, and cannot explain itself to an auditor.
• Predictive or generative models adapt and handle ambiguity, but they are not repeatable, can be wrong with confidence, and drift as they retrain.
• People handle anything, but they do not scale and are hard to make consistent.

Helixor combines the parts that work. A deterministic core decides what policy can settle, and a learning loop improves that policy from outcomes under a regression gate. A reasoning service handles the ambiguous remainder: it abstains when the evidence is not there, and those cases go to people.

The platform#

Measured: Built-in data-protection pack, runtime 0.3.1, Apple M5 Max, single process, 2026-10-02; call time, evaluate() end to end, median of three runs. Your hardware and payloads change the result. See the reproducible benchmark.

In every edition today, Community included, a receipt is a recomputable fingerprint derived from SHA-256, not a signature: it ties a logged decision to its pack and input, but anyone can compute one, so it does not show that a log was left unaltered. Signed, chained receipts are Planned. See Receipts.

Where it fits#

Read next#