Latest / The AI Practitioner Brief / Gemini 4 Carbon, Netflix's Log AI, and a DB Benchmark — October 29, 2026

Transcript

Gemini 4 Carbon, Netflix's Log AI, and a DB Benchmark — October 29, 2026 · The AI Practitioner Brief

• 0:05
  SPEAKER_01: Welcome to The AI Practitioner Brief,
• 0:07
  SPEAKER_01: the podcast from AIPpractitioner.substack.com,
• 0:11
  SPEAKER_01: where I turn the latest AI and tech news into practical insights
• 0:14
  SPEAKER_01: for AI practitioners.
• 0:16
  SPEAKER_01: I'm Lina Faik,
• 0:17
  SPEAKER_01: an ML engineer,
• 0:18
  SPEAKER_01: consultant, and lecturer in advanced machine learning at Sorbonne University.
• 0:22
  SPEAKER_01: It's Thursday, October 29.
• 0:25
  SPEAKER_00: Thursday already.
• 0:26
  SPEAKER_00: Let's get into it.
• 0:27
  SPEAKER_01: With me is Jimmy,
• 0:28
  SPEAKER_01: my co-host on The Brief,
• 0:29
  SPEAKER_01: who asks the questions I'd skip past, and today has a nice contradiction built in.
• 0:34
  SPEAKER_01: Google says it built the smartest model it's ever shipped,
• 0:37
  SPEAKER_01: and almost nobody outside the company is allowed to touch it yet.
• 0:40
  SPEAKER_00: That sounds like a story.
• 0:42
  SPEAKER_00: What's on the list?
• 0:43
  SPEAKER_01: We'll start with the headlines, five stories to get you current, then three deep dives.
• 0:47
  SPEAKER_01: Google built a cybersecurity-focused model that just topped every ranking,
• 0:51
  SPEAKER_01: and almost nobody can use it yet.
• 0:54
  SPEAKER_01: Netflix taught an AI to read its own crash logs instead of a person doing it.
• 0:58
  SPEAKER_01: And a new warehouse benchmark tested some old reputations in cloud databases
• 1:03
  SPEAKER_01: and found a few of them wrong.
• 1:04
  SPEAKER_00: A warehouse benchmark that overturns reputations.
• 1:08
  SPEAKER_00: I like that one already.
• 1:09
  SPEAKER_01: First up, NVIDIA released NemoTron 3.5 Transcribe, part of a model family it calls NemoTron.
• 1:16
  SPEAKER_01: It's open-weight, meaning anyone can download the underlying model and run it themselves.
• 1:21
  SPEAKER_01: It handles transcription,
• 1:22
  SPEAKER_01: translation, and figuring out who's speaking across up to 40 languages.
• 1:26
  SPEAKER_00: Is that actually usable or a demo?
• 1:29
  SPEAKER_01: It ships with a companion tool called Granary that lets you fine-tune it
• 1:32
  SPEAKER_01: on your own vocabulary, so it's built to be adapted, not just tried once.
• 1:36
  SPEAKER_00: That's the useful kind.
• 1:38
  SPEAKER_01: Next, Artificial Analysis,
• 1:39
  SPEAKER_01: an independent group that runs standardized tests across AI models and publishes
• 1:43
  SPEAKER_01: the rankings, shipped version 5 of its index.
• 1:47
  SPEAKER_01: We'll come back to why that matters,
• 1:48
  SPEAKER_01: because it's the same index behind today's biggest model story.
• 1:52
  SPEAKER_00: Tease accepted.
• 1:53
  SPEAKER_01: Anthropic also rolled out new reporting tools for Claude,
• 1:56
  SPEAKER_01: its AI assistant,
• 1:57
  SPEAKER_01: giving companies a breakdown of what their AI spending is actually buying.
• 2:01
  SPEAKER_01: Enterprise customers get usage surveys and pooled budgets with per-team limits.
• 2:06
  SPEAKER_00: Finally, watching a bill show up with no idea which team burned it is miserable.
• 2:11
  SPEAKER_01: That's the AI side.
• 2:12
  SPEAKER_01: Elsewhere in tech today,
• 2:13
  SPEAKER_01: Apple announced a touchscreen MacBook Pro with an OLED display,
• 2:17
  SPEAKER_01: a screen type with deeper blacks and sharper contrast.
• 2:21
  SPEAKER_01: It swaps the notch for a dynamic island,
• 2:23
  SPEAKER_01: the pill-shaped cutout that already shows live activity on iPhones.
• 2:27
  SPEAKER_00: A touchscreen Mac.
• 2:28
  SPEAKER_00: People have wanted that for 15 years.
• 2:31
  SPEAKER_01: Last headline,
• 2:32
  SPEAKER_01: Slack is launching a code API
• 2:33
  SPEAKER_01: that lets AI agents spin up their own dedicated channel,
• 2:37
  SPEAKER_01: pull in the right teammates and files, and post progress updates as they work.
• 2:41
  SPEAKER_00: So the agent gets a desk instead of just a task.
• 2:44
  SPEAKER_01: Pretty much, and it still runs inside whatever permissions your workspace already enforces.
• 2:49
  SPEAKER_01: That's the headlines.
• 2:50
  SPEAKER_01: Let's get into the first deep dive.
• 2:51
  SPEAKER_00: Google's model.
• 2:53
  SPEAKER_01: Google's model.
• 2:54
  SPEAKER_01: On October 28th,
• 2:55
  SPEAKER_01: Google announced Gemini 4 Carbon,
• 2:57
  SPEAKER_01: calling it the strongest model in the Gemini 4 family.
• 3:01
  SPEAKER_01: It's built specifically for cybersecurity defense and long, multi-step coding work.
• 3:06
  SPEAKER_00: Carbon.
• 3:07
  SPEAKER_00: Is that about emissions?
• 3:08
  SPEAKER_01: It's just the code name.
• 3:09
  SPEAKER_01: One of the newsletters I read described it as an efficiency
• 3:12
  SPEAKER_01: and sustainability release, but that doesn't match any of the actual reporting.
• 3:17
  SPEAKER_01: Every outlet covering the launch describes a security and coding model
• 3:20
  SPEAKER_01: with no mention of emissions at all.
• 3:22
  SPEAKER_00: So that framing was just wrong.
• 3:24
  SPEAKER_01: Looks like it.
• 3:26
  SPEAKER_01: What's confirmed is the benchmarks.
• 3:27
  SPEAKER_01: Google reported 88.2% on SEC Bench Pro, a test of finding security vulnerabilities in code.
• 3:34
  SPEAKER_01: It also posted strong scores on two more benchmarks for writing exploits and patching bugs.
• 3:39
  SPEAKER_00: Those numbers mean nothing to me without something to compare them to.
• 3:43
  SPEAKER_01: Here's the comparison.
• 3:44
  SPEAKER_01: Artificial Analysis,
• 3:45
  SPEAKER_01: the group from the headlines,
• 3:47
  SPEAKER_01: ranked it first on their Intelligence Index, a composite score across many tasks.
• 3:52
  SPEAKER_01: It scored 59 points.
• 3:54
  SPEAKER_01: That's about 9 points ahead of Gemini 4 Argonne, Google's previous flagship.
• 3:58
  SPEAKER_00: 9 points on a scale I don't know the bounds of.
• 4:01
  SPEAKER_01: Fair, it's a relative ranking, not a percentage.
• 4:04
  SPEAKER_01: But first place on that index is also why this is the lead story on every AI outlet this week.
• 4:09
  SPEAKER_00: Who can actually use it?
• 4:10
  SPEAKER_01: Almost nobody yet.
• 4:11
  SPEAKER_01: Google only gave access to a subset of cyber defense teams through
• 4:15
  SPEAKER_01: a program called Fairwind that brings in trusted partners early.
• 4:18
  SPEAKER_01: There's no date for wider access.
• 4:20
  SPEAKER_00: So it's announced, not released.
• 4:22
  SPEAKER_01: Exactly that distinction.
• 4:24
  SPEAKER_01: Pricing is set for when it does roll out further.
• 4:26
  SPEAKER_01: $2 per million tokens in, the chunks of text the model reads, $10 per million tokens out.
• 4:32
  SPEAKER_01: That's during an introductory period after which it rises to $4 and $20.
• 4:37
  SPEAKER_01: Cached input, repeated context the model doesn't have to reprocess, is 95% cheaper.
• 4:44
  SPEAKER_00: And the security benchmarks, who ran those?
• 4:46
  SPEAKER_01: Google did,
• 4:47
  SPEAKER_01: on its own model,
• 4:48
  SPEAKER_01: and said the cyber scores were run without guardrails,
• 4:51
  SPEAKER_01: meaning the safety restrictions that would normally apply
• 4:53
  SPEAKER_01: in production were turned off for the test.
• 4:55
  SPEAKER_00: That's a big asterisk.
• 4:57
  SPEAKER_00: If the safety breaks were off for the test,
• 4:59
  SPEAKER_00: does the customer-facing version even score the same?
• 5:02
  SPEAKER_01: Nobody outside Google has run it to check, so that's the open question right now.
• 5:06
  SPEAKER_00: What does a practitioner actually do with a model they can't touch?
• 5:10
  SPEAKER_01: Mostly watch the Fairwind program for who gets let in next,
• 5:13
  SPEAKER_01: and wait for a real-world result once it's available.
• 5:16
  SPEAKER_01: If you're pricing this in now, you're pricing in a promise, not a product.
• 5:20
  SPEAKER_00: A very specific, well-benchmarked promise.
• 5:22
  SPEAKER_01: Which is exactly the problem artificial analysis wrote about this week,
• 5:26
  SPEAKER_01: in the same report that ranked this model first.
• 5:28
  SPEAKER_00: So the test that crowned it is also arguing, nobody should fully trust tests like it.
• 5:33
  SPEAKER_01: That's basically the whole piece.
• 5:35
  SPEAKER_01: Build a test the market treats as gospel,
• 5:37
  SPEAKER_01: and you've quietly decided who wins a trillion dollar market.
• 5:40
  SPEAKER_01: Which is a good reason to look at a story where someone used AI
• 5:43
  SPEAKER_01: to check something more mundane, and the result is actually measurable.
• 5:47
  SPEAKER_00: Netflix.
• 5:49
  SPEAKER_01: They built an internal tool years ago called Pensive that figures out why
• 5:53
  SPEAKER_01: a data job failed, like a batch processing task that crashed overnight.
• 5:57
  SPEAKER_01: This week they described an AI-powered upgrade to it.
• 6:00
  SPEAKER_00: What was wrong with the old version?
• 6:02
  SPEAKER_01: The original pensive used fixed rules to pattern match stack traces,
• 6:06
  SPEAKER_01: the chain of function calls a program was in when it crashed,
• 6:09
  SPEAKER_01: against a known list of failure types.
• 6:11
  SPEAKER_01: If a failure didn't match a known pattern, an engineer had to dig through the raw logs by hand.
• 6:16
  SPEAKER_00: And the new version doesn't need the pattern to already exist.
• 6:19
  SPEAKER_01: Right, it uses a model to read the logs and reason about what went wrong,
• 6:23
  SPEAKER_01: including failure types nobody had written a rule for.
• 6:26
  SPEAKER_01: Netflix says it now covers every failure type,
• 6:28
  SPEAKER_01: including ones that used to come back unclassified.
• 6:31
  SPEAKER_00: How does feeding logs to a model actually work?
• 6:34
  SPEAKER_00: Logs can be huge.
• 6:35
  SPEAKER_01: That's the actual trick.
• 6:36
  SPEAKER_01: Instead of handing the model the whole log file,
• 6:39
  SPEAKER_01: which can run to gigabytes,
• 6:40
  SPEAKER_01: the system first narrows down to the specific span,
• 6:43
  SPEAKER_01: the handful of lines around the real error, and only sends that to the model.
• 6:47
  SPEAKER_00: Why does that matter instead of just giving it everything?
• 6:49
  SPEAKER_01: Two reasons.
• 6:50
  SPEAKER_01: Cost, since models charge by how much text you feed them,
• 6:54
  SPEAKER_01: And accuracy,
• 6:54
  SPEAKER_01: because a huge pile of mostly irrelevant log lines makes a model more likely
• 6:59
  SPEAKER_01: to hallucinate,
• 7:00
  SPEAKER_01: to state something false with total confidence,
• 7:02
  SPEAKER_01: since it's pattern matching across noise instead of the actual cause.
• 7:06
  SPEAKER_00: So narrower context beats more context.
• 7:09
  SPEAKER_01: For this kind of task, yes.
• 7:11
  SPEAKER_01: Netflix reported that failed jobs
• 7:12
  SPEAKER_01: without this system needed 321% more manual log digging actions from an engineer
• 7:17
  SPEAKER_01: to find the cause.
• 7:19
  SPEAKER_00: That's a real number, not a vibe.
• 7:21
  SPEAKER_01: It's Netflix's own reported figure,
• 7:23
  SPEAKER_01: not independently audited,
• 7:24
  SPEAKER_01: but it's specific and it matches the simpler story,
• 7:27
  SPEAKER_01: less manual digging for the engineer on call.
• 7:30
  SPEAKER_00: Is this published research or just an internal post?
• 7:33
  SPEAKER_01: It's a Netflix engineering blog post, building on diagnosis work they've published before.
• 7:37
  SPEAKER_01: Not a peer-reviewed paper,
• 7:39
  SPEAKER_01: so treat the coverage numbers as a company's own account of its own tool.
• 7:42
  SPEAKER_00: What does this mean for someone who isn't Netflix?
• 7:45
  SPEAKER_01: If you're building any kind of AI-assisted debugging or support tool,
• 7:49
  SPEAKER_01: the lesson transfers directly.
• 7:50
  SPEAKER_01: Narrow the context to the suspect span before you scale up log volume.
• 7:54
  SPEAKER_01: Don't just dump more text at the model and hope.
• 7:57
  SPEAKER_00: That's a cheap thing to test before you throw more compute at a problem.
• 8:00
  SPEAKER_01: It is.
• 8:01
  SPEAKER_01: And it's the kind of fix that costs an afternoon, not a budget line.
• 8:04
  SPEAKER_00: Is anyone outside Netflix checking that number?
• 8:07
  SPEAKER_01: None that's been published, no.
• 8:09
  SPEAKER_01: The next story flips that though,
• 8:10
  SPEAKER_01: a benchmark built specifically so nobody has to take anyone's word for it.
• 8:15
  SPEAKER_00: Which warehouse won?
• 8:17
  SPEAKER_01: Depends what you're doing with it.
• 8:18
  SPEAKER_01: And that's the actual finding.
• 8:20
  SPEAKER_01: A data pipeline company called Estuary teamed up with a data consultancy,
• 8:24
  SPEAKER_01: Cordyne, and benchmarked seven cloud data warehouses.
• 8:27
  SPEAKER_01: That includes Mother Duck,
• 8:29
  SPEAKER_01: a cloud version of the open source database DuckDB,
• 8:32
  SPEAKER_01: Microsoft's data platform Fabric,
• 8:34
  SPEAKER_01: the open source analytics database ClickHouse, and Databricks.
• 8:38
  SPEAKER_00: Seven sounds like a lot to run fairly.
• 8:40
  SPEAKER_01: They ran 244 queries.
• 8:42
  SPEAKER_01: The data sets ranged from one gigabyte up to one terabyte.
• 8:46
  SPEAKER_01: And they pushed concurrency,
• 8:47
  SPEAKER_01: how many users hit the system at once, up to 100 simultaneous sessions.
• 8:51
  SPEAKER_00: What were they actually testing for?
• 8:53
  SPEAKER_01: Industry reputations, mostly.
• 8:55
  SPEAKER_01: Amazon's Redshift carries a reputation as the legacy engine everyone migrates away from.
• 9:00
  SPEAKER_01: Mother Duck gets called a small data tool that falls over past laptop scale.
• 9:04
  SPEAKER_01: Fabric gets called not performance competitive.
• 9:07
  SPEAKER_01: The point of the benchmark was checking whether any of that still holds.
• 9:10
  SPEAKER_00: Uh, and?
• 9:11
  SPEAKER_01: At the 100 GB scale,
• 9:13
  SPEAKER_01: Mother Duck had the fastest single user performance and the lowest cost per query,
• 9:17
  SPEAKER_01: which undercuts the small data toy label directly.
• 9:20
  SPEAKER_01: Fabric handled 100 concurrent users in under 5 seconds.
• 9:23
  SPEAKER_01: That undercuts the other reputation too.
• 9:25
  SPEAKER_00: So two reputations just got disproven.
• 9:28
  SPEAKER_01: Two reputations got disproven.
• 9:30
  SPEAKER_01: The one that held up in the wrong direction was ClickHouse,
• 9:33
  SPEAKER_01: which ran into real reliability issues under that same concurrent load,
• 9:37
  SPEAKER_01: even though it's usually praised for raw speed.
• 9:39
  SPEAKER_00: What kind of reliability issues?
• 9:41
  SPEAKER_00: Crashes?
• 9:42
  SPEAKER_00: Timeouts?
• 9:43
  SPEAKER_01: That detail isn't in what I could read.
• 9:45
  SPEAKER_01: The fuller breakdown sits behind Estuary's own full report,
• 9:48
  SPEAKER_01: and the public summary doesn't go further than naming the problem.
• 9:51
  SPEAKER_00: So that's an honest gap, not a dodge.
• 9:54
  SPEAKER_01: Right.
• 9:54
  SPEAKER_01: What is public is the method.
• 9:56
  SPEAKER_01: The whole benchmark and its code are posted on GitHub,
• 9:59
  SPEAKER_01: so anyone running a similar workload can rerun it instead of taking Estuary's word
• 10:03
  SPEAKER_01: for it.
• 10:03
  SPEAKER_00: That is so benchmark you don't just have to take their word for.
• 10:06
  SPEAKER_01: Which is the contrast worth sitting with today.
• 10:09
  SPEAKER_01: Google's own cyber benchmarks,
• 10:11
  SPEAKER_01: Netflix's own coverage numbers,
• 10:13
  SPEAKER_01: and then one benchmark built so anyone can check the work themselves.
• 10:16
  SPEAKER_00: I'd still bet most teams pick the warehouse with the best sales deck, not the best benchmark.
• 10:21
  SPEAKER_01: That's probably true.
• 10:22
  SPEAKER_01: And it's exactly why a result anyone can rerun is worth more than it usually gets credit for.
• 10:27
  SPEAKER_00: What does a data team actually do with this?
• 10:29
  SPEAKER_01: Pick a warehouse based on your actual workload, not its reputation.
• 10:33
  SPEAKER_01: If you're running small, fast, interactive queries, Mother Duck's result matters to you.
• 10:38
  SPEAKER_01: If you're running 100 people against it at once,
• 10:40
  SPEAKER_01: Fabric's result matters more,
• 10:42
  SPEAKER_01: and ClickHouse's reliability issue is worth testing yourself before you commit to it
• 10:46
  SPEAKER_01: at scale.
• 10:47
  SPEAKER_00: That's a workload question, not a brand question.
• 10:50
  SPEAKER_00: Fair enough.
• 10:50
  SPEAKER_01: Today was really one story told three times.
• 10:53
  SPEAKER_01: A company's own numbers look great until somebody else checks them, and today almost nobody can.
• 10:58
  SPEAKER_01: Google's got the top-ranked model and the locked door,
• 11:01
  SPEAKER_01: Netflix has an internal number nobody outside the company audited,
• 11:05
  SPEAKER_01: and the one case where anybody can actually rerun the test is a database benchmark,
• 11:09
  SPEAKER_01: not an AI one.
• 11:10
  SPEAKER_00: I'll bet Google widens the Fairwind program before the end of the year.
• 11:14
  SPEAKER_00: Once a couple of outside cyber labs get in and start talking about it publicly,
• 11:19
  SPEAKER_00: holding the line gets harder.
• 11:20
  SPEAKER_01: We'll see if that door opens.
• 11:22
  [music]