The Typed Decision Revolution: Why Agents Shouldn't Ask LLMs to Make Decisions

A Paradigm Shift Around "Decision-Making" in AI

A recently published technical commentary placed two names side by side: Jev (from TypeSafe AI, founded by a former OpenAI researcher, which just closed an $870M funding round at a $7.5B valuation led by a16z), and VIDRAFT Darwin-ZTC, described as an "open-weight alternative." Both share the same core argument — agents shouldn't be asking a chat model to make decisions.

This seemingly simple observation is turning out to be an underappreciated pain point in the agent engineering stack. Most agent systems today still rely on conversational models to handle routing, classification, or safety judgments — generating a chunk of text, then parsing that prose back into a programmatically usable decision. This process is slow, non-deterministic, and every generated token is an opportunity for drift or hallucination.

What Jev Does — and Why It Matters

According to the commentary, Jev doesn't generate text for routing and classification. Instead, it returns structured decisions directly: a choice selected from a fixed set of options, a score on an ordered scale, or a probability for a yes/no statement.

This means a safety node can be written with logic like if (safety >= 0.9) execute; — no text parsing required. The decision output is a directly consumable typed value, not a natural language string requiring regex matching or secondary inference.

The article also mentions an intriguing detail: OpenAI reportedly shipped a Decisions API within two weeks of Jev's emergence. This serves as indirect confirmation that typed decisions aren't a niche concept — they're a direction that top-tier players are scrambling to capture. When a former OpenAI researcher takes this idea to a $7.5B valuation and prompts their former employer to follow suit within weeks, the heat around this space speaks for itself.

Zero-Token Confidence: The Technical Core of ZTC

When spotlighting the open-source camp, the commentary specifically calls out VIDRAFT's Darwin-27B-ZTC-v2 — an open-weight model that scores decisions using ZTC (Zero-Token Confidence), producing results without generating a single token.

ZTC completes a decision in a single forward pass by applying a calibrated probe to the model's final hidden state. The core logic can be condensed into a few lines:

# One forward pass, zero generated tokens
h     = model(text).last_hidden_state[last_non_pad_token]
score = ((h - mu) / sd) @ w   # calibrated probe -> typed decision

The concept of a calibrated probe is worth unpacking. A probe is essentially a linear classifier trained to extract a specific semantic signal from the language model's internal representations (hidden state vectors). Unlike fine-tuning the entire model, a probe only adjusts a lightweight linear transformation layer at minimal cost. "Calibrated" refers to the use of post-processing techniques — such as temperature scaling or isotonic regression — to ensure the probe's output scores statistically reflect true confidence. That is, when the output is 0.9, the actual frequency of correct predictions should be close to 90%.

ZTC's (h - mu) / sd @ w line captures this entire process: normalize the hidden state (subtract mean, divide by standard deviation), then apply a linear projection to get the final score. The entire inference path requires no sampling, making it inherently deterministic. This is fundamentally different from traditional softmax probability outputs — softmax depends on token generation, whereas the probe operates directly on activations from the final layer of the forward pass.

The model reads the input, completes a single forward pass, and returns a decision directly. Because no tokens are generated, the result is deterministic and cheap enough to run on every single request. This is the three-fold advantage of typed decisions over "let the chat model decide": eliminate generation overhead, remove non-determinism, and avoid the drift introduced when parsing text back into a decision.

The Open-Source Camp: Available Today

The gap between closed and open source is straightforward here — you don't have to wait for a heavily funded commercial product to launch before experimenting with this approach. VIDRAFT's decision stack is fully available under the Apache-2.0 license.

Relevant resources include:

• ZTC methodology and inference code: github.com/final-bench/ztc
• Darwin-27B-ZTC-v2 and decision benchmarks: github.com/final-bench/s1mb
• ONGRID (Ontology Graph + Retrieval + Typed Decision Engine): github.com/final-bench/ongrid
• Models and demos: huggingface.co/FINAL-Bench

For engineers building agent systems, this means you can plug a deterministic, low-cost typed decision module directly into an existing pipeline — without incurring commercial API costs or accepting black-box risks. One caveat worth noting: much of this article draws from VIDRAFT's own promotional material, and details about Jev's funding and OpenAI's follow-up are sourced from a single commentary. Readers should validate claims against independent benchmarks before adoption.

ONGRID is a component of this decision stack that deserves a separate mention. It integrates an ontology graph, vector retrieval, and a typed decision engine into a unified system: the ontology graph structurally represents domain knowledge and the logical relationships between decision options; the retrieval layer finds relevant contextual constraints for each incoming request; and the ZTC model delivers structured decisions based on those constraints. The key advantage of this architecture is the separation of "knowledge representation" from "decision inference" — the graph can be maintained and audited independently, the decision model can be upgraded independently, and the two are decoupled through a retrieval interface. For engineering scenarios requiring interpretable, traceable decision nodes embedded in agent pipelines, ONGRID offers a more controllable alternative to bare LLM calls.

Key Questions Answered

What is a typed decision model? A model that returns structured, typed results — such as a choice, score, or probability — that software can consume directly, without parsing free-form text.

What is ZTC (Zero-Token Confidence)? A method that produces a decision in a single forward pass without generating any tokens, by applying a calibrated probe to the model's final hidden state. It is deterministic and inexpensive.

Why not just use a chat model to make decisions? For a decision task, text generation is overhead, outputs are non-deterministic, and parsing text back into a decision introduces drift. Typed, zero-token decisions sidestep all three problems simultaneously.

Closing Thoughts

From Jev's massive funding round to OpenAI's rapid follow-up, to the open-source ZTC implementation, this wave of "typed decisions" reveals a clear trend: agent engineering is separating "decision-making" from language generation and handing it to faster, more deterministic, and cheaper purpose-built mechanisms. For production-grade agents that prioritize reliability, this may deliver more practical value than chasing ever-larger conversational models.