System One models: fast decisions without text generation

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.

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

You provide a state — a structured description of the situation (not natural language prose).
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
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

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)

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
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:

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

{
  "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

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

Prefill the context

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

Broadcast the KV cache

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

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.

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

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)

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:

W_derivative = W_base ⊙ M      (element-wise mask)
W_derivative = W_base + ΔW     (additive delta)

Mask Fine-Tuning (MFT)

Learns binary masks M ∈ 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

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.

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), Wanda (arxiv 2306.11695)

Task Arithmetic

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

τ = 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:

W_multi = W_pretrained + Σ αᵢ · τᵢ

Source: arxiv 2212.04089 (1,956 citations)

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

Creates derivative models from multiple fine-tuned variants:

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

Source: NeurIPS 2023

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

LoRA (Low-Rank Adaptation)

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

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

The common pattern

Every masking technique follows the same flow:

Start with base weights

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

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).

Apply element-wise

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

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.
SGLang (0.5.21+)	Native decisions API	Decision models	See SGLang optimization.
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

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.

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.

Train your own decision model

Unsloth’s decision model training 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.

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

Pair a connector, register a deployment, and create your first key end to end.

What size model fits your GPU?

Match any model — including System One derivatives — to your available VRAM.

Get Started

Models

Concepts

Reference

System One models: fast decisions without text generation

System 1 vs System 2 thinking

What is Jev

How Jev works

Jev availability

What is Bongard

Architecture

JEPA training

Bongard availability

Decision-2.0-Vega-27B

Laya — the practical local System One model

Three checkpoints

How Unsloth serves Laya

Train your own decision model

Laya vs JEV-27B

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

How it works

Results

System1-Arena: how they compare

System One vs LLMs: when to use which

Creating derivative models with masks

Mask Fine-Tuning (MFT)

Sparse pruning (SparseGPT, Wanda)

Task Arithmetic

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

DARE (Drop And REscale)

LoRA (Low-Rank Adaptation)

The common pattern

Relevance to Tokios

Decision model endpoints

Practical paths

Quickstart

What size model fits your GPU?

​System 1 vs System 2 thinking

​What is Jev

​How Jev works

​Jev availability

​What is Bongard

​Architecture

​JEPA training

​Bongard availability

​Decision-2.0-Vega-27B

​Laya — the practical local System One model

​Three checkpoints

​How Unsloth serves Laya

​Train your own decision model

​Laya vs JEV-27B

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

​How it works

​Results

​System1-Arena: how they compare

​System One vs LLMs: when to use which

​Creating derivative models with masks

​Mask Fine-Tuning (MFT)

​Sparse pruning (SparseGPT, Wanda)

​Task Arithmetic

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

​DARE (Drop And REscale)

​LoRA (Low-Rank Adaptation)

​The common pattern

​Relevance to Tokios

​Decision model endpoints

​Practical paths

Quickstart

What size model fits your GPU?

System 1 vs System 2 thinking

What is Jev

How Jev works

Jev availability

What is Bongard

Architecture

JEPA training

Bongard availability

Decision-2.0-Vega-27B

Laya — the practical local System One model

Three checkpoints

How Unsloth serves Laya

Train your own decision model

Laya vs JEV-27B

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

How it works

Results

System1-Arena: how they compare

System One vs LLMs: when to use which

Creating derivative models with masks

Mask Fine-Tuning (MFT)

Sparse pruning (SparseGPT, Wanda)

Task Arithmetic

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

DARE (Drop And REscale)

LoRA (Low-Rank Adaptation)

The common pattern

Relevance to Tokios

Decision model endpoints

Practical paths