The $7.5B Bet To Fix What's Broken About AI

Reading time: 10m 53s

A new AI race is forming, and TypeSafe is leading the way

Less than a month after coming out of stealth, TypeSafe, the company behind the decision model Jev, closed a Series A round led by Andreessen Horowitz (a16z), with participation from Sequoia Capital, existing investor DCVC, and the tech illuminati (aka a bunch of the best angel investors).

Raising $870 million at a $7.5 billion valuation is no small feat. The question that immediately comes to mind is: how come the huge appetite? Is Jev and the emerging decision model paradigm so promising that it merits investors chucking north of a billion dollars into it?

Let’s find out.

The promise versus reality

The discourse surrounding AI is in a state of superposition.

For those of us who try to stay at the frontier, trying out the newest models, experimenting with different agent harnesses, tools, and MCPs, we are inclined to say that AI is the best thing since sliced bread. 

The juxtaposed side is those who’ve tried it and found it an unreliable, rambling nuisance, good only for creating funny tungtungtungsahur videos.

Irrespective of which camp you reside in, I think it’s fair to say that AI has certainly not lived up to the promise of ushering in the next industrial revolution. 

The promise was, in fact, that AI would bring automation to our everyday lives, letting us focus on the key decisions while it handled the dirty work. 

But if it can’t do the dirty work correctly 100% of the time due to hallucinations and ill-placed confidence when delivering made-up information, then using it becomes another burden you’re forced to shoulder because your company is AI-aligned. 

But how can it be simultaneously extremely useful for some, while for others, nothing more than a playful companion for slop video creation? 

It comes down to the gap between what the tool was designed to do and what people believe its intended purpose is.

Tool optimized for assistance

A 2023 study titled "Navigating the Jagged Technological Frontier" by researchers from Harvard Business School, MIT Sloan, Wharton, and the Boston Consulting Group (BCG) showed this divide in practice. 

In the study, researchers concluded that there are two segments of tasks, one that falls within the frontier and the other that falls outside of it, meaning tasks that AI is capable of handling and those it cannot.

The first set of tasks involved creative product innovation, analytical writing, and marketing strategy, and resulted in:

• 12.2% more tasks completed
• 25.1% faster task completion.
• 40% higher quality results

The latter segment involved an experiment with a task that seemed of the same difficulty, but where researchers deliberately injected contradictory data across interviews and spreadsheets, resulting in the model generating a highly persuasive, fluent, yet completely wrong analysis. Sounds familiar?

Over the years, the exact use cases in which AI excels and where it falls short have become increasingly clear to everyone, with the former including research, copywriting, long conversations, coding, video and image generation, and a few others. 

The latter includes data entry, accounting/taxes, insurance, or basically anything that requires reliability and has no human in the loop.

Breaking it down further, the left column works because any output that the model generates is firewalled by a human who does the final sense-check. 

Conversely, the right column lacks output checks or warnings, making it unreliable for tasks requiring accountability and precision. With real money at stake, most would not implement this technology, or have already failed spectacularly.

From this, we can infer the truth where LLMs stand today - they’re optimized for assistance, not automation. And that is by design, as they were literally built to please humans.

A turning point for LLMs

Today, the models we’re using are trained using some version of Reinforcement Learning from Human Feedback (RHLF) method. As the name suggests, it works by having humans rank multiple model outputs, and the model is fine-tuned to produce more of what raters prefer.

Without realizing it, you were also helping to train ChatGPT’s or other frontier labs’ next models whenever the chatbot asked you to choose between two or more responses. That’s the core concept used in training as well.

While RLHF transformed LLMs from pure next-word predictors into excellent conversationalists and ushered us into the generative AI boom, it also picked up quirks along the way.

These quirks include some we are already acutely familiar with, like overconfidence, hallucinations, or inconsistent results for the same query, and extend to more technical limitations like mode collapse, which manifests as repeating phrases like “You’re absolutely right” and identical response structures across different queries. 

Such quirks aren’t a problem in a conversational assistant, where a person reads the response and applies their own judgment.

Where this does become a problem is when you need the model itself to make a judgment that your code will consume. For layered software systems involving AI, dependability is key, and LLMs alone cannot achieve that.

For that, they need decision models. 

Decision models: A new paradigm

Dubbed a System One Model (SOM), TypeSafe’s Jev is a different, albeit complementary, take on what an AI model should do. 

Featuring $0.042 per million input tokens, free output, and 70–500ms end-to-end latency, Jev is blazing fast and cheap. In fact, TypeSafe estimates that Jev is more than 193.6x faster and 444.6x cheaper than LLMs on certain tasks.

The speed and cost-effectiveness stem from Jev computing all probabilities in parallel rather than generating one token at a time.

In the image below, Jev achieved near-frontier model accuracy while being orders of magnitude cheaper in executing 4 workflows (automations). 

For those wondering, the System One name comes from the concept Daniel Kahneman popularized in his book Thinking, Fast and Slow, where System 1 thinking is fast and intuitive, and System 2 is slower and more deliberate. 

The book describes a number of experiments that examine the differences between these two thought systems and how they can arrive at different results even with the same inputs. 

That last part perhaps best explains the difference between LLMs and SOMs. While both model types understand natural-language input, they produce completely different results, thus serving different use cases. 

Whereas LLMs are designed to produce text (and other formats) for humans to view, Jev is built to make fast, structured decisions that software can use directly, making it an ideal choice for automation. 

Jev is trained using a new training method called Reinforcement Learning for Calibrated Decisions (RLCD), resulting in a model that can return only three defined answers, called primitives: choice, score, and noul.

• Choice is a good fit when the answer comes from a known set of unordered options, for example, routing a ticket to a department, classifying a document type, or detecting a programming language. 
• Score fits when the answer falls on a spectrum, and you can describe what each point on that spectrum means: bug severity, customer frustration, skill level. The levels are yours to define, and the model returns a position along them.
• Noul fits a clean yes/no question where the probability itself is the useful signal: does this message contain personally identifiable information, is the customer requesting a refund, does the resume mention distributed systems?

While Noul is meant to deliver answers to simple binary true-or-false scenarios, the Choice and Score primitives provide an answer along with a probability score on a scale from 0 to 1.

A probability distribution indicates how confident the model is in the accuracy of its answer. This allows developers to build an intelligent decision tree that fits into a larger software environment. 

TypeSafe documentation outlines three initial confidence states that help us better understand how probabilities build confidence in AI-automated systems. Here, a developer can encode different paths depending on where an answer falls on the probability scale:

Example (the probability thresholds can be set to any value):

• High confidence (probability score over 0.9): Act automatically. The model has a clear read, and you can proceed without human involvement.

• Medium confidence (probability score under 0.9): Proceed with caution. The model has a reasonable answer but is not certain. Depending on context, you might ask the user to confirm, flag for review, or gather more information before acting.

• Low confidence (probability under 0.7): Do not act. Route to a human, request clarification, or fall back to a different system. The model is telling you it does not have enough information, or the question is not a good fit.

Math, probabilities, confidence states? At this point, most people (including me) have probably lost the thread.

All we came here to do is find out whether Jev can help us build the next $10 million ARR SaaS business. 

It can, just not in the way you think.

What can you actually do with Jev?

First things first, Jev is not built to replace the LLM behind Claude Code, Cursor, OpenCode, Copilot, Muse Spark, Grok Bot, or similar tools. Instead, it's meant to augment your coding agent to write code that uses Jev to make critical decisions.

Model routing

There are 500+ models on OpenRouter, and choosing the right one for different scenarios is tricky. That’s why OpenRouter features an auto router, which dynamically selects the best-fit model to answer a given prompt. 

With Jev, however, the LLM aggregator reports that on four agent benchmarks, Jev-router solved 82% more tasks than their auto router and a faster median time to first token than every other router.

Hermes Agent skill selection

There are more than 180+ skills in the Hermes Skill directory, and agents select them by truncating and loading them into the system message, which raises costs, impairs selection, and causes context rot throughout the session.

Jev’s Skill Suggestion selects at most one skill per agent turn from a catalog of 180+ skills, using two requests to rank and recheck the top candidates. This results in a 50%+ reduction in the number of times the agent loads the wrong skill.

Customer support

With Jev, a programmer can create a system that automatically escalates refund requests to a human, enhancing the customer support experience.

Here’s roughly how that would look. 

An AI agent asks Jev, “Is the user asking for a refund?” Jev picks up the chat, reads it, sees the word “refund” in the client message, and replies with a 95% probability. The agent then uses this information to create a ticket for a human to review.

Technically, this can be done with regular LLMs, but Jev can do it at orders-of-magnitude lower cost and speed, which is crucial for a company that receives hundreds, if not thousands, of support messages per day.

Double-checking citations

Even though DeepResearch firmly sits in the "too good to be true" column, humans still have to sense-check the results, namely, whether the facts match what’s included in the cited literature. 

But checking by hand is slow and tedious. You have to find the cited document, locate the quote, and read enough of the surrounding text to determine whether it supports the claim. Then repeat the process for every citation.

With the help of Jev, it's possible to automate that process so that high-confidence citations are passed automatically, and anything below a certain threshold is flagged for the user's manual review. 

There are countless other ways to use Jev, but I believe these examples best capture its core value proposition, which is to cheaply triage or classify a large volume of items with Jev, then pass only the relevant items to a full model like ChatGPT or Claude for writing, reasoning, or nuanced responses. 

The industry’s response

Shortly after TypeSafe announced Jev, OpenAI released the DecisionAPI, a decision endpoint for GPT-6 Luna. Everyone immediately took to social media to grave-dance on Jev, not realizing the announcement does quite the opposite - it validates the decision model paradigm and places Jev at the forefront.

Nonetheless, OpenAI couldn’t simply let a startup, let alone one run by an ex-OpenAI employee, take away its business. 

On October 6, OpenAI released the open beta of DecisionsAPI, with pricing at $0.10 per 1 million input tokens and free output. Even though OpenAI is most certainly losing money on this, the move can prevent enterprise developers from offloading high-volume routing workloads onto cheaper alternatives like Jev.

But OpenAI wasn’t the only one to respond rapidly, either.

Cloudflare shipped Clef and Clef Flash, multimodal decision models that convert a state and a schema of typed questions into decisions, priced at $0.24 and $0.09 per 1 million input tokens, respectively.

Amazon’s AI R&D lab, Strands, released Decider 2B, a small, open-source decision model that developers can run locally on their machines. 

Perplexity shipped decider-v1.1, a 27-billion-parameter decision model that even undercuts Jev's cost per 1m input tokens.

Most recently, Microsoft joined the lobby as well.

The fact that so many competitors have launched their offerings so soon after coming out of stealth certainly put a fire under TypeSafe’s buttocks. 

But before we get too hasty and call something “dead,” let’s consult the largest model aggregator, OpenRouter, to gauge how threatened the new startup actually is. 

For now, it’s all blue and a landslide for Jev, but given how fast things can change, I wouldn’t call Jev a guaranteed winner just yet. 

Whoever comes out on top isn’t even a concern of ours unless you’re a TypeSafe investor. Quite the opposite, as we, the consumers, get to use discounted compute while the labs battle it out on the new frontier. 

Conclusion

For all these years, companies have been building toward a singular interface and a singular type of consumer - a human that writes (or speaks) into a chatbox.

What, in their minds, constituted the perfect way to interact with AI also shaped how the models were built and trained, turning them into a friendly yet autistic friend who is super intelligent but, a lot of the time, is too smart and overconfident for its own sake. 

I feel like once TypeSafe came out of stealth, the whole industry had an “aha” moment, so everyone jumped on the bandwagon.

Since most of the population doesn’t fully understand frontier models’ capabilities anyway, and power users are developers or tech-savvy individuals, why not build a model for them that strips away conversational fluff altogether?

More importantly, by introducing determinism into the AI equation, decision models bring us closer to realizing the vision of AI automation by increasing confidence at each workflow step through math and probabilities.

Some believe it's a glorified decision tree, but because Jev is trained in understanding human language, it acts as a translation layer between chaotic human intent and rigid software architecture. 

The result of all this is that it ultimately improves the experience for end users of AI-enabled products by bringing use cases that historically sat outside the frontier into it. 

That said, TypeSafe acknowledges that the current iteration of Jev is not perfect. It describes this “jaggedness” by noting areas where Jev may struggle, such as tasks requiring additional levels of indirection. 

Jev can also be quite literal in its understanding and struggle with tasks that demand numeric precision, among other failure modes described here.

It’s reasonable to assume competitors face similar drawbacks inherent in decision-model design. Still, these issues will likely be ironed out quickly, much as LLMs have advanced in just four years since their release. 

Nonetheless, decision models present a fork in the road for AI development, one that optimizes for use cases beyond the chat interface and makes AI reliable enough to transform the economy through real automation.