Token Drop

DaaX.ai

A weekly, unscripted conversation from the DaaX team on the most interesting developments in AI. Sunil Baliga and Sajjad Khazipura (DaaX Co-Founders), along with Sam Pooni (DaaX Architect) and the occasional guest, explore, discuss, and debate new AI research, news, and real-world use cases. Built for developers and business leaders who want perspectives from experienced AI practitioners. All opinions expressed on this podcast are those of the panelists and do not necessarily reflect the views of their employers.

  1. 6d ago

    Databricks' State of AI Agents and Stanford's AI Index: What They Reveal About Enterprise AI in 2026

    About This Episode Databricks’ State of AI Agents and Stanford HAI’s AI Index agree: enterprises are moving from chatbots to multi-agent systems, and evaluation, governance and verifiable trust decide what reaches production. Sunil, Sajjad and Sam unpack the key findings, from AI agents creating most new databases to the “jagged frontier” of models that win Math Olympiad gold but can’t tell time, then look at Mistral’s trillion-parameter Large 4 and the question the reports leave open: how do you prove what an agent was allowed to do? Episode Summary Sam opens with Databricks’ State of AI Agents report: multi-agent workflows grew 327% in four months, AI agents create about 80% of databases on Databricks’ serverless Postgres service, 78% of companies use two or more LLM families, and teams using evaluation and governance tools get roughly 6x and 12x more projects into production. The hosts discuss why converting unstructured text, from supplier PDFs to server logs, into structured tables unlocks SQL and analytics. Sajjad notes that evals qualify a model before deployment, while runtime verification like DaaX’s ClaimGuard checks it in production. Sam explains why agent workloads break traditional OLTP databases, driving new systems like Lakebase. Sajjad then covers the Stanford AI Index: capability is accelerating, the US-China model gap has closed, and models that win Math Olympiad gold still can’t reliably tell time, a “jagged frontier” he ties to symbolic verifiers like Lean and to neuro-symbolic AI. Responsible AI lags capability, adoption is spreading at historic speed, and AI sovereignty is becoming national policy. Sam argues the model is becoming a commodity, the router is the control point, and verifiable trust moves pilots into production. The hosts close with Mistral Large 4, a trillion-parameter open-weight model with 52 billion active parameters, and Sam’s point that none of the reports address how agent actions are permitted, proven and audited. Full transcripts at https://daax.ai/podcast/episode-31-enterprise-ai-reports Chapters ● 0:00 — Episode 31: two industry reports ● 0:47 — Databricks’ State of AI Agents report ● 2:27 — From chatbots to multi-agent systems ● 3:18 — AI agents are building the databases ● 3:45 — Model flexibility: most companies use multiple LLMs ● 4:31 — Evaluation and governance get more projects into production ● 4:59 — Information extraction: turning unstructured text into tables ● 7:58 — From screen scraping to normalized databases ● 9:25 — SQL, logs and analytics ● 10:30 — Structured and unstructured data must interoperate ● 11:44 — Custom benchmarks vs. runtime verification ● 13:23 — Databases for the agent era: OLTP limits and Lakebase ● 15:54 — OLTP, OLAP, HTAP and Delta Lake ● 17:09 — Stanford HAI’s AI Index Report ● 17:45 — AI capability isn’t plateauing ● 18:10 — The US-China model gap has closed ● 18:48 — Data centers and chip concentration ● 19:09 — The jagged frontier: Math Olympiad gold, but can’t tell time ● 20:01 — Neuro-symbolic AI and the Lean verifier ● 20:33 — Responsible AI isn’t keeping pace ● 20:58 — US investment leads, but talent attraction is declining ● 21:32 — Adoption at historic speed ● 22:44 — Learning AI at every stage of life ● 23:28 — AI sovereignty and open-weight models ● 24:28 — Public trust and runaway agents ● 25:22 — The router is the control point ● 26:28 — Verifiable trust: from pilots to production ● 27:59 — Mistral Large 4, “Le Chonk” ● 29:50 — How it compares to Luna, Sol and Astra ● 30:58 — Open-weight models and growing active parameters ● 33:09 — What the reports miss: permission, proof and accountability ● 35:23 — Wrap-up

  2. Oct 24

    The FACTS Benchmark Explained: How Google DeepMind Tests Whether LLMs Tell the Truth

    About This Episode Most AI benchmarks ask whether a model is smart. FACTS, from Google DeepMind and Kaggle, asks whether it tells the truth. In this educational episode, Sunil, Sajjad and Sam walk through the four FACTS benchmarks (parametric, search, multimodal and grounding), explain how FACTS Grounding uses long expert-written passages and two LLM judges that must agree, and show why even state-of-the-art models score in the low-to-mid 80s. They also cover where the benchmark falls short, from judge bias to rewarding refusals, why smaller models can be more truthful than large reasoning models, and where domain-specific benchmarks like legal are heading. Episode Summary Responding to listener feedback asking for broader, more educational episodes, Sunil opens a discussion of AI benchmarks, starting with FACTS, the benchmark DaaX has been competing on. Sajjad places it in a long line of language benchmarks, from Stanford's SQuAD through GLUE, MNLI and SNLI to Stanford's HELM, before describing the FACTS suite from Google DeepMind and Kaggle. It has four parts: FACTS Multimodal, for questions about images; FACTS Parametric, a closed-book quiz of what a model already knows; FACTS Search, which tests whether a model can find and report the right answer using web search; and FACTS Grounding, which asks a model to answer questions using only a supplied document. Sajjad explains why FACTS Grounding is so demanding. Expert-written passages, much like SAT reading passages and up to about 32,000 tokens long, span domains such as legal, financial, technical and medical. Of roughly 920 questions, 860 are public. Most require long-form answers that combine several facts from across the passage, follow per-question instructions on format and length, and preserve the source's tone and intent; calling a knife "the best" when the source says "one of the better knives" is penalized. In version 2, two mandated judges, Gemini Flash and GPT-5, must both agree that an answer is eligible and factually accurate. Even the leading model scores around 85%. Sam gives a non-technical framing: a brilliant lawyer who makes up one fact in roughly one brief in three, and four exams told as an analyst's working day. Examples show why partial credit doesn't exist, from a locomotive dated 1939 instead of 1949 to a passage implying nine items without ever stating the number. Full transcript at https://daax.ai/podcast/episode-30-facts-benchmark Chapters ● 0:00 — Episode 30 and a recommendation: Signalful ● 0:48 — A broader, educational format: AI benchmarks ● 1:51 — What is FACTS? ● 2:39 — A short history of language benchmarks: SQuAD, GLUE, HELM ● 3:29 — Google DeepMind and Kaggle's FACTS suite ● 3:58 — The four FACTS benchmarks ● 5:15 — How FACTS Grounding works ● 6:51 — Two judges that must agree ● 7:55 — What makes it grueling ● 9:50 — How the judges decide ● 10:20 — Mandated judges: Gemini Flash and GPT-5 ● 11:06 — Public vs. private datasets ● 11:49 — Domain knowledge, or reading comprehension? ● 13:01 — Long-form answers and instruction following ● 14:08 — Matching the source's tone and intent ● 15:22 — FACTS Grounding v1 vs. v2 ● 15:55 — The leaderboard: no model near 90% ● 16:38 — The brilliant lawyer who makes things up ● 17:41 — Does it tell the truth? Four exams as a day in the life ● 19:07 — Numerical and logical reasoning traps ● 20:11 — Non-determinism, and why DaaX verifies every claim ● 21:08 — One wrong date, zero credit ● 22:06 — Eight items on the table, one in the pocket ● 23:10 — Sorting kitchen knives and the cognitive surface ● 24:26 — Parametric scoring: accuracy, hedging and F1 ● 25:10 — Where the benchmark falls short: LLM judges and bias ● 26:00 — Grounding rewards refusals ● 26:34 — FACTS Grounding is effectively a RAG test ● 27:05 — Domain-specific benchmarks: legal ● 28:44 — Legal vocabularies, ontologies and Harvey ● 29:39 — Small models winning on truthfulness ● 31:35 — Wrap-up

  3. Oct 17

    When AI Agents Go Shopping: Making Sense of UCP, ACP, AP2, and the Agentic Commerce Stack

    About This Episode Google's UCP, OpenAI's ACP, Google's AP2, Visa's Trusted Agent Protocol: a wave of agentic commerce protocols has arrived over the past year. Tony Fernandes (https://www.linkedin.com/in/tofernandes), who spent many years at Visa and most recently served as VP of Payment Processing Architecture, maps how they fit together, from agent communication and agent trust to shopping, mandates and payment tokens. The hosts then press on the questions the protocols don't yet answer: who's liable when an agent buys the wrong thing, what evidence settles a dispute, whether every buyer could see a different price, and what happens to brands when software does the shopping. Episode Summary Sunil opens by asking why so many agentic commerce protocols appeared this year. Tony explains that every step of shopping (searching, choosing, authenticating and paying) has always been done by a person, and the payments industry built its trust frameworks around that. When an AI agent acts on someone's behalf, whether on direct instruction or on a standing rule like "buy it when the price drops," authentication, payment tokenization and fraud detection all need rethinking, and legitimate shopping-agent traffic must not be mistaken for a bot attack. He then lays out the landscape by function: MCP and A2A for agent communication; Visa's Trusted Agent Protocol and ERC-8004 for agent trust; UCP and ACP for discovering products and building a cart; AP2 for mandates, meaning what an agent is authorized to do; and agent-ready payment tokens, the successors to the tokens that already keep card numbers out of Apple Pay and Google Pay. In his loose layering, AI surfaces like ChatGPT, Gemini and Perplexity sit on top, the commerce protocols UCP and ACP sit below them, and everything else is plumbing. Sajjad notes that the need for determinism can't be overstated, since an LLM may phrase even a correct answer differently every time, and these protocols supply the guardrails and transaction flow. Asked whether UCP mirrors how a person browses, compares and checks out, Tony explains that UCP standardizes how merchants expose shopping to agents so agents don't need point-to-point integrations. The two leading protocols differ in architecture: UCP is decentralized, with merchants keeping control of their catalogs and exposing them in real time through APIs, while ACP is centralized, with merchants feeding catalogs to OpenAI, which raises freshness concerns. For now, businesses are being advised to support both. Sam presses on the hard questions. If buyer and seller agents close a deal in milliseconds, how can a person challenge the terms? Tony points to AP2 mandates that travel with the transaction, and expects both fully automated and human-in-the-loop models depending on risk and transaction size, with early adoption in recurring purchases and approved suppliers. The conversation moves through liability when an agent misreads a request, personalized pricing, sellers hiding instructions in product pages, comparing unstructured product data, brand erosion when agents shop, and who pays shopping agents and merchants for access. Sajjad asks whether a single agent could replace hundreds of phone apps, and Tony notes that brands will resist giving up their direct customer relationships. Sunil proposes a "day in the life of an agentic transaction" as a future episode. Asked what protocol is still missing, View full transcripts at https://daax.ai/podcast/episode-29-agentic-commerce Chapters ● 0:00 — Welcome Tony Fernandes: why so many agentic commerce protocols now? ● 0:54 — What changes when an agent shops for you ● 2:35 — A map of the agentic commerce protocols ● 3:05 — How agents communicate: MCP and A2A ● 4:19 — Should we trust this agent? Visa Trusted Agent Protocol and ERC-8004 ● 4:45 — What are we buying? UCP and ACP ● 5:17 — Agent mandates: AP2 ● 5:35 — Pay

  4. Oct 10

    Jev and "Zero Hallucination": What It Actually Guarantees, and What It Doesn't

    About This Episode At San Francisco Tech Week, Sunil was told that TypeSafe's new model, Jev, "doesn't hallucinate." In this episode, Sajjad and Sam explain what that claim really means. Jev always returns one of the options you give it, but nothing guarantees it picks the right one. The hosts cover why Jev is so fast and cheap, how it fits Daniel Kahneman's System 1 / System 2 framework alongside slower reasoning models, and why even very fast answers still need to be checked. Episode Summary Sunil opens with a conversation from San Francisco Tech Week, where someone told him Jev "doesn't hallucinate." His answer was that it depends on what you mean by hallucination, and Sajjad agrees. Jev is given a fixed set of choices and will never invent a new one, so that kind of hallucination is gone. Whether it picks the correct choice is a separate question. Sajjad gives TypeSafe credit for real progress, and Sam notes that the company's own launch post says plainly that the 0% hallucination figure is guaranteed by design, not measured, and that Jev can be wrong. The candor is in the body of the post; the headline is what people repeat. Sam explains how Jev works. It answers three kinds of questions: choice (pick one of up to 255 options you define), score (place something on a scale such as calm, frustrated or angry), and true/false probability. Each answer comes with probabilities and a confidence score. Sunil asks how a model with a confidence score can still be wrong, and Sajjad says that is the heart of the matter: the confidence itself can be wrong. Two launch-week demos show both sides. In one, Jev moved a ping-pong paddle into position in real time. In the other, a version of the trolley problem, it made poor choices between two tracks. Sam lists five places a wrong answer can come from (training data, weights, decoding, output text and the consumer) and explains that Jev removes only two of them. Sunil draws the practical line: a misjudged egg on a sorting line may be tolerable, but a wrong call while flying a plane is not. Sajjad introduces Kahneman's Thinking, Fast and Slow: System 1 is fast, automatic perception, and System 2 is slow, deliberate reasoning. Jev is a System 1 model, and reasoning models are closer to System 2. An intelligent platform needs both. Sam explains why Jev is so cheap: it runs only the prefill pass of a transformer, with no token-by-token decode loop, much like a BERT-style encoder with classification heads. The hosts discuss OpenAI's newly announced Jev-like API and open-source alternatives, and say DaaX is considering a Jev-style model for fast classification and routing inside its pipeline, with ClaimGuard still verifying that answers are grounded. The episode ends with plans for a webinar or whiteboard "chalk talk" to explain the architecture with diagrams. Read full transcript at ⁠https://daax.ai/podcast/episode-28-jev-zero-hallucination Chapters ● 0:00 — Tech Week: "Jev doesn't hallucinate" ● 1:01 — Credit where it's due ● 2:45 — What's guaranteed, and what isn't ● 4:59 — Who supplies the options? ● 5:29 — Jev's three question types ● 6:42 — If there's a confidence score, how can it still be wrong? ● 7:08 — Launch-week demos: ping-pong ● 7:52 — Launch-week demos: the trolley problem ● 9:45 — Real-time applications and OpenAI's egg-sorting example ● 10:52 — Five places a wrong answer can come from ● 12:23 — Errors you can tolerate vs. errors you can't ● 13:03 — System 1 vs. System 2: Kahneman's framework ● 16:05 — Jev as System 1, reasoning models as System 2 ● 18:45 — OpenAI's Jev-like API and open-source alternatives ● 19:12 — Using a Jev-style model inside a verification pipeline ● 20:11 — Why Jev is so cheap: prefill without the decode loop ● 23:17 — A webinar is coming ● 25:01 — Reading the fine print on "zero hallucination" ● 26:03 — Speed and cost compared ● 27:32 — Where Jev fits: classify, route, score, and guardrails ● 28:27 — Wrap-up

  5. Oct 3

    Verify the Output, Not the Model: Formal Methods and the Future of AI Safety

    About This Episode Christian Szegedy co-authored the Inception (GoogLeNet) architecture and the original Batch Normalization paper, discovered adversarial examples in neural networks, and co-founded xAI after nearly two decades at Google. For the past several years he's been focused on formal verification and auto-formalization — using AI to generate mathematical proofs that can be checked with absolute certainty. In this episode, he joins Token Drop to explain why he believes formally verifying an AI model's output, not the model itself, is the realistic path forward — and why he publicly bet against Terence Tao's early skepticism about how fast AI capability would actually rise. Episode Summary Sunil opens by noting the throughline in Christian Szegedy's career: from formally verifying that a chip's RTL matches its netlist, to formally verifying that an LLM's output can be trusted. Christian agrees it's less a career pivot than a generalization — chips demanded rigorous verification because a single mistake was catastrophically expensive (he cites the Pentium floating-point bug), while software historically didn't justify the cost. AI changes that calculus: with AI agents increasingly able to find and exploit vulnerabilities at scale, Christian argues formally verified software is becoming economically necessary rather than a luxury confined to military-grade systems. Sajjad presses on a question Christian raised years ago in a widely circulated exchange with Terence Tao: can AI not just prove theorems, but write the formal specifications themselves? Christian's answer is a genuine, on-record update to his own prior thinking — frontier labs reached extremely high levels of mathematical reasoning without relying on formal verification during training at all, which he admits surprised him. He still believes auto-formalization has real value, but the harder-won insight is that specification-writing, not verification itself, has always been the expensive part — and that expense, more than any technical limitation, is why formal methods never broke into mainstream software. Sam brings in Christian's own 2023 paper, "Towards Guaranteed Safe AI" (co-authored with Yoshua Bengio, Stuart Russell, and Max Tegmark), and its three-part framework — a world model, a safety specification, and a verifier that produces a proof certificate — asking which leg breaks first outside of pure mathematics. Christian's honest answer: it depends entirely on the domain, and in fuzzier areas like creative writing, formal verification may barely matter at all, while in domains like legal or insurance document processing, writing a correct specification may be the harder problem. The conversation closes on what Christian sees as the still-unsolved core of AI safety: not whether an agent does the thing you asked correctly, but how you specify that it shouldn't also do something else entirely — a problem he says current explainability research doesn't yet address, partly because solving it doesn't make anyone money. Read full transcript at https://daax.ai/podcast/episode-27-formal-verification Chapters ● 0:00 — Introducing Christian Szegedy ● 1:18 — From chip verification to AI verification: why the theme generalizes ● 2:55 — Security implications: AI agents breaking into systems ● 3:36 — Do regulated industries need a formal verification stamp? ● 4:37 — Auto-formalization: can AI write the specs itself? ● 8:08 — Sajjad's tribute: Inception, batch normalization, and adversarial examples ● 9:38 — What does formal verification even mean for an LLM's output? ● 15:20 — "Towards Guaranteed Safe AI": which leg of the triad breaks first? ● 19:11 — Batch norm vs. layer norm: a personal note ● 21:10 — Is formal math really recursive self-improvement? ● 24:31 — Lightning round: Lean or natural language by 2035? ● 24:58 — The one open problem AI needs to solve first ● 29:38 — The frontier of explainability: the "something else" problem ● 30:50 — Wrap-up

  6. Sep 26

    What Does "Deterministic AI" Actually Mean? Graphs, Jev, and the Limits of Constrained Choice

    About This Episode An LLM with a 95% success rate sounds great — until you chain 10 steps together and that number drops to 59%. Nav Mathur, co-founder of Cerebrix and formerly nearly nine years at Neo4j, joins Token Drop to unpack what "deterministic AI" actually means, and why graphs are central to achieving it. The conversation also takes on Jev, the buzzy new "hallucination-free" model that launched days before this recording — what it actually solves, and the harder half of the problem it doesn't. Episode Summary Nav Mathur opens with the number that motivates his company: LLMs claim roughly 95% accuracy per step, but chain 10 or more steps together in an enterprise workflow and that compounds down to around 59% — a result no CEO or director will accept. He walks through three techniques for pulling that number back toward reliable: a "harness" (or, as Nav and Sunil both prefer, a "sidecar") that reminds the LLM what it's working on at every step; constraining the model to pre-approved enterprise tools and data rather than letting it pull anything off the internet; and carrying multi-step context explicitly so the model doesn't confuse, say, an upstream supplier's part ID with a downstream one — a mistake Nav calls "disastrous hallucination," because you still get a confident answer, just a wrong one. Sajjad distinguishes two separate facets of determinism — getting the same answer every time versus getting semantically identical answers worded differently — both of which break enterprise integrations that expect structured input. Sam pushes the conversation further with a sharper claim: graphs aren't valuable because they're inherently deterministic (databases have been deterministic for fifty years) — they're valuable because determinism is fundamentally about deletion. A graph draws only the roads you allow; everything else is excluded by construction. That framing leads into a real architectural debate: should the LLM call tools, or should tools call the LLM only when they need help? Sajjad argues both qualify as neuro-symbolic architectures, and the right choice depends on how well-defined the business process is. The back half of the episode digs into Jev, the model TypeSafe AI launched the week of this recording, claiming no hallucinations, dramatically higher speed, and lower cost by constraining output to a fixed set of choices. Sajjad's read, backed by a conversation with a prominent mathematician earlier that same day: Jev solves half the problem. It genuinely won't pick a fifth option when given four — but nothing guarantees it maps the right input to the right choice, illustrated through a stock-trading example where great quarterly earnings could still get classified as "sell." Nav's own use for it is narrower and more interesting: not as a primary answer engine, but as a fast, cheap second opinion — verifying whether another LLM's reasoning actually supports its conclusion. Read full transcript at https://daax.ai/podcast/episode-26-deterministic-ai Chapters ● 0:00 — Introducing Nav Mathur, co-founder of Cerebrix ● 1:19 — Why 95% accuracy per step becomes 59% after 10 hops ● 2:31 — The harness (or sidecar): reminding the LLM what it's doing ● 3:24 — Constraining LLMs to approved enterprise tools and data ● 4:14 — The upstream/downstream part ID problem: how confusion becomes "disastrous hallucination" ● 7:16 — Determinism defined: same inputs, same output — except the data keeps changing ● 8:02 — Sajjad's two facets of determinism: consistency vs. wording ● 10:07 — Sam's reframe: determinism in graphs comes from deletion, not structure ● 13:30 — Directed acyclic graphs and modeling a supply chain as a tree ● 15:34 — Dynamic demand shifts and predictive "what-if" analysis ● 18:07 — Sam's DAG framework: no loops, fixed paths, "a boring agent" ● 19:31 — LLM calling tools vs. tools calling the LLM: two neuro-symbolic archit

  7. Sep 19

    A Four-Person Team and AI: Rebuilding Chip Design Around the Digital Twin

    About This Episode A single hardware architect, with a team of three software engineers, built what used to take roughly a hundred people. Peter Suaris, co-founder of AxPro Semi, joins Token Drop to explain how AI collapsed the traditional silo-by-silo chip design process into one continuous pipeline — architect prompts a model, gets a cycle-accurate C++ model, generates a full digital twin from it, and iterates all the way to RTL without ever handing off to a separate team. The second half of the episode turns that hardware story into a direct blueprint for software: how do you bring the same formal verification discipline chip designers have used for decades to a world of LLMs and autonomous agents? Episode Summary Peter Suaris — with a background spanning Analog Inference, Wave Computing (which acquired MIPS), and Cadence — describes the design challenge behind his 10x productivity claim: building a cycle-accurate digital twin of a full SoC, including CPU, accelerator, and cache subsystem, capable of running real workloads like a 7–13 billion parameter LLM. Historically, this work happened in silos — a CPU architect here, an SoC architect there, each working from spreadsheets and small models with a software team translating intent into code over week-long iteration loops — and all of it got thrown away once the RTL team took over. Peter's team instead trained a single hardware architect to prompt AI directly: build the C++ model, generate a digital twin from it, boot Linux and run PyTorch on that twin, refine it toward something close to Verilog, then generate RTL. One person, with three software engineers supporting him, replaced what used to require on the order of a hundred. Sajjad and Sam press on the verification side: does the team use formal methods, or exhaustive simulation, and how does a digital twin capture stochastic events like cache misses and memory contention? Peter's answer is pragmatic — mostly exhaustive simulation driven by the application, with formal verification reserved for implementation-level correctness — and he's candid about where he still refuses to let AI run fully autonomously: when a timing fix touches a large system, he wants to see and approve the change himself, because losing track of what an automated tool did inside a complex design is the failure mode he's most afraid of. Full transcript: https://daax.ai/podcast/episode-25-digital-twin-chip-design Chapters ● 0:00 — Introducing Peter Suaris, co-founder of AxPro Semi ● 1:01 — Building a cycle-accurate digital twin of a full SoC ● 3:33 — How chip design used to work: silos, spreadsheets, and the handoff cliff ● 6:04 — The new process: one architect, AI, and no separate software team ● 9:16 — Why AI is only powerful "in the hands of the expert" ● 10:11 — Using the digital twin for verification and validation ● 13:04 — Building the software ecosystem before the hardware is even done ● 13:55 — Injecting branch mispredictions and boundary tests with AI ● 14:36 — Fault injection systems and the difficulty of running them ● 17:33 — Determi

  8. Sep 12

    10,000 Agents, 88 Hours: What OpenAI's Navier-Stokes Proof Reveals About Neuro-Symbolic AI

    OpenAI says its latest internal model found a counterexample disproving global regularity for the Navier-Stokes equations — one of math's seven Millennium Prize Problems — using 10,000 concurrent agents running for 88 hours. This episode digs past the headline number and asks the more interesting question: how did 10,000 agents actually converge on a verified answer, and what does the architecture that made it possible reveal about how neuro-symbolic AI systems should be built? Episode Summary Sunil opens with the number that caught everyone's attention: 10,000 agents, 88 hours, to disprove global regularity for a smooth solution to Navier-Stokes. His real question is procedural — with that many agents throwing out ideas in parallel, how does the system converge? How does anyone know when it's done? Sajjad and Sam reconstruct the architecture from public reporting: 10,000 instances of an agent built around OpenAI's latest model generated candidate proof strategies in parallel, informally critiquing and refining each other's intermediate results — closer to swarm intelligence than a brute-force sweep. Periodically, a consolidation layer ("Codex") cross-pollinated the most promising findings back into the groups still exploring, redirecting effort as some paths proved more promising than others (the project reportedly started on a related Euler problem before OpenAI redirected agents toward Navier-Stokes). Final adjudication ran through a completely separate pipeline: Lean, an open-source formal verification framework in the same family as Z3, Vampire, and Datalog, which mechanically checked whether a candidate proof actually held — a full 17 hours of formalization and verification on top of the 88 hours of exploration. The panel connects this directly to their own architecture. Sajjad draws the parallel to ClaimGuard: no matter how good the generating model is, DaaX's position has always been that you verify the output against grounding independently rather than trust it outright. Sam highlights what he considers the real innovation — the system doesn't just label an answer right or wrong, it produces a counterexample, and feeds that counterexample back to improve the next round of candidates. That closed loop, generate → critique → verify → redistribute → regenerate, is what let 10,000 agents converge in under four days on a problem mathematicians have worked on for decades. Full transcript at https://daax.ai/podcast/episode-24-navier-stokes-neuro-symbolic-ai Chapters ● 0:00 — This week's topic: OpenAI's Navier-Stokes result ● 1:24 — Sajjad's read: 10,000 agents, peer review, and a Lean-based verifier ● 3:59 — What is Lean? Symbolic verification, explained ● 5:01 — Sunil's chip-design analogy: what do you verify against without a "golden" reference? ● 5:40 — How DaaX's own retrieval-and-verification pipeline actually works ● 7:31 — Sunil's guess: verifying against the algorithm's own well-defined output ● 8:31 — Sam's numbers: 130 billion tokens, 2.7 million inter-agent messages ● 9:31 — Why counterexamples, not just right/wrong labels, matter for neuro-symbolic systems ● 12:11 — The HPC era: brute force, the n-body problem, and drug discovery ● 14:53 — What's different this time: intelligent candidate generation with a feedback loop ● 15:01 — Could this have been done with old-school HPC? (88 hours vs. 88 days) ● 19:32 — Not peer review — informal, adversarial swarm intelligence ● 21:08 — How the problem was actually routed: from Euler to Navier-Stokes ● 23:04 — Cross-pollination: explore, extract, redistribute, explore again ● 24:11 — The closed feedback loop, and why it maps directly to ClaimGuard ● 28:17 — Anima Anandkumar's physics-informed neural network:

About

A weekly, unscripted conversation from the DaaX team on the most interesting developments in AI. Sunil Baliga and Sajjad Khazipura (DaaX Co-Founders), along with Sam Pooni (DaaX Architect) and the occasional guest, explore, discuss, and debate new AI research, news, and real-world use cases. Built for developers and business leaders who want perspectives from experienced AI practitioners. All opinions expressed on this podcast are those of the panelists and do not necessarily reflect the views of their employers.