LLM calibration – PJFP.com

Diogo Almeida spent years inside OpenAI arguing that the entire field was optimizing the wrong thing, and then left to prove it. In this long interview recorded days after the launch of Jev, the TypeSafe co-founder and CEO lays out the thesis he could not build where he was: that language models have been tuned to please humans when the real customer should have been code. The conversation runs from the internals of mode collapse to the design of a three-primitive API, from a trillion tokens a day to why he thinks the entire “pace the frontier” debate rests on an assumption nobody examines. It is the most technically unguarded founder interview of the year, and it is also, in places, a founder who admits he has cried several times this week.

TLDW

Almeida describes Jev as the first of a new class of models he calls machine native system one models, or large programmable models, where the consumer of the output is code rather than a human reader. He explains why RLHF’s mode collapse poisons calibration and makes string models bad at decisions, why refusal is a type error that has no business existing in an API, and why he refuses to publish public benchmarks because they are trivially gameable. He walks through the three API primitives and how each maps to a programming construct, argues that system messages are global variables and that problems should be decomposed into many cheap parallel questions, and explains why robustness rather than determinism is the right north star so there is no seed parameter. He gives the economic thesis: total factor productivity growth above three percent within five years, all models currently tied at roughly zero percent of economically valuable work, and an inverse SaaS apocalypse rather than mass unemployment. He attacks the frontier pacing argument as a sleight of hand that assumes everyone must keep scaling RLVR, says zero RLVR is optimal for his model shape, calls most neolabs value destroying, and says that if you gave him a billion dollars he would not pre-train. He tells the story of leaving OpenAI, including the Thanksgiving GPU run during the board coup, the fight to ship InstructGPT and the disappointment of watching it become a copywriting slop engine. He closes by giving away two research agendas he will not pursue himself: genuinely intelligent games, and coding agents freed from what he calls the tyranny of the KV cache.

Thoughts

The sharpest idea in the first half is the claim that refusal is a type error. It sounds like a joke and it is not. Almeida’s point is that a refusal is an unmodeled return value: the caller asked for a decision and received an apology, which no type signature anywhere in the stack accounts for. A human in a chat window can absorb that. A dependency running unattended in the background cannot, and neither can the third party who imported that dependency and has no idea an AI is buried in it. From there he makes the more uncomfortable argument, which is that safety alignment and capability alignment are structurally opposed. Capability alignment means doing what the caller asked. Safety alignment means following somebody else’s instructions instead of the caller’s. That is a perfectly reasonable trade for a consumer product with parents and children using it, and an incoherent one for an API. His analogy is that intelligence should be infrastructure like a database, and databases do not audit what you query them for. The host pushes back properly on this, raising military use, and Almeida does not dodge: he says he would prefer his technology not be used to kill people, he will put his thumb on the scale socially, and he will not do it at the technological layer, because every overfit to a particular concern fractures the model’s general intelligence a little more. You can disagree with the conclusion. It is a real position, consistently held, and it is far more thought through than the usual libertarian shrug.

The middle of the conversation contains the part practitioners should actually steal, and it has nothing to do with Jev specifically. Almeida’s view is that the industry has been writing AI code in the worst possible style: one enormous system message containing all the state and all the instructions at once, then hoping every instruction lands, then bolting on a second model to check whether the first one behaved. He calls system messages disgusting global variables, and the comparison holds up. The alternative he pushes is to pass structured, nested, semantic objects rather than templated strings, and to decompose a task into many small independent questions asked in parallel rather than one large one. The payoff is not elegance, it is measurability. When you find a failure, you do not rewrite a prompt and hope; you add a question, set a threshold, keep the case as a test, and it is fixed permanently rather than until the next context rot. He calls this ML without the ML, and it is the most accurate three-word description of the workflow I have heard. There is a real cost he acknowledges openly: decomposing means paying for overlapping context repeatedly, which is exactly why nobody did this before, because with chat-priced models it was slower, more expensive and worse. His answer is that intelligence per dollar is the metric that unlocks the pattern, and the trick he offers for the remaining cost is to pay for a large state once and fan many cheap ID-addressed questions across it.

Then there is the economics, which is where the interview stops being about a product. Almeida is the only lab founder I have heard name total factor productivity growth as the target, and he wants above three percent within five years. The corollary is brutal and he says it plainly: every model on the market today is tied at roughly zero percent of the world’s economically valuable work, and he would guess the real figure has not yet crossed one percent. He then poses the question the whole field has been avoiding, which is how a technology that can approach millennium prize problems in mathematics has automated essentially none of the boring, unsatisfying, rote work that actual people are actually stuck doing. His answer is that the engine is fine and the plugs are missing. The supporting observation is devastating in its simplicity: it is 2026, software is functionally identical to 2019 software, and the only visible difference is a chat box in the corner that cannot be trusted with any decision the company has a stake in. His prediction is not the SaaS apocalypse everyone expects but the inverse, because the incumbents are the ones who actually know which tasks are worth automating. He also predicts no mass unemployment, which given the rest of his worldview reads less like optimism and more like a man who thinks the technology is currently too unreliable to be the threat people fear.

The most genuinely contrarian stretch comes late, when the host raises frontier pacing and the joint statements the labs have been signing. Almeida’s response is that the argument is internally consistent and starts from a premise with alternatives. The pacing case assumes that progress requires ever more RLVR, which means giving models ever broader latitude to do arbitrary things in the middle of a trajectory, because that latitude is what makes them powerful afterward. If that is the only path, then yes, the world gets dangerous. But he does not need to do more RLVR at all. He says zero is the optimal amount for his model shape, which turns the safety discussion from a law of nature back into a research choice. He calls it a sleight of hand, and then says something that lands harder: the people at fault are not the public and not the policymakers, but the researchers, because the public reasonably assumes the labs are pursuing the best available direction and has no way to know what optionality exists. He extends the same complaint to the funding environment, saying most neolabs are value destroying because they redo work from scratch with a low chance of moving anything, and that valuing pure research pedigree is backwards when what actually creates value is picking the right task. The interview also contains an uglier detail that he visibly does not enjoy hearing, which is the host relaying that in at least one room the pacing conversation is political positioning around the 2028 election. His reaction is the most human moment in two hours: he says it makes him lose faith in humanity a bit, and that he would rather stay a naive technologist.

The last twenty minutes are the reason to watch the whole thing, because Almeida spends them giving away work he will never do. The one that matters is coding agents freed from what he calls the tyranny of the KV cache. His argument is that the cache is why agent architecture is stuck: to use it efficiently you must keep appending to a single linear context with a single model, which forbids state management, abstraction and decomposition, the three things software engineering figured out decades ago. That constraint, he says, is the actual explanation for why routing is hard, why sub-agents disappoint, and why compaction remains an unsolved mess. You cannot hand a sub-agent a genuinely smaller task because the state you would need to pass costs more intelligence to summarize than the task itself is worth. If context becomes cheap enough, the shape changes completely: hierarchies of labeled subtasks you can search for relevant context on demand, parallel agents reading each other’s state, swarms coordinating with real locks instead of asking each other what they are working on. And then the reframe that is worth the price of admission on its own, which is that continual learning is not a learning problem at all. Starting from scratch every session and then inventing an exotic research program to fix it is strange when the actual deficiency is that you have no cheap way to look anything up. It is a memory management problem. He is right, he knows he is not going to get to it, and he is openly hoping someone reading takes it.

Key Takeaways

Jev is the first of what Almeida calls machine native system one models, or large programmable models. The defining property is that code, not a human reader, is the intended consumer of the output.
The class name matters more than the product name. He is not attached to “system one models” but rejects “decision models” because there are machine native types coming that are not decisions.
The model is named after Jevons paradox and is optimized for intelligence per dollar. Jev is the brand for whatever sits on the intelligence per dollar frontier, not for raw capability.
His critique of RLHF centers on mode dropping. A calibrated, mode covering distribution tolerates outliers, while RLHF-tuned models drop minority modes and become conservative because visible errors are punished far harder than subtly wrong output that looks right.
That same mechanism is his rebuttal to Yann LeCun’s famous slide about error compounding with sequence length. He calls it mathematically obvious and empirically wrong, and says mode collapse is precisely why the predicted failure does not occur.
He rates LeCun as among the most accurate thinkers in the field while declining to endorse JEPA as the fix, calling it excellent early research whose practicality is unproven.
Refusal is described as a type error. A refusal returned into a background dependency breaks software stochastically, and the downstream consumer has no way to know an AI is in the chain.
Safety alignment is framed as the opposite of instruction following, since it means obeying a third party rather than the caller. He considers it appropriate in a first party product and unacceptable in an API.
His preferred metaphor is intelligence as a database rather than a coworker. Databases do not police what they are queried for, and he argues the same boundary gives software engineers maximum power.
He is opposed to public benchmarks on principle, arguing they are gameable even by labs trying not to game them, and citing the era when every lab had a team collecting MMLU-shaped data.
He is not anti-measurement. TypeSafe runs internal evals but treats not fooling itself about model quality as a top level discipline, because any alternative incentive corrupts the number.
Trust, in his model, comes from putting a model into your own workflow and measuring it there, plus a company that keeps adding nines of reliability over time.
His “bitterest lesson” is that choosing the right task and setting the right north star beats both compute and algorithms. He counts only about two and a bit such shifts in the LLM era: RLHF, RLVR as a fractional one, and now RLCD.
RLCD is presented as a north star rather than an algorithm, in the same way RLHF names the task of instruction following rather than PPO specifically. No paper has been published on it.
He calls data the thing that determines model capability and is hiring what he describes as infinite data people, insisting they be the highest status role rather than treated as a slur.
TypeSafe deliberately does not train on user data, even though it probably could. Real usage follows a power law that would overfit the model to the present when the goal is unbuilt future use cases.
His layering analogy is that today’s LLMs are UDP and his models are TCP, with many more layers of machine native intelligence still to be built on top.
There is no seed and no determinism guarantee. He considers determinism mildly useful for unit tests but the wrong north star, and says robustness, meaning similar outputs for semantically identical inputs, is the property that matters.
TypeSafe tests robustness by injecting UUIDs and nonces into otherwise identical prompts and checking that outputs stay stable, which he notes most LLMs fail badly.
He commits firmly that deployed models will not be silently changed, calling that practice insane for an API, while explicitly declining to promise long term support for any given version.
New model versions will ship faster than developers are used to. An LTS designation for the current version is under consideration because fracturing the fleet across many versions is worse than the alternative.
The three API primitives are a boolean-like type whose unusual spelling derives from the letters of Bernoulli, a score, and a choice. All three are new concepts rather than existing programming types, on purpose.
Each primitive maps to a programming construct: the Bernoulli-derived type to an if statement, a score to sorting or thresholding, and a choice to a switch on an enum that you can optionally hydrate into a function.
They were deliberately not named int, float or bool so that tools like Instructor or Pydantic could not silently coerce a score into an integer and mislead the developer.
Inputs including state, instructions and criteria can all be structured JSON objects. He argues that flattening them into a templated system message is old thinking, since stringification is for human output.
System messages are called disgusting global variables. His alternative is many small explicit questions asked in parallel, each independently evaluable.
His worked example is refusal itself: rather than asking “should I refuse,” ask many independent questions about specific situations, so a missed case is fixed permanently by adding a question and a threshold.
He calls this approach ML without the ML, since thresholds are tuned against real examples rather than trained.
A practical cost-saving pattern he recommends: pay for a large state once, attach IDs to every message or element, then fan many cheap parallel questions across those IDs.
Fine tuning is not offered and he is ambivalent about it, noting that generality often helps edge cases within a narrow task and that other labs have launched and then withdrawn fine tuning.
His preferred alternative is calibration plus a cascade: trust a confident small model, escalate ambiguous cases to a larger one. Multiple model sizes are explicitly on the roadmap.
Intelligence per second is treated as a separate metric from intelligence per dollar. He acknowledges the magic of the 1 to 100 millisecond latency band but says that is not Jev’s niche.
The launch passed a trillion tokens per day, and he emphasizes that the volume holds overnight, meaning machines rather than humans experimenting.
He considers waitlist signups meaningless for a developer platform. One power user’s for loop outweighs the entire world trying a few queries, and rate limits are the metric that actually binds.
Pre-launch validation went badly. More than half the people who tried it did not understand it, non-technical staff feared they were selling a vitamin rather than a painkiller, and revenue before launch was almost nothing.
That experience makes him question product market fit as a concept, since the product and the market both existed while the response was indifference right up until it was not.
His economic north star is total factor productivity growth above three percent within five years, a metric he notes no other lab talks about and which he ties to the original OpenAI charter language.
He believes all models today are roughly tied at zero percent of the world’s economically valuable work, likely under one percent, and that the real shift will show up in economic statistics rather than demos.
He expects an inverse SaaS apocalypse, with existing software companies supercharged because they know best which tasks are worth automating, and no mass unemployment.
Whether a task is system one or system two is framed as an empirical question, not a philosophical one, comparable to asking why robotics has not worked despite the money spent.
The host’s own testing found Jev state of the art on single hop reasoning with monotonic degradation as hops increase, which Almeida accepts as a fair characterization of the current frontier.
Each paradigm is defined by its north star: RHLF optimizes to please humans, RLVR optimizes benchmarks because a benchmark is by definition programmatically verifiable, and RLCD optimizes reliability for programmatic use.
There is no reasoning trace in Jev and he considers string-based reasoning slow, inefficient and fragile, while leaving the door open to cheaper forms of reasoning.
He claims Jev degrades less in long context than other models, and frames context length as a case study in giving people what they say they want versus what they need.
Four use case families were mapped from first principles before launch: dark data analysis, coding agents, real time intelligence in the loop, and intrinsically composable smart software.
Dark data is the enterprise unlock. Companies hoarded data they could never afford to run an LLM across, and he calls it a data scientist’s dream.
Voice-driven computer control surprised him. He says he is anti-demo as much as he is anti-benchmaxxing, and wants to find the weaknesses before celebrating.
He sees a structural problem for the leading coding agents: they are architected around a single model world, while open source agents are free to experiment with multi-model patterns.
Because open agents can copy each other, the first one to find a pattern that only works with a cheap system one model will pull everyone along with it.
On frontier pacing, he argues the entire case assumes continued scaling of RLVR, and says zero RLVR is optimal for his model shape, which makes the danger a choice rather than a law.
He blames researchers rather than the public for closed-mindedness, since the public cannot be expected to know what alternative directions exist.
He calls most neolabs value destroying, criticizes the valuation of pure research pedigree, and says the labs are the right place for researchers who want to explore rather than solve.
If given a billion dollars he says he would not pre-train, preferring to slice, combine and Frankenstein existing capability because it solves problems more cheaply.
He hates fracturing intelligence, and blames the chat-first plus reasoning-mode architecture for sycophancy, overconfidence, hallucination and the bold-and-emoji style that wins human preference leaderboards.
For that reason the model is not trained to claim an identity. He would rather it report what the internet thinks than be told it is Jev from TypeSafe, because identity training fractures the model.
The origin story runs through a Thanksgiving research sprint on idle OpenAI GPUs that coincided with the board coup, which he describes only as annoying while declining to elaborate.
He fought to ship InstructGPT, including an unpublished algorithm he wrote himself because cleaning the PPO data was too slow, and it took roughly half the LLM market almost immediately.
The disappointment that followed shaped everything: instruction following looked superhuman yet ended up powering copywriting tools, and he worried they had made the internet worse.
The insight that became TypeSafe came from working backwards from an AI-based economic revolution and asking who would be calling the API. The answer was many nines of code, and all the optimization was aimed at humans.
Sam Altman read the document and told him to go work on it. He assumed Anthropic must already be doing it and that he was too late.
The company formed fast: he recruited Eric first, asked Sasha only for a sanity check and she folded her own startup on the spot, funding closed within two weeks and people moved into his apartment.
He describes himself as zero percent entrepreneurial, says he never wanted to be a CEO, and traces the decision to feeling disempowered inside an organization where every conversation routed back to ChatGPT.
His longest-standing grievance is the function calling interface. He wanted a genuine probability per function so a developer could set their own refusal threshold rather than pleading in a system message.
The first task he gives away is intelligent games, where even simple state machines for NPCs could make a world far more compelling without calling a model in the game loop.
The second is coding agents freed from the KV cache, which he argues is the hidden reason routing, sub-agents and compaction are all hard, and the subject of his piece titled after the Wu-Tang line.
His reframe of continual learning is that it is a memory management problem, since the difficulty is having no cheap way to look up historical context rather than any failure to learn.
He imagines agent swarms that read each other’s state and coordinate with real locks, plus searchable trees of labeled subtasks, once context becomes cheap enough to stop passing everything upward.
Latency is now a hiring constraint. He is building out infrastructure geographically because the speed of light matters, and is unhappy that European users get only a threefold speedup.
The stated ambition is not to be a one model company but to become something like an AWS of intelligence, shipping more shapes of machine native intelligence beyond Jev.

Detailed Summary

A New Class of Models Where Code Is the Consumer

Asked the definitive question of what Jev actually is, Almeida starts with the category rather than the product. The industry has pre-trained models built to autocomplete the internet, RLHF models built to reply to text in a chat window, and RLVR models sitting in an awkward gray area beside them. What it lacks is a class of models whose outputs are meant to be consumed directly by code, which is where the company name comes from. He describes the class as machine native, system one, and large programmable, and says the goal is to make AI as powerful as possible by integrating it with software rather than by wrapping it in a conversation. Jev is the first of these, and the name comes from Jevons paradox because it is optimized for intelligence per dollar. He frames the design space as a tradeoff between reliability, cost, calibration and speed, and says Jev is the name that will attach to whatever sits on the intelligence per dollar frontier rather than to any particular architecture.

Mode Collapse, Calibration, and Why LeCun’s Slide Is Wrong

The most technical stretch of the interview is his account of what RLHF did to probability distributions. He notes that nobody paid attention to the downsides of RLHF in his launch material, particularly mode dropping. He then uses it to resolve a puzzle he clearly enjoys: Yann LeCun’s well known slide arguing that as sequence length grows, the probability of an error compounds toward certainty. Almeida says the argument is mathematically obvious and empirically false, and that the disconnect is exactly mode collapse. A calibrated, mode covering model is not catastrophically punished for outliers, the way pre-GAN generative models produced blurry images rather than dropping minority classes. RLHF-tuned models instead drop the modes and become extremely conservative, because an obvious error is punished hard while a subtly wrong output that looks correct is not. That conservatism is what keeps long strings from derailing, and it is also, in his words, total poison for calibration. His conclusion is that this is precisely why string models are bad at making decisions. He rates LeCun as among the most accurate thinkers in the field while declining to endorse JEPA as the fix, calling it very cool early research whose practicality he will not vouch for, and adding that the research world is full of diamonds in the rough that nobody has polished because they have not picked the right task.

Refusal as a Type Error

He addresses a question his Discord keeps asking, which is why TypeSafe does not implement refusals. His answer separates safety as a principle, which he supports, from safety alignment as an implementation, which he considers misaligned with users. A refusal reaching a human in a coding session is merely annoying, and he suggests developers have been Stockholm syndromed into accepting it. A refusal reaching a dependency running in the background is something else entirely, because the software breaks stochastically based on what a user typed somewhere upstream, and the person who imported that dependency has no idea why. He argues this comes from people who do not understand software and are fixated on an AI coworker metaphor he calls a horseless carriage. What he wants instead is a cognitive core general enough to serve use cases nobody has imagined, which is why it works on tasks TypeSafe never trained for. He draws a hard line between capability alignment, which means doing what the user asked and which developers love because predictability reduces testing, and safety alignment, which by construction means following somebody else’s instructions. The former is what he is chasing to as many nines as he can get, until calling for intelligence is as unremarkable as a database query.

Infrastructure Does Not Police Its Users

The host presses on the obvious objection, which is military use, and Almeida engages rather than deflecting. He accepts there are pragmatic places where such a position can be held, and says the foundation of a general purpose technology is not one of them. He would prefer his technology not be used to kill people and will put his thumb on the scale, but not at the technological layer, because every overfit to a particular concern fractures the model’s intelligence further, and he considers current models already badly fractured. His formulation is that intelligence will resemble a database more than a coworker, and that a database is not responsible for auditing the purposes of its queries. He extends this to customer conversations, describing his bafflement when companies ask permission to deploy: TypeSafe is an API and the caller is a developer, and it should not even be possible for TypeSafe to know what the full downstream task is, because a properly decomposed system does not expose it. He frames that opacity as a feature that gives engineers maximum power, and says the bias will stay out of the technological layer as long as he is in charge.

Why There Are No Public Benchmarks

Almeida is emphatic that he is anti public benchmark and merely lukewarm on private proxy benchmarks. His reasoning starts from what TypeSafe is actually selling, which is intelligence per dollar and per second, and his observation that cost and speed are the things you pay while intelligence is the thing you receive. The problem is that intelligence has an ineffable quality that benchmarks cannot capture, which is why the reaction that mattered after launch was not the video but developers discovering hours later that the model was genuinely usable. He argues public benchmarks are extremely gameable even by labs that try not to game them, recalling when every lab kept a team collecting MMLU-shaped data, which he describes as benchmarking with extra steps. His alternative is vibes and trust until a developer puts the model into a specific workflow and measures it there, paired with a company obligation to keep adding nines. He notes this cost TypeSafe real money during fundraising, when investors wanted benchmarks and the team refused on the grounds that the practice rewards bad actors. TypeSafe does run internal evals, and he insists the discipline of not gaming them is a top level priority that he enforces hard, since otherwise the company would be flying blind on its own frontier claims.

The Bitterest Lesson and the Primacy of Data

He offers his own variant of Rich Sutton’s argument, which he calls his bitterest lesson. Where Sutton’s bitter lesson elevates general methods and compute, Almeida says that data matters far more than compute and that picking the right task with a clear north star is the hardest and most important thing of all. He counts the times this has happened in the LLM era: RLHF, which shifted the task to instruction following and which nobody realized was possible; RLVR, which he scores as roughly a fifth of a shift and generously at that; and now RLCD. On RLCD he is careful to say it is not jargon, because RLHF likewise names a task rather than an algorithm, given that DPO and its descendants are all doing RLHF without using the algorithm from the original paper. The north star for RLCD is programmable AI with programs in the loop and the human removed. He considers TypeSafe a data company in the sense that model capability means data, and is hiring what he calls infinite data people. He describes onboarding them with a talk longer than the interview itself, and explains that the shape of the data follows the shape of the task: RLVR’s data is environments, RLHF’s is human feedback, and TypeSafe has its own kind. His team works like artists studying a cognitive core, finding its jagged edges and addressing each one in a way that generalizes rather than patching a single case.

Robustness Instead of Determinism

Asked why there is no seed parameter, he treats reliability as a catch-all for every reason AI fails to automate something, including type safety, determinism and jaggedness. Determinism means identical inputs producing identical outputs, which he concedes is mildly interesting for unit tests and considers the wrong north star. The property he cares about is robustness: similar inputs producing similar outputs. His test is to inject UUIDs or nonces into otherwise identical prompts and check that the answers stay stable, since the question is semantically unchanged, and he notes how badly most language models fail this. Robustness, he argues, is exactly where people get burned when AI makes decisions. He is not opposed to shipping determinism if developers make the case, but notes it trades against intelligence per dollar, and that TypeSafe is doing what he cheerfully calls disgusting things to stay on that frontier. The host predicts he will be peer pressured into seeds eventually, as every provider has been, and Almeida concedes only that he has been told his brand of unshakable is a polite word for stubborn.

Model Versioning and the Quantization Question

The host raises the concern developers were already voicing, which is that a company facing GPU constraints and optimizing for cost has every incentive to quietly quantize a model after launch. Almeida’s answer is unambiguous: they will not change a model once deployed, and doing so would be insane for an API even if it is fine for a first party product where you can change whatever you like. What he explicitly refuses to promise is longevity. TypeSafe plans to ship new models far faster than developers expect, and he will not commit to long term support for any particular version, though he acknowledges that developers hate broken dependencies and that the current version may get an LTS designation precisely because so many people are using it. The alternative, a fleet fractured across a hundred versions while the company iterates quickly, is what he wants to avoid. He says research is underway on a better mechanism, and predicts model-to-model deltas will typically be smaller than the variance from calling a string model twice, with the large jumps coming when a previously jagged capability becomes smooth.

Three Primitives That Are Deliberately Not Types

The API exposes three primitives, and none of them is named after an existing programming type. The boolean-like one takes its odd spelling from the letters of Bernoulli, because what it returns is a Bernoulli probability rather than a true or false. There is a score, and there is a choice. The naming is intentional: a score is not an integer, and if a library like Instructor or Pydantic silently mapped it to an int or a float, the developer would be misled. He says they erred toward clarity over familiarity. Each primitive maps cleanly onto a programming construct rather than a type: the Bernoulli-derived value drives an if statement, a score drives sorting or thresholding above and below a cut, and a choice is a switch on an enum that you may optionally hydrate into a function call. He is scathing about function calling as the incumbent alternative, describing the enum as the important part and a function call as an extremely ugly way to expose the same thing. More types are coming, and each will map to a programming primitive.

Decomposition, Structured State, and ML Without the ML

Asked for pro tips, he gives the section of the interview most likely to change how people build. Every part of the input, including state, instructions and criteria, can be a structured JSON object, and he says people underread this and assume everything is strings. Flattening structured state into a templated system message is old thinking, because you would never stringify your variables inside a program except when printing for a human. Deeper nesting is harder to reason over and TypeSafe is actively working on that, but the direction makes code more legible and agnostic to implementation. He calls system messages disgusting global variables into which you dump everything and hope each instruction lands, and recommends instead asking many small questions in parallel. His refusal example makes the case concrete: rather than asking whether to refuse, ask many independent questions about specific situations, so that discovering an unhandled case is a good outcome rather than a mystery. You add the question, set the threshold, keep the example as a test, and the behavior is fixed permanently rather than until context rot erodes the prompt. He calls this ML without the ML, and notes the honest caveat that this is exactly the pattern people abandoned before, because with expensive slow models it was worse on every axis than one big call. He is candid about where the models are not yet good enough, singling out automated trading as something people should probably leave to professionals, and pointing to confidence estimates as the mechanism for escalating hard cases to a human.

Calibration Limits, Fine Tuning, and Cascades

The host presses on the obvious gap: thresholding is the only lever a developer has, so what happens when the calibration itself is locally wrong? Almeida immediately corrects the premise that he claimed perfect calibration, then accepts the criticism that his only answers today are decompose further or adjust the threshold. He points to a report issues button and a commitment that every model version will be noticeably better or they will stop shipping. On fine tuning he is genuinely undecided, noting that generality often helps edge cases even within a narrow task, and that other providers have launched and retracted fine tuning offerings. What he finds more promising is calibration plus a cascade, where a confident answer from a cheap model is trusted and an uncertain one escalates to a larger model. He explicitly confirms multiple model sizes are coming, and speculates that if the cheapest intelligence gets cheap enough, people might stop writing regular expressions altogether.

A Trillion Tokens a Day and What Actually Counts

On launch metrics he is careful about which numbers mean anything. The milestone he will name is passing a trillion tokens a day, and what matters to him is that the volume persists overnight, which means machines are calling the API rather than humans trying it out. Waitlist signups, he says, do not matter for a developer platform, and he suspects many signups are not developers at all, arriving expecting a chatbot and leaving confused. His estimate is that if every human on earth wrote a couple of queries it would be a rounding error next to one power user’s loop. The metric that actually binds is rate limits, because once a developer gets value they immediately want more. He admits the team was called marketing geniuses on social media and says there was no marketer, only a group being their genuine irreverent selves, and notes the launch video had reached roughly 38 million views. He is dismissive of neolab framing, says the company sells parody swag about it, and insists what he wants is to be a reliable developer platform rather than the most fashionable lab.

TFP Growth and the Inverse SaaS Apocalypse

The economic section starts from a line the host says he has never seen a lab commit to, which is total factor productivity growth above three percent in five years. Almeida ties it back to the original OpenAI charter language about performing the majority of economically valuable work, and argues the field owes an answer to how a system can solve millennium prize problems while automating a rounding error of actual work. His position is that every model today sits at roughly zero percent, possibly not yet one, and that when the shift happens it will show up in economic statistics rather than in demos. He expects no mass unemployment and a great many beneficial shifts. He also says he is tired of AI being the foreground character and wants it to disappear into the background while the world simply becomes more delightful. His sharpest observation is that software in 2026 is essentially unchanged from 2019, differing only by a chat box on the side that cannot be trusted with decisions the company has a stake in. Rather than a SaaS apocalypse, he predicts the inverse, since incumbents know better than anyone which tasks are worth automating.

Where System One Ends

Asked how to tell a system one problem from a system two problem now that people are trying to put Jev on everything, he says the honest answer is that it is empirical, in the same way scaling laws are empirical and in the same way robotics has not worked despite the money. His belief is that pre-trained condensations of intelligence are fundamentally system one thinkers, and that system one is simply the best available description of what language models are strong at. He is generous about RLVR’s achievements in system two while noting how fragile and fractal the resulting capability is, comparing today’s complaints about jaggedness to the old complaints that ChatGPT was general but bad at grade school math. Each paradigm’s character follows from its north star: RLHF optimizes to please humans, RLVR optimizes benchmarks by definition since a benchmark is just programmatically verifiable output, and RLCD optimizes reliability under programmatic use. The host reports his own hands-on finding that Jev is state of the art at single hop reasoning and degrades monotonically as hops increase, which Almeida accepts while framing the work ahead as unearthing and smoothing capability rather than adding reasoning in strings. TypeSafe does not discard system two tasks; the intelligent behavior on them is low confidence and high uncertainty, which is itself a useful answer.

Four Families of Use Cases

The company mapped its use cases from first principles long before release, and they fall into four families. The first is dark data, the piles of information large companies hoarded but never dared run a language model across because the cost was prohibitive, which he calls a data scientist’s dream and one of the two biggest volume drivers. The second is coding agents. The third is real time intelligence in the loop, where every ten milliseconds shaved improves the product, with e-commerce and assistant-style applications called out and games mentioned with obvious enthusiasm. The fourth is smart software, meaning intrinsically composable systems doing things that could not previously exist, with a programming language built on Jev cited as an example he loves. Computer use arrived from an unexpected direction and impressed him, though he notes he is as anti-demo as he is anti-benchmaxxing and wants to find the weaknesses first. He also volunteers the cost pattern he thinks people are missing, which is to attach IDs to every element of a large state, pay for that state once, and then fan many cheap parallel questions across the IDs.

Coding Agents Built for a Single Model World

He describes something he finds genuinely surprising happening in the coding agent space. The two leading agents are architected around a single model world, which made sense while the game consisted of shopping between broadly similar models at different capability levels. Open source coding agents are currently experimenting freely with cheap system one calls, and since they are all at rough parity and there is only so much you can do with a while loop, the first one to find a pattern that depends on this new model class will briefly hold a monopoly on it and everyone else will copy it immediately. What the incumbents do in that situation is the open question, given their architecture. He says he would love to integrate with everyone, considers it not his job as infrastructure to be opinionated, and mentions an internal design patterns document under review by his team that he hopes to publish for agent builders.

The Argument Against Pacing the Frontier

On the joint statements labs have signed about pacing frontier development, he calls the discussion narrow because it assumes everyone must keep doing more RLVR. He first clarifies that RLVR was never really about verifiable rewards, since that had been failing long before the reasoning era, and is better understood as a shape in which the model is given latitude to do whatever it wants in the middle in order to solve the hardest problems. That latitude is the source of both the capability and the risk, which is why he calls the framing a sleight of hand: the labs are saying they intend to keep doing the thing that produces dangerous behavior, and then describing the resulting danger as a property of the world. He notes he does not need to do any RLVR, and that zero is optimal for his shape. He assigns the fault to researchers rather than the public, since the public reasonably assumes the labs are pursuing the best available direction and has no way to know what optionality exists. He is explicit that his goal is not to convince labs to change direction but to spark hope in software engineers that the things they always wanted automated can finally be automated. Later the host relays that in at least one researcher gathering the pacing position is political positioning aimed at the 2028 election, and Almeida’s reaction is unfeigned dismay, followed by a broader objection to misleading people even in service of what someone believes is the greater good.

Fracturing Intelligence

His unifying technical objection to how models are built today is fracturing. Optimizing a single model for chat and for reasoning forces the intelligence to split, and the resulting pathologies are the ones users complain about constantly: sycophancy, overconfidence, hallucination, and the bolded, emoji-laden, follow-up-question style that performs well in human preference arenas without answering the question. He traces these to the weirdness of strings, where a model must be miscalibrated and mode dropped and overconfident to avoid going off the rails, because the reward model punishes visible errors so severely. This warps the probability space and then interacts badly with reasoning training. He says that at OpenAI nobody was really studying this subtlety because attention was entirely on chat. The principle extends to identity: he will not train the model to say it is Jev from TypeSafe, because that too is a fracture, and what he wants is smooth predictable intelligence that reports what the internet contains. Identity, he argues, belongs to the first party product, not the API, since nobody building a chatbot wants it announcing which model it runs on.

Leaving OpenAI

The origin story is the most personal part of the conversation. The host remembers a Thanksgiving sprint when Almeida cancelled everything to commandeer idle GPUs, which turns out to have coincided with the board coup, an episode he describes as annoying while declining to elaborate. The problem had been on his mind since before ChatGPT launched, when he watched that team do what he considered the right task and cared enormously about the experience. He had fought hard to deploy InstructGPT, including writing an unpublished algorithm himself because cleaning the PPO data was too slow, and it took roughly half the LLM market almost immediately. He genuinely asked whether it was AGI, given it looked superhuman at instruction in, instruction out, and says everyone should have an answer for why it was not. What actually happened is that it powered copywriting tools and what is now called slop, and he worried they had made the internet worse. He went back to first principles and asked what would be calling the AI in an actual economic revolution, humans or code. The answer was many nines of code, while all the optimization was going into the human path. He wrote a document, Sam Altman told him to go work on it, and he assumed Anthropic must already be doing it. Eventually the instruction following team declared victory, he started training models expecting a week of work, and it took years. He called Eric first, approached Sasha only for a sanity check and she folded her startup on the spot, funding closed within two weeks, and people moved into the apartment of a self-described neat freak.

Advice for Researchers and a Verdict on Neolabs

Asked what a frustrated frontier lab researcher should do, he answers bluntly and with visible awareness that he is burning bridges. Most neolabs, in his view, are bad, and he does not want to be counted among them. The reason is that he does not value researchers as such; he values people who care about picking the right task, which makes credentialism backwards since pure research pedigree generally does not create value. His pragmatic read is that neolabs destroy value by redoing work from scratch with a low probability of moving the frontier, and that most he has spoken to want funding to play with experiments rather than a direction. If a researcher genuinely wants to explore, he says the established labs are probably the best place to do it. If they want to solve a real problem and break out of the field’s single-track thinking, they should absolutely go. He extends the same logic to capital allocation with his flattest line on the subject, that a billion dollars would not buy him a pre-training run, because slicing, combining and Frankensteining existing capability is inelegant and solves problems.

The Tasks He Is Giving Away

The closing question asks which north stars he wants other people to take, since his own next fifty years are spoken for. The fun one is games. He points at a demo where NPCs could be controlled by a model and argues you would not even need to call an expensive model in the game loop, since simple intelligent state machines for NPCs could make a static world genuinely compelling, citing his own affection for Stardew Valley. The serious one is coding agents freed from the tyranny of the KV cache, the subject of a piece he titled after the Wu-Tang line. His argument is that efficient cache use forces you into a single model and a continuously appended context, which forbids state management, abstraction and decomposition, and that this single constraint explains why routing is hard, why sub-agents underperform and why compaction is such a mess. You cannot give a sub-agent a genuinely easier task because summarizing the state to hand over would cost more intelligence than the task. If context became cheap, the design space opens: hierarchies of labeled subtasks that can be searched for relevant context on demand, parallel agents reading and writing each other’s state with real coordination rather than asking each other what they are doing, and cheap access to historical context. That last one produces his best reframe, which is that continual learning is a memory management problem rather than a learning problem, since the actual deficiency is having no smart way to look things up. He hopes to publish the document, jokes that his team may veto him, and says that if he were not running a company this is what he would be doing.

Notable Quotes

“How can AI be so unbelievably smart? How can we like solve millennium prize problems in math but still not automate even the most basics of works?”
Diogo Almeida, on the question he says he opens his talks with and which the entire company exists to answer

“Refusal is just like obviously a type error. If you ever want this in a dependency running in the background, what happens if that refuses? What if someone else is using that dependency?”
Diogo Almeida, explaining why TypeSafe does not implement refusals in an API

“We are an API, you are a developer. It’s none of my business, right?”
Diogo Almeida, on companies asking his permission before deploying

“The public benchmarks are extremely extremely gameable. Even if they try not to, they still will. Back in the old days, every lab had a team to collect data that looks like MMLU to make it look better.”
Diogo Almeida, on why TypeSafe published no benchmark numbers at launch

“System messages are like disgusting global variables where you just put everything in there and you put all the instructions at once. And then you hope that every single instruction gets nailed instead of asking the questions in parallel.”
Diogo Almeida, on the prompting pattern he wants developers to abandon

“It’s 2026 now. How is the software basically exactly the same despite AI being so freaking awesome other than sometimes having a chat box on the side?”
Diogo Almeida, making the case that AI has automated almost none of the economy

“I obviously don’t think I need to do more RLVR on our models. I think zero is the optimal amount for our shape, right?”
Diogo Almeida, on why he considers the frontier pacing debate built on an unexamined premise

“If you gave me a billion dollars I wouldn’t pre-train. I still believe that to be true.”
Diogo Almeida, on where he thinks capital is being wasted in AI research

“When that happens, what’ll be calling the AI if AI is an API? Will it be humans or it’ll be code? And I figured it was many nines of code, but all the optimization was going into the humans part.”
Diogo Almeida, on the question that became TypeSafe

“Isn’t it kind of weird that you start from scratch every time and you need to solve a problem called continuous learning? That’s actually like a memory management problem because you don’t have a smart way of looking up the memory, right?”
Diogo Almeida, reframing continual learning near the end of the interview

This is one of the densest founder interviews in recent memory, and the summary above leaves out the tangents on mid-training, the API naming debates, the Discord town halls and the story about his chief of staff making him lock in. Watch the full conversation here.

Tag: LLM calibration

Why I Couldn’t Build Jev at OpenAI: Diogo Almeida on TypeSafe, System One Models, RLCD, and Making AI Programmable