> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tokios.com/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Tokios exposes private local models through https://api.tokios.com using an outbound-only connector tunnel.
> Use 'connector' for the local tokios-connector process.
> Use 'deployment' for the public model name in the API model field.
> Use 'upstream model id' for the model served by Ollama, llama.cpp, vLLM, LM Studio, or another local backend.
> API keys use the prefix sk-tok-. Connector tokens use the prefix ct-tok-.

# System One models: fast decisions without text generation

> System One models answer structured questions with probabilistic decisions — no token generation, 200× faster than autoregressive LLMs. Covers Jev (TypeSafe AI), Bongard (open-weight), and the mask-based techniques that create derivative models from existing weights.

A **System One model** answers structured questions with calibrated probabilities instead of generating text. Where an LLM like Qwen3.6 or DeepSeek-V4.1-Flash produces tokens one at a time (Kahneman's **System 2** — slow, deliberate reasoning), a System One model looks at the input and returns a decision in a single forward pass (**System 1** — fast, intuitive judgment).

TypeSafe AI released the first System One model, **Jev**, in September 2026. An open-weight counterpart, **Bongard**, followed later that month. This page explains the architecture, how these models differ from LLMs, and the mask-based techniques that let you create specialized derivative models from existing weights.

> [!NOTE]
>
> Last verified: 2026-10-20

## System 1 vs System 2 thinking

Daniel Kahneman's dual-process theory describes two modes of cognition:

| | System 1 | System 2 |
| - | - | - |
| **Speed** | Fast, automatic | Slow, effortful |
| **Process** | Pattern matching, intuition | Step-by-step reasoning |
| **Output** | A judgment or decision | A chain of thought |
| **LLM analogue** | Discriminative classifiers, System One models | Autoregressive LLMs (Qwen, DeepSeek, Llama) |

Every LLM you can run locally — Qwen3.6, DeepSeek-V4.1-Flash, Gemma 4, Llama 4 — is a System 2 model. It generates text token by token, reasoning through the problem as it goes. That is flexible and powerful, but slow: each token requires a full forward pass through the model.

A System One model skips the generation step entirely. You give it a structured description of a situation and a typed question. It returns a probability distribution over answers in one forward pass — no tokens, no chain of thought.

## What is Jev

**Jev** is TypeSafe AI's first public System One model, announced September 15, 2026. It is a discriminative transformer trained with **RLCD** (Reinforcement Learning for Calibrated Decisions) on synthetic data.

### How Jev works

1. You provide a **state** — a structured description of the situation (not natural language prose).
2. You ask a **typed question** using one of 3 primitives:
   * **Choice** — select from a set of options
   * **Score** — rate something on a numeric scale
   * **Noul** — a binary yes/no judgment
3. Jev returns a **calibrated probability distribution** over the answer space.

The key difference from an LLM: Jev does not generate text. It produces a probability vector in a single forward pass. TypeSafe reports **200× faster inference** and **400× lower cost** than comparable LLMs for the same decision tasks.

### Jev availability

Jev is **proprietary**. TypeSafe AI has not published architecture details, model weights, or a technical paper. You can access it through TypeSafe's API. It is not something you can self-host or run through Tokios today.

Source: [TypeSafe AI — Introducing System One Models & Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev)

## What is Bongard

**Bongard** is the first open-weight System One model, released September 30, 2026. It performs probabilistic judgment tasks using a different architecture than Jev but the same System One philosophy: structured input, decision output, no text generation.

### Architecture

| Property | Value |
| - | - |
| Total parameters | 7.09B |
| Backbone | T5Gemma 2 4B-4B (encoder-decoder) |
| Head | Trained bilinear head on top of the backbone |
| Training | 3 stages: supervised → JEPA → sandbox RL |

The bilinear head is what makes Bongard a discriminative model rather than a generative one. The encoder processes the structured input, and the head produces calibrated probability distributions over answer spaces.

### JEPA training

Bongard uses **Joint Embedding Predictive Architecture** (JEPA) as its second training stage. JEPA trains the model to predict representations of missing parts of the input in embedding space — not pixel-by-pixel or token-by-token, but in abstract feature space. This gives the model a world model it can use for judgment without needing to generate observations.

### Bongard availability

Bongard is **open-weight**. The paper (arxiv 2609.39111) describes the full architecture and training procedure. You can self-host Bongard and connect it to Tokios the same way you would an LLM — run it behind an OpenAI-compatible endpoint, register a deployment, and call it through `https://api.tokios.com`.

Source: [Bongard paper (arxiv 2609.39111)](https://arxiv.org/html/2609.39111v1)

## Decision-2.0-Vega-27B

**Decision-2.0-Vega-27B** is currently the highest-performing System One model: **73.0% accuracy** on System1-Arena (Oct 2026), beating Jev's 72.6%. It is a 27B-parameter discriminative model designed for fast structured decisions.

## Laya — the practical local System One model

**Laya** by Convai Innovations is the System One model that Unsloth ships as "Decision-Laya" in Unsloth Desktop. It is a non-autoregressive bidirectional transformer (ModernBERT / mmBERT backbone) trained with RLCD (Reinforcement Learning for Calibrated Decisions).

| Property | Value |
| - | - |
| **HuggingFace** | [convaiinnovations/laya](https://huggingface.co/convaiinnovations/laya) |
| **Params** | 322M–421M (3 variants) |
| **Size** | 449–844 MB (GGUF) |
| **Latency** | \~33ms per decision on GPU |
| **Hardware** | 4–5 GB RAM, CPU or GPU |
| **License** | Apache 2.0 |

### Three checkpoints

| Variant | Backbone | Context | Use case |
| - | - | - | - |
| `laya-multilingual` | mmBERT-base (322M) | 1024 tokens | 100+ languages |
| `laya-english` | ModernBERT-large (421M) | 512 tokens | English-only, highest accuracy |
| `laya-typed-decisions` | ModernBERT-large (421M) | 1024 tokens | Structured workflows |

### How Unsloth serves Laya

Unsloth Desktop has built-in Decision API support:

1. Enable in **Settings > API > Decision API**
2. Serves at `POST http://localhost:8888/v1/systemone` — TypeSafe Jev-compatible
3. Supported model IDs: `laya`, `laya-multilingual`, `laya-english`, `laya-typed-decisions`

```json theme={"theme":{"light":"github-light","dark":"css-variables"}}
{
  "model": "laya",
  "state": "Customer says the parcel arrived damaged and wants their money back.",
  "questions": {
    "refund": {"type": "noul", "instructions": "Is the customer asking for a refund?"},
    "department": {"type": "choice", "instructions": "Route to which dept?", "criteria": {"billing": "invoices", "tech": "bugs"}}
  }
}
```

### Train your own decision model

Unsloth lets you fine-tune any supported LLM into a System 1 decision model:

* **Supported bases:** Qwen3.5 (0.8B, 4B), Qwen3.8, Gemma 4, Llama 3.2
* **Method:** LoRA (rank 16) + decision head replacing the LM head
* **Results:** Qwen3.5 0.8B went from 20.7% to 74.3% accuracy across typed-decisions, BANKING77, and CLINC150
* **Hardware:** Works on 4 GB VRAM
* **Docs:** [Train your own Decision Model](https://unsloth.ai/docs/basics/train-your-own-decision-model-with-unsloth)

### Laya vs JEV-27B

| | Laya | JEV-27B |
| - | - | - |
| Size | 449 MB | 53.8 GB |
| Backbone | ModernBERT (421M) | Qwen3.8-27B (25.6B) |
| Accuracy | Good for routing/tagging | Higher (96% of TypeSafe Jev teacher) |
| Serving | Unsloth Desktop (built-in) | vLLM only |
| Endpoint | `/v1/systemone` | `/v1/decide` |
| Hardware | 4 GB RAM, CPU OK | 53.8 GB VRAM, H100/B200 |
| Training | Unsloth can fine-tune | Custom recipe only |
| Fallback to text gen | No | Yes (System 2 on same weights) |

Laya is the practical System 1 for Tokios users today — it runs on anything, ships with Unsloth Desktop, and speaks the Jev API. JEV-27B is the high-accuracy option for workstation hardware.

## Converting LLMs to System 1 behavior: Qwen2.5-RLCD

You do not need a purpose-built discriminative architecture to get System 1-style behavior. **Qwen2.5-RLCD** demonstrates how to convert an autoregressive LLM into a fast decision engine using **parallel constrained decoding** — a form of inference-time vocabulary masking.

### How it works

**1. Prefill the context**

Load the prompt and schema descriptions into the KV cache once, as you would for any LLM inference.

**2. Broadcast the KV cache**

Copy the KV cache across all M schema fields you need to evaluate. Each field gets its own attention context.

**3. Mask the vocabulary**

For each field, restrict the output vocabulary to only the valid choice tokens. Everything outside the valid set is masked to -∞ before softmax.

**4. Read probabilities in one pass**

Calculate normalized probabilities over the masked slice: `P(cᵢ) = exp(zᵢ/T) / Σ exp(zⱼ/T)`. All fields evaluate in parallel in a single forward pass.

### Results

| Metric | Value |
| - | - |
| Base model | Qwen2.5-1.5B |
| Latency reduction | 5.6–7.0× vs standard autoregressive decoding |
| Schema validity | 100% (every output is a valid choice) |
| Hardware | Apple Silicon M4 |

The model returns calibrated confidence scores alongside each decision — the same output shape as a purpose-built System One model, but running on weights you can download and self-host.

Source: [Qwen2.5-1B-RLCD model card](https://huggingface.co/harshatheg/Qwen-2.5-1B-RLCD)

## System1-Arena: how they compare

The **System1-Arena** benchmark (October 2026) evaluated 30 models — 10 System 1, 7 closed LLMs, 13 open LLMs — on structured decision tasks.

| Model | Type | Accuracy | Notes |
| - | - | -: | - |
| Decision-2.0-Vega-27B | System 1 | 73.0% | Best overall |
| Jev | System 1 | 72.6% | 70–500ms latency |
| GPT-6 Luna | Closed LLM | 71.2% | 4× slower than Jev |
| Bongard | System 1 (open) | — | Open-weight, 7.09B |

System 1 models match fast LLMs on classification and routing tasks with **better calibration** (lower Brier scores). They lag on forecasting (48.3% vs 61.6% for LLMs) and closed-loop agentic tasks (17.4% success).

The practical recommendation from System1-Arena: **hybrid routing** — use System 1 models for high-volume, low-latency classification; use reasoning LLMs for forecasting, planning, and open-ended tasks.

Source: [System1-Arena paper (arxiv 2610.21244)](https://arxiv.org/html/2610.21244)

## System One vs LLMs: when to use which

| Task | System One (Jev, Bongard) | LLM (Qwen, DeepSeek, Llama) |
| - | - | - |
| Structured classification | Fast, calibrated probabilities | Works but slower — generates text you must parse |
| Numeric scoring | Direct output | Generates text, must extract number |
| Open-ended reasoning | Cannot do it | Core strength |
| Natural language conversation | Cannot do it | Core strength |
| Code generation | Cannot do it | Core strength |
| Real-time decision pipelines | 200× faster, 400× cheaper | Too slow for high-throughput |
| Few-shot flexibility | Needs typed input format | Accepts natural language prompts |

System One models are not replacements for LLMs. They are complementary: use System One for high-throughput structured decisions, LLMs for everything that requires language understanding or generation.

## Creating derivative models with masks

The broader technique behind both System One models and lighter LLM variants is **applying a mask on top of existing weights** to create a specialized derivative without full retraining. Several approaches exist, all following the same pattern:

```text theme={"theme":{"light":"github-light","dark":"css-variables"}}
W_derivative = W_base ⊙ M      (element-wise mask)
W_derivative = W_base + ΔW     (additive delta)
```

### Mask Fine-Tuning (MFT)

Learns binary masks M ∈ {0,1} on **frozen** model weights. The effective weights become W ⊙ M — you zero out selected weights without changing the rest. Uses straight-through estimators to train the masks via gradient descent.

* Does not update model weights — only learns which to keep and which to zero out
* LLaMA3.1-8B: +4.15 average gain on IFEval
* Outperforms full fine-tuning in some benchmarks

The counterintuitive result: carefully removing weights can **improve** model performance on specific tasks, not just compress it.

Source: [arxiv 2503.22764](https://arxiv.org/abs/2503.22764)

### Sparse pruning (SparseGPT, Wanda)

Post-training masks that zero out unimportant weights. Wanda prunes by |weight| × activation magnitude. Achieves 50–60% sparsity without any fine-tuning.

```text theme={"theme":{"light":"github-light","dark":"css-variables"}}
For each weight matrix W:
  Compute importance scores (magnitude or weight × activation)
  Create mask M where top-k% weights = 1, rest = 0
  Apply: W_effective = W ⊙ M
```

Sources: [SparseGPT (arxiv 2301.00774)](https://arxiv.org/abs/2301.00774), [Wanda (arxiv 2306.11695)](https://arxiv.org/abs/2306.11695)

### Task Arithmetic

Creates a **task vector** that represents the direction in weight space for a specific capability:

```text theme={"theme":{"light":"github-light","dark":"css-variables"}}
τ = W_finetuned - W_pretrained
W_edited = W_pretrained + α · τ
```

Task vectors are composable — you can add capabilities by adding vectors, subtract capabilities to remove them, or combine multiple tasks:

```text theme={"theme":{"light":"github-light","dark":"css-variables"}}
W_multi = W_pretrained + Σ αᵢ · τᵢ
```

Source: [arxiv 2212.04089](https://arxiv.org/abs/2212.04089) (1,956 citations)

### TIES-Merging (Trim, Elect, Integrate, Sparse)

Creates derivative models from multiple fine-tuned variants:

1. **Trim** — remove small delta weights, keep only the top-k% most significant changes
2. **Elect** — resolve sign conflicts when multiple fine-tuned models disagree on direction
3. **Integrate** — average the remaining delta weights into a single sparse mask

Source: [NeurIPS 2023](https://arxiv.org/abs/2306.01708)

### DARE (Drop And REscale)

Randomly drops up to 99% of task vector weights before merging, then rescales the remaining weights to maintain expected value. Creates extremely sparse delta masks. Surprisingly effective despite the aggressive sparsification.

Source: [arxiv 2311.03099](https://arxiv.org/abs/2311.03099)

### LoRA (Low-Rank Adaptation)

The most widely used mask technique. Freezes base model weights W and adds a low-rank decomposition:

```text theme={"theme":{"light":"github-light","dark":"css-variables"}}
W_effective = W + B · A
where B ∈ R^(d×r), A ∈ R^(r×d), r ≪ d
```

Only A and B are trained (typically r = 8–64 vs d = 4096+). The delta weights ΔW = BA form a structured mask of changes from the base model. LoRA adapters can be stacked, swapped, and shared independently of the base model.

Source: [arxiv 2106.09685](https://arxiv.org/abs/2106.09685)

### The common pattern

Every masking technique follows the same flow:

**1. Start with base weights**

Load a pretrained model W\_base. This is your foundation — the weights stay frozen or nearly frozen.

**2. Compute or learn a mask/delta**

Depending on the technique: binary mask (MFT), pruning mask (SparseGPT/Wanda), task vector (Task Arithmetic), sparse merge (TIES/DARE), or low-rank delta (LoRA).

**3. Apply element-wise**

`W_derivative = W_base ⊙ M` for multiplicative masks, or `W_derivative = W_base + ΔW` for additive deltas.

**4. Result: specialized variant**

You get a model tuned for a specific task, hardware tier, or capability — without retraining from scratch.

This is how models like **Bonsai 2 27B** (a ternary-compressed derivative of Qwen3.8-27B at 5.9 GB) achieve 98.2% benchmark retention from the base model. The mask captures what matters; the rest is discarded.

## Relevance to Tokios

System One models and mask-based derivatives both fit the Tokios model: you run the weights locally, and Tokios gives you a stable, authenticated endpoint at `https://api.tokios.com`.

### Decision model endpoints

Every backend that serves System One models exposes a decision endpoint. Tokios tunnels HTTP — it does not restrict paths — so any of these work through `https://api.tokios.com`:

| Backend | Decision endpoint | Model | Notes |
| - | - | - | - |
| **Unsloth Desktop** | `POST /v1/systemone` | Laya (built-in) | Enable in Settings > API > Decision API. Jev-compatible format. |
| **Ollama** (0.35+) | `POST /v1/systemone` | Jev-style models | Native support for System 1 decision models. |
| **LM Studio** | `POST /v1/decisions` | Decision models | See [LM Studio optimization](/guides/lm-studio-optimization.md). |
| **SGLang** (0.5.21+) | Native decisions API | Decision models | See [SGLang optimization](/guides/sglang-optimization.md). |
| **vLLM** + serve\_decide.py | `POST /v1/decide` | JEV-27B | Custom wrapper by AutoTrust. |

The `/v1/systemone` endpoint follows the **TypeSafe Jev API format** — the same schema that TypeSafe's proprietary Jev uses. Laya, Unsloth Desktop, and Ollama all speak this protocol, so a client written for TypeSafe Jev works with Laya through Tokios by changing only the base URL.

### Practical paths

**1. Laya via Unsloth Desktop — easiest path**

Laya is 449 MB, runs on 4 GB RAM on CPU, and Unsloth Desktop serves it at `localhost:8888/v1/systemone` out of the box. Point the Tokios connector at Unsloth Desktop and call `https://api.tokios.com/v1/systemone` from anywhere. Apache 2.0, no license restrictions.

**2. JEV-27B via vLLM — highest accuracy**

JEV-27B (25.6B params, 53.8 GB VRAM) runs on vLLM with AutoTrust's `serve_decide.py`. It inherits Qwen3.8-27B's reasoning capability as System 2 fallback. Needs H100 80GB or B200. The `/v1/decide` endpoint tunnels through Tokios.

**3. Train your own decision model**

Unsloth's [decision model training](https://unsloth.ai/docs/basics/train-your-own-decision-model-with-unsloth) lets you fine-tune Qwen3.5 (0.8B, 4B), Qwen3.8, Gemma 4, or Llama 3.2 into a System 1 model with LoRA + decision head. Works on 4 GB VRAM. Serve the result through Unsloth Desktop or vLLM.

**4. Bonsai 2 27B — compressed LLM, not System One**

Bonsai 2 is a ternary-compressed Qwen3.8-27B (5.9 GB) that still generates text. It is not a discriminative decision model, but it fits on consumer hardware and serves through standard `/v1/chat/completions` via Ollama or llama.cpp.

> **[Quickstart](/quickstart.md)**
>
> Pair a connector, register a deployment, and create your first key end to end.

> **[What size model fits your GPU?](/guides/model-fit.md)**
>
> Match any model — including System One derivatives — to your available VRAM.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.