Model card: System One, recommended setup

MANIFEST.sha256

@@ -2,7 +2,7 @@
 50cbab8a892c5f2993b8c7351a99182507472def3b1374558308605d99b86b32  ./LICENSE-base
 2014f13a6fe1d9178c84cde47bb087a7a74adbe38650f1823a944077081e86d0  ./LICENSING.md
 e4dcac398e39a098e07f625ed239949296a2000d95dcc275cb0d8083ebb51dc9  ./NOTICE
-8d6727e6a244cf82bd9d0eebae028f0924b917b71c0c8628084d224cf3335ba9  ./README.md
+28c7af7e249d0e7bc648f9a83e42740dc37487f748eb12b457b53a6f2fba61e6  ./README.md
 c44489690e63adb3abd8c65ede675fadc5714126e3f866cbd292df824880cb77  ./assets/decisionnode-banner.png
 5febf5c3cb5843034f2251d959c475a4a629dec65bf3ea494b4fed0a3b8aa3aa  ./calibration.json
 28b44a18f60b7e3039c503971b6d194b51c723f0c8a62d56bd6ce7f7f34e9f87  ./config.json

README.md

@@ -5,6 +5,7 @@ base_model: Qwen/Qwen3.5-2B-Base
 base_model_relation: finetune
 library_name: transformers
 tags:
+  - system-one
   - decision-making
   - classification
   - calibration
@@ -17,7 +18,9 @@ tags:
 
 # DecisionNode Edge
 
-DecisionNode Edge is an open-weight decision model from [Bynn Intelligence](https://decisionnode.com). It reads text and images and answers each question with a typed, calibrated decision: a choice, a score, a yes-or-no probability or a number. 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](https://decisionnode.com/docs/api).
+DecisionNode Edge is an open-weight System One decision model from [Bynn Intelligence](https://decisionnode.com). It reads text and images and answers each question with a typed, calibrated decision: a choice, a score, a yes-or-no probability or a number. 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](https://decisionnode.com/docs/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 0.9.1, the larger of the two DecisionNode Edge models. [DecisionNode Edge Mini](https://huggingface.co/bynn-intelligence-com/decisionnode-edge-mini) is a 0.85-billion-parameter sibling for CPUs and constrained devices.
 
@@ -29,6 +32,7 @@ This repository contains DecisionNode Edge 0.9.1, the larger of the two Decision
 - **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 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](#recommended-setup)).
 
 ## The DecisionNode family
 
@@ -63,6 +67,51 @@ Available only on the hosted platform:
 
 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 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 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](https://decisionnode.com/docs/api) directly.
+
+```python
+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"))
+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
 
 | | |
@@ -197,12 +246,13 @@ DecisionNode Edge is designed for the frequent, well-defined judgments inside so
 - 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
+- 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 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.
+- **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](#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 does not produce text. Use it through the runtime; loading it in a text-generation pipeline yields meaningless output.