Everything you need to know about System One decision models, zero-egress architecture, and Helixor's in-process engine.
Helixor Decision Engine is a neurosymbolic AI decision engine from Helixor Inc. It runs inside the application that uses it and is built for operational decisions where a wrong answer is costly, such as eligibility, limits, routing and release. Neural components read and interpret the input, and a symbolic core makes the decision. The decision itself is never sampled from a language model: given the same input and pack version, Helixor returns the same action every time, spends zero model tokens and sends no data over the network.
How it decides. Policies are written as playbooks, which are readable files that each describe one decision. A playbook compiles into a sealed, versioned decision pack that loads into your application's memory. At runtime, codons extract typed facts from the raw input, rules pass or fail against those facts, and the engine returns one action from the closed set the pack declares. Each result also carries a remedy (the smallest change that would satisfy the rules) and a receipt hash that fingerprints the pack, the decision and the input for audit. When the data is missing or ambiguous, Helixor abstains instead of guessing and reports what evidence it needs.
Where it runs. Helixor can be embedded as an in-process library (about 25 µs per typical decision), run as a loopback sidecar or a private-network REST service with streaming, operate fully air-gapped, or work in a hybrid setup where only rule-selected requests escalate to hosted models. SDKs are available for Python, Java and TypeScript, along with an HTTP API and a CLI.
Alongside LLMs, not instead of them. Helixor handles structured decisions locally and can strip sensitive data before anything reaches a cloud model. It serves teams in financial services, healthcare and life sciences, the public sector, defense, legal and tax, and software. Helixor Inc. is a member of the NVIDIA Inception program.
The Helixor Solver is the mathematical optimization side of the engine. The decision engine picks one action for one case, while the solver finds the best feasible plan across many interacting variables: who works which shift, which truck takes which route, where inventory should go.
Tensor Constraint Networks. The solver represents a problem as a Tensor Constraint Network, a set of low-rank tensors wired together by constraints. Bounds and contradictions propagate through the network, so infeasible regions are ruled out without being searched one by one. Because the work is tensor math, it runs on standard CPUs and is accelerated on GPUs.
Driven by playbooks, like decisions. Each optimization is declared in a solver playbook, in the same way a decision is. The playbook specifies the problem type, the records it requires, the hard and soft constraints and the objective. You don't write solver code; you describe the problem, and the solver chooses the strategy.
Problem types include:
Certified or refused. Every solve returns either a solution with a certificate showing which constraints it satisfies, or a typed refusal explaining why it could not solve, for example because required records were missing or the constraints conflict. The solver never fills in missing business data on its own.
Helixor doesn't replace your models. It sits at the decision points around them. Language models are good at reading messy input and generating text. They aren't built to make the same decision the same way every time, or to show exactly why they made it. Helixor handles that part, so each does the job it's suited for.
Where Helixor fits in an LLM or agent workflow:
The model proposes; Helixor decides. This is the neurosymbolic boundary. Neural models, including LLMs, can read unstructured input and propose what it contains. Those proposals are turned into typed facts that the symbolic core checks against your rules before they affect a decision. A model's output never becomes a decision just because the model produced it.
Escalation when a model is needed. When a request needs evidence Helixor doesn't hold locally, open-ended multi-step reasoning or a calibrated probability, Helixor abstains and says what's missing. Your rules then choose which of those requests escalate to a model or to hosted reasoning. Escalated requests carry only redacted text, a goal and the specific questions to answer. If escalation fails, the request fails closed and is not passed through unchecked.
A System One decision model is a new category of foundation AI model optimized for instant, structured judgment instead of free-form text generation.
The name is inspired by psychologist Daniel Kahneman's framework from Thinking, Fast and Slow, where System 1 refers to the human brain's fast, instinctive, and automatic thinking loop. Instead of generating conversational text word-by-word like general-purpose LLMs, System One models deliver instant, structured judgment against a rigid schema.
Core Characteristics of System One Models:
Where They Fit in the AI Stack:
System One models are not meant to replace LLMs; they act as a high-speed guard or decision layer right beside them. Incoming requests pass first through the System One model: low-risk or structured tasks route directly to fast automations or code branches, while high-complexity tasks requiring creative generation route to frontier LLMs (such as GPT-4o or Claude). By filtering millions of micro-decisions (such as moderation, classification, or function calling) through a fast System One model, applications avoid wasting massive compute and budget on conversational models just to get a simple "yes" or "no."
Helixor shares the System One goal, but it does much more. Like a System One model, it gives fast, structured judgment instead of generated text. A System One model is still a single neural model: it classifies or scores an input and reports how confident it is. Helixor is a neurosymbolic decision system: neural models can read the input, but a symbolic core decides against your own rules, explains the result, and can optimize whole plans.
What Helixor adds:
In short, a System One model is a fast classifier. Helixor is the decision layer around it: your rules, your evidence, a result you can reproduce and audit, and a solver for the problems too big for a single choice.
Yes. Given the complete set of data to reason over, Helixor reasons significantly better, faster, and more reliably than LLMs.
Because of its deterministic execution paths and microsecond hardware speed, Helixor does not rely on probabilistic guessing. Instead, it can evaluate every possible option, constraint branch, and outcome simultaneously, proving and recording cryptographic receipts of all those evaluations in real time.
The only advantage LLMs possess in reasoning is their broad pre-trained world knowledge, and that is only an advantage if external, unverified pre-training knowledge should actually be used in your decision making. In enterprise workflows, regulated finance, statutory compliance, and high-stakes operations, decisions must be made strictly against your verified facts, customer states, and organizational policies. In those environments, an LLM's pre-trained knowledge introduces hallucinations, unpredictable drift, and arithmetic errors.
Why Helixor Outperforms LLMs in Enterprise Reasoning:
TypeSafe AI's Jev is a cloud-hosted System One decision model designed for rapid structured evaluations via a remote SaaS endpoint. While both Jev and Helixor prioritize structured judgment over autoregressive text generation, their underlying architectures serve different enterprise requirements: