Jev 决策模型与 NylonME：AI 的“拆解时代”来了

A Model That Can't Write Just Broke the Internet On September 15, TypeSafe AI released a model called Jev. The company was founded by former OpenAI researcher Diogo Almeida — a core author of RLHF and InstructGPT, the research that turned ChatGPT into ChatGPT. After two years in stealth and $40M led by DCVC, what they shipped was surprisingly restrained: Jev can't write a single word. No text generation. No poetry. No code. No chatting. You hand it a state and a set of predefined questions; it returns structured decisions with calibrated probabilities: yes/no (Noul), multiple choice (Choice), scale scores (Score). One call answers every question in parallel, with 70–500ms end-to-end latency. TypeSafe claims it is 20–200x faster and 40–400x cheaper than frontier LLMs on decision tasks — $0.042 per million input tokens, output free. Within 48 hours of release, the community was already pushing it hard: the Browser Use team used it for browser-operation decisions — a real flight lookup in 7 seconds for $0.0039; someone used it to compress Claude Code's context, squeezing a million-token session down to eighty thousand in one second; someone even recreated parallel decision ability with Qwen-2.5-1B on a MacBook in two hours. Everyone else is talking about how fast and cheap Jev is. Our first reaction after watching the launch was a little different: We've been waiting nearly a year for this day. What Jev Proves: Most "Intelligence" in Agent Systems Isn't Language at All The entire reason Jev exists is a fact many people would rather not admit: a large share of LLM calls inside Agent systems never needed language generation in the first place. No need to be modest — let's dissect ourselves first. NylonME's memory engine has an "understanding layer" on the write path, currently powered by LLM calls. Break down what each call is actually doing: LLM call in NylonME What the task really is Matching decision primitive Conflict detection: does the new memory contradict existing ones? Yes/no judgment Noul (boolean probability) Query classification: single-hop or multi-hop? (sets diffusion depth) 4-way choice Choice (option selection) Reflection quality control: is this implicit fact worth persisting? Yes/no + scoring Noul + Score Deduplication: is this memory already the one in the store? Yes/no judgment Noul Conversation fact distillation: decompose dialogue into structured facts Text generation Still needs an LLM Reflection content generation: write out the unstated common sense Text generation Still needs an LLM See it now? Of six calls, four are judgments and only two are generation. Today, a judgment call has to go through full autoregressive generation — the model first "writes" an analysis, then we parse the JSON it emits and pray the format isn't broken — all to extract what is essentially 1 bit of information: yes or no. It's like hiring a literary writer to produce an 800-word essay just to find out whether it will rain today — and then counting whether the character "rain" appears in the essay. What decision models like Jev do is turn those four calls from "writer composing an essay" into "function invocation": state goes in, a calibrated yes/no comes out, in 70 milliseconds, at near-zero cost, with a zero percent chance of format errors — because the output space is locked at call time. The Industry Has Finally Started "Disassembling" Intelligence In a blog post earlier this year, we wrote a passage that quite a few people called alarmist at the time: AI is not equal to large language models, and certainly not equal to OpenAI, Kimi, or DeepSeek. A large model is one pillar of the AI edifice — an important one, but neither the only one nor the foundation. Our argument back then was memory: intelligence also includes memory, intuition, and context, while a large model is only a reasoning engine. Nine months later, the industry's evolution has outrun even our expectations — the concept of "intelligence" is being disassembled into specialized components, each carried by a dedicated engine: System 2 reasoning — slow, deliberate, generative thinking. This is LLM territory; GPT, Claude, Kimi, and DeepSeek keep competing here. System 1 decision — fast, intuitive, massive-volume judgment. Jev opened this category; TypeSafe literally borrowed Kahneman's "System 1" naming. Long-term memory — experience accumulated across sessions, tasks, and time. This is memory-engine territory — the direction NylonME went all-in on from day one. Kahneman's dual-system theory tells us one thing: human intelligence has never been a single engine. Intuition, reasoning, and memory are three different mechanisms, each with its own physical basis and its own optimization target. The AI industry spent three years trying to let one autoregressive text generator do everything; now it is finally conceding: architecturally, they were always meant to be separate. The interesting part is the name Jev itself. TypeSafe says it pays homage to the economist William Stanley Jevons — the Jevons paradox: the more efficiently a resource is used, the more of it gets consumed in total. Drive the cost of a decision to near zero, and demand for decisions explodes. The same logic holds for memory: when the marginal cost of writing and recalling memory approaches zero, every agent, every workflow, every piece of software will start storing memory. That is the underlying logic behind our call a year ago that "memory engines will become as ubiquitous as databases." Jev + NylonME: A Bill That Actually Adds Up Plug a decision model into a memory engine and the math is easy. Take NylonME's write path. For one session write, the current understanding-layer cost is roughly: one distillation generation (must be an LLM) + up to four conflict-detection judgments (decision-model-able) + several quality judgments in the reflection stage (decision-model-able). Swap the judgment calls to a decision model: Latency: each judgment drops from seconds to ~100 milliseconds. Overall tail latency on the write path is cut by more than half — a perceptible difference for real-time scenarios like voice assistants and online customer service. Cost: at official pricing, ten thousand judgments cost about $0.42. That means you can afford to let the engine "ask a few more questions for every memory it writes" — is this worth storing? which existing memory is it most similar to? is the confidence high enough to auto-merge? The fine-grained judgments that used to be too expensive are now free to do. Reliability: the output space is locked to preset types — no JSON parse failures, no format hallucinations. The engine's internal control plane becomes type-safe from that day on. But Jev itself is not the endpoint, and it has a dealbreaker for us: closed-source, API-only, English-first. The customer base of an enterprise-grade memory engine — finance, healthcare, government — happens to be the most compliance-sensitive crowd there is. A memory engine handles an enterprise's most sensitive data assets: customer preferences, operational experience, decision history. Sending that data out of the intranet and through an American startup's API fails the compliance review in many industries before anything else. However low Jev's $0.042 per million tokens is, it can't undercut the red line of "data never leaves the premises." So We Decided to Build Our Own Today we're officially announcing the next stop on the NylonME roadmap: a self-built decision model, deeply integrated with the memory engine. Our decision model will not be a general-purpose product; it is born only for memory scenarios. Compared with general decision models, its difference is sharing the same underlying representation as the memory engine: Salience scoring, nativized. In NylonME, each memory's salience is currently computed by a fixed formula over time decay, emotional intensity, and mention frequency. A self-built decision model can directly output "what should this memory's salience be in the current context" — turning a hand-tuned formula into a learned judgment. Diffusion control as decisions. Every step of context-resonance retrieval — "should we keep diffusing, and along which edge" — is at heart a judgment call. The decision model natively participates in graph traversal instead of the current one-size-fits-all fixed-depth parameter. Conflict detection and merge routing. Not just answering "is there a contradiction," but giving a routing decision — merge, coexist, or mark-as-revised — all with calibrated probabilities. High-confidence calls execute automatically; low-confidence ones escalate to humans or the upstream LLM. Same process, same deployment. The decision model ships in the same binary as the memory engine — works offline, deploys on-prem, data never leaves. This is something cloud APIs like Jev can never give enterprise customers. The memory engine "remembers," the decision model "judges," and the LLM "reasons and expresses." Three engines, each doing its own job — together they form the complete substrate of an intelligent agent. Final Words September 2026 will be remembered not because some large model topped another benchmark, but because this month the industry started seriously taking apart the word "intelligence." Jev proved that decision-making can be split out of the LLM — 200x faster, 400x cheaper. We proved earlier that memory must be split out of the LLM — a context window is not memory, and prompt engineering cannot pile up long-term experience. More disassemblies are coming: emotion, intuition, planning… every dimension will grow its own dedicated engine. The era of one model ruling everything is over. Not because large models got worse — but because they finally don't have to do everything themselves. For every team building Agents, this is good news: you don't need to wait for an omnipotent super-model. You need to mount the right components in the right positions. For the memory engine, choose NylonME. For the decision model — give us a little more time. NylonME is an open-source persistent memory engine (Apache-2.0), GitHub: nylon-memory/NylonME. Full LoCoMo benchmark: recall@10 85.4%, end-to-end J 75.4%, with reproduction scripts shipped in the repo.