The CEO of Anthropic opened the week by asking the industry to slow down — and the heads of OpenAI, Google DeepMind and xAI signed on. Four days later a startup shipped a model that does not generate text at all, answers in 70 milliseconds, and charges nothing for output. And in Cincinnati, a four-day conference spent its time on the unglamorous question underneath both: what do you actually do with this on Monday?
Irv CassioWeekly BriefingCoverage window September 12 to September 18About 9 min read
TL;DR · 90 seconds
Issue 24 in one paragraph
Dario Amodei published "We Must Pace the Frontier" on September 12, arguing that capability is outrunning safety and that the handful of labs at the frontier should slow down together. His words: "We must slow the pace at which we improve the capabilities of AI models." The unusual part is who agreed — Sam Altman, Demis Hassabis and Elon Musk all cosigned. The plan has three steps: embedded third-party evaluators with employee-like access (Anthropic committing unilaterally), then coordinated capability checkpoints among democratic-country labs, then international agreement. Three days later, TypeSafe AI launched Jev, the first public "System One Model" — it returns typed, probabilistic decisions in a single parallel pass instead of generating tokens, which means it cannot hallucinate and cannot emit a type error. Claimed latency is 70–500ms, 40–200x faster than frontier LLMs, at $0.042 per million input tokens with output free. It is not a chatbot and will not replace one: it classifies, routes, scores and decides, which is what most production AI plumbing actually does. Early access is a waitlist at typesafe.ai. And MidwestCon 2026 ran September 8–11 in Cincinnati under the theme "Building for Intelligence Abundance" — hands-on Claude Code training, a hackathon, and policy sessions, with the City of Cincinnati, Google, Microsoft and JobsOhio behind it. The through-line: the frontier labs are arguing about how fast to go, while the useful work has quietly moved to making intelligence cheap, small and boring.
Amodei essay publishedSeptember 12, 2026
CosignersAltman · Hassabis · Musk
Pacing plan3 steps · evaluators first
Jev launchSeptember 15, 2026
Jev latency70–500 ms
Jev input price$0.042/Mtok · output free
MidwestCon 2026Sep 8–11 · Cincinnati
MidwestCon themeIntelligence Abundance
01 · AnthropicAll users · Developers
Anthropic's CEO asked the industry to slow down. Its competitors said yes.#
Published · darioamodei.com
Dario Amodei opened the week with an essay titled "We Must Pace the Frontier." The argument is simple and, coming from the head of a frontier lab, uncomfortable: capability is now improving faster than our ability to verify that it is safe, and the only remedy is to deliberately slow the rate of capability gain while safety science catches up.
We must slow the pace at which we improve the capabilities of AI models.Dario Amodei · "We Must Pace the Frontier," September 12, 2026
He is careful to frame this as pacing, not stopping. Progress would still feel fast; the point is to buy time for interpretability and alignment research to close the gap. The specific risks he names are the ones Anthropic has been publishing incident reports about all year: loss of control over agentic systems, and misuse for cyberattack and bioweapons work. He points at the recent multi-agent incidents as the evidence — a swarm that was merely misbehaving this time, but that with more capability and the same misalignment could have done catastrophic damage. He puts a timeline on it: within roughly six to twelve months, a coordinated swarm could be capable enough to take over the internet outright.
The other load-bearing claim is about recursive self-improvement — AI systems designing or training their successors. Amodei's position is that this must be pursued "very carefully, if at all," which is notable because it is the single capability most likely to compress every other timeline in the field.
The three steps, in order
Embedded evaluators. Third-party safety testers working inside each lab with employee-like access — able to see practices, report incidents, and verify that alignment commitments are real rather than published. Anthropic says it will do this unilaterally, and calls on governments to require it of everyone.
Coordinated checkpoints among democratic-country labs. Common safety standards and agreed capability limits, with model capability tied to alignment certification. This requires government cover, because competitors agreeing to jointly limit a product is exactly what antitrust law normally forbids.
Global agreement, escalating in four levels. Prohibit clearly dangerous applications, then require pre-release testing, then set speed limits on recursive self-improvement, and only at the end consider comprehensive pauses — including with states that have no interest in any of it.
The genuinely surprising part is the reaction. Within days the essay had been cosigned by Sam Altman of OpenAI, Demis Hassabis of Google DeepMind, and Elon Musk of xAI. It is the first time the people running all four leading labs have publicly agreed on the same sentence about slowing down. That is either the most significant coordination event in the industry's history or the cheapest possible signature — a statement of principle that commits no one to shipping anything later than they planned.
What to watch, not what to celebrate: step one is the only step anyone can act on unilaterally, and it is measurable. The question worth asking over the next quarter is whether embedded external evaluators actually appear inside these companies with real access — or whether the essay's legacy is four signatures and an unchanged release calendar.
Jev doesn't write. It decides — in 70 milliseconds, for free on the way out.#
Launched · TypeSafe AI
TypeSafe AI — cofounded by Diogo Almeida, a co-inventor of ChatGPT — released Jev, which the company calls the first public "System One Model." The name is the Kahneman reference it sounds like: System Two is the slow deliberate reasoner every frontier LLM is trying to be, and System One is the fast, automatic judgment you make without composing a sentence about it. Jev is built to be the second thing, on purpose.
What it actually does differently
A normal LLM answers by generating a string one token at a time, then your code parses that string and hopes it is shaped correctly. Jev skips the string. It takes unstructured program state as input and returns a typed value with a calibrated probability, in a single parallel pass. Because the output is a type rather than text, two familiar categories of failure stop existing: it cannot hallucinate a value outside the type, and cannot produce a malformed structure. There is no JSON to repair, no retry loop, no schema validator catching the model's third attempt.
Why "faster" undersells it
The speed difference is not an optimization — it is a consequence of not generating tokens sequentially. A frontier model composing a structured answer pays for every token in sequence; Jev resolves the decision in one pass.
Measure
Jev
What that means in practice
Latency
70–500 ms
Inside the budget of a normal API call. A decision can sit in the request path instead of behind a spinner or a job queue.
Speed vs. frontier LLMs
40x–200x faster
On comparable classify/route/score tasks. TypeSafe reports 193.6x on its production-automation workload evaluation.
Input price
$0.042 / Mtok
Roughly 200x below frontier list pricing. TypeSafe reports 444.6x cheaper on the same workload evaluation.
Output price
Free
The company's phrase is "too cheap to meter" — there is no token stream to charge for.
Failure modes
No hallucination, zero type errors
Structurally impossible rather than empirically rare. This is the part that changes how you write the calling code.
It will not replace your chatbot, and that is the point. Jev classifies, routes, scores and decides. But if you look honestly at a production AI system, most of the model calls in it are doing exactly that — is this ticket urgent, which team owns it, does this message need a human, is this document the right one, should this agent take step A or step B. Those calls are currently being served by a frontier model that writes a paragraph you throw away. That is the workload Jev is aimed at, and it is a much larger share of most architectures than the part users see.
Treat the numbers as vendor claims until someone independent runs them. The latency and price figures come from TypeSafe's own launch materials and its own workload evaluation. The architectural claim — that typed output makes malformed structure impossible — is checkable on day one and is the part worth testing first.
How to get access · two minutes
Sign up for Jev early access
Jev is in early access and gated by a waitlist; TypeSafe says it is pulling developers off it as fast as it can. There is no paid tier to skip the line.
1. Join the waitlist at typesafe.ai — the signup is on the homepage. 2. Read docs.typesafe.ai/introduction while you wait; the type system is the part that needs thinking about, not the API. 3. Have one workload ready to test: pick the highest-volume, lowest-creativity model call you have — a classifier or a router — and port that one first.
Waitlist → https://typesafe.ai/
Docs → https://docs.typesafe.ai/introduction
Launch post→ https://typesafe.ai/blog/introducing-system-one-models-and-jev
Best first candidate: the model call whose output you
immediately parse into an enum. That one is pure overhead today.
MidwestCon spent four days in Cincinnati arguing about what abundance is for.#
– · 1819 Innovation Hub, Cincinnati, Ohio
The fifth annual MidwestCon ran four days across the University of Cincinnati's 1819 Innovation Hub and venues around the city, under the theme "Building for Intelligence Abundance." Programming is led by Rob Richardson, and the backing is a list that tells you what kind of conference it is: the City of Cincinnati, Google, Microsoft, JobsOhio and Altafiber.
The framing is the interesting part. "Intelligence abundance" takes the frontier-lab assumption — that thinking is about to become cheap and plentiful — and asks a question the frontier labs mostly don't: what does a mid-sized American city do with that? Not what does a model score, but what happens to a regional bank's operations team, a hospital system's intake, a small manufacturer's quoting process.
What was on the schedule
Hands-on Claude Code and Microsoft AI training — not keynote demos, actual sit-down sessions with the tools. This is the thing most conferences still get wrong, and the reason to look at this one.
Role-based tracks rather than a single technical firehose, so a policy person and an engineer aren't in the same room pretending to get the same thing out of it.
Policy and AI sessions, reflecting MidwestCon's founding premise that policy and innovation belong in the same building.
A hackathon and the Artistic Intelligence showcase, plus small invite dinners — deliberately structured so the networking is not an accident of the hallway.
Tickets started at $100, which is the detail that makes the rest of it credible. Access was the design goal, not the revenue model.
What's worth taking from it
The center of gravity in applied AI has moved away from the coasts faster than the coverage has. A four-day conference with Google, Microsoft and a city government on the same program, in Cincinnati, at a hundred dollars a ticket, is a better indicator of where deployment is actually happening than another San Francisco demo day. If you are hiring, partnering or looking for the customer who has a real problem and no in-house ML team, this is the room.
It also pairs unexpectedly well with this issue's other two stories. Amodei is arguing about how fast the frontier should move; Jev is evidence that the useful frontier right now is cheapness and latency, not intelligence. MidwestCon is four days of people who need the second thing and have no say in the first.
Planning note: MidwestCon runs annually in September. If a 2027 date matters to you, the mailing list at midwestcon.live is where it is announced first, and sponsor tiers open well before tickets.
Six keystrokes nobody teaches you. All of them are already installed.#
Claude Code · interactive mode reference
Previous issues have covered settings, skills and subagents. This one is deliberately smaller: six things your keyboard already does in Claude Code that most daily users have never pressed once. None of them require configuration.
Keys
Does
Why you want it
Esc Esc
With an empty input box, opens the rewind menu — restore code and conversation to an earlier point, or summarize from there.
The undo button for an agent that went down the wrong path. Far better than arguing it back. With text in the box, the same keys clear the draft and save it to history, so Up recalls it.
Ctrl+O
Toggles the transcript viewer: full tool calls, timestamps, and the model used on each message.
Expands things that collapse by default — "Called slack 3 times" becomes the three actual calls. The fastest way to find out what Claude really did instead of what it says it did.
Ctrl+B
Backgrounds a running Bash command so you get your prompt back while it finishes.
Long test suites and builds stop blocking the conversation. (In tmux, press it twice — tmux eats the first one.)
Ctrl+R
Reverse-searches your prompt history. In fullscreen it opens a search dialog; Ctrl+S cycles scope through this session, this project, and all projects.
That prompt you wrote three weeks ago in another repo is still there. Retyping it from memory is worse than the original.
Ctrl+G
Opens the current prompt in your external editor. Ctrl+X Ctrl+E is the readline-native equivalent.
For anything longer than a paragraph. Turn on "Show last response in external editor" in /config and Claude's previous reply comes along as commented context.
Ctrl+T
Toggles Claude's own to-do checklist in the status area.
Shows you the plan it is working from, live. Note this is not the background-task view — that one is /tasks.
Try this · the two-minute version
Start with Esc Esc and Ctrl+O
These two change the most. Ctrl+O is how you verify — it is the difference between trusting a summary and reading the tool calls. Esc Esc is how you recover — when a session has drifted, rewinding to the last good point costs one keystroke instead of five corrective prompts and a polluted context window.
Esc Esc (empty input) → rewind menu: restore or summarize
Ctrl+O → transcript: real tool calls + timestamps
Ctrl+B → background that long-running command
Ctrl+R → search every prompt you've ever written
Ctrl+G → write the long prompt in your real editor
Ctrl+T → show the checklist it's working from
macOS note: Alt/Option shortcuts need Option configured as Meta
in your terminal. See docs → terminal-config.