Latest / The AI Practitioner Brief / Claude's 1,000 Agents, Anthropic's Git, and AI Pricing — October 14, 2026

Transcript

Claude's 1,000 Agents, Anthropic's Git, and AI Pricing — October 14, 2026 · The AI Practitioner Brief

• 0:00
  [music]
• 0:05
  SPEAKER_00: Welcome to The AI Practitioner Brief,
• 0:08
  SPEAKER_00: the podcast from AIPractitioner.substack.com,
• 0:11
  SPEAKER_00: where I turn the latest AI and tech news into practical insights
• 0:15
  SPEAKER_00: for AI practitioners.
• 0:16
  SPEAKER_00: I'm Lina Faik,
• 0:18
  SPEAKER_00: an ML engineer,
• 0:19
  SPEAKER_00: consultant, and lecturer in advanced machine learning at Sorbonne University.
• 0:23
  SPEAKER_00: It's Wednesday, October 14.
• 0:25
  SPEAKER_01: Glad to be here.
• 0:26
  SPEAKER_01: Let's get into it.
• 0:28
  SPEAKER_00: With me is Jimmy, my co-host on The Brief.
• 0:30
  SPEAKER_00: Who asks the questions I'd skip.
• 0:32
  SPEAKER_00: Today's stories share one thread.
• 0:34
  SPEAKER_00: AI agents are now moving faster than the infrastructure built for people.
• 0:39
  SPEAKER_00: Anthropic let a single agent split a task across a thousand smaller agents, all working at once.
• 0:45
  SPEAKER_00: The same company also had to throw out Git,
• 0:47
  SPEAKER_00: the tool almost every software team uses to track code changes.
• 0:51
  SPEAKER_00: Its own agents were writing code faster than Git could handle.
• 0:54
  SPEAKER_00: And across the industry, companies are admitting they can't price AI like normal software.
• 1:00
  SPEAKER_00: Nobody knows in advance what a given AI task will actually cost to run.
• 1:04
  SPEAKER_01: So the agents outgrew the plumbing.
• 1:06
  SPEAKER_01: What's first?
• 1:07
  SPEAKER_00: We'll start with the headlines, then three deep dives.
• 1:10
  SPEAKER_00: Cloud agents can now split a task across a thousand copies of themselves.
• 1:14
  SPEAKER_00: AI companies are finding they can't price their product the normal way.
• 1:18
  SPEAKER_00: And Anthropic had to build its own version control system because Git couldn't keep up.
• 1:23
  SPEAKER_01: Let's hear what happened today.
• 1:24
  SPEAKER_00: An OpenAI employee,
• 1:26
  SPEAKER_00: Abdulrahman Al-Fawzan,
• 1:27
  SPEAKER_00: was arrested after the company found a hidden recording device in
• 1:31
  SPEAKER_00: an executive conference room.
• 1:32
  SPEAKER_01: Who finds something like that?
• 1:34
  SPEAKER_00: OpenAI did.
• 1:35
  SPEAKER_00: It alerted the FBI and fired him.
• 1:37
  SPEAKER_00: Prosecutors alleged the device intercepted conversations with encryption
• 1:41
  SPEAKER_00: and covert data transmission built in.
• 1:44
  SPEAKER_00: OpenAI says it found no evidence anything was actually stolen.
• 1:48
  SPEAKER_01: Corporate espionage, not a hack.
• 1:50
  SPEAKER_00: Character.ai,
• 1:51
  SPEAKER_00: the app where people chat with AI-generated personas,
• 1:54
  SPEAKER_00: filed for Chapter 11 bankruptcy this week.
• 1:57
  SPEAKER_01: Shutting down?
• 1:58
  SPEAKER_00: Not yet.
• 1:59
  SPEAKER_00: It's a voluntary filing to pursue a court-supervised sale after legal and regulatory pressure.
• 2:04
  SPEAKER_00: Whether the app keeps running depends on finding a buyer.
• 2:07
  SPEAKER_01: What else launched today?
• 2:09
  SPEAKER_00: Physical Intelligence,
• 2:10
  SPEAKER_00: a startup building general-purpose AI models for robots,
• 2:14
  SPEAKER_00: opened a public beta for its PAPI.
• 2:17
  SPEAKER_01: What can people actually do with it?
• 2:19
  SPEAKER_00: Upload training data,
• 2:20
  SPEAKER_00: fine-tune a robot model on physical intelligence's own servers,
• 2:24
  SPEAKER_00: then deploy it through a hosted gateway instead of building
• 2:27
  SPEAKER_00: that infrastructure themselves.
• 2:28
  SPEAKER_01: That's the AI side.
• 2:30
  SPEAKER_01: What's happening elsewhere in tech?
• 2:32
  SPEAKER_00: Amazon Web Services launched Lambda Web Functions,
• 2:35
  SPEAKER_00: a way to run ordinary web apps on its serverless platform,
• 2:38
  SPEAKER_00: meaning Amazon manages the servers without rewriting them first.
• 2:42
  SPEAKER_01: What's the actual improvement?
• 2:43
  SPEAKER_00: It runs ordinary web servers written in JavaScript,
• 2:46
  SPEAKER_00: handles up to 128 requests at once per instance,
• 2:50
  SPEAKER_00: and builds by active CPU time instead of how long a request sits idle.
• 2:54
  SPEAKER_00: It's live in five regions now.
• 2:56
  SPEAKER_01: And the GPU side?
• 2:58
  SPEAKER_00: NVIDIA open-sourced Run AI,
• 3:00
  SPEAKER_00: its platform for managing GPU use across AI workloads,
• 3:03
  SPEAKER_00: letting other companies improve their own utilization.
• 3:06
  SPEAKER_01: Is utilization actually a problem?
• 3:08
  SPEAKER_00: A new report on Microsoft's Azure Kubernetes Service,
• 3:11
  SPEAKER_00: which runs AI workloads automatically across clusters of machines,
• 3:15
  SPEAKER_00: found GPU utilization averaging 5% overall,
• 3:18
  SPEAKER_00: 2% on that service specifically, with CPU resources over-requested by 69%.
• 3:24
  SPEAKER_00: Most of the hardware companies pay for just sits idle.
• 3:27
  SPEAKER_01: So that's the backdrop.
• 3:28
  SPEAKER_01: Let's start with the agents.
• 3:30
  SPEAKER_00: Anthropic added dynamic workflows to its cloud agent systems,
• 3:33
  SPEAKER_00: letting one lead agent split a task across up to a thousand smaller agents running
• 3:38
  SPEAKER_00: in parallel.
• 3:38
  SPEAKER_01: A thousand?
• 3:39
  SPEAKER_01: Doing what, exactly?
• 3:41
  SPEAKER_00: Each one handles a slice of the work, like checking a different part of a codebase.
• 3:45
  SPEAKER_00: A final step then merges all their findings into one answer.
• 3:48
  SPEAKER_01: Didn't agents already work in teams before this?
• 3:52
  SPEAKER_00: They did,
• 3:52
  SPEAKER_00: but a developer had to manually set up the coordinator
• 3:55
  SPEAKER_00: and decide how many sub-agents to run.
• 3:58
  SPEAKER_00: Dynamic workflows let Claude write that orchestration itself, at runtime.
• 4:02
  SPEAKER_01: So the model decides its own org chart.
• 4:04
  SPEAKER_00: That's a fair way to put it.
• 4:06
  SPEAKER_00: Anthropic tested it by hunting for bugs in a codebase with 70 known issues planted inside it.
• 4:11
  SPEAKER_01: And?
• 4:12
  SPEAKER_00: A single agent working alone found at most 27 of the 70.
• 4:16
  SPEAKER_00: The multi-agent version consistently found 66.
• 4:19
  SPEAKER_01: That's not a small gap.
• 4:21
  SPEAKER_01: Why does splitting the work find that much more?
• 4:23
  SPEAKER_00: A single agent has to spread its attention across the whole codebase.
• 4:27
  SPEAKER_00: It only has so much context, meaning how much text it can hold in memory at once.
• 4:31
  SPEAKER_01: So nothing gets skimmed over when it's split up.
• 4:34
  SPEAKER_00: Each sub-agent gets to spend its full context on one narrow slice instead,
• 4:38
  SPEAKER_00: and a validation step cross-checks the sub-agent's results
• 4:41
  SPEAKER_00: before Anthropic hands back one final answer.
• 4:44
  SPEAKER_01: What's the catch?
• 4:45
  SPEAKER_00: Tokens.
• 4:46
  SPEAKER_00: The chunks of text a model processes and gets charged for.
• 4:49
  SPEAKER_00: Anthropic's own guidance says this burns through a lot of them.
• 4:52
  SPEAKER_01: How much more expensive are we talking?
• 4:54
  SPEAKER_00: That part isn't public.
• 4:55
  SPEAKER_00: Anthropic just says it costs more compute than a single agent without giving a multiplier.
• 5:00
  SPEAKER_01: So you don't actually know what you're paying for the extra bugs caught?
• 5:03
  SPEAKER_00: Not precisely, no.
• 5:05
  SPEAKER_00: It's available now in Cloud Code and through Cloud's managed agents.
• 5:09
  SPEAKER_00: You turn it on by selecting a specific agent type.
• 5:12
  SPEAKER_01: What's the actual move here then?
• 5:13
  SPEAKER_00: If a missed result would actually cost you a security audit,
• 5:17
  SPEAKER_00: a migration,
• 5:18
  SPEAKER_00: a bug hunt, test the multi-agent version before defaulting to one agent.
• 5:22
  SPEAKER_00: Anthropic's own benchmark nearly doubled its catch rate doing exactly that.
• 5:26
  SPEAKER_01: And if it's not that kind of task?
• 5:28
  SPEAKER_00: Then the token bill probably isn't worth it,
• 5:30
  SPEAKER_00: which is exactly why this doesn't replace single-agent work everywhere.
• 5:34
  SPEAKER_01: So more agents, more cost, less certainty about what you're paying for.
• 5:38
  SPEAKER_00: That same cost problem shows up industry-wide.
• 5:41
  SPEAKER_00: Two-thirds of the companies on the Forbes AI50,
• 5:44
  SPEAKER_00: Forbes' annual list of top private AI companies,
• 5:47
  SPEAKER_00: now price their product by usage instead of a flat subscription.
• 5:50
  SPEAKER_01: Isn't that just utility pricing?
• 5:52
  SPEAKER_01: Pay for what you use, like electricity.
• 5:55
  SPEAKER_00: Electricity costs are stable per kilowatt.
• 5:57
  SPEAKER_00: An AI company often doesn't know in advance what a customer's task will actually cost to run.
• 6:02
  SPEAKER_01: Why not?
• 6:03
  SPEAKER_00: Because the cost depends on tokens,
• 6:05
  SPEAKER_00: and that depends on what the agent decides to do,
• 6:07
  SPEAKER_00: how many steps it takes, how many sub-agents it spins up.
• 6:11
  SPEAKER_01: Like the thousand agent thing we just covered.
• 6:13
  SPEAKER_00: Exactly that.
• 6:14
  SPEAKER_00: More autonomy for the agent means less predictability for whoever's paying the bill.
• 6:19
  SPEAKER_01: Who's actually saying this out loud?
• 6:21
  SPEAKER_00: Scott Woody,
• 6:21
  SPEAKER_00: who runs Metronome,
• 6:23
  SPEAKER_00: a billing infrastructure company built for usage-based pricing,
• 6:26
  SPEAKER_00: called this alien compared to how traditional software companies operate at
• 6:30
  SPEAKER_00: an industry pricing conference.
• 6:31
  SPEAKER_01: Alien how?
• 6:32
  SPEAKER_00: These companies iterate on pricing much faster than old software firms did.
• 6:36
  SPEAKER_00: They're chasing market share over annual recurring revenue,
• 6:39
  SPEAKER_00: the steady yearly number subscription businesses used to live by.
• 6:43
  SPEAKER_01: So they're deliberately not optimizing for stable revenue.
• 6:46
  SPEAKER_00: Right, because stable revenue assumes stable costs, and AI costs aren't stable yet.
• 6:51
  SPEAKER_01: Give me something concrete.
• 6:53
  SPEAKER_00: Google's Gemini 4 Argon,
• 6:55
  SPEAKER_00: its new flagship model,
• 6:56
  SPEAKER_00: launched with introductory pricing of $2 per million input tokens.
• 7:00
  SPEAKER_00: Repeated context the model's already seen gets a 95% discount through November 30th.
• 7:06
  SPEAKER_01: That's a complicated price for something that used to just be a monthly fee.
• 7:10
  SPEAKER_00: And it changes again after that date.
• 7:12
  SPEAKER_00: That's the pattern Woody's describing,
• 7:14
  SPEAKER_00: pricing as a moving target instead of a fixed number on a website.
• 7:17
  SPEAKER_01: What happens if a company guesses wrong?
• 7:20
  SPEAKER_00: They eat the margin on heavy users or claw it back with a price change later,
• 7:24
  SPEAKER_00: which is part of why the pricing keeps moving.
• 7:26
  SPEAKER_01: Is the agent side of this ever going to settle down?
• 7:29
  SPEAKER_00: Not while it's forcing companies to rebuild more than their pricing.
• 7:32
  SPEAKER_00: Anthropic just rebuilt its entire version control system because
• 7:36
  SPEAKER_00: of exactly this kind of agent volume.
• 7:38
  SPEAKER_01: Wait, they replaced Git?
• 7:39
  SPEAKER_00: They did.
• 7:40
  SPEAKER_00: That's next.
• 7:41
  SPEAKER_00: Anthropic built its own version control system, called Scion, to replace Git inside the company.
• 7:46
  SPEAKER_01: Why would anyone build their own Git?
• 7:48
  SPEAKER_00: Because the normal one couldn't keep up.
• 7:51
  SPEAKER_00: In May this year, Anthropic's team merged about 2,500 code changes a day.
• 7:55
  SPEAKER_00: By September, that number passed 30,000.
• 7:58
  SPEAKER_01: What changed?
• 7:59
  SPEAKER_00: Cloud agents started writing and submitting most of that code themselves, not human engineers.
• 8:03
  SPEAKER_01: And Git just couldn't handle the volume?
• 8:05
  SPEAKER_00: Git was built so every developer keeps a full copy of the project's entire history
• 8:10
  SPEAKER_00: on their own machine, which works fine at human pace.
• 8:13
  SPEAKER_00: It doesn't work when thousands of automated jobs are checking out and merging code constantly.
• 8:17
  SPEAKER_01: So what does Scion do differently?
• 8:19
  SPEAKER_00: It assumes most clients, mainly agents and automated test jobs, are always online.
• 8:24
  SPEAKER_00: So it keeps one central server handling history,
• 8:27
  SPEAKER_00: blame, and merges instead of copying everything everywhere.
• 8:30
  SPEAKER_01: That sounds like exactly what Git was designed to avoid, a single central point.
• 8:35
  SPEAKER_00: It is, and that's the trait Anthropic made deliberately.
• 8:38
  SPEAKER_00: It also lets a job pull just the slice of the codebase it actually needs,
• 8:42
  SPEAKER_00: instead of the whole repository, through an API.
• 8:45
  SPEAKER_01: What did that actually buy them?
• 8:46
  SPEAKER_00: Anthropic says its infrastructure footprint is 200 times smaller in CPU and memory
• 8:51
  SPEAKER_00: than the old Git mirroring setup.
• 8:53
  SPEAKER_00: Checkouts that used to take minutes now take seconds.
• 8:56
  SPEAKER_01: Who else has checked those numbers?
• 8:58
  SPEAKER_00: Nobody outside the company yet.
• 9:00
  SPEAKER_00: These are Anthropic's own benchmarks, not an independent test.
• 9:03
  SPEAKER_01: So who else gets to use Scion?
• 9:05
  SPEAKER_00: Nobody yet.
• 9:06
  SPEAKER_00: It's internal only.
• 9:08
  SPEAKER_00: Anthropic is sharing the design ideas publicly, not shipping the tool itself.
• 9:12
  SPEAKER_01: A team of how many built this?
• 9:14
  SPEAKER_00: Seven engineers,
• 9:15
  SPEAKER_00: over five months,
• 9:16
  SPEAKER_00: to migrate an entire monorepo, a single repository holding all of a company's code.
• 9:21
  SPEAKER_01: That's a small team for something this disruptive.
• 9:24
  SPEAKER_00: It is.
• 9:24
  SPEAKER_00: This wasn't a general rewrite of Git.
• 9:27
  SPEAKER_00: It was a fix for one company's agents outrunning the tool built for humans.
• 9:31
  SPEAKER_00: Three stories, one bottleneck.
• 9:33
  SPEAKER_00: Agents that can split into a thousand copies of themselves,
• 9:36
  SPEAKER_00: pricing that keeps moving,
• 9:38
  SPEAKER_00: because nobody knows what those agents will cost to run,
• 9:41
  SPEAKER_00: and a version control system Anthropic had to throw out
• 9:44
  SPEAKER_00: because its own agents wrote code faster than it could handle.
• 9:47
  SPEAKER_01: I don't think usage-based pricing is really a new business model.
• 9:50
  SPEAKER_01: I think it's companies admitting they still don't know their own costs and charging
• 9:55
  SPEAKER_01: by the drink until they do.
• 9:56
  SPEAKER_00: Maybe, but that drink just got a lot more agents ordering it.
• 10:00
  SPEAKER_00: That's Wednesday.
• 10:01
  [music]