168 Hours Since Jev AI Was Released — And the Operating System Just Changed Species

I have been waiting for this type of AI since 1979.

Not this brand. Not this API. The shape of the machine. The one that does not write a poem when you ask it a question. The one that looks at a situation and decides.

On September 15, 2026, TypeSafe AI walked out of two years of stealth and shipped Jev, the first public System One model. It is named after William Stanley Jevons — the economist who noticed that when a resource gets cheaper, civilization does not use less of it. Civilization uses more.

Jev is the anti-chatbot. It does not draft. It does not apologize. It does not “think out loud” for three minutes and then emit a paragraph you have to parse with a regex and a prayer. You give it state.

You give it typed questions. It answers every question at once, with a probability and a confidence, in 70 to 500 milliseconds. Output tokens are free because there are no output tokens worth metering. Input is $0.042 per million tokens.

The company was founded by Diogo Almeida, a former OpenAI researcher who helped invent the RLHF recipe behind InstructGPT and ChatGPT. After helping invent the chat era, he spent two years building the thing chat was never for. TypeSafe raised a $40 million seed led by DCVC. Current public model: jev-1.13.0.

I have now lived with it for a week. One hundred and sixty-eight hours. I have run it the way I used to run expert systems on a Commodore 64, on a hot-rodded IBM PC/AT, on Connection Machine LISP, on a Macintosh System 7 agent I modified until it looked like something the industry would reinvent in 2026 and call new.

I am telling you, with four and a half decades of scar tissue on this exact problem:

This is how the next operating system works. Eventually the OS is just a Jev-like AI with peripherals.

The history that actually matters

Most coverage starts in 2024, when Almeida, Erik Gafni, and Sasha Sheng founded TypeSafe in San Francisco. That is the corporate timeline. The intellectual timeline is older, and it is why I cannot stay calm about this release.

In 1979 I was already building proto-AI. By 1984, on my birthday, I prototyped on a Commodore 64 from a book that is still in my bones: Artificial Intelligence on the Commodore 64. Four months later I had a paying customer I found by flipping a phone book. The pitch was obscene in its honesty: your business needs this AI, I can build it on a Commodore 64, and if it does not do what I said, don’t pay me. That firm had a military contract. They stayed six years.

Those systems were not chatbots. They were expert systems: a knowledge base plus an inference engine. You encoded what a domain expert would decide given a state. Forward chaining. Backward chaining. Certainty factors. Production rules. On a good day they felt like magic. On a bad day they felt like you were hand-carving a nervous system out of IF-THEN granite.

I called one line of work an Expert Artificial Neuron System. Agencies in DC, Boston, Los Alamos, San Diego, and San Francisco used systems I trained. At the peak there were hundreds of them. One ran for decades on a standalone IBM PC/AT I had turbo’d — I wrote about speeding up the AT in Byte in 1986 — and I am told a descendant of that box is still in a secure room. In 1986 I programmed expert systems in LISP on a Thinking Machines Connection Machine and learned to read the LED field the way a mechanic reads an engine. In 1993 I took Charles River Analytics’ Open Sesame! on Macintosh System 7 — the first commercial intelligent assistant that watched you and offered to automate a habit after it saw the pattern three to five times — and I modified it until it crossed applications and looped on itself. I still have the System 7 Mac.

Here is what those decades taught me, the lesson Silicon Valley keeps having to relearn:

Intelligence that software can use is not the same species as intelligence that humans can read.

The expert-system winter was not a winter of the idea. It was a winter of maintenance. Rules were brittle. Knowledge engineers were expensive. The world refused to sit still inside a decision tree. Then neural nets arrived, then transformers, then RLHF, then a planetary chat window. We got models that could write anything and decide almost nothing reliably enough to put in the kernel.

Every production “agent” of 2023–2025 was a confession of that gap. You asked an LLM a bounded question. It wrote a paragraph. You stripped the markdown. You parsed the JSON. You validated the schema. You retried when it added a poem. You called that tool use. I called it what it was: a 1984 expert system with a novelist sitting in the inference engine.

Jev takes the novelist out of the engine.

Almeida’s launch line is the right one: Models have been superhuman at chat for years, so where is all the automation? The answer was always architectural. Chat is System Two in Kahneman’s language — slow, verbal, deliberative, optimized to please a human rater. Automation is System One — fast, narrow, calibrated, good enough to branch on. TypeSafe trained Jev with Reinforcement Learning for Calibrated Decisions (RLCD), not RLHF. RLHF rewards answers humans like. RLCD rewards probabilities that match how often the answer is actually right. That single shift is the difference between a charming intern and a circuit.

The name is the thesis. Make a machine decision two orders of magnitude faster and cheaper, and you do not “save inference.” You put a decision on every keystroke, every packet, every window focus, every interrupt. You put a decision in the operating system.

What Jev actually is

Jev is a hosted model. Current public alias: jev-latest → jev-1.13.0. You send:

1. State — a string, a JSON object, or an array. A support ticket. A DOM accessibility tree. An OCR dump of the screen. A game state. A log line. A policy plus a transcript. Text only. No images, audio, or video in the official model.

2. Questions — mixed types, evaluated in one parallel pass against the same state.

Three primitives. That is the entire instruction set of the new machine:

Primitive | Question | What comes back

Choice | Which predefined option fits? Up to 255. | The pick, a probability for every option, confidence

Score | Where does this sit on an ordered rubric? | A (possibly fractional) score, a legend, probabilities, confidence

Noul | Is this statement true? | A probability from 0 to 1

It never writes a sentence. It cannot invent a fourth department, wrap it in a haiku, and break your parser. It can still pick the wrong in-schema answer — that is a real limitation. Design for it.

Context is 64k tokens per request, with 32k budgeted to state plus the longest single question. Launch rate limits: 250,000 tokens per second and 1,200 requests per minute. TypeSafe says customer requests are not used as training data and there is no per-account fine-tune. You shape behavior with better state, tighter questions, and thresholds on confidence.

Engineer Paarangat Rai called it the useful name: an AI-native if statement.

That is not a downgrade from ChatGPT. That is the missing opcode.

The technical difference with LLMs, without the marketing fog

1. The output object is different.

An LLM is a next-token model. Its native product is a string. Structured output is a costume the string wears. Jev’s native product is a typed decision. There is no JSON mode because there is no JSON to mode. The schema is the model’s mouth.

2. The sampling geometry is different.

Autoregressive generation is sequential. Token N cannot exist until token N-1 is chosen. That is why a “simple classification” from a frontier model still costs seconds when the model is also narrating its reasoning. Jev uses a parallel sampler. Every question, every option, one forward evaluation. Adding questions barely moves latency. That is why six judgments about one ticket can return together in a fraction of a second instead of as six separate novels.

3. The training target is different.

RLHF makes a model good at being approved. Verifiable-reward reasoning models make a model good at puzzles with a checkable finish line. RLCD makes a model good at knowing how sure it is. Calibration is not a dashboard decoration. It is how you put the model in a hot path: act above 0.92, escalate between 0.6 and 0.92, refuse below. Expert systems had certainty factors for a reason. We forgot, then we paid for the forgetting in retries.

4. The failure mode is different.

LLM failure is unbounded: wrong facts, invented tools, schema drift, sycophancy, prompt injection that turns into a new personality. Jev failure is bounded: it assigns mass to the wrong predefined option. You still need tests. You still own the side effects in code. The blast radius changed species.

5. The economics are different.

Frontier chat: input often $0.20–$10 per million tokens, output commonly several times input, latency 3–329 seconds on hard workflows. Jev: $0.042 / MTok input, output free, 70–500 ms typical. TypeSafe’s own workflow evals claim 193.6× faster and 444.6× cheaper at the high end. Independent tests are more honest and still wild: one careful write-up measured 1.7× against a cheap classifier-style LLM on a single yes/no, and 100.7× when six sequential “thinking” LLM calls were collapsed into one Jev request (74.42 s → 0.739 s). Both numbers can be true. The multiplier is a function of how many decisions you were wrongly asking a novelist to make.

6. It is not “a smaller LLM.”

TypeSafe is explicit: Jev is off the usual intelligence-versus-cost Pareto curve because it is not competing at text generation. Observers suspect a transformer backbone, but the product is not a language model in the ChatGPT sense. Calling it a classifier is closer, and still incomplete. A 2019 zero-shot NLI classifier does not give you 255-way calibrated Choice, parallel Score, Noul, and a developer surface designed to live inside an agent harness.

7. Hallucination, precisely.

“Zero hallucinations” in TypeSafe’s language means zero free-text inventions and zero type errors. It does not mean zero wrong answers. A system that cannot leave the answer key can still circle the wrong letter. That is engineering, not magic.

What I have been doing with it since the hour it shipped

I did not wait for a think-piece. I wired it the way I used to wire expert systems: state in, decision out, act or escalate.

Hours 1–6. First calls against tickets, emails, and log lines I have been sitting on for years. Three questions in one request — department as Choice, urgency as Noul, temperature as Score — and the answer lands before my finger leaves the enter key. The feeling is physical. I have not felt that particular click since a well-tuned production system on DOS. Not “smart.” Finished.

Hours 6–24. Routing. This is the job 90% of “agents” are actually doing while they pretend to be employees. Which tool. Which model. Which queue. Which human. Jev does this as a Choice over a list you already trust. The LLM, if you still need one, only gets the cases that survive the gate.

Day 2. Computer use. Not the screenshot-to-Opus tax. OCR or an accessibility tree becomes state. Possible clicks become a Choice. Type-into-this-field becomes a second question in the same pass. A small writer model is called only when the operation is actually “type text.” That is the architecture the best public demos converged on in week one, and it is the architecture I have believed in since Open Sesame! was watching my Finder in 1993. Perception local. Decision fast. Generation rare.

Day 3. Guardrails. Prompt-injection checks as Noul. “Does this retrieved chunk support the claim?” as Noul. “Is the agent done?” as Noul. These are the questions we used to bury inside a 40-line system prompt and then argue with. They do not belong in a prompt. They belong in a primitive.

Day 4–5. Batch. The expert-system dream was never one clever consult. It was the night shift: a thousand files, a million events, a decision on each, a human only when confidence dropped. I ran Jev across archives the way I used to run rule bases across case files. The cost lands in fractions of a cent. The latency lands in the same breath as the request.

Day 6–7. I stopped treating it as a model and started treating it as a kernel personality. Window focus is state. Keychain permission is a Noul. “Which of these 40 open documents is the user actually working on?” is a Choice. “How interrupted is this human?” is a Score. That is not an app. That is an operating system beginning to notice you.

I will not pretend every test was a miracle. Tight questions win. Lazy questions lose. If you hand Jev mush, you get a confident shrug toward the least-mushy option. Same law as 1984. The knowledge engineer is not dead. The knowledge engineer just got a millisecond inference engine that does not get tired and does not write sonnets.

20 receipts: how fast this thing actually is

These are the public measurements and launch demonstrations from the first week, plus the pattern I kept hitting on my own bench.

1. 70–500 ms typical end-to-end latency versus 3–329 seconds for frontier LLM workflows.

2. TypeSafe workflow evals: 193.6× faster, 444.6× cheaper at the published high end.

3. Independent six-judgment ticket test: 74.42 seconds → 0.739 seconds. That is 100.7×, and 7,499× cheaper in that write-up.

4. Single yes/no against a cheap LLM: still faster — about 477 ms vs 790–928 ms. The modest number is the honest floor. The huge number is the honest ceiling.

5. Zürich → London on live Google Flights with a Jev-driven browser agent: 7.1 seconds end to end, $0.0039, page loads included.

6. Mac computer-use step: $0.0002 per decision versus $0.032 for Claude Opus 5 on a bare screenshot. Model latency 0.13–0.38 s vs 5.2 s. End-to-end step about 1.5 s vs 5.5 s.

7. Same computer-use family: ~100× faster than LLM computer use in public demos, 155× cheaper than Opus 5 in a cross-OS build.

8. Stagehand + Jev remote browser task: $0.001, described by the builders as near-instant.

9. Voice-to-browser loop: transcript to Jev, probabilities back in ~300 ms, then the click. $0.0002 a decision.

10. Doom at ~10 decisions per second, about $7/hour, structured game state in, button Choice out. Real-time is no longer a metaphor.

11. One Doom-style harness measured 212 ms mean decision latency and matched a hand-coded aimer on kills — the point is not esports, the point is a game loop.

12. Chess with tactical facts supplied in state: median API 166 ms, p90 256 ms, a 40-move game in about 7 seconds of thinking time.

13. Blitz chess: Jev beating a thinking frontier model on the clock by not burning the clock. Speed is a rating.

14. Support-ticket bake-off, 30 labeled tickets, three questions each: Jev median 575 ms and $0.022 per 1,000 tickets, versus 1,472 ms / $0.088 for a cheap LLM and 2,002 ms / $1.66 for a strong one.

15. Ego Lite shopping: 20 Amazon product decisions in 3.71 seconds versus 54.45 seconds for GPT-5.6 Sol on the same task. Same 10/10 result in that demo. Less monologue.

16. 777 judgments on a writer’s archive in under 0.7 seconds for about a quarter of a cent.

17. Context-compaction test reported in the wild: 44.8 seconds → 5.6 seconds.

18. Agent-routing cases measured in the 145–271 ms band; coding-harness decisions 239–430 ms.

19. Someone multiplexed Jev across on the order of 100,000 emails and scored them for pocket change in about a minute of wall clock. That is the night-shift expert system I was not allowed to have in 1987.

20. Launch economics as a weapon: $42 per billion input tokens, output free, official headroom of 250,000 tokens per second. At that price you do not “call the model.” You inhabit it.

I keep a twenty-first in my head that is not a benchmark. It is the feeling of asking twelve questions about one messy JSON blob and watching all twelve land together. In the expert-system era, twelve questions was a consultation. In the LLM era, twelve questions was a bill. In the Jev era, twelve questions is a frame of animation.

Why this is how operating systems will work

An operating system is already a decision engine with amnesia.

Scheduler: which process runs. Memory manager: what gets the page. Filesystem: who may write. Window server: which surface is focused. Permission broker: whether this binary may see the camera. Every one of those is a Choice, a Score, or a Noul wearing C.

For fifty years we wrote those decisions as rules because rules were the only thing fast enough to sit in the hot path. When we wanted “intelligence” we put it in user space and accepted seconds. That split — dumb-fast kernel, smart-slow userland — is the split Jev annihilates.

Imagine the OS loop as what it always was:

• Observe state (processes, windows, files, network, the last 30 seconds of user behavior, the accessibility tree, the OCR of the screen, the calendar, the battery).

• Ask typed questions (Is this dialog a phishing pattern? Which of these 40 windows is the task? Does this USB mount look like the user’s known drive or a surprise? How interrupted is the human? Is this compile relevant to the focused project?).

• Act in code. No prose. No parser. Confidence below threshold means ask the human, or wait, or refuse.

That is an expert system. That is Open Sesame! with a frontier-calibrated primitive instead of a heuristic that fired after seeing a habit five times. That is what I was reaching for when I hot-rodded an AT so the consult would return before the user stood up.

The end state is not “Windows with a chatbot in the search box.” The end state is the OS as a Jev-like AI. Files and apps become state. Drivers become actuators. The kernel is a real-time decision bus. System Two models — the writers, the reasoners, the researchers — get summoned the way we used to launch a heavy process: rarely, on purpose, with a budget. System One sits on the interrupt.

I have believed this since before most of the current industry was born. The missing piece was never “more parameters.” The missing piece was a model class that was allowed to be fast because it refused to talk.

Jev is the first one that shipped.

Will Jev itself be the OS? Probably not as a brand. TypeSafe is a hosted API. The official weights are not on your laptop. Latency still includes a network hop. That matters, and it will matter until someone puts a System One model on the Neural Engine, on the NPU, on the microcontroller beside the keyboard. The community is already cloning the idea onto laptops with parallel constrained decoding. That is the tell. When the idea is more infectious than the product, you are looking at a category.

Give it a generation of silicon and the chat window becomes a compatibility layer — the way we still keep a terminal around for people who love typing at ghosts.

Sidebar — Install Jev on Mac, Linux, and Windows

Official Jev is a cloud API, not a local app. You install a client. The model stays at TypeSafe, or at a gateway that already hosts it.

1. Get a key

• Official: console.typesafe.ai → API keys. Environment variable: TYPESAFE_API_KEY.

• Or skip the waitlist via Vercel AI Gateway (typesafe-ai/jev), OpenRouter, or Cloudflare.

• Playground first if you want zero setup.

2. Same SDK commands on all three operating systems

Python 3.10+:

pip install typesafe-sdk

or

uv add typesafe-sdk

Node 20+:

npm install @typesafe-ai/sdk

3. Set the key

• Mac / Linux (bash/zsh): export TYPESAFE_API_KEY="your-key"

• Windows PowerShell: $env:TYPESAFE_API_KEY="your-key"

• Windows cmd: set TYPESAFE_API_KEY=your-key

4. First call (any OS with curl)

curl -X POST https://api.typesafe.ai/v1/systemone \

-H "Authorization: Bearer $TYPESAFE_API_KEY" \

-H "Content-Type: application/json" \

-d '{"model":"jev-latest","state":"Payment failed twice. Refund the duplicate today.","questions":{"urgent":{"type":"noul","instructions":"Does this need urgent support?"}}}'

That is the whole install. No GPU. No 40 GB download. No CUDA ritual. If you want a local Jev-like loop, community repos exist (MLX on Apple Silicon, llama.cpp on Linux / Windows via WSL). Those are replicas of the idea, not the official weights.

The shift

Every few decades the unit of software changes.

Files. Then applications. Then services. Then prompts. Each unit was a bet about where intelligence lives.

Jev changes the unit again. The unit is a typed decision with a calibrated probability. Everything above that — agents, computer use, copilots, operating systems — is orchestration. Everything below that is state.

I have watched this field sell summers and winters since Jimmy Carter was in office. I have watched people confuse a demo that talks with a system that runs. I have watched expert systems get declared dead by people who then rebuilt them out of prompts and called it agency.

One hundred and sixty-eight hours is not enough time to know whether TypeSafe wins the category. It is enough time to know the category is real.

The chat era optimized for the human holding the phone.

The System One era optimizes for the machine holding the loop.

When decisions are this fast and this cheap, you do not add AI to the operating system.

You notice the operating system was always waiting to become one.

I built the first version of this idea on a Commodore 64 and a promise I had no right to make.

Jev is the version that can keep it.

168 hours after Jev. Still here. Still wiring the consult to the kernel.

I am working with a group that will make this open source.

More soon.