System One Decides. System Two Writes. Mixing Them Cuts Hallucinations.
Most production GenAI stacks ask one model to decide and write in the same breath. That is where hallucinations hide, and where cost grows: the model invents a string, your glue code parses it, and only then do you discover the route was wrong, the passage was irrelevant, or the tool call should never have run.
TypeSafe recently named a clearer split. System One models are built for fast, typed decisions. System Two-style generative LLMs remain the right tool for prose, plans, and explanation. Mixing them, with System One gating cheaply before System Two writes, is one of the most practical ways Australian teams can cut confident nonsense without giving up generation where it earns its keep.
This is not pop psychology. It is an interface choice: what does software need as a return type, and when is free text actually required?
TypeSafe's naming nods to Kahneman, but the engineering claim is concrete. A System One model such as TypeSafe Jev takes state plus typed questions (Noul, Choice, Score and similar shapes) and returns calibrated probabilities. It does not generate free text. Public claims put typical latency around 100ms and input pricing around $0.042 per million tokens, with output tokens effectively free because there is no string stream to bill. Schema matching is part of the contract: the model answers inside types your code already understands.
System Two, in this framing, is the familiar frontier LLM. It generates text, plans multi-step work, explains itself, and drafts tool arguments. That flexibility is why chat and agents exploded. It is also why production teams spend so much time on parsing, validation, retries, and post-hoc guardrails. Strings can be anything, including a hallucination that looks like a JSON tool call.
We have argued this interface split before from the TruFyre side: your chat model writes brilliant answers; production needs typed decisions. System One versus System Two is the same idea with a useful label and a model class built for the decision half.
System Two alone is powerful and expensive in the wrong places. You pay for generation to answer questions that were really gates: is this passage relevant, is this tool allowed, does this draft violate policy? When the model is wrong, the failure mode is often a fluent wrong string. Your observability still shows a successful completion.
System One alone cannot write the customer email, the incident summary, or the multi-hop plan. It is not trying to. If you need prose, you still need a generative model (or a human). Treating every problem as a typed decision will starve the workflows that genuinely need language.
The failure of mixtures that are only prompts is subtler. Asking one LLM to "first decide, then write" still leaves both jobs inside one string sampler. You have not changed the return type. You have asked the same interface to role-play two.
A cleaner production shape looks like this.
1. User or agent turn arrives with the request, tool intent, and context.
2. Retriever, tools, and state assemble passages, schemas, and session facts into something software can score.
3. System One scores route, relevance, risk, or policy fit as typed decisions with calibrated probabilities.
4. Branch in code: drop or refuse below threshold, escalate to a human or higher tier, or allow.
5. System Two generates prose, plans, or tool arguments only when allowed, and only on kept context.
6. Optional System One verify scores the draft for grounding or policy before you commit, respond, or act.
The important move is architectural, not rhetorical. Thresholds live in code. Branches are ordinary software. Generation is a privilege the gate grants, not the default for every hop.
That is the same posture behind tru-jev-harness: cheap typed decisions before expensive generation, with RAG keep/drop and tool allow/escalate/block shaped for TypeSafe Jev. The open harness lives at github.com/trufyrelabs/tru-jev-harness.
RAG gate, then generate. Embed and retrieve as usual. Before you spend a frontier completion, ask System One whether each candidate passage earns a place in the context window. Keep a minimum set only when scores clear a threshold. Generate the answer on the kept set. Hallucinations that come from stuffing weak neighbours into the prompt never get a chance to sound authoritative.
Tool risk gate, then act. Agents fail less often on "can the model invent a tool name" than on "should this tool run now". Score risk, destination sensitivity, and policy fit as typed decisions. Allow, escalate, or block in code. Let System Two draft arguments only on the allow path. Outbound email and irreversible writes stay behind an explicit gate, not behind hope that the chat model refuses.
Draft, then verify. Sometimes you need System Two first: a summary, a reply, a plan. Run it, then ask System One to score grounding against retrieved evidence, policy fit, or refusal conditions. Fail closed to revise, escalate, or drop. Verification does not replace generation; it prices a second cheap look before customer-visible commit.
None of these patterns invent a magic accuracy number. They change when you spend tokens and when software is allowed to trust a string.
Boards and assurance functions ask who decided, on what evidence, and under which threshold. A chat completion that mixed routing, retrieval judgement, and prose into one transcript is hard to audit. A System One decision with an explicit score, a logged threshold, and a code branch is something you can put next to a control owner.
Latency and cost matter in AU production the same way they matter everywhere else, but the operational story is sharper when spend is visible. Paying frontier rates to answer "is this chunk relevant" is optional once a System One path exists. Public Jev claims (roughly 100ms-class latency and $0.042 per million input tokens) are useful as an order-of-magnitude contrast with frontier chat pricing, not as a promise that every workflow will see the same ratio. Measure on your own traces.
Thresholds in code also travel better across environments than prompt folklore. Staging and production can share the same gate functions even when generative models differ by region, vendor, or data residency constraint.
You do not need to rebuild the agent platform to try the mixture. Pick one expensive or risky hop: RAG keep/drop, tool allow/block, or draft verify. Put a typed decision in front. Log the score, the threshold, and the branch. Keep System Two for the write. Soften the blast radius of hallucinations by refusing to generate when the gate says no.
TypeSafe's System One announcement is a useful news hook for that design. TruFyre's view is practical: decide with types, write with language models, and let ordinary software own the mix. If you want a working starting point, read the tru-jev-harness post, clone the harness, or talk to us at trufyre.ai.
