# OpenDXP, the open standard

> OpenDXP (Open Decision Exchange Protocol) is an open standard that lets any engine run any System One model: portable weights, the input described as data, calibration, conformance tests, and one way to ask over HTTP or MCP.

Source: https://systemonemodels.tech/docs/opendxp

Every System One model answers the same request: a state, and typed questions
with calibrated probabilities, in one pass. What differs is inside: each model
ships its own inference code, so running twenty models means installing twenty
runtimes, and comparing them means writing twenty harnesses.

**OpenDXP**, the Open Decision Exchange Protocol, makes a model a package that
any OpenDXP engine runs without code written for it, and gives every
application and AI agent one way to ask it. It is to decision models what MCP
is to agent tools. The specification, its schemas, the converters, the
conformance tools and the reference runtime are open source (Apache-2.0):
[github.com/systemonemodels/opendxp](https://github.com/systemonemodels/opendxp),
and `pip install opendxp`.

Packaging your own model? Read [Make your model OpenDXP compatible](https://systemonemodels.tech/docs/opendxp-compatible),
a ten-minute guide from your checkpoint to the badge.

## Four parts

1. **Requests and answers**: one format for a state and typed questions
   (choice, score, noul), and for the calibrated answers.
2. **Packages**: the model as data that any engine runs.
3. **Conformance**: proof that an engine answers as the model's own code does.
4. **Bindings**: how requests travel. Over HTTP (`POST /v1/systemone`,
   `GET /v1/models`) between an application and any server, and over the
   Model Context Protocol between an AI agent and a tool.

## Two profiles

**`encoder-markers`.** A bidirectional encoder scores one marker token per
option: Laya, Julia 1, Von, open-jev, GLiNER2.5-Decide. The package ships an
ONNX graph with fixed inputs and one output (`option_logits`), plus
`template.json`: how the question, the options and the state are laid out and
truncated.

**`causal-letters`.** A language model reads each option letter's probability
at an answer slot: Decider, AnyJev, Kev, Nimble, JevK5, lev. The package ships a
GGUF build and `prompt.json`: the prompt pieces, the option labels and the
slot. Since 0.2 a prompt can lay out each question type on its own, inside the
model's chat template, and ask a question once per **rotation** of its options,
combining them so no option wins by its position. That is how
[AnyJev](https://github.com/nokia-applied-research/AnyJev) (Nokia) turns an
instruction-tuned model into a decision model without training it.

Both add `calibration.json` (a temperature per question type, optionally per
number of options) and `conformance.jsonl`: requests with the probabilities
the model's own code gives for them.

## The package

An OpenDXP package is a folder with an `odxp.json` manifest that names every
file it uses, with its SHA-256. Nothing in it is executed: templates are filled
by placeholder substitution, and the weights run through ONNX Runtime or
llama.cpp. In a model version it sits in an `odxp/` folder, where the engine
finds it by its manifest:

```text
odxp/odxp.json                the manifest: standard, profile, files, limits
odxp/model.onnx               encoder-markers (its weights can stay in model.safetensors)
odxp/model.gguf               causal-letters
odxp/tokenizer.json
odxp/template.json            encoder-markers; causal-letters has prompt.json
odxp/calibration.json
odxp/conformance.jsonl
```

## Run it anywhere

```bash
pip install "opendxp[onnx]"     # encoder-markers; "opendxp[gguf]" for causal-letters
opendxp run odxp/ --request request.json
opendxp serve odxp/             # POST /v1/systemone on 127.0.0.1:8790
opendxp mcp odxp/               # a tool for AI agents (Claude, Cursor, ...)
```

GGUF runs through llama.cpp on CPUs and on NVIDIA, AMD, Apple, Intel and Vulkan
GPUs; ONNX runs through ONNX Runtime, whose execution providers also reach NPUs
(OpenVINO, Core ML, QNN). The engine picks the device, not the model's author.

## Compatible

A model is **OpenDXP compatible** when the reference runtime reproduces its
conformance file on a CPU: the same decision on every question, and
probabilities within 0.01 of the model's own code. **OpenDXP portable** adds a
named accelerator backend. The [System One Engine](https://systemonemodels.tech/docs/engine) checks a
package when it serves it, and on its own when a package of up to 2.5 GB is
published; the model's page shows the badge, and so does its owner's profile.
The badge is earned only this way: by publishing a model whose package passes.

## Status

OpenDXP 0.2 adds the HTTP and MCP bindings and the typed layouts, chat
templates and rotations above. Its reference implementation converts Laya,
Julia 1, Decider and AnyJev and checks them against each model's own code:
three Laya checkpoints, Julia 1 (from our export and from its authors' own ONNX
graph) and Decider pass with every decision the same, and AnyJev on Qwen3-1.7B
passes 52 of 52 cases with all 90 decisions the same as Nokia's own code.
Julia 1 also passes on Apple's Core ML. The numbers and how they were measured:
[VALIDATION.md](https://github.com/systemonemodels/opendxp/blob/main/VALIDATION.md).