System One Models: Faster AI Agents, Lower Cost

Most teams default to the biggest model they can afford and call it good engineering. Typesafe AI's new System One models and Jev agent runtime make a concrete case that this is the wrong move for most production agent work.

What Typesafe AI Actually Shipped

System One models are small, fast, cheap models tuned for the kind of work agents do most: routing, classification, slot-filling, short-horizon decisions. Jev is their agent runtime built to orchestrate those models, handle tool calls, and manage state across steps.

The framing borrows from cognitive psychology -- System 1 thinking is fast and automatic, System 2 is slow and deliberate. The argument is that most agent steps are System 1 work dressed up as System 2 problems, and you're paying GPT-4-class prices for tasks a much smaller model handles just as well.

That is not a new observation. It is, however, one that most teams ignore in practice.

Why Model Selection Is an Agent Architecture Decision

When you wire up an agent, every node in your graph has a latency budget, a cost ceiling, and an accuracy floor. A reasoning-heavy step -- say, synthesizing a 20-document research result -- probably needs a large model. A routing step that decides which tool to call next probably does not.

The mistake is treating model selection as a one-time call at project start rather than a per-step decision. What Typesafe AI is shipping makes that per-step model routing easier to implement by giving you a purpose-built small model and a runtime that is designed around it.

The practical effect: lower cost per run, lower latency per step, and agents that can run more steps within the same time budget.

Where This Breaks Down

Smaller models fail in predictable ways. They hallucinate more on long-context tasks. They struggle with multi-hop reasoning. They are less reliable at following complex structured-output schemas without careful prompting and retry logic.

So the architecture question is not "should I use small models" but "which steps can tolerate a smaller model's failure modes, and what guardrails do I need when they fail."

Evals are not optional here. If you drop model size on a step, you need a test suite that catches regressions on that step's output. Shipping without evals and assuming the cheaper model is fine is how you get subtle accuracy degradation that nobody notices until a client does.

Our free AI Opportunity Audit can help you map which parts of your workflow are actually good candidates for this kind of optimization -- it pulls the three highest-impact automations from your current setup without you having to spec anything from scratch.

What a Practical Multi-Model Agent Looks Like

Here is a pattern that works in production:

• A small, fast model handles intent classification and tool routing at the top of the graph.
• A mid-size model handles most tool-call parameter extraction and short summarization.
• A large model is reserved for final synthesis, complex reasoning steps, or cases where the smaller model returns a low-confidence signal.

You add a thin confidence layer between steps -- either the model self-rates, or you run a lightweight classifier on the output -- and use that to decide whether to escalate to the next model tier.

The result is an agent that runs most requests through cheap fast models and only pays large-model prices when the task actually warrants it. Latency drops. Cost drops. Quality holds, because the expensive model still catches the hard cases.

Typesafe AI building a runtime specifically for this pattern is a signal that the tooling is catching up to where the architecture thinking already was.

Closing

If you are evaluating where smaller, faster models could reduce cost and latency in your agent stack -- or want this kind of architecture built for your team -- book a call and we can walk through what makes sense for your use case.