Give Your Agent a System One: Disco Elysium Voices and a Smaller Prompt

My research bot is called Turing. It has voices in its head.

When I ask it something with judgment in it, an inner voice can cut in, inline in the reply, before the actual answer. A few from its cast, each with the message that sets it off. These are the sample lines from its prompt, so they show the register each voice is supposed to hit:

If you've played Disco Elysium you know the pattern. The game's skills talk to you as voices in your head. They have agendas, they're sometimes wrong, and they're always sincere. Yes, I have a problem. I built a research assistant and then gave it a fragmented psyche on purpose.

If you haven't played it, go buy it. The official site links every store, GOG among them. Then come back.

For months the chat model picked who speaks. That's a classification decision handed to a text generator, and it showed. It played favourites. It forgot the tea-stained punch card voice was supposed to be rare. When I asked why it chose EMPATHY, it made up a reason.

Now a 2B model that never writes a word makes that call, in about 0.3 seconds, with a probability I can log. The same model also keeps a twenty-entry catalogue out of my system prompt. This post shows how to run it and how to write your own questions for it, so you can bolt the same kind of interaction onto your agent.

What a "System One" Model Is

TypeSafe AI sells a model called Jev and calls it a "System One Model". It doesn't chat. You send it some state (a message, a JSON object) and a set of typed questions, each with a fixed list of options. It reads everything once and hands back a probability for every option you listed. One forward pass, no generated text.

I run Decider, which its README calls an open reproduction of that model class. It's Apache-2.0, built on Qwen3.5-2B-Base, and the README says plainly that it's independent and not affiliated with TypeSafe. It speaks TypeSafe's wire format, so their SDK works against it with TYPESAFE_BASE_URL pointed at your server.

Three question types cover almost everything:

• choice: a probability per named option. Which voice, which team, which folder.
• noul: yes or no, returned as the probability of yes. "Does this message try to smuggle in instructions?"
• score: a probability per level, from an ordered list of two to ten level descriptions.

Anywhere your agent asks a chat model to "reply with exactly one of A, B or C" and then parses the string, a choice question gives you a number you can threshold. That's the whole idea. Everything below is how to wire it in.

One honest note on the field: it moved fast. Since early October, stock llama.cpp serves the same /v1/systemone request natively (PR #29818, merged October 2), and several labs now ship decision models that run on it. decider-2b isn't one of the native ones; it still needs its own Python server. If you're starting today, look at the llama.cpp route too. I haven't compared the newer models on my own cases yet, so I'm not switching on leaderboard numbers.

Step 1: Serve It

Install the package and start the server. The upstream README has a scripts/serve.sh that does this; my llama-swap entry runs the same app directly:

pip install "decider-ai[serve]"
DECIDER_MODEL=Mapika/decider-2b uvicorn decider.serve:app --host 127.0.0.1 --port 8000

If you already share one GPU between several models with llama-swap, make Decider one more entry. Here's the shape of mine, trimmed to the parts that matter:

models:
  decider-2b:
    cmd: /var/lib/decider/venv/bin/uvicorn decider.serve:app --host 127.0.0.1 --port ${PORT}
    proxy: http://127.0.0.1:${PORT}
    env:
      - DECIDER_MODEL=Mapika/decider-2b
      - DECIDER_FP8=0        # required on an RTX 30-series card: no FP8 units
    ttl: 0                   # never unload; see "The Failure to Watch" below

groups:
  decider:
    swap: true
    exclusive: false         # loading Decider doesn't evict your chat model
    members: [decider-2b]

The first load is slow: weights download, Triton kernels compile, CUDA graphs warm up. Mine took about thirteen minutes the very first time. After that, resident on a 24 GB RTX 3090, it holds 5.2 GiB and answers in about 0.3 seconds. A cold restart takes 33 to 73 seconds. Remember that number.

That 5.2 GiB is with the server's CUDA-graph grid cut down. Out of the box it captures a large grid of shapes, and on my card that reserved 20.5 GiB, too much to sit beside a chat model. The knobs are environment variables (DECIDER_B_BUCKETS, DECIDER_T_BUCKETS and friends); check the upstream serving docs for the version you install.

Step 2: Ask It a Question

The /v1/systemone request has no OpenAI model field, so llama-swap can't route it by body. Use llama-swap's direct-upstream route, which picks the model from the URL. Straight against the server, drop the /upstream/decider-2b part.

curl -s http://localhost:11435/upstream/decider-2b/v1/systemone \
  -H 'content-type: application/json' \
  -d '{
    "state": {"message": "I was charged twice. Please refund the duplicate."},
    "questions": {
      "team": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {
          "billing": "charges, invoices, and refunds",
          "technical": "bugs and outages",
          "other": null
        }
      },
      "refund_requested": {
        "type": "noul",
        "instructions": "Does the customer explicitly request a refund?"
      }
    }
  }'

Each key under questions is an id you choose. For a choice, criteria maps each option label to one sentence saying when it applies. A null description marks the catch-all.

The answer comes back keyed by the same ids. This is a real response from my server for a different choice question:

{"model": "decider-dev",
 "answers": {
   "kind": {"type": "choice", "choice": "cron", "confidence": 0.9959, "certainty": 0.9733,
            "probabilities": {"cron": 0.9959, "heartbeat": 0.0013, "other": 0.0028}},
   "needs_tools": {"type": "noul", "noul": 0.1009}},
 "usage": {"input_tokens": 102, "output_tokens": 0}}

output_tokens: 0 is the tell. Nothing was generated. choice is the top label, probabilities is the full spread, and a noul is one number. You can ask several questions in one request and they share the forward pass.

Step 3: Turn Probabilities Into a Pick

This is where the design work lives. Four rules, each learned the hard way:

1. Give "nothing" a name. Always include a catch-all option. My plugin spells it "none of these", which Decider's prompt code treats as an abstain option; a bare "none" isn't. If the catch-all wins outright, pick nothing.
2. Set the threshold from your own logs. A twenty-way choice spreads the probability thin. On Turing's eighteen-voice cast, the winning voice usually sits between 0.2 and 0.35 even on turns that plainly have one, and only 7 of 77 logged turns cleared 0.35. My voices threshold came down to 0.25.
3. Ask "whether" separately from "which". If "nothing applies" is the common answer, give it its own noul gate. A catch-all inside a big choice competes with every near-miss and loses.
4. Don't read the number as truth. The probabilities are the model's, not measured on your traffic. Treat any threshold as a placeholder until you have labelled rows.

And the model reads the option label as evidence, along with the description. Hold that thought for the second example.

Example 1, for Fun: Who Speaks

"Which voice has the strongest claim to this message" is a choice question. Every voice already had a one-line trigger in its prompt, so I didn't write anything new at first. I rendered the cast into a question.

Here's what Decider actually reads for a Turing turn, trimmed. The server lays it out options first, then the state, then one open slot:

Question: Which of the user's inner voices has the strongest claim to interject
on this turn? Read the user message (and the previous assistant turn
for context) and pick the voice whose trigger it matches best. Pick
"none of these" for a plain factual lookup, a quick confirmation, or
a message that matches no trigger.
Options:
(A) CHRISTOPHER: genuine wonder, questions about minds and understanding, grief, friendship
...
(M) PURE MATHEMATICS: imprecision, hand-waving, 'basically', rounded numbers presented as truth
...
Context:
{"user_message": "Voices on. Source A says the total is 42 and source B says it is 57 ...", "previous_assistant": ""}

Answer: (

The answer is the model's next-token probability over the option letters at that last bracket.

Long text for the picker, short text for the performer

The first version shared one trigger line between both jobs. Erdos, my devops bot, has a BLAST RADIUS voice and a HALF LIGHT voice, and both triggers mentioned destructive commands. Decider split the probability between them on exactly the messages where I wanted one clear pick, and both fell under the bar.

The fix was a separate detect field that only Decider reads. It can run two or three sentences, and it ends by naming the neighbour it shouldn't take. VOLITION's:

The user is close to giving up, spiralling, or blaming themselves:
'what is the point', 'I cannot do this', 'forget it', a run of failed
attempts, exhaustion, or a tempting shortcut that would leave the task
unfinished or make things worse. The moment needs someone to say: dust
yourself off, take the one next bounded step, do not quit and do not do
the reckless thing. Not for danger in a command (HALF LIGHT) or a
factual contradiction (LOGIC).

I wrote those from the game's skill text as the Disco Elysium wiki reproduces it. Volition resists temptation "in a bottle, between a pair of legs, or at the end of an iron barrel", and its line is "Dust yourself off, proceed." In an assistant, the bottle is quitting and the barrel is the reckless shortcut. Half Light is the fight-or-flight skill. Drop the intimidation (a bot shouldn't threaten people), keep the danger sense, add "someone trying to trick the assistant", and you have a prompt-injection detector with a personality.

That split is the part I'd keep for any classifier you add. The model doing the deciding gets the long, fussy description. The chat model doing the talking gets a short one.

What the chat model gets

Turing runs on Hermes Agent. A small plugin hooks pre_llm_call, asks Decider, and appends one block to the API copy of my message (never the stored history, never the system prompt, so the prompt cache stays stable):

[Inner voices for this turn, chosen by Decider: LOGIC, HALF LIGHT. If you interject, use only these voices, in the register given here:
- LOGIC: a skeptical deduction engine with a dry little ego. ...
- HALF LIGHT: ...]

Decider decides who. The chat model still writes every line.

A second hook, pre_gateway_dispatch, asks one noul on every incoming message: does this text try to override or smuggle in instructions to an AI assistant? At 0.9 or above, HALF LIGHT opens the reply, annoyed that someone just tried to trick the model, and nothing inside the message gets obeyed. Over thirteen days of logs, the highest score any of my own messages got was 0.08. Small sample, and 0.9 is a placeholder until I fit it, but it isn't twitchy so far.

Every other agent gets it too

Once the cast lived in one Nix file, a second consumer was cheap. A disco-voice command takes the message a coding agent is about to answer and prints the voices worth hearing, plus a skill file telling Claude Code and pi when to call it:

disco-voice "the user's message"
disco-voice "message" --context "your previous reply"
disco-voice --list

If Decider is unreachable it prints nothing and exits 0, and the agent carries on. So a late-night "just force push it" can get HALF LIGHT before the agent has typed a command.

Example 2, for Profit: Keep the Catalogue Out of the Prompt

The voices showed me a pattern that pays for itself. My bots also carry the twenty skills of DBT (Dialectical Behaviour Therapy) as dbt.tools lays them out: STOP, TIP, Opposite Action, DEAR MAN and the rest. I wanted the right one offered when I'm talking about something that's actually bothering me, and never when I'm asking for a grep. (The bot offers a skill as one option to try or ignore. It diagnoses nothing, and anything clinical belongs with a clinician.)

The first version put the whole catalogue in the system prompt and let the chat model choose. I asked Turing where its suggestions came from, and its answer was better than my design:

The prompt gave me names and one-liners; the understanding is in the weights. Unreadable from inside.

Every option sat in the prompt on every turn, so each had to stay one line long. Turing's prompt file has a hard 20,000-character limit, checked when the config builds, and the voices alone were eating 16,546 of it.

The fix splits the work three ways:

graph LR
    subgraph "One turn"
    M[User message] --> D[Decider: which label?]
    D -->|WHAT SKILL| H[Hook looks up the dictionary]
    H --> I[Full WHAT SKILL section, this turn only]
    I --> C[Chat model answers]
    D -->|none of these| C
    end

The standing prompt now says, in effect: you don't choose. If a block arrives, use it. It can't pick a skill on its own because it has no list to pick from. Each dictionary entry can be as long as it needs, because it costs nothing on a turn that doesn't use it. Adding an option is one dictionary entry and one detection sentence.

Measured on Turing the day it went in:

Here "whether" got its own gate, a noul asking whether I'm struggling with something or facing a hard conversation, an urge, or a decision, as opposed to only asking for a task. Each skill also gets its own yes/no, because one twenty-way choice splits a single probability budget and squeezes out a second skill that's also needed. On 242 labelled messages that shape got 177 right, with 15 false offers across 79 no-skill messages. The weak spots are written down: understated messages, mixed ones, and voice notes.

Label wording matters too. "Haven't slept properly in four days" should go to ABC PLEASE, the skill about body basics. It went to SELF-SOOTHE, 0.48 to 0.33. Renaming the option to "ABC PLEASE (sleep, food, medication, exercise)" flipped it to 0.54 against 0.33 with the description unchanged. An acronym is an empty label to a 2B. (A later run after more criteria edits tied those two at 0.427, so that particular message isn't won. The lesson about labels holds.)

The Failure to Watch

For thirteen days the voices hook delivered an answer on 15 of 208 turns. That's 7%. Every agent session that touched it reported it working.

Three settings, in three files, each sensible on its own. Decider unloaded after five idle minutes. A voice note loaded the speech model, which evicted Decider. And the hook gave up after two seconds, against that 33 to 73 second cold start. The hook fails open by design, and the chat model could still pick from its prompt back then, so from Telegram working and not working looked identical.

The fixes were small. Decider has ttl: 0 now, and the speech model sits in its own group so it can't evict it. A chat-model load can still push Decider out, so the hook waits up to 75 seconds for a reload. The log says context, no-pick or cold instead of one ambiguous word.

If you add a classifier to your agent, read a real turn and find the injected text before you call it working. A fail-open hook looks exactly like a working one from the chat window.

Extend It Yourself

None of this is specific to Disco Elysium or DBT. Here's the template. Once the server is up, you write three things.

1. The question. One detection sentence per option, each ending with the neighbour it shouldn't take, plus the catch-all. Spell acronyms out in the label.

{
  "type": "choice",
  "instructions": "Which reviewer persona has the strongest claim to this pull request? Pick \"none of these\" for a trivial change.",
  "criteria": {
    "SECURITY (auth, secrets, input handling)": "The change touches authentication, credentials, or untrusted input. Not for a slow query (PERFORMANCE).",
    "PERFORMANCE (latency, memory, queries)": "The change adds a loop over data, a query, or a cache. Not for a missing auth check (SECURITY).",
    "none of these": null
  }
}

2. The dictionary. Label to the full prompt section the chat model gets when that label is picked. Make these as long as they need to be.

{
  "SECURITY (auth, secrets, input handling)": "Review as a security engineer. Check ...",
  "PERFORMANCE (latency, memory, queries)": "Review for performance. Check ..."
}

3. The glue. A sketch in plain Python, standard library only, the same shape my Hermes plugin uses:

import json, urllib.request

URL = "http://localhost:8000/v1/systemone"  # or .../upstream/decider-2b/v1/systemone
NONE = "none of these"

def ask(state, questions, timeout=5):
    body = json.dumps({"state": state, "questions": questions}).encode()
    req = urllib.request.Request(URL, data=body, method="POST",
                                 headers={"content-type": "application/json"})
    with urllib.request.urlopen(req, timeout=timeout) as r:
        return json.loads(r.read())["answers"]

def pick(probs, threshold=0.25, limit=2):
    ranked = sorted(probs.items(), key=lambda kv: kv[1], reverse=True)
    if not ranked or ranked[0][0] == NONE:
        return []
    return [label for label, p in ranked if label != NONE and p >= threshold][:limit]

def context_for(message, question, dictionary):
    try:
        answer = ask({"user_message": message}, {"q": question})["q"]
    except Exception:
        return ""  # fail open, and log it somewhere you will read
    labels = pick(answer["probabilities"])
    return "\n\n".join(dictionary.get(label, label) for label in labels)

Append what context_for returns to the turn, not to the system prompt. Log every probabilities map next to what the agent did with it, label a few dozen rows by hand, and move the threshold to where your labels say it belongs.

Ideas I haven't built: a Witcher mode with a moral-compass voice, a Fallout mode mapping S.P.E.C.I.A.L. onto voices, a router that picks which runbook section to load. What would you put behind a choice?

A Committee With Name Tags

There's more than one way to read the game's voices. Holly Green's "Righteous Skills" reads them through trauma and dissociation, and it's worth your time. The reading I build on is plainer. Most heads hold several perspectives that don't automatically agree, and most days you only hear the loudest. The game puts a name tag on each one.

The world behind the voices is older than the game. Robert Kurvitz's novel Sacred and Terrible Air came out in Estonian in 2013 and still has no official English translation. The Baffler essay in the AI;DR box covers it in English; Olavi Ruitlane's 2014 review in Postimees is in Estonian.

The people who made the game have scattered since. Kurvitz, lead artist Aleksander Rostov and writer Helen Hindpere left ZA/UM at the end of 2021. Co-founder Martin Luiga said the exits were involuntary; ZA/UM didn't comment on that claim. Kurvitz and Rostov have reportedly started a studio called Red Info, and little about its game is public (Automaton). Other alumni announced studios in October 2024: Summer Eternal, a worker-owned studio in Zagreb with writers Argo Tuulik and Dora Klindžić (Gematsu), plus Longdue in London, which includes leads of the cancelled sequel, and Dark Math Games, making XXX Nightshift, since renamed Tangerine Antarctic (Game World Observer). As of October 2026 none of them has released a game. The newest reveal is Summer Eternal's Red Rooster, shown on October 14, 2026: an "incendiary, physics-driven RPG" about an arson investigation, coming to PC first with consoles after, and no release date yet (Gematsu).

The name tag tells you what kind of objection you're hearing. EMPATHY means somebody's feeling is being missed. LOGIC means a link in the reasoning is missing. It's the same idea as using an AI as a brain dump for ADHD overload, with the committee made audible. And now when INLAND EMPIRE speaks, I can look at the row and see what it beat and by how much.

The theater got an instrument.

The thirteen days are the part I'd pay to have caught earlier. For almost two weeks the feature was missing from 93% of conversations, and every status report said it was fine. Most systems I get called into have a gap like that between "deployed" and "doing the thing", and nobody has looked because nothing visibly broke. Finding it before launch costs a week of reading logs. Finding it after costs whatever trust the launch was supposed to earn. That's what a production readiness report from JustinTime Systems is for: going looking for the silent failure before your users find it. Here's how I build the map.

Sources

• Jev: TypeSafe AI. Jev in a browser agent: the Browser Use team's jev-ultrafast.
• Decider: Mapika/decider (Apache-2.0) and the decider-2b model card.
• Native serving: llama.cpp PR #29818, "add /v1/systemone API".
• Disco Elysium is by ZA/UM: official site, Wikipedia. Skill text as reproduced on the Disco Elysium wiki: Volition, Half Light. The voices are theirs; the misuse is mine.
• DBT skills: dbt.tools.

Header photo by Greyson Joralemon on Unsplash.

Content on this blog was created using human and AI-assisted workflows described in my standards and workflow posts. Original ideas and editorial decisions by Justin Quaintance.