bynn-intelligence-com/decisionnode-edge-mini

DecisionNode Edge Mini

DecisionNode Edge Mini is an open-weight System One decision model from Bynn Intelligence. It reads text and images and answers each question with a typed decision: a choice, a score, a yes-or-no probability, a number, or a place in an image (a point or a box). It never generates free text. It runs entirely on your own hardware, from a datacenter GPU to a laptop CPU, and uses the same request and response format as the DecisionNode API.

A System One model is a class of AI model that returns typed, probabilistic decisions from a fixed answer space instead of generating text. Given a piece of state and a set of questions defined in code, it answers each one with a schema-valid value such as a chosen option, a score, or a probability, and then stops.

This repository contains DecisionNode Edge Mini 0.9.2, the smallest DecisionNode model, built for CPUs and constrained devices. DecisionNode Edge is its 2.2-billion-parameter sibling, about 5 points more accurate. When accuracy matters most, use the hosted models on the DecisionNode API: DecisionNode, the most accurate model in the family, or DecisionNode Flash.

Highlights

• Typed decisions instead of text. Six question types (choice, score, truth, number, point and box), answered as values with probabilities, ready to use in code without parsing.
• Calibrated. Probabilities are calibrated on held-out data, so a fixed threshold such as 0.7 means the same thing from one question to the next.
• Constant cost per question. Every question is a single forward pass, whether it has 2 options or 255.
• Fast everywhere. Optimized backends for NVIDIA GPUs, Apple silicon, x86 CPUs and llama.cpp devices, selected automatically, with consistent answers across all of them.
• Private by design. Inference runs offline. Nothing you send to the model leaves your machine.
• Compatible with the DecisionNode API. Code written for the hosted API runs against DecisionNode Edge Mini with only the transport changed.
• Escalates when unsure. Settle most questions on the device and send only the low-confidence ones to the hosted models (see Recommended setup).

The DecisionNode family

DecisionNode Edge Mini is an open-weight member of the DecisionNode family, for decisions on your own hardware. The hosted models lead the family. For speed, use DecisionNode Flash: it answers in milliseconds and keeps high accuracy. When a decision needs the highest accuracy, use DecisionNode. Both are available through the DecisionNode API with the full feature set, at very low cost.

Model	Availability	Decision accuracy	Best for
DecisionNode Flash	Hosted API	78.3%	speed and accuracy together: decisions in milliseconds, at the lowest hosted cost
DecisionNode	Hosted API	81.7%	the highest accuracy, for the hardest decisions
DecisionNode Edge	Open weights	74.2%	on-device and private deployment, from GPUs to laptops
DecisionNode Edge Mini	Open weights	69.2%	CPUs and constrained devices

All four models are measured on the same 15-benchmark evaluation suite (see Evaluation).

Available only on the hosted platform:

• Boosters. Specialist models that read each image before the decision is made: Human Age, AI-generated image detection, Face detection, Face recognition, OCR, Depth Vision and Segment Vision. See boosters.
• Knowledge. Connect your own documents, and the Knowledge booster retrieves the passages each decision needs. See knowledge.
• Fine-tuning. Adapt DecisionNode to your own decisions and data. See fine-tuning.
• Video. Video input, read as frames.
• Scale. Streaming sessions for high-frequency decisions, batch jobs at a discount, file uploads and inputs of up to 65,536 tokens.
• Low cost. Pricing starts at a few cents per million input tokens, output tokens are free, and every account includes a free daily allowance. See pricing.

Create a free account to get an API key.

Open models

Model	Parameters	Decision accuracy	NVIDIA RTX PRO 6000 (vLLM)	Apple M5 Max (MLX)	Desktop CPU (OpenVINO)
DecisionNode Edge	2.21B	74.2%	9.5 ms	35 ms	0.46 s
DecisionNode Edge Mini	0.85B	69.2%	7.3 ms	17 ms	0.24 s

Decision accuracy is the mean over our 15-benchmark evaluation suite (see Evaluation). Times are the median for one question at about 500 tokens of input; the desktop CPU is an 8-core AMD Ryzen 7 9800X3D.

Recommended setup

DecisionNode Edge Mini is built to run where the decision is made: on a robot, a drone, a vehicle, a camera, a laptop or your own servers. We recommend pairing it with the hosted models in a cascade:

1. DecisionNode Edge Mini answers every question first, locally, in milliseconds and without a network round trip.
2. When its confidence is below your threshold (we suggest 0.7), the same question goes to DecisionNode Flash on the hosted API.
3. When Flash is also below the threshold, the question goes to DecisionNode, the most accurate model. Its answer is final: below the threshold, your code takes its safe action, such as holding, declining or slowing down.

Most questions are settled on the device, and only the hard ones reach the API. You keep local speed and privacy for the common case, and the highest accuracy where it matters. All three models share one request and response format and calibrated probabilities, so the same request and the same threshold work at every step.

If you run your own hardware, from GPUs to embedded devices, this is the setup we recommend. If you prefer a fully managed inference service at very low cost, call the hosted API directly.

import os

import requests
from huggingface_hub import snapshot_download
from decisionnode_edge import EdgeModel

edge = EdgeModel.load(snapshot_download("bynn-intelligence-com/decisionnode-edge-mini"))
API = "https://api.decisionnode.com/v1/decide"
HEADERS = {"Authorization": f"Bearer {os.environ['DECISIONNODE_API_KEY']}"}


def confidence(answer):
    if answer["type"] == "truth":  # distance from 0.5, on the same 0 to 1 scale
        return abs(2 * answer["truth"] - 1)
    return answer["confidence"]


def decide(request, threshold=0.7):
    answers = edge.decide(request)["answers"]
    for model in ("decisionnode-flash-latest", "decisionnode-latest"):
        unsure = {k: q for k, q in request["questions"].items() if confidence(answers[k]) < threshold}
        if not unsure:
            break
        hosted = requests.post(API, headers=HEADERS, timeout=10,
                               json={**request, "model": model, "questions": unsure})
        hosted.raise_for_status()
        answers.update(hosted.json()["answers"])
    return answers  # still below the threshold: take the safe action

Pass images as base64 data with a media_type (not a local path), so the same request is valid on the device and on the hosted API. Only the questions that are still unsure are sent, and a decision never changes when the same request is sent again, so each question costs at most one call per hosted model.

Model details

Developer	Bynn Intelligence Inc.
Version	0.9.2 (October 2026): the 0.9.1 weights with runtime 0.9.2, which adds point and box questions
Parameters	0.85 billion (0.75 billion in the language model, 0.10 billion in the vision encoder)
Base model	Qwen3.5-0.8B-Base
Input	Text, and up to 16 images per request (JPEG, PNG or WebP)
Output	Typed decisions: choice, score, truth, number, point and box
Context	Evaluated on inputs of up to 8,192 tokens; the runtime accepts up to 16,384
Weights	bfloat16 safetensors, plus an 8-bit GGUF build (0.8 GB)
License	AGPL-3.0, or a commercial license from Bynn Intelligence

Quick start

Install the runtime from PyPI:

pip install decisionnode-edge            # PyTorch, Transformers and safetensors
pip install "decisionnode-edge[images]"  # adds image support

Ask a question:

from huggingface_hub import snapshot_download
from decisionnode_edge import EdgeModel

model = EdgeModel.load(snapshot_download("bynn-intelligence-com/decisionnode-edge-mini"))
response = model.decide({
    "state": "Customer: I was charged twice and nobody has replied for 3 days.",
    "questions": {
        "route": {
            "type": "choice",
            "instructions": "Where should this go?",
            "criteria": {"billing": "money", "bug": "broken", "account": "login"},
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgent is this?",
            "criteria": ["routine", "today", "urgent", "critical"],
        },
        "refund": {"type": "truth", "instructions": "Refund this automatically?"},
    },
})
print(response["answers"]["route"]["choice"], response["answers"]["refund"]["truth"])

The response follows the DecisionNode API:

{
  "model": "decisionnode-edge-mini-0.9.1",
  "answers": {
    "route": {"type": "choice", "choice": "billing", "confidence": 0.92, "probabilities": {"account": 0.02, "billing": 0.95, "bug": 0.03}},
    "urgency": {"type": "score", "score": 1.75, "confidence": 0.67, "legend": {"0": "routine", "1": "today", "2": "urgent", "3": "critical"}, "probabilities": {"0": 0.01, "1": 0.27, "2": 0.68, "3": 0.04}},
    "refund": {"type": "truth", "truth": 0.06}
  },
  "usage": {"input_tokens": 100, "output_tokens": 0}
}

Images are passed as base64 data with a media_type, or as a local path:

model.decide({
    "state": {"claim": {"merchant": "Nordic Rail", "total": "740.00", "currency": "SEK"}},
    "images": [{"id": "receipt", "path": "receipt.jpg"}],
    "questions": {
        "total_matches": {"type": "truth", "instructions": "Does the total on the receipt equal the total in the claim?"},
        "items": {"type": "number", "instructions": "How many line items are on the receipt?", "min": 0, "max": 50},
    },
})

The runtime also runs from the command line (python -m decisionnode_edge <model-folder> request.json) and as a local HTTP server (python -m decisionnode_edge serve <model-folder>).

Question types

Type	You provide	You receive	Runs on
choice	1 to 255 options, each with an optional description	the selected option, a confidence and a probability for every option	DecisionNode Edge Mini and the hosted API
score	1 to 10 ordered levels, from low to high	the expected level, a confidence and a probability for every level	DecisionNode Edge Mini and the hosted API
truth	a statement or question, with optional true and false criteria	the probability that the answer is yes	DecisionNode Edge Mini and the hosted API
number	min, max and step (up to 4,096 values)	the most probable value, the expected value, a confidence and the probable values	DecisionNode Edge Mini and the hosted API
point	an image and what to point to	a point (x, y) in pixels or fractions of the image, the probability that the thing is there, and a confidence	DecisionNode Edge Mini and the hosted API
box	an image and what to box	a bounding box (x1, y1, x2, y2), the probability that the thing is there, and a confidence	DecisionNode Edge Mini and the hosted API

Write what the question means into instructions and criteria; the question's key is never shown to the model. Images are seen by every question in the request.

Points and boxes

A point question asks where something is in a picture, a box question asks for a rectangle around it. Add max (2 to 16) to get every match as a list:

model.decide({
    "images": [{"id": "belt", "path": "belt.jpg"}],
    "questions": {
        "pick": {"type": "point", "instructions": "The yellow package closest to the robot arm."},
        "damage": {"type": "box", "instructions": "The damaged package.", "units": "normalized"},
        "parcels": {"type": "box", "instructions": "Every parcel on the belt.", "max": 10},
    },
})

Each answer gives the place (x, y for a point; x1, y1, x2, y2 for a box) in pixels or fractions of the picture, present (the probability that the thing is in the picture at all) and a confidence for the place. A point takes 3 short prompts on the picture and a box 5.

On 300 held-out photos with one object each, Edge Mini puts a point on the object 90.3% of the time, and its box overlaps the true box by at least half (IoU 0.5) 65.7% of the time, with a mean IoU of 0.53. Asked for every match on 197 pictures with up to 16 objects, its points reach a precision of 52% and a recall of 49%, its boxes 26% and 22%. For boxes, DecisionNode Edge and the hosted models are considerably more accurate. On the same photos, DecisionNode places points at 96.0% and boxes at 92.7%, and DecisionNode Flash at 95.0% and 89.7%.

Performance

EdgeModel.load selects the fastest backend installed on your machine. Every backend computes the same internal representation and applies the same decision head and calibration, so answers are consistent across devices. Median time for one question at about 500 and 2,000 tokens of input:

Device	Backend	Install	Time
NVIDIA GPU	vLLM	pip install "decisionnode-edge[vllm]"	7.3 / 15 ms (RTX PRO 6000)
Apple silicon	MLX	pip install "decisionnode-edge[mlx]"	17 / 65 ms (M5 Max)
x86 CPU	OpenVINO	pip install "decisionnode-edge[openvino]", then a one-time build	0.24 / 0.90 s (Ryzen 7 9800X3D)
Any device llama.cpp supports, including NVIDIA Jetson	llama.cpp with the included 8-bit GGUF	llama-server on your path	10.5 / 30 ms (RTX PRO 6000), 30 / 112 ms (M5 Max), 0.58 / 2.7 s (Ryzen 7 9800X3D)
Any	PyTorch (reference)	included	14 / 16 ms (RTX PRO 6000, with optional kernels)

Each backend reproduces the reference bfloat16 answer on at least 98% of a fixed set of held-out questions. Images, and inputs longer than a backend supports, are handled by the PyTorch backend automatically. A request with several questions costs one forward pass per question.

GPU memory in bfloat16 with PyTorch, one request at a time:

Input	Peak memory
Weights alone	1.7 GB

The 8-bit GGUF build needs roughly half the memory for the weights.

Evaluation

We evaluate the DecisionNode models on an internal suite of 15 held-out decision benchmarks. The suite covers routing and triage, classification, scoring against rubrics, rule following, long documents, multilingual input, knowledge-intensive questions, decisions in web tasks and resistance to prompt injection.

Model	Mean accuracy
DecisionNode Edge Mini (bfloat16)	69.2%
DecisionNode Edge Mini (8-bit GGUF)	69.1%

Compared with DecisionNode Edge, Edge Mini gives up about 5 points of accuracy and runs about 1.8 times faster on a CPU. The 8-bit build matches the bfloat16 weights on all 15 benchmarks; 4-bit builds lose accuracy and are not offered.

Intended use

DecisionNode Edge Mini is designed for the frequent, well-defined judgments inside software, where hand-written rules are too brittle and a general-purpose language model is too slow, too costly or too far away:

• routing and triage of tickets, messages, documents and alerts
• classification and scoring against criteria you define in the request
• validation and guardrail checks before an action runs
• reading values from images, such as whether a total matches or how many items are present
• locating things in images: a point for a robot to pick, a box around a defect or a person at the door
• on-device decisions in robots, drones, vehicles and cameras, with the hosted models for the hard cases
• applications that must run offline or keep data on the device

Limitations

• Decisions about people need human oversight. Do not use DecisionNode Edge Mini to make consequential decisions about individuals on its own. Uses in hiring, credit, housing, insurance, education, benefits, law enforcement or health care require a person who reviews each decision and can overrule it, in line with the DecisionNode acceptable use policy.
• Calibrated, not infallible. An answer given with probability 0.9 is wrong about one time in ten. Use the probabilities to decide when to defer to a person or a larger model (see Recommended setup).
• Accuracy varies by domain and language. Evaluate the model on your own data before relying on it.
• Input length. The model was evaluated on inputs of up to 8,192 tokens. The runtime accepts up to 16,384 tokens and rejects longer inputs rather than truncating them.
• Not a generative model. DecisionNode Edge Mini does not produce text. Use it through the runtime; loading it in a text-generation pipeline yields meaningless output.
• Scope. Video input, boosters, knowledge and fine-tuning are available on the hosted DecisionNode platform, not in DecisionNode Edge Mini.

Files

File	Contents
model.safetensors, config.json	model weights (bfloat16) and configuration
readout.safetensors, calibration.json	decision head and calibration
box_calibration.json	the calibration of box confidence on the /v1/systemone route
tokenizer.json, tokenizer_config.json	tokenizer
preprocessor_config.json, video_preprocessor_config.json	image preprocessing settings
decisionnode_edge.json	prompt format and limits used by the runtime
decisionnode-edge-mini-0.9.1-q8_0.gguf, decisionnode_edge_build.json	8-bit GGUF build for llama.cpp and its build record
runtime/	the decisionnode-edge Python package, for offline installation (pip install ./runtime)
examples/request.json	an example request
LICENSE, LICENSING.md, NOTICE	license terms
LICENSE-base	the license of the base model
MANIFEST.sha256	checksums of every file

License

DecisionNode Edge Mini is released under the GNU Affero General Public License v3.0. For use in commercial products and services without the obligations of the AGPL, a commercial license is available from Bynn Intelligence Inc.; see LICENSING.md.

The base model, Qwen3.5-0.8B-Base, is released by the Qwen team under the Apache License 2.0, reproduced in LICENSE-base.

Citation

@misc{bynn2026decisionnodeedgemini,
  title  = {{DecisionNode Edge Mini}},
  author = {{Bynn Intelligence}},
  year   = {2026},
  url    = {https://huggingface.co/bynn-intelligence-com/decisionnode-edge-mini}
}

Contact

Commercial licensing, questions and reports: licensing@bynn.com. The DecisionNode API and accounts: decisionnode.com.