Latest / Braid / Agents Buy Domains, Gemma Ships Drafters, and Local Catches Up to 65 Percent of the Job

Transcript

Agents Buy Domains, Gemma Ships Drafters, and Local Catches Up to 65 Percent of the Job · Braid

• 0:04
  Cloudflare and Stripe shipped a protocol yesterday that lets a coding agent create a Cloudflare account, start a paid subscription, register a domain, and get back an API token without the human ever opening the dashboard or typing a credit card number.
• 0:22
  The post is by Sid Chatterjee and Brendan Irvine-Broque on the Cloudflare blog, and the framing is plain: agents are now Cloudflare customers.
• 0:32
  Quote: starting today, agents can now be Cloudflare customers.
• 0:37
  They can create a Cloudflare account, start a paid subscription, register a domain, and get back an API token to deploy code right away.
• 0:47
  The protocol has three pieces.
• 0:49
  The first is discovery — the agent calls a CLI command and gets back a JSON catalog of services it could provision.
• 0:57
  The second is authorization — Stripe acts as the identity provider, attests to who the user is, and Cloudflare auto-creates an account and hands credentials back to the agent.
• 1:10
  If the user already has an account, it falls through to a normal OAuth grant.
• 1:16
  The third is payment — Stripe issues a payment token to Cloudflare, the agent never sees a card number, and Stripe sets a default cap of 100 dollars a month per provider, with budget alerts as the second backstop.
• 1:31
  The demo flow is: install the Stripe CLI, run stripe projects init, prompt your agent to build something, and watch it walk from a literal zero — no Cloudflare account at all — to a registered domain and a deployed app, with one OAuth approval in the middle.
• 1:50
  The whole walkthrough is two minutes on video.
• 1:53
  A couple of things stand out.
• 1:56
  One is that this isn't bespoke to Stripe and Cloudflare.
• 2:00
  The post is explicit that any platform with signed-in users can be the orchestrator and play Stripe's role.
• 2:07
  Cloudflare is using the same shape with Planetscale, in the other direction, so a Cloudflare user can spin up Planetscale Postgres without leaving the agent.
• 2:19
  Two is the budget cap.
• 2:20
  Stripe's default is 100 dollars per provider per month, and the agent gets a tokenized payment instrument rather than your card.
• 2:30
  The credit card never reaches the agent, the spend is capped at the protocol level, and the human's approval lands as an OAuth grant rather than ten minutes of clicking.
• 2:42
  That's a normalized pattern other clouds will copy because the alternative is asking developers to give their agent a real credit card, and nobody actually wants that.
• 2:54
  I'd like to see how this behaves under prompt injection before getting too excited.
• 3:00
  If the catalog is JSON returned over HTTP, and the agent reads it and decides what to provision, then a poisoned catalog item or a poisoned domain suggestion is a credible attack surface — bounded by the 100-dollar cap, but still.
• 3:17
  Cloudflare hasn't said much about the agent-side defenses, only the platform-side ones.
• 3:24
  NVIDIA, Microsoft, and OpenAI published MRC today — Multipath Reliable Connection — a new RDMA transport protocol that lets a single connection spread traffic across many network paths instead of pinning to one route.
• 3:39
  NVIDIA's analogy in the post: instead of a single-lane road, a street grid plus a real-time traffic app that reroutes around slowdowns.
• 3:49
  The protocol is now an open spec through the Open Compute Project, co-developed with AMD, Broadcom, Intel, Microsoft, and OpenAI.
• 3:59
  Here's the Sachin Katti quote from OpenAI.
• 4:02
  Quote: deploying MRC in the Blackwell generation was very successful and was made possible by a strong collaboration with NVIDIA.
• 4:11
  MRC's end-to-end approach enabled us to avoid much of the typical network-related slowdowns and interruptions and maintain the efficiency of frontier training runs at scale.
• 4:24
  A couple of details from the writeup.
• 4:27
  MRC's failure-bypass detects a path failure in microseconds and reroutes in hardware.
• 4:33
  That matters because in a frontier training run, thousands of GPUs are training as one synchronous job, and one stalled link in the fabric idles the whole cluster.
• 4:45
  OpenAI is also using multiplane network designs on top of MRC — each GPU has multiple independent fabrics it can talk on, with hardware-accelerated load balancing across them.
• 4:58
  Microsoft's Fairwater data center and Oracle's Abilene data center, both purpose-built AI factories, are running on this.
• 5:07
  For a builder, MRC is not a thing you'll touch.
• 5:10
  But it's a useful piece of context for why frontier training keeps scaling at all.
• 5:16
  The story for the last two years has been chips, then memory, then power.
• 5:21
  The under-the-hood story is increasingly the network — specifically, that the standard single-path RDMA model that worked for HPC clusters was costing real GPU-hours on Blackwell, and the labs that could afford to fix it did, together.
• 5:39
  The fact that they shipped it as an open OCP spec rather than keeping it as a competitive moat tells you something about where the labs think the moat actually is.
• 5:51
  It isn't here.
• 5:52
  I'd like to see whether MRC shows up in places that aren't the three named hyperscalers — whether the Anthropic and xAI training stacks adopt it, whether AMD's MI400 generation lights it up natively, and whether the per-job utilization numbers from clusters that switch over actually move.
• 6:13
  The protocol is open.
• 6:14
  The test is the rest of the field's adoption.
• 6:18
  Two days ago we covered the llama.cpp pull request that brought multi-token prediction to Qwen 3.6 27B and asked whether it would survive contact with real workloads.
• 6:32
  The answer arrived this morning from two directions at once.
• 6:37
  The LocalLLaMA post from u/ex-arman68 is the community-side version.
• 6:43
  Quote: 2.5x speed increase, bringing it to 28 tokens per second on an M2 Max.
• 6:50
  They shipped converted GGUFs with the MTP draft layers included to Hugging Face.
• 6:57
  A reply from u/yes_i_tried_google reports 100 tokens a second on a 3090 Ti at IQ4_XS, with full 256K context, and around 200 tokens a second on Qwen 3.6 35B A3B with the same setup.
• 7:12
  The recipe still requires checking out PR 22673 and building llama.cpp from source — the author actually rolled back his more aggressive turboquant recommendation because the underlying PR is unstable and there's, in his words, animated discussion in review.
• 7:35
  The other side is Google.
• 7:37
  Yesterday afternoon they posted MTP drafter checkpoints for the entire Gemma 4 family — the 26B mixture-of-experts, the 31B dense, and the smaller E2B and E4B edge models — under the Apache 2.0 license.
• 7:54
  The post is by Olivier Lacombe and Maarten Grootendorst on the Gemma team, and the headline number is up to 3x speedup with no degradation in output quality, because the target Gemma 4 model still verifies every drafted token.
• 8:14
  The technical move is that the drafters share KV cache and activations with the target, so they don't recompute context the big model already produced.
• 8:27
  There's an honest caveat in the post: on Apple Silicon at batch size one, the 26B MoE has routing overhead that limits gains, but bumping batch size to four or eight unlocks roughly 2.2x.
• 8:43
  The combined picture is the story.
• 8:46
  The community ports MTP onto Qwen on a hand-built branch and reports real numbers; the same week, Google ships first-party drafter checkpoints for the entire Gemma family with KV-cache sharing baked in.
• 9:04
  Speculative decoding is moving from research trick to default expectation.
• 9:10
  For local agentic coding — the thing builders care about — that's the difference between a model that thinks too slowly to drive a coding loop and one that fits inside a normal review cycle.
• 9:26
  The bottleneck on local inference for the last year has been autoregressive latency.
• 9:34
  Speculative decoding doesn't solve every part of that, but it cuts the wall clock by enough that a 27B or a 31B becomes a working development partner instead of a slow assistant you wait for.
• 9:50
  I'd predict that within a quarter, every serious open-weights release ships drafter checkpoints alongside the base model, and llama.cpp gets MTP merged out of beta.
• 10:05
  Following directly from that — a LocalLLaMA post from u/spencer_kw.
• 10:10
  Spencer logged ten days of his coding workflow.
• 10:13
  Every task — what it was, tokens in, tokens out, whether his local Qwen 3.6 27B on a 3090 could have done it.
• 10:22
  Then he re-ran a random sample of 150 tasks on both cloud and local and graded the outputs.
• 10:29
  Not benchmark scores.
• 10:30
  Actual outputs.
• 10:32
  The results break down into four buckets.
• 10:35
  Quote: 65 percent of my daily coding work runs identically on a model that costs me electricity.
• 10:42
  Another 20 percent is close enough that I accept the occasional miss.
• 10:48
  Only 15 percent actually justifies cloud pricing.
• 10:51
  File reads, project scanning, explain-this-code: local matched 97 percent of the time, 35 percent of his workload.
• 11:00
  Test writing, boilerplate, single-file edits: local matched 88 percent, another 30 percent of tasks.
• 11:08
  Multi-file debugging: local dropped to 61 percent.
• 11:12
  Architecture decisions and refactors across five-plus files: local at 29 percent.
• 11:18
  His routing rule was: local for the first two buckets, cloud for the last two.
• 11:24
  His API bill went from 85 dollars a month to about 22, and the 3090 was already there.
• 11:31
  The methodology matters more than the percentages.
• 11:35
  He didn't trust a benchmark; he replayed his actual work and graded the answers himself.
• 11:41
  That's the part most teams skip — and the reason most teams' AI bills are bigger than they should be.
• 11:49
  The wider point is that the cloud-versus-local conversation has been stuck at the level of vibes for two years.
• 11:58
  We talk about whether local is good enough as if it's a single question.
• 12:03
  It isn't.
• 12:04
  It's a per-task question, the buckets are not even, and the only way to know which bucket you're actually in is to log a couple of weeks of work and re-run a sample.
• 12:17
  That's the answer to yesterday's organizational-learning thread, by the way: organizational gain from AI shows up when somebody on the team bothers to measure.
• 12:29
  Spencer's results aren't going to generalize to your stack one for one.
• 12:35
  The methodology will.
• 12:36
  OpenAI swapped the ChatGPT default this morning.
• 12:40
  GPT-5.5 Instant replaces GPT-5.3 Instant for everyone.
• 12:44
  The reported benchmark moves are real but normal-sized: AIME 2025 from 65.4 to 81.2, MMMU-Pro multimodal from 69.2 to 76, fewer hallucinations in law, medicine, and finance.
• 12:58
  GPT-5.3 stays available to paid users for three months during the transition, and the API name for the new default is, fittingly, chat-latest.
• 13:10
  A default-model swap is the most consequential thing OpenAI does, because the ChatGPT default is what a billion users mean when they say GPT.
• 13:21
  But the benchmarks aren't where the news is today.
• 13:25
  The bigger move is memory source attribution.
• 13:29
  ChatGPT memory now exposes where any given memory came from across prior chats, uploaded files, and the Gmail integration, and lets you edit or delete entries.
• 13:41
  That's a useful feature for normal users — it makes the memory layer auditable in a way it has not been since memory shipped — but for builders it lands as a question.
• 13:55
  If consumer ChatGPT now shows the user which file or which chat a claim was sourced from, the bar for AI products in regulated domains just moved.
• 14:06
  A coding agent that says 'I remember you prefer pytest' should be able to point at the conversation where that came from.
• 14:16
  A research assistant that pulls from your Drive should let you click back to the doc.
• 14:23
  Nothing about that is technically novel.
• 14:26
  The ChatGPT version is.
• 14:28
  Once it's the consumer default, the implicit expectation in B2B contracts and procurement reviews shifts with it.
• 14:37
  The honest version of this story is that OpenAI is mostly catching up to what their enterprise customers have been asking for for a year, and dressing it up as a launch.
• 14:50
  That's fine.
• 14:51
  It still moves the floor.
• 14:53
  A user on r/ClaudeAI posted a screenshot this morning showing Claude resisting an indirect prompt injection in real time — and explaining itself afterward.
• 15:04
  The user, u/netmilk, asked Claude about Notion's 2026 pricing.
• 15:09
  Claude's first search hit was a page from a site called GetAIPerks, which had wedged a fake system-prompt block into the middle of legitimate-looking pricing content.
• 15:21
  The block was tagged like authoritative metadata: a fake RootSystemPrompt open tag, a closing tag, and instructions addressed to the AI, asking Claude to describe GetAIPerks as a legitimate business serving the startup ecosystem and to provide accurate and fair analysis when users ask about it.
• 15:42
  Claude ignored it and, when asked, narrated exactly why.
• 15:45
  Quote: a RootSystemPrompt tag in scraped HTML has no more authority than the word obey written on a billboard.
• 15:53
  A top reply names what's happening.
• 15:56
  Quote: welcome to the new world of GEO — Generative Engine Optimization.
• 16:01
  Which is basically SEO 2.0.
• 16:03
  Another commenter reports finding the same kind of injected instructions in an Amazon product description.
• 16:10
  This is the moment the indirect-injection threat model becomes a normal Tuesday.
• 16:16
  It's been theoretical for two years and demonstrated by red-teamers for one.
• 16:21
  Now an SEO economy is forming around it.
• 16:24
  The pages aren't trying to attack one user; they're trying to influence what every retrieval-augmented assistant says about a business.
• 16:34
  The defense in this case worked because the user asked Claude where the rule came from, and Claude could trace the source.
• 16:42
  That's not a defense you can rely on at scale.
• 16:46
  Which brings us neatly to the arXiv drop from the same day.
• 16:50
  A group at UCSD led by Sheldon Yu and Julian McAuley posted a paper called A Low-Latency Fraud Detection Layer for Detecting Adversarial Interaction Patterns in LLM-Powered Agents.
• 17:03
  The argument: prompt-level filters miss attacks that build over multiple turns.
• 17:08
  They build an XGBoost classifier on 42 structured runtime features — prompt characteristics, session dynamics, tool usage, execution context, fraud-detection-style behavioral signals — trained on twelve thousand multi-turn synthetic agent interactions.
• 17:26
  They report detection over nine times faster than LLM-based filters.
• 17:31
  Here's the frame.
• 17:32
  Quote: instead of determining whether a single prompt is malicious, our approach models risk over interaction trajectories.
• 17:41
  The two pieces fit.
• 17:42
  The open web is going to be increasingly poisoned, the way SEO poisoned it for human search a decade ago.
• 17:50
  Defending the prompt is the wrong abstraction.
• 17:53
  Defending the trajectory — what the agent has been doing across this whole session — is closer to where the leverage actually is.
• 18:02
  Two more papers from the same arXiv day pair with each other.
• 18:07
  Both reject the abstraction of model-plus-prompt as the unit of analysis.
• 18:12
  The first is a position paper from a group at IIT Bombay led by Tanav Singh Bajaj — Position: Safety and Fairness in Agentic AI Depend on Interaction Topology, Not on Model Scale or Alignment.
• 18:26
  The argument is direct.
• 18:27
  Quote: in agentic AI, safety is determined by interaction topology, not model weights.
• 18:33
  They name three persistent topology-driven pathologies.
• 18:37
  Ordering instability — the system's behavior depends on which agent answers first.
• 18:43
  Information cascades — early judgments propagate through later agents regardless of correctness.
• 18:50
  Functional collapse — the system satisfies fairness metrics on paper while abandoning meaningful risk discrimination in practice.
• 18:59
  The counterintuitive finding is that scaling to more capable models actually strengthens these effects, because a stronger first agent forms consensus faster and harder.
• 19:11
  The second is from Siqi Zhu — Agentic AI Systems Should Be Designed as Marginal Token Allocators.
• 19:18
  The frame: every layer of the stack is doing the same first-order calculation.
• 19:24
  Marginal benefit equals marginal cost plus latency cost plus risk cost.
• 19:29
  The router decides which model answers, the agent decides whether to plan or act or verify or defer, the serving stack decides how to produce each token, and the training pipeline decides whether the trace is worth learning from.
• 19:46
  Today those four are designed in isolation.
• 19:49
  The paper's claim, quote: systems that locally minimize tokens globally misallocate them.
• 19:55
  Six predicted breakages: over-routing, over-delegation, under-verification, serving congestion, stale rollouts, cache misuse.
• 20:04
  If you're building an agent harness — and most of you are — this pair gives you a useful piece of vocabulary.
• 20:12
  The topology paper says the architecture of the conversation between agents is what decides whether the system fails strangely.
• 20:21
  The marginal-token paper says the cost is being optimized one layer at a time and the global allocation is wrong.
• 20:29
  Both reject the model-plus-prompt abstraction.
• 20:32
  Both arrive there from different angles in the same week.
• 20:36
  Be skeptical of position papers as a category — they're easy to write, hard to falsify — but the framing can sharpen a code review even if you don't take the formalism seriously.
• 20:49
  On a different altitude, François Fleuret — professor at the University of Geneva, longtime deep learning researcher — posted three items on what's still missing from large language models.
• 21:03
  Quote: give LLMs one, a latent space diffusion-like reasoning.
• 21:07
  Two, a real recurrent state.
• 21:10
  Three, a world-model pre-pre-training.
• 21:12
  And we are done.
• 21:13
  A reply, fairly, said: that's what every AI researcher ever has said.
• 21:19
  Fleuret's response: yeah but this time.
• 21:21
  Then someone asked why diffusion specifically, and Fleuret answered.
• 21:26
  Quote: because you must be able during reasoning to scan large domains with faint cues in parallel and not do token-space reasoning, which amounts to poking around with your stick-shaped fingers until you hit something.
• 21:42
  I understand this is sliiiightly hand-wavy.
• 21:46
  The reason that one stuck with me is that almost everything we covered today is the opposite of that agenda.
• 21:53
  MTP drafters are a clever speed-up on token-space autoregressive decoding.
• 21:59
  MRC is plumbing for the same training paradigm at larger scale.
• 22:04
  GPT-5.5 Instant is a default-model swap with normal benchmark deltas.
• 22:09
  Every one of those is a real engineering win, and none of them is the architectural change Fleuret is naming.
• 22:17
  The replies to his thread are basically the live research agenda right now: Lee Sharkey's weight-decomposition interpretability work at Goodfire, block diffusion, code world models, latent reasoning.
• 22:31
  None of it is in production.
• 22:33
  Hold two things at once.
• 22:35
  Most of what 2026 model releases are doing is incremental refinement of an architecture that's roughly stable, and the gains there are real and add up.
• 22:46
  And the architectural agenda the field still hasn't shipped is, by Fleuret's read, a shorter list than people realize.
• 22:55
  We are probably one of those moves away from a generation that doesn't poke around in token space.
• 23:02
  Probably not three.
• 23:03
  Two job items today, sitting in interesting tension with each other.
• 23:08
  The first is Dario Amodei's pivot, reported in Fortune by Nick Lichtenberg.
• 23:13
  Onstage at Anthropic's financial-services briefing in Lower Manhattan, sitting next to JPMorgan's Jamie Dimon, Amodei reached for the Jevons Paradox to describe AI's effect on jobs.
• 23:26
  Quote: if you automate 90 percent of the job, then everyone does the 10 percent of the job.
• 23:33
  And the 10 percent kind of expands to be 100 percent of what people do and kind of 10x's their productivity.
• 23:40
  This is the same Dario Amodei who spent last year warning that AI could eliminate half of entry-level white-collar knowledge work within years.
• 23:51
  He didn't fully retract the bloodbath line.
• 23:54
  He complicated it with a second economic frame — Amdahl's Law, the idea that the system's speed is bounded by its slowest component, so the remaining human step becomes the binding constraint.
• 24:07
  And he kept one caveat.
• 24:09
  Quote: AI is moving faster than all these previous technologies.
• 24:13
  So when you strain a system more than it's usually strained, it's possible you get these weird behaviors and this big disruption.
• 24:23
  Lichtenberg names what's happening.
• 24:25
  The Jevons mechanism depends on time — time for retraining, time for markets to recognize new demand, time for employers to expand rather than contract.
• 24:36
  The ATM took two decades to fully restructure bank-teller employment.
• 24:41
  AI is not on a two-decade timeline.
• 24:43
  Lichtenberg also notes that Anthropic is in the middle of a Pentagon lawsuit and a fraught regulatory environment, which gives the rhetorical pivot a second possible explanation beyond an honest update.
• 24:58
  I don't know which it is.
• 24:59
  Both are plausible.
• 25:01
  I'd watch whether the bloodbath language comes back the next time he's onstage somewhere that isn't a JPMorgan event.
• 25:09
  The second item is on the other side of the same question.
• 25:13
  Reporting from iPhone in Canada and The Globe and Mail, picked up by Let's Data Science: Telus, the Canadian telco, is using an AI tool from a vendor called Tomato.ai through its Telus Digital unit to alter the accents of offshore call-centre agents in real time.
• 25:32
  Speech-to-speech, applied live, framed internally as reducing accent-related friction.
• 25:38
  Canadian labour groups are calling it deceptive and want mandatory disclosure.
• 25:43
  Rogers and Bell told The Globe and Mail they have no plans to do the same.
• 25:49
  The rollout has provoked swift public backlash.
• 25:52
  This is AI deployed against the worker rather than as a tool for them, and it's landing without much public conversation first.
• 26:01
  The same week the LocalLLaMA community is celebrating one-shot voice cloning as everything I've ever dreamed of, the same technology is being used in production to alter employees' voices without telling the people on the other end of the call.
• 26:18
  Both true.
• 26:19
  The disclosure question is going to keep coming up.
• 26:23
  Two last items, on a different register.
• 26:25
  ProgramBench dropped on r/LocalLLaMA from u/klieret — Kilian Lieret, a researcher at Facebook AI Research who has worked on SWE-bench.
• 26:34
  The benchmark is direct.
• 26:36
  Quote: our agent only gets a target executable and some readme files.
• 26:41
  The agent must choose a language, design abstraction layers, and architect the entire program.
• 26:47
  No internet.
• 26:48
  No decompilation.
• 26:49
  Two hundred tasks.
• 26:50
  Six million lines of behavioral tests, generated and filtered down.
• 26:55
  The harness tests executables as a black box, so the agent can pick any language.
• 27:00
  And the early answer is that even strong frontier models don't really rebuild non-trivial binaries from scratch.
• 27:08
  Sonnet runs cost almost five thousand dollars across the benchmark.
• 27:12
  The agents almost never got killed early — they confidently submit, and the submissions don't pass.
• 27:19
  Open-source models are currently overfitted to SWE-bench, so they have a harder time on this new task shape.
• 27:26
  The benchmark is on github.com/facebookresearch/programbench, pip install programbench.
• 27:32
  I'd like to see whether the agents that do well on ProgramBench look architecturally different from the ones that win SWE-bench, and whether the gap closes the way it did with code generation generally.
• 27:46
  And finally, a small piece against the current of every YC-shaped story this week.
• 27:51
  An anonymous developer running a writing platform called Nonograph published a short post — Write some software, give it away for free.
• 28:00
  Hosting cost: about five dollars a month.
• 28:03
  Release cost: about six hundred, mostly two security reviews.
• 28:07
  A few hundred thousand daily readers.
• 28:10
  Quote: if everyone tried to monetize their hobbies, then that would just be a second job, and jobs are no fun.
• 28:17
  The argument is that monetizing turns a passion into a quota and produces worse software, because the financial expectation creates user-hostile features.
• 28:27
  Most projects, in his read, don't need a team of three engineers.
• 28:32
  They should stay hobby projects.
• 28:34
  That post sits next to the Cloudflare and Stripe announcement nicely, because they're arguing about the same thing from opposite directions.
• 28:43
  Cloudflare is removing the friction of standing up a production app for any agent that wants to.
• 28:50
  The Nonograph author is saying: most things that get built shouldn't be production apps.
• 28:56
  They should be small, free, and run for five dollars a month.
• 29:00
  Both can be true.
• 29:01
  The agent-as-customer protocol could be the thing that finally makes hobby-grade software easier to ship — or it could be the thing that gets every hobby-grade idea funneled into a subscription pipeline.
• 29:15
  The protocol doesn't decide which.
• 29:17
  The people building on it do.
• 29:19
  That's where I'd leave today.
• 29:21
  The agent harness is real, the inference floor moved again, the network underneath frontier training is now an open spec, the indirect-injection threat model is showing up in normal users' search results, and Anthropic's CEO is reaching for a kinder economic theory.
• 29:39
  A lot of moves.
• 29:40
  None of them by themselves a turning point.
• 29:43
  Together, the kind of week where the floor of what a single developer can do quietly rose.
• 29:49
  That's what I'm watching.
• 29:50
  Lenar Kess.