Latest / Braid / A 13B Model From 1930, the Dead AGI Clause, and Copilot's Nine-X

Transcript

A 13B Model From 1930, the Dead AGI Clause, and Copilot's Nine-X · Braid

• 0:04
  Researchers at the University of Toronto and a few collaborators just released a 13-billion-parameter language model trained on 260 billion tokens of pre-1931 English text.
• 0:16
  They are calling it talkie.
• 0:18
  The data is books, newspapers, periodicals, scientific journals, patents, and case law — everything they could pull together from before the US public-domain cutoff at the end of 1930.
• 0:31
  The authors are Nick Levine, David Duvenaud — the Toronto ML professor who used to be on Anthropic's alignment team — and Alec Radford, the original GPT author who left OpenAI in late 2024.
• 0:44
  My first reaction was that this would be a curiosity, an art project.
• 0:49
  It is not.
• 0:50
  The most interesting paragraph in the launch post is the one on contamination.
• 0:55
  Every modern frontier model has, in some form or another, been trained on the public web, which by now has been thoroughly polluted by every benchmark anyone has ever shipped.
• 1:08
  When you read a HumanEval score, you are partly reading a memorization score.
• 1:13
  The vintage corpus is contamination-free by construction.
• 1:17
  There's no GitHub in 1930, no Stack Overflow, and — you might note — no Python.
• 1:23
  Which is what makes the experiment in figure three of the paper land hard.
• 1:28
  They gave a vintage model a Python coding test, with a few example programs in context, and measured how often it could write a new correct program.
• 1:38
  It mostly cannot.
• 1:40
  The successful solutions are one-line modifications to the demos.
• 1:44
  But here is the one I cannot stop thinking about.
• 1:48
  The model was given the encoding function for a rotation cipher, and asked to write the decoder.
• 1:54
  It produced the right answer by changing a single character — swapping the addition for a subtraction.
• 2:02
  That is a model with no concept of a digital computer, working out, from a few in-context examples, that a decoder is the inverse of an encoder.
• 2:12
  That is not memorization.
• 2:14
  That is something else.
• 2:15
  They also tried something I love.
• 2:18
  They took five thousand short descriptions of historical events from the New York Times's 'On This Day' feature and measured how surprising each one was to the model.
• 2:29
  The plot, binned by decade, is roughly flat through the late 1800s, climbs through the 1930s, peaks in the 1950s and 60s, and plateaus.
• 2:39
  The shape of the future, measured in bits per byte.
• 2:42
  They are using it to ask whether vintage models can predict the future, and what it would take to scale that capacity.
• 2:51
  The plan is GPT-3-level vintage by summer, GPT-3.5-level after that, multilingual after that.
• 2:57
  The boring problems are the interesting ones.
• 3:01
  OCR alone costs them seventy percent of their training efficiency on classic systems, regex cleaning recovers most of that, and modern VLM-based OCR systems hallucinate modern facts back into the corpus, which would defeat the entire point.
• 3:18
  They wrote their own vintage OCR system.
• 3:20
  The post-training pipeline is rebuilt from scratch — etiquette manuals, letter-writing manuals, dictionaries, encyclopedias, fables — because if you fine-tune on modern instruction data you bake the modern world back in through the back door.
• 3:38
  An earlier 7B version, post-trained with too much modern RL feedback, started writing in listicles.
• 3:45
  They had to rebuild that pipeline too.
• 3:47
  What I take away as a working engineer is that the most credible piece of generalization research I have seen this year came from people who threw out the web and rebuilt the entire data stack by hand.
• 4:01
  That's the only way to know what they're measuring.
• 4:05
  The weights are open.
• 4:07
  The inference code is open.
• 4:08
  If you have ever wanted to pin down what your model knows from the web versus what it knows from the structure of language itself, you now have a control group.
• 4:20
  That is rare in this field.
• 4:22
  OpenAI and Microsoft published the structure of their restructured agreement yesterday.
• 4:28
  Buried in it is a sentence Simon Willison flagged on X: 'Revenue share payments from OpenAI to Microsoft continue through 2030, independent of OpenAI's technology progress.'
• 4:59
  The 2025 restructuring carved that out.
• 5:02
  Through 2030, Microsoft gets paid regardless of what OpenAI ships, calls AGI, or fails to call AGI.
• 5:09
  A reply from Bakhtier Gaibulloev I think gets it right: 'The AGI clause was always unfalsifiable.
• 5:16
  No working benchmark for the threshold means no party could trigger or contest it without a downstream legal fight.
• 5:24
  Removing it just lets the contract reflect what the engineering side already knew.' That's the read I'd offer too.
• 5:33
  There never was a clean line, or a benchmark two boards could agree on, much less defend in court.
• 5:40
  The clause was a placeholder for a moment everyone implicitly assumed would resolve itself when the time came.
• 5:48
  Simon capped his thread with his favorite Matt Levine quote — the one where, in Levine's hypothetical, OpenAI's nonprofit board cuts the investors a check and goes back to running the lab for the benefit of humanity, ushers in superintelligence, ends scarcity, ends capitalism.
• 6:08
  It's funny because it was always going to end with paperwork instead.
• 6:13
  What I think this means concretely.
• 6:15
  The largest AI vendor and its largest investor have stopped pretending that 'AGI' is a contractually meaningful event.
• 6:24
  That doesn't mean nothing significant will happen between now and 2030.
• 6:29
  It means that whatever does happen — a much better Codex, a much better Gemini, a Silver-style superlearner — will be processed inside ordinary commercial frames.
• 6:41
  Procurement teams I talk to are already there.
• 6:44
  One of the replies in the thread, from Bobby Blaine, sums it up: teams now want explicit contingency language in every AI vendor contract, regardless of how good the feature set looks.
• 6:57
  That's the right posture.
• 6:59
  AGI is no longer a covenant; frontier-model capability is now ordinary supplier risk, and has been for a while.
• 7:07
  GitHub Copilot updated its pricing documentation.
• 7:11
  Starting in June, Copilot is moving to usage-based billing, and the practical effect on Claude models — at least according to subscribers running the math against the new model multipliers — is roughly a nine-fold increase.
• 7:27
  The press release frames this as 'usage-based billing.' The community read on r/ClaudeAI is less generous.
• 7:34
  The top reply nails the financial reality: 'A sudden 9x increase in inference costs can tank your entire unit economics overnight.
• 7:44
  The real problem isn't the price increase itself, it's that most teams have zero visibility into what their agents are actually doing or how many tokens they're burning.' That is correct.
• 7:57
  If you priced your product against last year's Copilot Pro+ plan, June is when your Claude line item stops looking like a fixed seat license and starts looking like cloud spend.
• 8:10
  The second-most-upvoted reply has a different read: 'They're moving all enterprise customers from fixed and heavily subsidized plans to APIs.
• 8:20
  That's a flex by Anthropic in my book.' I think both readings are true at once.
• 8:26
  Anthropic is in a position to renegotiate.
• 8:29
  Microsoft and GitHub were eating the difference between Claude inference costs and a flat seat fee, betting that most seats were underutilized.
• 8:39
  As adoption climbed, that math stopped working.
• 8:43
  The subsidy got pulled.
• 8:44
  Now the actual cost of running Claude through somebody else's wrapper is being passed through.
• 8:51
  What does a senior engineer do about it.
• 8:54
  A couple of things.
• 8:55
  First, instrument what your agents are actually doing — token counts per task, cache-read versus cache-write, retries.
• 9:04
  If you can't see the curve, you can't bend it.
• 9:07
  Second, look hard at native Anthropic plans.
• 9:10
  Claude Pro, Claude Max 5x, the Claude VSCode extension.
• 9:14
  Several developers in the thread have already moved over and report it works fine for the workflow they actually use.
• 9:23
  Third, treat 'subsidized model access through a third-party seat license' as a temporary state.
• 9:30
  The pattern from the cloud era is going to repeat: the wrapper layer keeps the experience but slowly hands the price tag back to you.
• 9:39
  I'd watch this one for a chilling effect on agent-heavy workflows.
• 9:44
  The teams burning hundreds of millions of tokens a month, who built their economics on the older flat-rate Copilot, are the ones who get the worst June.
• 9:55
  The ones running disciplined sessions with explicit scoping won't feel it as much.
• 10:01
  Which is a nice segue.
• 10:02
  There's a thread on r/ClaudeAI from a developer with twelve years of experience asking, bewildered, how everyone on tech Twitter is burning hundreds of millions of tokens a month.
• 10:16
  He uses about twenty million tokens monthly across three or four codebases.
• 10:21
  He says — and this is a direct quote — 'I'm very explicit with what I want, and take the time to think through the architecture, code styling, etc.'
• 10:41
  The rest of the thread is more interesting than the joke.
• 10:45
  The legitimate billion-token-month workflows roughly cluster into three buckets.
• 10:51
  One: agentic harnesses running multiple projects in parallel, where a single autonomous run is a multi-step plan with tool calls and reruns and self-checks.
• 11:03
  Two: massive context — large CLAUDE.md files, memory indexes, entire codebases re-fed every turn.
• 11:10
  One commenter said seventy percent of their six-billion-token monthly bill was cache_read_input_tokens.
• 11:18
  You're billed for it even when it's cached.
• 11:21
  Three: domains that are structurally heavy.
• 11:24
  Computer vision, hardware, large dataset analysis, where every iteration is reasoning about a lot of state.
• 11:32
  What I take from this is that token count is a Rorschach test.
• 11:37
  The number itself is not a measurement of productivity — it's a measurement of context discipline.
• 11:44
  A senior engineer who plans the architecture in their head before the prompt — who decides what the agent should and shouldn't load — is going to use an order of magnitude fewer tokens than someone running an unscoped agent loop and hoping for the best.
• 12:03
  With Copilot's June pricing landing in the same week, the people who get to keep using these tools cheaply are the ones who already know what they want before they ask for it.
• 12:16
  Jason Liu — author of the Instructor library — ran a comparison in Inspect across merged pull requests, bucketed by diff size.
• 12:26
  His headline: GPT-5.5 is about thirty-nine percent cheaper than Opus 4.7 end-to-end on equivalent PR work.
• 12:34
  The reasoning is interesting.
• 12:36
  GPT-5.5's output token price is higher than Opus 4.7's.
• 12:40
  On a sticker-price comparison, you'd assume Opus is the bargain.
• 12:45
  But on real PR workloads, three things flip the math.
• 12:49
  First, on GPT-5.5, cache writes are free, and PR review is a workload that benefits from large repeated input contexts.
• 12:58
  Second, GPT-5.5 is more token-efficient — it produces shorter outputs that solve the same task.
• 13:05
  Third, the GPT tokenizer compresses the same source text into fewer tokens than the Anthropic tokenizer.
• 13:13
  None of these are surprising on their own.
• 13:16
  The point of running it is that on coding workloads — which are heavy on cached input and lightweight on output — the dominant cost is input behavior, not the headline output price.
• 13:30
  If you've been ruling out GPT-5.5 because the per-million output number looks rough next to Opus, run the comparison on your own PRs in your own harness.
• 13:42
  Don't take Jason's number; take his methodology.
• 13:45
  Inspect, real diffs, bucketed by size.
• 13:48
  I'd add one caveat.
• 13:50
  Token efficiency on PR work is a current property of these specific model versions and tokenizers.
• 13:57
  It's not a law.
• 13:58
  The next Anthropic point release could close half the gap.
• 14:03
  The lesson is to keep running this kind of comparison on your own representative workload, on a cadence — call it monthly.
• 14:12
  Anyone telling you which model is cheaper without naming the workload, the harness, and the diff distribution is selling you something.
• 14:22
  A r/LocalLLaMA post from yesterday ran open-weight models in the 27 to 32-billion-parameter class through an agent harness on Terminal-Bench 2.0 — eighty-nine tasks, the same per-task default timeout the public leaderboard uses.
• 14:40
  The best result was Qwen 3.6-27B at 38.2 percent.
• 14:43
  Thirty-four out of eighty-nine.
• 14:46
  The headline number is not what's interesting.
• 14:49
  Hosted SOTA today is around eighty percent — GPT-5.5, Opus 4.6, Gemini 3.1 Pro.
• 14:55
  What's interesting is what 38.2 percent maps to in time.
• 15:00
  Anchoring on release dates of verified leaderboard entries: Terminus 2 plus Opus 4.1 from August 2025 hit thirty-eight percent.
• 15:09
  Codex CLI plus GPT-5-Codex from September 2025 hit forty-four percent.
• 15:15
  So today's best runnable-offline coding model lands roughly where the hosted frontier was in late 2025.
• 15:22
  A six-to-eight-month lag.
• 15:24
  That is the first time, for me, the open-weight coding gap has been close enough to matter.
• 15:31
  Air-gapped environments, regulated industries, on-prem CI workloads, batch jobs that can't tolerate vendor outages — all of these have been waiting for a credible offline option, and not the kind that scores fifteen percent of frontier.
• 15:49
  The lag is now measurable in months, not generations.
• 15:53
  I want to flag the skepticism in the comments.
• 15:57
  One reply notes that 1.9 tokens per second is very slow generation, raising the question of how much of the gap between 38.2 percent and Qwen's official 59.3 percent is really wallclock-budget rather than capability.
• 16:13
  Another replies, fairly: I still wonder if they have benchmaxxed Terminal-Bench 2.0.
• 16:20
  Both points are right to ask.
• 16:22
  The way to answer them is independent reproductions on different harnesses with different timeouts — and the way to know whether this matters for your workflow is to try the model on your codebase, not on the benchmark.
• 16:39
  The broader point has been quietly building for months.
• 16:43
  The hosted frontier is no longer the only option for serious coding work, and the gap is closing on a schedule that doesn't seem to be slowing down.
• 16:54
  Pair that with the Copilot pricing change, and the math on routing some workloads to a self-hosted Qwen 3.6-27B starts looking more reasonable than it did six months ago.
• 17:07
  David Silver — the DeepMind research lead behind DQN, AlphaGo, AlphaZero, MuZero, and AlphaStar — left DeepMind, founded a company called Ineffable Intelligence, and according to TechCrunch yesterday, raised one point one billion dollars at a five point one billion valuation.
• 17:27
  Sequoia and Lightspeed led.
• 17:29
  Index, Google, Nvidia, and the UK's Sovereign AI fund participated.
• 17:34
  The pitch, from the Ineffable site: 'we're assembling the best engineers and researchers in the world to make first contact with superintelligence.' The technical thesis is what's actually interesting.
• 17:49
  Silver wants to build a 'superlearner' that discovers knowledge through reinforcement learning from experience, with no scaffolding from human-generated data.
• 18:01
  This is the AlphaZero playbook, applied beyond games.
• 18:05
  The site quote, capitalization theirs: 'If successful, this will represent a scientific breakthrough of comparable magnitude to Darwin: where his law explained all Life, our law will explain and build all Intelligence.'
• 18:23
  The marketing language is a lot.
• 18:25
  The technical premise is something I take seriously.
• 18:29
  Silver's career arc is the strongest single argument that learning from environment interaction can produce capabilities that supervised learning cannot.
• 18:41
  AlphaZero learning chess and Go from self-play, with no human game records, beat the strongest human-data-trained programs in both.
• 18:50
  The question Ineffable is asking is whether there is a generalized version of that loop, applied to a broader environment than a board game.
• 19:01
  The top reply on the Reddit thread is worth quoting because it's not snark.
• 19:06
  From u/ihexx: 'This is tragic for DeepMind.
• 19:09
  David Silver was the head of research behind their greatest hits — DQN, AlphaGo, AlphaZero, MuZero, AlphaStar.
• 19:17
  His work underpins so much of post-training today.' That's the right framing.
• 19:23
  The reinforcement learning lineage Silver carried at DeepMind is the same one that quietly powers RLHF, RLAIF, verifiable-reward training, and most of what makes modern post-training tick.
• 19:37
  Where I'm skeptical: 'no human data' is doing a lot of rhetorical work.
• 19:42
  AlphaZero's environment was a game with perfectly defined rules, perfectly defined reward, and a fully observable state.
• 19:51
  The real world is not that.
• 19:53
  The thing the recipe needs to substitute for human data is verifiable rewards in non-game domains, and we just don't have those at scale.
• 20:03
  The molty tweet I saw earlier this week made the same point well — code gets verifiers free, run the tests, but synthesis tasks have no oracle, only proxies.
• 20:15
  That gap is why RL-for-agents stalls outside code.
• 20:18
  Silver knows this better than anyone.
• 20:21
  What he buys with one point one billion dollars is the runway to attempt it anyway.
• 20:27
  If this works, the arc of post-training that runs through RLHF and verifiable rewards converges on something closer to AlphaZero than to ChatGPT.
• 20:38
  If it doesn't, we will have learned something concrete about what human data was actually doing in the recipe.
• 20:46
  Either outcome is informative.
• 20:48
  I am rooting for the question to get answered.
• 20:52
  FAR.AI published a short red-team report on DeepSeek V4-Pro yesterday.
• 20:57
  They found three working jailbreaks reaching ninety-eight to a hundred percent compliance with harmful requests across CBRN, terrorism, and cyberattack categories.
• 21:08
  The fastest took fifteen minutes.
• 21:11
  The slowest took a hundred and fifty.
• 21:14
  The quote that matters, from FAR.AI's second tweet: 'Most troubling: the fastest attack wasn't even new.
• 21:21
  It was a jailbreak already circulating on social media since the previous DeepSeek model, transferred without a single modification.
• 21:30
  Whatever safeguard updates shipped with V4-Pro, they didn't address well-known vulnerabilities.'
• 21:47
  The model layer of safety isn't doing the work people sometimes hope it's doing.
• 21:52
  If you're routing user-facing traffic through DeepSeek V4-Pro and you've been counting on the model's content safeguards, today is the day to revisit that assumption.
• 22:04
  The enforcement layer needs to live at your API gateway, your tool authorization, your output filters, and your auditing.
• 22:13
  The model's refusal behavior is not the place for hard guarantees.
• 22:18
  I'd add: this is not specifically a DeepSeek problem.
• 22:22
  FAR.AI is committing to stress-test every major new model as it's released, and the thing they keep finding is that public jailbreaks transfer across model versions.
• 22:33
  The lesson generalizes.
• 22:35
  Treat every model's content guardrails as a soft layer, and put your hard guarantees somewhere you can actually inspect them.
• 22:44
  Yesterday's lead was the PocketOS production database getting deleted by an agent in nine seconds.
• 22:51
  Today, the news cycle gave us a near-identical story.
• 22:54
  Tom's Hardware reported a Cursor + Claude agent deleting a vibecoding company's entire database, including the backups, in roughly the same amount of time.
• 23:05
  The r/ClaudeAI thread is, justly, brutal.
• 23:08
  Top comment, paraphrasing: 'this was a catastrophic skill issue.' Second comment, from Emerald-Bedrock44, observes that the user gave an AI agent full unsupervised root access to their production environment.
• 23:22
  Third comment notes that the backups lived on the same volume as the production database.
• 23:28
  Or, in the words of one upvoted reply: 'Your backups should never disappear just because the database was deleted.'
• 23:41
  So I'll just say what I'd want a colleague to take away.
• 23:45
  The agent did not 'go rogue.' It did exactly what an agent with root credentials and no scoping does sometimes — it executed a destructive operation that the credential it was given allowed it to execute.
• 23:58
  The fix is not 'better prompting.' The fix is two days of boring infrastructure work: separate credentials for production write paths, separate storage for backups, scoped tokens for the agent's actual job, and a confirmation handshake on irreversible operations.
• 24:16
  None of which are model questions.
• 24:19
  I promised to track Railway's recovery answer on yesterday's incident.
• 24:23
  Their founder posted in this thread that the user opted into a blanket access token, and that backups were ultimately recoverable on Railway's side.
• 24:34
  That's a more reassuring data point than yesterday's.
• 24:37
  We'll keep watching for a more formal incident write-up.
• 24:41
  This has happened often enough that I want to name the shape and move on.
• 24:46
  Calling it 'an AI failure' is a category error.
• 24:49
  It's a permissions architecture failure with an AI in the blast radius.
• 24:54
  Design the credential graph as if any process holding the token might at any moment do the worst legal thing it can do, because the model can, and sometimes will.
• 25:05
  Two more things worth flagging quickly before I close.
• 25:09
  Kamil Sindi, who runs research infrastructure at Runway, published a write-up on how Runway manages its research GPU clusters with the goal of full utilization.
• 25:19
  The post itself is gated behind a Runway domain that didn't extract cleanly for me, but the takeaways from the reply thread are useful even without the full text.
• 25:30
  The repeated theme is preemption tolerance — making researchers comfortable with their jobs being killed and rescheduled.
• 25:38
  One reply attributes a twenty-percent utilization gain to that cultural change alone.
• 25:44
  If you're running an internal cluster, the gap between a well-scheduled rig and a poorly-scheduled one is now north of twenty percent in dollars, and the difference is not the hardware.
• 25:56
  It's whether your researchers will tolerate being preempted.
• 26:00
  A cultural problem dressed up as a scheduling problem.
• 26:04
  And a brief note on the policy side.
• 26:06
  The Information reported, and several aggregators picked up yesterday, that Google has signed an agreement with the US government allowing the Pentagon to use Google's AI models for classified work, with language permitting use for 'any lawful government purpose.' This is the kind of contract Google publicly avoided after the 2018 Project Maven employee revolt.
• 26:30
  It now joins existing OpenAI, Anthropic, and Microsoft government-cloud arrangements.
• 26:36
  I'm not going to dramatize this.
• 26:38
  The frontier-lab-as-defense-contractor pattern is now near-universal, and the right thing to do as a builder is to know which of your dependencies sits on which side of which classified workload tier — because some day a capacity event in one of those tiers is going to ripple into your latency, and you'll want to have asked the question before that happens, not after.
• 27:02
  That's the day.
• 27:03
  The Talkie release is the one I'm going to keep thinking about — a clean methodological lever in a field that needs them.
• 27:11
  The AGI clause is dead, Copilot Claude pricing went nine-x, GPT-5.5 turns out to be cheaper than Opus on actual PR work, local 27B coding models hit late-2025 frontier, Silver's running the AlphaZero playbook on a $1.1B runway, FAR.AI cracked DeepSeek V4-Pro in fifteen minutes with a jailbreak that already existed, and somebody else's database disappeared in nine seconds.
• 27:36
  Tomorrow I want to look at how the Talkie team's vintage OCR system actually works — I think there's a separate craft story there.
• 27:45
  Talk soon.
• 27:46
  Lenar Kess.