System One: a new model category on Berget AI

Today we are launching System One, a new model category on the Berget API. You send a state and a set of typed questions; every answer comes back as a structured judgement — a choice with its probabilities, a level on a scale, or a yes/no probability. No prose to parse. Our first model in the category, Laya, is open for evaluation, running on infrastructure in Sweden.

What a System One model does

Software spends its days making small judgements. Which team owns this ticket? Is there a credential in this file? Does this record already exist? The usual approach is to prompt a chat model and parse free text. That works until the decision sits in a request path: prose must be parsed, prompts burn tokens, and retries add latency to an operation that should be over in milliseconds.

System One makes it a typed request: one state — a chat message, a record, a shell command — plus any number of questions:

• choice — pick one from named criteria; returns the selected key, a confidence, and the probability for every option.
• noul — a yes/no question; returns a probability between 0 and 1.
• score — a level on ordered criteria; returns the level with its probabilities.

One request carries many questions, answered in a single pass. Every response includes a usage block, so meters and budgets behave as they do for chat completions.

curl https://api.berget.ai/v1/systemone \
  -H "Authorization: Bearer $BERGET_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "laya-latest",
    "state": "I was charged twice.",
    "questions": {
      "route": {"type": "choice", "instructions": "Which team?",
                "criteria": {"billing": "Payments", "technical": "Bugs"}},
      "refund": {"type": "noul", "instructions": "Does the customer ask for a refund?"}
    }
  }'

Built for the fast end

Laya is for the questions where a fast, well-scoped answer beats a slow, brilliant one: locating information, routing, de-duplication, pre-screening high-volume streams. One internal experiment shows the pattern: an agent searching a codebase, with Laya choosing the next step — ls, grep or cat, and on which target — in about 25 ms per decision. A ten-step search finished in 2.1 seconds, most of it spent reading files the model pointed at, rather than files a chat model guessed at.

For assessments that carry real consequences — compliance verdicts, nuanced judgement calls — use one of the larger models instead. All Berget models sit behind the same API and key, so a common setup is to let Laya filter the high volumes and send the complicated or risky cases to a larger model.

Jev-compatible from day one

TypeSafe AI coined the System One category and launched Jev earlier this month. Laya serves the Jev contract's request and answer shapes, usage block and batch semantics — 24 of 25 conformance checks pass; the one that fails (choosing among a single option) is an edge case under fix. If you already call Jev with the TypeSafe SDKs, moving to System One is a configuration change:

from typesafe_sdk import TypeSafeClient  # typesafe-sdk 0.7.1

client = TypeSafeClient(
    base_url="https://api.berget.ai",
    api_key=key,
    model="laya-latest",
)

import { TypeSafeClient } from '@typesafe-ai/sdk'; // 0.6.0

const client = new TypeSafeClient({
  baseURL: 'https://api.berget.ai',
  apiKey: process.env.BERGET_API_KEY,
  defaultModel: 'laya-latest',
});

Fast, and measured

We timed the engines on four suites — fixed sets of test questions, each aimed at one kind of judgement, like spotting a credential in a file or picking the next step in a task. Three engines answered them: Jev on TypeSafe AI's hosted API (jev-1.13.0), and a Qwen 3.5-4B and Laya, both running on our servers in Sweden. Calling Jev over the internet added a round trip of about 178 ms, so the fair comparison is the engine estimate: total time minus network time:

Under load, Laya against a Qwen 3.5-2B doing the same job under the same conditions — three replicas of each engine, eight questions per request, a 500 ms service level:

Zero errors, and every response inside the 500 ms service level, for both engines at every concurrency.

Early on accuracy — and we say so

Speed counts for little if the answers are wrong, so here is the part we would rather publish than defend later: on the same suites, Laya trails the larger engines. On the core suite it is right for 56.4% of the questions, against 88.5% for Jev on TypeSafe's API and 84.6% for Qwen 3.5-4B — and it is overconfident about its own answers. Laya today is the open multilingual decision model from ConvAI Innovations, served as-is. That gap is why Laya ships for evaluation only, behind quality gates, while we label our own decision data to fine-tune it. There are early bright spots: on questions asking whether two records are duplicates, Laya scores 75%, the same as Jev and Qwen. We'll publish the full tables, method and datasets in a separate benchmark post.

Until the numbers move, treat Laya's probabilities as hints, and send verdicts with real consequences to a model that has earned its confidence.

Where the data lives

System One runs on our servers in Sweden, under EU jurisdiction, with zero retention: states, questions and answers are never stored, analysed, or trained on — the same policy covers the whole platform. For anyone putting sensitive data in front of a model, the engine that judges sits inside the same jurisdiction as the data itself. Nothing to configure, no residency toggle to remember. The data never leaves the country.

Try it

Laya is open for evaluation now, billed at €0.50 per million input tokens — answers carry no output tokens. Create an API key in the Berget console, point the TypeSafe SDK at https://api.berget.ai, and send your first request to /v1/systemone — the curl above is complete. If you find the edge cases where Laya gets it wrong, we would rather hear about them from you than find them in production.