# 168 Hours Since Jev AI Was Released — And the Operating System Just Changed Species
**作者**: Brian Roemmele
**日期**: 2026-09-22T14:38:03.000Z
**来源**: [https://x.com/BrianRoemmele/status/2102407078958842234](https://x.com/BrianRoemmele/status/2102407078958842234)
---
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](//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](https://x.com/@typesafe)-ai/sdk
3. Set the key
- Mac / Linux (bash/zsh): export TYPESAFE_API_KEY="your-key"
- Windows PowerShell: [$env](https://x.com/search?q=%24env&src=cashtag_click):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](https://api.typesafe.ai/v1/systemone) \
-H "Authorization: Bearer [$TYPESAFE_API_KEY](https://x.com/search?q=%24TYPESAFE_API_KEY&src=cashtag_click)" \
-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.
## 相关链接
- [Brian Roemmele reposted](https://x.com/BrianRoemmele)
- [Brian Roemmele](https://x.com/BrianRoemmele)
- [@BrianRoemmele](https://x.com/BrianRoemmele)
- [47K](https://x.com/BrianRoemmele/status/2102407078958842234/analytics)
- [console.typesafe.ai](https://console.typesafe.ai/)
- [@typesafe](https://x.com/@typesafe)
- [$env](https://x.com/search?q=%24env&src=cashtag_click)
- [https://api.typesafe.ai/v1/systemone](https://api.typesafe.ai/v1/systemone)
- [$TYPESAFE_API_KEY](https://x.com/search?q=%24TYPESAFE_API_KEY&src=cashtag_click)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [10:38 PM · Sep 22, 2026](https://x.com/BrianRoemmele/status/2102407078958842234)
- [47.1K Views](https://x.com/BrianRoemmele/status/2102407078958842234/analytics)
- [View quotes](https://x.com/BrianRoemmele/status/2102407078958842234/quotes)
---
*导出时间: 2026/9/23 09:45:10*
---
## 中文翻译
# Jev AI 发布 168 小时 —— 操作系统的物种已经变了
**作者**： Brian Roemmele
**日期**： 2026-09-22T14:38:03.000Z
**来源**： [https://x.com/BrianRoemmele/status/2102407078958842234](https://x.com/BrianRoemmele/status/2102407078958842234)
---
我从 1979 年起就在等待这种类型的 AI。
不是这个品牌。不是这个 API。是机器的形态。那种你问它问题它不会写诗的机器。那种会审视一个情境并做出决定的机器。
2026 年 9 月 15 日，TypeSafe AI 走出两年的隐身状态，发布了 Jev——首个公开的 System One 模型。它以威廉·斯坦利·杰文斯的名字命名——那位注意到当一种资源变得更便宜时，文明不会减少使用它，而是会用得更多的经济学家。
Jev 是反聊天机器人。它不起草文稿。它不道歉。它不会“大声思考”三分钟，然后吐出一段你需要用正则表达式加祈祷才能解析的文字。你给它状态。
你给它类型化的问题。它在 70 到 500 毫秒内一次性回答所有问题，每个答案都带有概率和置信度。输出 token 是免费的，因为没有值得计费的输出 token。输入是每百万 token 0.042 美元。
这家公司由 Diogo Almeida 创立，他曾是 OpenAI 研究员，参与发明了 InstructGPT 和 ChatGPT 背后的 RLHF 方法。在帮助发明聊天时代之后，他花了两年时间构建聊天从来不是为了的东西。TypeSafe 融集了由 DCVC 领投的 4000 万美元种子轮。当前公开模型：jev-1.13.0。
我已经和它共同生活了一个星期。一百六十八个小时。我像过去在 Commodore 64 上、改装加速的 IBM PC/AT 上、Connection Machine LISP 上、以及在我修改到看起来像整个行业会在 2026 年重新发明并称之为新事物的 Macintosh System 7 代理上运行专家系统那样运行了它。
我要告诉你，带着四十五年半在同一个问题上留下的伤疤：
这就是下一个操作系统的工作方式。最终，操作系统只是带有外设的类 Jev AI。
真正重要的历史
大多数报道从 2024 年开始，Almeida、Erik Gafni 和 Sasha Sheng 在旧金山创立了 TypeSafe。那是公司时间线。思想时间线更久远，这也是我无法对这个发布保持冷静的原因。
1979 年，我已经在构建早期 AI。到 1984 年，在我生日那天，我根据一本至今刻在我骨子里的书《Artificial Intelligence on the Commodore 64》在 Commodore 64 上做了原型。四个月后，我通过翻电话簿找到了一位付费客户。推销词诚实得近乎无耻：你的业务需要这个 AI，我可以在 Commodore 64 上构建它，如果它做不到我说的，就别付钱。那家公司有一份军方合同。他们合作了六年。
那些系统不是聊天机器人。它们是专家系统：知识库加推理引擎。你编码一个领域专家在给定状态下会做出的决定。前向链。后向链。确定性因子。产生式规则。顺利的时候它们像魔法。不顺利的时候，就像你在 IF-THEN 花岗岩上手工雕凿神经系统。
我把其中一项工作称为专家人工神经元系统。位于华盛顿特区、波士顿、洛斯阿拉莫斯、圣地亚哥和旧金山的机构使用过我训练的系统。鼎盛时期有数百套。其中一套运行了几十年，就在一台被我改装加速的独立 IBM PC/AT 上——我曾在 1986 年的《Byte》杂志上写过给 AT 提速——据说那台机器的后续机至今仍在某间保密机房里。1986 年，我在 Thinking Machines 的 Connection Machine 上用 LISP 编程专家系统，学会了像机械师读发动机那样读 LED 阵列。1993 年，我在 Macintosh System 7 上使用 Charles River Analytics 的 Open Sesame!——第一款商用智能助手，它会观察你，并在看到某个习惯三到五次后主动提出将其自动化——我修改它直到它能跨应用程序运行并自我循环。那台 System 7 Mac 我还留着。
这几十年教给我的，是硅谷一直不得不重新学习的一课：
软件能使用的智能，与人类可阅读的智能，不是同一个物种。
专家系统的寒冬不是理念的寒冬，是维护的寒冬。规则脆弱。知识工程师昂贵。世界拒绝乖乖待在决策树里。然后神经网络来了，然后是 Transformer，然后是 RLHF，然后是一个全球性的聊天窗口。我们得到了什么都能写的模型，却几乎没有能可靠到放进内核的决策能力。
2023 到 2025 年的每一个生产级“智能代理”都是对这个鸿沟的坦白。你问 LLM 一个有边界的问题。它写一段话。你剥掉 Markdown。你解析 JSON。你验证模式。它在里面加诗时你就重试。你把这叫工具调用。我把它叫做它本来的样子：一个推理引擎里坐着一位小说家的 1984 年专家系统。
Jev 把小说家从引擎里请了出去。
Almeida 的发布词说得对：模型在聊天上已经超越人类多年，那么自动化都到哪儿去了？答案一直是架构层面的。用卡尼曼的话说，聊天是系统二——缓慢、语言化、深思熟虑、为取悦人类评分员而优化。自动化是系统一——快速、狭窄、经过校准、好到足以用来分支。TypeSafe 用校准决策强化学习（RLCD）而非 RLHF 训练 Jev。RLHF 奖励人类喜欢的答案。RLCD 奖励与答案实际正确频率相匹配的概率。这一个转变，就是讨人喜欢的实习生与电路之间的区别。
名字就是论点。让机器决策快两个数量级、便宜两个数量级，你就不是在“节省推理”。你是在每一次按键、每一个数据包、每一次窗口聚焦、每一个中断上都放一个决策。你把决策放进了操作系统。
Jev 到底是什么
Jev 是一个托管模型。当前公开别名：jev-latest → jev-1.13.0。你发送：
1. 状态——一个字符串、一个 JSON 对象或一个数组。一张支持工单。一棵 DOM 可访问性树。屏幕的 OCR 转储。一个游戏状态。一行日志。一份政策加一段对话记录。仅限文本。官方模型不支持图像、音频或视频。
2. 问题——混合类型，针对同一状态一次性并行评估。
三个原语。这就是新机器的全部指令集：
原语 | 问题 | 返回内容
Choice | 哪个预定义选项合适？最多 255 个。 | 所选选项、每个选项的概率、置信度
Score | 这在有序量表上处于什么位置？ | 一个（可以是小数的）分数、一个图例、概率、置信度
Noul | 这个陈述是否为真？ | 一个 0 到 1 之间的概率
它从不写句子。它无法发明第四个部门、用俳句包装它并弄坏你的解析器。它仍然可能选错模式内的答案——这是一个真实的局限。要为此做好设计。
每次请求上下文为 64k token，其中 32k 分配给状态加上最长的单个问题。发布时限速：每秒 250,000 token、每分钟 1,200 次请求。TypeSafe 表示客户请求不会被用作训练数据，也没有按账户微调。你通过更好的状态、更精确的问题和置信度阈值来塑造行为。
工程师 Paarangat Rai 给了它一个贴切的名字：一个 AI 原生的 if 语句。
这不是 ChatGPT 的降级版。这是缺失的操作码。
与 LLM 的技术差异，没有营销迷雾
1. 输出对象不同。
LLM 是下一个 token 预测模型。它的原生产品是字符串。结构化输出是字符串穿的戏服。Jev 的原生产品是类型化决策。没有 JSON 模式，因为没有可设为 JSON 模式的东西。模式就是模型的嘴。
2. 采样几何不同。
自回归生成是顺序的。Token N 在 token N-1 被选定之前无法存在。这就是为什么当一个前沿模型还在叙述它的推理时，一个“简单分类”仍需几秒钟。Jev 使用并行采样器。每个问题、每个选项，一次前向评估。增加问题几乎不影响延迟。这就是为什么针对一张工单的六个判断可以在不到一秒内一起返回，而不是六篇独立的小说。
3. 训练目标不同。
RLHF 让模型擅长被认可。可验证奖励的推理模型让模型擅长终点可检验的谜题。RLCD 让模型擅长知道自己的把握有多大。校准不是仪表盘上的装饰。它是你把模型放进热路径的方式：高于 0.92 就执行，0.6 到 0.92 之间就上报，低于就拒绝。专家系统有确定性因子是有原因的。我们忘了，然后在重试中为这份遗忘买了单。
4. 失败模式不同。
LLM 的失败是无边界的：错误事实、发明工具、模式漂移、谄媚、变成新人格的提示注入。Jev 的失败是有边界的：它把概率质量分配给了错误的预定义选项。你仍然需要测试。代码中的副作用仍归你负责。但爆炸半径换了物种。
5. 经济学不同。
前沿聊天模型：输入通常每百万 token 0.20 到 10 美元，输出常是输入的数倍，困难工作流上延迟 3 到 329 秒。Jev：输入每百万 token 0.042 美元，输出免费，典型延迟 70 到 500 毫秒。TypeSafe 自己的工作流评估声称高端情况下快 193.6 倍、便宜 444.6 倍。独立测试更诚实，也依然惊人：一篇严谨的评测测得，在单个是非题上对比廉价的分类器式 LLM 快 1.7 倍，而当六次顺序“思考”的 LLM 调用合并为一次 Jev 请求时快 100.7 倍（74.42 秒 → 0.739 秒）。两个数字都可以是真的。倍数取决于你曾错误地要求小说家做多少个决策。
6. 它不是“更小的 LLM”。
TypeSafe 明确表示：Jev 不在通常的智能与成本帕累托曲线上，因为它不在文本生成上竞争。观察者怀疑它有 Transformer 骨干，但这个产品不是 ChatGPT 意义上的语言模型。称它为分类器更接近，但仍不完整。2019 年的零样本 NLI 分类器给不了你 255 选一的校准 Choice、并行 Score、Noul，以及一个为驻留在智能代理框架内而设计的开发者界面。
7. 幻觉，精确地说。
用 TypeSafe 的话说，“零幻觉”意味着零自由文本捏造和零类型错误。它不意味着零错误答案。一个离不开答案本的系统，仍然可能圈错字母。这是工程，不是魔法。
它发布后的这些小时我在用它做什么
我没有等深度评论。我像当年布线专家系统那样布线它：状态进，决策出，执行或上报。
第 1 到 6 小时。对我积攒多年的工单、邮件和日志行进行首次调用。一次请求三个问题——部门用 Choice、紧急度用 Noul、温度用 Score——答案在我手指离开回车键之前就落定了。那种感觉是身体性的。自从 DOS 上一套调校良好的生产系统以来，我再没感受过那种特定的“咔哒”。不是“聪明”。是完结。
第 6 到 24 小时。路由。这是 90% 的“智能代理”在假装自己是员工时实际在做的工作。哪个工具。哪个模型。哪个队列。哪个人。Jev 用 Choice 在你本就信任的列表上完成这件事。LLM——如果你还需要的话——只处理通过闸门的案例。
第 2 天。计算机使用。不是截图到 Opus 的那种税。OCR 或可访问性树变成状态。可能的点击变成 Choice。在字段中输入文字成为同一轮中的第二个问题。只有当操作真的是“输入文本”时才调用一个小的写作模型。这是第一周最佳公开演示所趋同的架构，也是自 1993 年 Open Sesame! 观察我的 Finder 以来我就一直相信的架构。感知本地化。决策快速。生成罕见。
第 3 天。护栏。提示注入检查用 Noul。“这段检索内容是否支持该主张？”用 Noul。“代理完成任务了吗？”用 Noul。这些是我们过去埋在 40 行系统提示里然后再三争论的问题。它们不属于提示。它们属于原语。
第 4 到 5 天。批量。专家系统的梦想从来不是一次聪明的咨询，而是夜班：一千个文件，一百万个事件，每个都做一个决策，只有置信度下降时才需要人。我像当年跨案卷运行规则库那样，用 Jev 跨档案运行。成本落在几分之一美分。延迟与请求落在同一次呼吸里。
第 6 到 7 天。我不再把它当作模型，开始把它当作内核人格。窗口聚焦是状态。钥匙串权限是一个 Noul。“这 40 个打开的文档中用户实际在处理哪一个？”是一个 Choice。“这个人被打断的程度如何？”是一个 Score。这不是一个应用。这是一个开始注意到你的操作系统。
我不会假装每一次测试都是奇迹。精确的问题赢。懒惰的问题输。如果你给 Jev 一团浆糊，你会得到一次自信地朝最不浆糊的选项的耸肩。和 1984 年同样的定律。知识工程师没有死。知识工程师只是得到了一个毫秒级的、不会疲倦、也不会写十四行诗的推理引擎。
20 张收据：这东西到底有多快
这些是第一周的公开测量和发布演示，加上我在自己的实验台上反复碰到的模式。
1. 典型端到端延迟 70 到 500 毫秒，对比前沿 LLM 工作流的 3 到 329 秒。
2. TypeSafe 工作流评估：公开高端数据为快 193.6 倍、便宜 444.6 倍。
3. 独立的六判断工单测试：74.42 秒 → 0.739 秒。即 100.7 倍，且在该评测中便宜 7,499 倍。
4. 单个是非题对比廉价 LLM：仍然更快——约 477 毫秒对 790 到 928 毫秒。温和的数字是诚实的下限。巨大的数字是诚实的上限。
5. 用 Jev 驱动的浏览器代理在实时 Google Flights 上查苏黎世到伦敦：端到端 7.1 秒，0.0039 美元，含页面加载。
6. Mac 计算机使用步骤：每个决策 0.0002 美元，对比 Claude Opus 5 在裸截图上的 0.032 美元。模型延迟 0.13 到 0.38 秒对 5.2 秒。端到端步骤约 1.5 秒对 5.5 秒。
7. 同一计算机使用系列：公开演示中比 LLM 计算机使用快约 100 倍，在一个跨操作系统构建中比 Opus 5 便宜 155 倍。
8. Stagehand + Jev 远程浏览器任务：0.001 美元，构建者称近乎瞬时。
9. 语音到浏览器循环：转写发给 Jev，约 300 毫秒内概率返回，然后点击。每决策 0.0002 美元。
10. 《毁灭战士》以每秒约 10 个决策运行，每小时约 7 美元，结构化游戏状态进，按钮 Choice 出。实时不再是比喻。
11. 一套《毁灭战士》式框架测得平均决策延迟 212 毫秒，并在击杀上媲美手工编码的瞄准器——重点不是电竞，重点是一个游戏循环。
12. 在状态中提供战术事实的国际象棋：API 中位数 166 毫秒，p90 256 毫秒，40 回合的棋局约 7 秒思考时间。
13. 快棋：Jev 不烧时间，在钟面上击败一个“思考”前沿模型。速度也是一种等级分。
14. 支持工单对比赛，30 张标注工单，每张三个问题：Jev 中位数 575 毫秒、每千张工单 0.022 美元，对比廉价 LLM 的 1,472 毫秒 / 0.088 美元，以及强模型的 2,002 毫秒 / 1.66 美元。
15. Ego Lite 购物：3.71 秒内完成 20 次 Amazon 产品决策，而 GPT-5.6 Sol 在同一任务上需 54.45 秒。该演示中同样的 10/10 结果。更少独白。
16. 对一位作者的档案做 777 次判断，不到 0.7 秒，花费约四分之一美分。
17. 野外报告的上下文压缩测试：44.8 秒 → 5.6 秒。
18. 代理路由案例测得在 145 到 271 毫秒区间；编程框架决策 239 到 430 毫秒。
19. 有人把 Jev 多路复用在大约 100,000 封邮件上，用零花钱的成本在约一分钟内完成打分。这就是 1987 年不被允许拥有的那个夜班专家系统。
20. 发布经济学即武器：每十亿输入 token 42 美元，输出免费，官方上限每秒 250,000 token。在这个价格下，你不是“调用模型”。你栖居于它之中。
我心里还留着第二十一条，它不是基准测试。那是就一个混乱的 JSON 块提问十二个问题、看着十二个答案一起落地的感觉。专家系统时代，十二个问题是一次咨询。LLM 时代，十二个问题是一张账单。Jev 时代，十二个问题是一帧动画。
为什么这就是操作系统未来的工作方式
操作系统本来就是一台患有失忆症的决策引擎。
调度器：哪个进程运行。内存管理器：谁获得页面。文件系统：谁可以写入。窗口服务器：哪个表面被聚焦。权限代理：这个二进制文件能否使用摄像头。它们每一个都是一个穿着 C 语言外衣的 Choice、Score 或 Noul。
五十年来，我们把这些决策写成规则，因为规则是唯一快到能待在热路径里的东西。当我们想要“智能”时，我们把它放进用户空间，接受秒级延迟。那个分裂——笨而快的内核、聪明而慢的用户态——正是 Jev 消灭的分裂。
把操作系统主循环想象成它本来的样子：
- 观察状态（进程、窗口、文件、网络、用户最近 30 秒的行为、可访问性树、屏幕 OCR、日历、电池）。
- 提出类型化的问题（这个对话框是钓鱼模式吗？这 40 个窗口中哪个是当前任务？这个 USB 挂载看起来像用户已知的驱动器还是意外？这个人被打断的程度如何？这次编译与聚焦的项目相关吗？）。
- 用代码行动。没有散文。没有解析器。置信度低于阈值意味着问人、等待或拒绝。
那就是一个专家系统。那就是用前沿校准原语取代了“看到习惯五次后触发”式启发法的 Open Sesame!。那就是当我改装 AT 好让咨询在用户站起来之前返回时所追求的东西。
终局不是“在搜索框里放聊天机器人的 Windows”。终局是操作系统本身成为一个类 Jev AI。文件和应用变成状态。驱动程序变成执行器。内核是一条实时决策总线。系统二模型——写作者、推理者、研究者——像我们过去启动重量级进程那样被召唤：很少、有意图、有预算。系统一坐在中断上。
早在当今行业大多数成员出生之前，我就相信这一点。缺失的从来不是“更多参数”。缺失的是一个被允许快、因为它拒绝说话的模型类别。
Jev 是第一个发布出来的。
Jev 本身会成为操作系统吗？作为品牌大概不会。TypeSafe 是一个托管 API。官方权重不在你的笔记本上。延迟仍然包含一次网络跳转。这很重要，而且会一直重要，直到有人把系统一模型放上神经引擎、NPU、键盘旁边的微控制器。社区已经在用并行约束解码把这一想法克隆到笔记本上。这就是信号。当想法比产品更具感染力时，你看到的是一个品类。
给它一代硅的时间，聊天窗口会变成一个兼容层——就像我们至今仍保留终端，给那些喜欢对着幽灵打字的人。
侧栏 —— 在 Mac、Linux 和 Windows 上安装 Jev
官方 Jev 是云 API，不是本地应用。你安装的是客户端。模型留在 TypeSafe，或已托管它的网关上。
1. 获取密钥
- 官方：[console.typesafe.ai](//console.typesafe.ai) → API keys。环境变量：TYPESAFE_API_KEY。
- 或通过 Vercel AI Gateway（typesafe-ai/jev）、OpenRouter 或 Cloudflare 跳过等待名单。
- 如果想零配置，可先用 Playground。
2. 三个操作系统上相同的 SDK 命令
Python 3.10+：
pip install typesafe-sdk
或
uv add typesafe-sdk
Node 20+：
npm install [@typesafe](https://x.com/@typesafe)-ai/sdk
3. 设置密钥
- Mac / Linux（bash/zsh）：export TYPESAFE_API_KEY="your-key"
- Windows PowerShell：[$env](https://x.com/search?q=%24env&src=cashtag_click)：TYPESAFE_API_KEY="your-key"
- Windows cmd：set TYPESAFE_API_KEY=your-key
4. 首次调用（任何有 curl 的操作系统）
curl -X POST [https://api.typesafe.ai/v1/systemone](https://api.typesafe.ai/v1/systemone) \
-H "Authorization: Bearer [$TYPESAFE_API_KEY](https://x.com/search?q=%24TYPESAFE_API_KEY&src=cashtag_click)" \
-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?"}}}'
安装就这么多。没有 GPU。没有 40 GB 下载。没有 CUDA 仪式。如果你想要本地类 Jev 循环，社区仓库已经存在（Apple Silicon 上的 MLX，Linux / Windows 经 WSL 的 llama.cpp）。那些是这个想法的复制品，不是官方权重。
转变
每隔几十年，软件的基本单位就会改变。
文件。然后是应用程序。然后是服务。然后是提示。每个单位都是一次关于智能栖身何处的赌注。
Jev 再次改变了这个单位。这个单位是带有校准概率的类型化决策。在它之上的一切——智能代理、计算机使用、副驾驶、操作系统——都是编排。在它之下的一切都是状态。
从吉米·卡特执政以来，我看着这个领域售卖夏天和冬天。我看着人们把会说话的演示误认成能运行的系统。我看着专家系统被宣称死亡，而宣布者随后用提示词把它们重建起来，并称之为智能代理。
一百六十八个小时不足以知道 TypeSafe 是否会赢得这个品类。但足以知道这个品类是真实的。
聊天时代为拿着手机的人类优化。
系统一时代为握着循环的机器优化。
当决策如此之快、如此之便宜时，你不是在操作系统里添加 AI。
你只是发现，操作系统一直在等待着成为它。
我在一台 Commodore 64 和一个我没有权利许下的承诺上构建了这个想法的第一个版本。
Jev 是能够兑现它的那个版本。
Jev 发布后 168 小时。我还在这里。还在把咨询接进内核。
我正在与一个将把这一成果开源的团队合作。
更多消息，敬请期待。
## 相关链接
- [Brian Roemmele 转发了](https://x.com/BrianRoemmele)
- [Brian Roemmele](https://x.com/BrianRoemmele)
- [@BrianRoemmele](https://x.com/BrianRoemmele)
- [47K](https://x.com/BrianRoemmele/status/2102407078958842234/analytics)
- [console.typesafe.ai](https://console.typesafe.ai/)
- [@typesafe](https://x.com/@typesafe)
- [$env](https://x.com/search?q=%24env&src=cashtag_click)
- [https://api.typesafe.ai/v1/systemone](https://api.typesafe.ai/v1/systemone)
- [$TYPESAFE_API_KEY](https://x.com/search?q=%24TYPESAFE_API_KEY&src=cashtag_click)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [2026 年 9 月 22 日晚上 10:38](https://x.com/BrianRoemmele/status/2102407078958842234)
- [47.1K 次浏览](https://x.com/BrianRoemmele/status/2102407078958842234/analytics)
- [查看引用](https://x.com/BrianRoemmele/status/2102407078958842234/quotes)
---
*导出时间： 2026/9/23 09:45:10* 
