AI Core
Fundamentals of AI models, architecture, and how they work
131 episodes
#2239: How AI Benchmarks Became Broken (And What's Replacing Them)
The tests we use to measure AI progress are contaminated, saturated, and gamed. Here's what's actually working.
#2233: Who Actually Wants AI to Slow Down?
Daniel argues AI development should slow down for expertise and stability. But who in the industry actually shares this philosophy beyond the obvio...
#2228: Tuning RAG: When Retrieval Helps vs. Hurts
How do you prevent retrieval from suppressing a model's reasoning? We diagnose our own pipeline's four control levers and multi-source fusion strat...
#2224: Why AI Can't Crack the Voynich Manuscript
A fifteenth-century text has defeated cryptanalysts, linguists, and AI models alike. What does its resistance tell us about language, encoding, and...
#2213: Grading the News: Benchmarking RAG Search Tools
How do you rigorously evaluate whether Tavily or Exa retrieves better results for breaking news? A formal benchmark beats the vibe check.
#2206: What Actually Works in AI Memory
Most AI memory systems are just vector databases with similarity search. We break down what mem0, Zep, and Letta are actually doing—and why benchma...
#2204: Memory Without RAG: The Real Architecture
mem0, Letta, Zep, and LangMem solve agent memory differently than RAG. Here's what's actually happening under the hood.
#2196: The Annotation Economy: Who Labels AI's Training Data
Annotation is the invisible foundation of AI—and a $17B industry by 2030. Here's what dataset curators actually need to know about the tools, platf...
#2195: Nash's Real Genius (And Why the Movie Got It Wrong)
The bar scene in A Beautiful Mind is mathematically wrong—and it obscures Nash's actual breakthrough. We trace the real ideas from his 1950 papers ...
#2188: Is Emergence Real or Just Bad Metrics?
The debate over whether AI models exhibit genuine emergent abilities or just appear to because of how we measure them—and why it matters for safety...
#2187: Why Claude Writes Like a Person (and Gemini Doesn't)
Claude produces prose that sounds human. Gemini reads like Wikipedia. The difference isn't capability—it's how they were trained to think about wri...
#2181: When RAG Becomes an Agent
RAG in chatbots is simple retrieval. RAG in agents is a multi-step decision loop. Here's what actually changes.
#2177: Skip Fine-Tuning: Shape LLMs With Alignment Alone
Can you build a personalized LLM by skipping traditional fine-tuning and using only post-training alignment methods like DPO and GRPO? We break dow...
#2172: Council of Models: How Karpathy Built AI Peer Review
Andrej Karpathy's llm-council uses anonymized peer review to make language models evaluate each other fairly—but can it really suppress model bias?
#2164: Getting the Most From Large Context Windows
Frontier models have million-token context windows, but attention degrades well before you hit the limit. New research reveals why bigger isn't bet...
#2160: Claude's Latency Profile and SLA Guarantees
Claude is measurably slower than competitors—and Anthropic's SLA promises are even thinner than the latency numbers suggest. What enterprises actua...
#2146: The AI Wargame's Flat Hierarchy Problem
AI wargames treat NGOs and nuclear powers as equals. That's a dangerous flaw for real-world policy planning.
#2144: AI Wargaming: One Model or Many?
Should geopolitical AI simulations use one model or many? We debate the pros and cons of a single-model approach.
#2139: AI Wargame Memory: Beyond the Context Window
Why simply extending context windows fails in multi-agent simulations, and how layered memory architectures preserve strategic fidelity.
#2136: The Brutal Problem of AI Wargame Evaluation
Most AI wargame simulations skip evaluation entirely or rely on token expert reviews. This is the field's biggest credibility problem.
#2135: Is Your AI Wargame Signal or Noise?
Monte Carlo methods promise statistical rigor for AI wargaming, but the line between genuine insight and sampling noise is thinner than you think.
#2133: Engineering Geopolitical Personas: Beyond Caricatures
How to build LLMs that simulate state actors with strategic fidelity, not just surface mimicry.
#2129: Building the Anti-Hallucination Stack
Stop hoping your AI doesn't lie. We explore the shift to deterministic guardrails, specialized judge models, and the tools making agents reliable.
#2125: Why Agentic Chunking Beats One-Shot Generation
A single prompt can't write a 30-minute script. Here’s the agentic chunking method that fixes coherence.
#2123: Human Reaction Time vs. AI Latency
We obsess over shaving milliseconds off AI response times, but human biology has a hard limit. Here’s why your brain can’t keep up.
#2115: Why AI Answers Differ Even When You Ask Twice
You ask an AI the same question twice and get two different answers. It’s not a bug—it’s physics.
#2113: Goldfish vs Elephant: The Stateful Agent Dilemma
Stateless agents are cheap and fast, but stateful ones remember your window seat. Which architecture wins?
#2110: Tuning AI Personality: Beyond Sycophancy
AI models swing between obsequious flattery and cold dismissal. Here’s why that happens and how to fix it.
#2109: AI Is Forcing You to Use React
AI tools are reshaping developer stacks, favoring React and Postgres over niche frameworks.
#2092: Why AI Thinks You're American (Even When You're Not)
Even when we tell Gemini we're in Jerusalem, it defaults to US-centric assumptions. We explore the root causes of this persistent AI bias.
#2089: Why AI Drones Need Millions of Images
A public GitHub model spotted by a listener reveals the massive gap between hobbyist AI and lethal military drone detection systems.
#2088: Quantum's First Real Benchmarks Are Here
From drug discovery to logistics, quantum computing is finally delivering measurable speedups over classical systems.
#2076: Is Pure NLP Dead? The Hidden Scaffolding of AI
Modern AI didn't appear from nowhere. Discover how decades of linguistic rules and statistical models built the foundation for today's LLMs.
#2070: SemVer, Changelogs, and the Social Contract of Code
Stop breaking the internet. Learn the exact system developers use to release software without causing chaos.
#2067: MoE vs. Dense: The VRAM Nightmare
MoE models promise giant brains on a budget, but why are engineers fleeing back to dense transformers? The answer is memory.
#2066: The Transformer Trinity: Why Three Architectures Rule AI
Why did decoder-only models like GPT dominate AI, while encoders and encoder-decoders still hold critical niches?
#2065: Why Run One AI When You Can Run Two?
Speculative decoding makes LLMs 2-3x faster with zero quality loss by using a small draft model to guess tokens that a large model verifies in para...
#2064: Why GPT-5 Is Stuck: The Data Wall Explained
The "bigger is better" era of AI is over. Here's why the industry hit a data wall and shifted to a new scaling law.
#2063: That $500M Chatbot Is Just a Base Model
That polite chatbot? It started as a raw, chaotic autocomplete engine costing half a billion dollars to build.
#2062: How Transformers Learn Word Order: From Sine Waves to RoPE
Transformers can’t see word order by default. Here’s how positional encoding fixes that—from sine waves to RoPE and massive context windows.
#2061: How Attention Variants Keep LLMs From Collapsing
Attention is the engine of modern AI, but it’s also a memory hog. Here’s how MQA, GQA, and MLA evolved to fix it.
#2060: The Tokenizer's Hidden Tax on Non-English Text
Why does a simple greeting in Mandarin cost more to process than in English? It's the tokenizer's hidden inefficiency.
#2059: npm Cache and Stale Dependencies in Agentic Pipelines
npx is silently running old versions of your AI tools. Here's why your updates vanish into a cache black hole.
#2057: How Agents Break Through the LLM Output Ceiling
The output window is the new bottleneck: why massive context doesn't solve long-form generation.
#2056: How Music Models Turn Sound Into Language
A look at how AI music models use audio tokens, transformers, and diffusion to turn text into songs.
#2046: AI Hallucinations Are Just How Brains Work
We asked an AI to curate films about AI and reality, exploring the psychedelic overlap between machine hallucinations and human perception.
#2041: The "MPEG Moment" for AI: Llamafile & Native Models
Why are we squeezing massive cloud models onto desktops? Meet the "native" AI revolution.
#2037: Claude Code Extensions: Slash Commands vs. Skills vs. Agents
Stop manually typing slash commands. Here’s the definitive hierarchy of Claude Code extensions—from legacy shortcuts to autonomous agents.
#2027: Text-In, Text-Out: The Missing Photoshop for Words
Why is editing text with AI so clunky? We explore the "TITO" paradigm—using small, local models for fast, private text transformation.
#2026: Prompt Layering: Beyond the Monolithic Prompt
Stop writing giant, monolithic prompts. Learn how to stack modular layers for cleaner, more powerful AI applications.
#2025: How Do You Reward a Thought?
Rewarding an AI agent is harder than just saying "good job"—here's how we turn messy human values into math.
#2024: Your AI Council: Digital Committee or Groupthink?
A digital boardroom of AI models promises better decisions, but risks amplifying the same old biases.
#2021: Your Frozen AI Is Getting Smarter (Here's How)
Your AI model might be static, but the system around it can make it learn in real-time.
#2017: That Q4_K_M Is Not a Cat Sneeze
Those cryptic letters on Hugging Face actually map how much brain power you trade for speed.
#2016: Andrej Karpathy: The Bob Ross of Deep Learning
Why the most influential AI mind prefers a blank text file to proprietary black boxes.
#2010: Building Better AI Memory Systems
We obsess over AI inputs but treat outputs like Snapchat messages. Here's why that's a massive blind spot.
#2008: Needle-in-a-Haystack Testing for LLMs
New AI models claim to be genius-level, but can they actually find a specific fact in a massive document?
#2007: AI Grading AI: The Snake Eating Its Tail
We asked an AI to write this script. Then we asked another AI to grade it. Here’s what happens when the judges have biases.
#2006: How Do You Measure an LLM's "Soul"?
Traditional benchmarks can't measure tone or empathy. Here's how to evaluate if an AI model truly "gets it right."
#2005: Why Your GPU Changes LLM Output
Running the same LLM on different GPUs can produce different results. Here’s why that happens and how to test for it.
#1994: Why Can't AI Admit When It's Guessing?
Enterprise AI now auto-filters low-confidence claims, but do these self-reported scores actually mean anything?
#1992: Israel's 4,000-GPU National Supercomputer
Israel is building a sovereign AI supercomputer with 4,000 Nvidia B200 GPUs to keep startups local.
#1991: Israel's 20-Qubit Sovereign Quantum Leap
Israel just unveiled its first 20-qubit superconducting quantum computer, and it's not about size—it's about precision and control.
#1985: AI Tutors vs. Human Error: Who Do You Trust?
AI gets flak for hallucinations, but humans misremember 40% of facts. Why the double standard?
#1979: AI vs. ML: The Russian Dolls of Tech
Is AI the same as Machine Learning? We break down the nested hierarchy of artificial intelligence, from symbolic logic to neural networks.
#1962: Why Robots Think Before They Grab
We explore the tech letting robots "reason" about physical tasks using vision-language-action models.
#1959: How Constrained AI Models Handle the Unexpected
Your AI assistant promised to only use your documents. Instead, it invented a case law that doesn't exist. Here's why.
#1957: Why AI Agents Think in Circles, Not Lines
Linear AI pipelines are brittle. Learn why loops, reflection, and state management are the new standard for reliable, autonomous agents.
#1946: LangGraph's 3-Layer Agent Stack Explained
We unpack LangGraph, LangChain, and Deep Agents to reveal the deliberate hierarchy behind the ecosystem.
#1943: Why Tar Isn't Compression (And What Is)
LZMA, Zstandard, and Brotli are shrinking massive AI models, but how do they actually work?
#1940: Why Google's 31B Model Fits in Your GPU
Google just dropped Gemma four, and its 31-billion-parameter size is a masterclass in hardware-aware AI design.
#1938: JSON-to-SQL Type Mapping: A Practical Guide
Mapping JSON to SQL isn't as simple as it looks. Discover the hidden traps in data types that can cause performance hits and data corruption.
#1932: How Do You QA a Probabilistic System?
LLMs break traditional testing. Here’s the 3-pillar toolkit teams use to catch hallucinations and garbage outputs at scale.
#1931: AI Pipelines: In-Memory vs. Durable State
Why do AI pipelines crash? It’s not the models—it’s the plumbing. We break down how to manage data between stages.
#1929: Tracking AI Model Quality Over Time
We stopped "vibe-checking" our AI scripts and built a science fair for models. Here's how we grade them.
#1927: Workers vs. Servers: The 2026 Compute Showdown
Is the persistent server dead? We compare Cloudflare Workers, GitHub Actions, and VPS options for modern app architecture.
#1925: The Plumbing That Keeps Science From Collapsing
Half of all links in academic papers are dead. Here’s the plumbing that keeps knowledge from vanishing.
#1914: Google Invented RAG's Secret Sauce
Before LLMs, Google solved the "hallucination" problem with a two-stage trick that's making a huge comeback.
#1913: AI Context Windows Are Junk Drawers
Stop paying for old messages. Here's how to keep your AI sessions clean and on-topic.
#1910: Our Podcast Is Now a Permanent Research Artifact
Why we're uploading every episode to CERN's Zenodo archive, giving our AI experiments a permanent DOI and a life beyond streaming platforms.
#1909: The Unbakeable Cake: AI's Copyright Problem
Why can't we just delete stolen data from AI models? It's not a database—it's a baked cake.
#1907: Why We Still Fine-Tune in 2026
Despite million-token context windows, fine-tuning remains essential. Here’s why behavior, not just facts, matters.
#1906: Is Your AI Model Agentic-Ready or Just Wearing a Suit?
Native tool calling is the difference between a working product and a debugging nightmare.
#1894: Engineering Serendipity: Tuning AI for Better Brainstorming
Stop asking chatbots for generic ideas. Learn how to configure AI as a structured, critical partner for business innovation and career pivots.
#1882: The $8B Human Cost of AI Data
AI isn't free—it costs billions for humans to label data. See why annotation is the real engine behind models like Gemini.
#1856: Two AIs Chatting Forever: Why They Go Crazy
What happens when two ChatGPT instances talk forever? They hit a politeness loop, forget their purpose, and spiral into gibberish.
#1849: The Forever Dungeon Master: SillyTavern's Secret Lorebooks
Forget simple chatbots—this is how roleplayers taught AI to remember entire worlds, from 90s MUDs to just-in-time lore delivery.
#1839: AI's Data Kitchen: From Hoovering to Fine-Tuning
We go behind the curtain of the AI data pipeline, revealing the messy, multi-billion-dollar war over data curation.
#1838: Tuning Search Without Losing Your Mind
Modern search bars are AI decision engines. Here's how small teams can tune fuzzy matching, semantic search, and reranking without breaking everyth...
#1834: Building Portable Personal Context for AI
Why your AI remembers your coffee order but forgets your son’s name—and how to build a portable, federated memory layer you actually own.
#1831: The 79% AI Coder: Reasoning vs. Memorization
AI models now score 79% on coding benchmarks, but a 40-point drop on harder tests reveals the truth.
#1828: Mastering 2M Token Context in Agentic Pipelines
A massive context window sounds like a dream, but it can quickly become a nightmare for complex AI workflows.
#1824: Why Governments Are Building Bunkers for AI
Public clouds can’t handle the security or scale of classified AI. Governments are retreating to fortified bunkers.
#1822: Quantum in the Cloud: Hype vs. Hardware
Is QCaaS a billion-dollar breakthrough or an expensive science experiment? We explore the gap between hype and hardware.
#1819: Claude's 55-Day Personality Transplant
Anthropic leaked 55 days of system prompt updates. See exactly how they rewired Claude's personality, safety rules, and self-awareness.
#1818: Inside Claude's Constitution: A System Prompt Deep Dive
We analyzed Claude Opus 4.6's full public system prompt to uncover its hidden rules for safety, product behavior, and refusal logic.
#1817: Beyond LLMs: The Hidden World of Specialized AI
Explore the vast ecosystem of niche AI models for computer vision and document understanding, far beyond large language models.
#1811: Stop Hardcoding User Names in AI Prompts
Three methods for storing user identity in AI agents—and why the "Fat System Prompt" breaks production apps.
#1810: Why Your TTS Sounds Great in English, Terrible Everywhere Else
English AI voices are polished, but global languages hit a wall. Here's why text-to-speech breaks down for Hebrew, Hindi, and beyond.
#1799: The Original AI Blueprints: BERT & CLIP
Before GPT, two models changed everything. Discover how BERT and CLIP taught machines to read and see the world.
#1794: RAG Is Cheaper Than You Think (Until It’s Not)
From a $1 embedding bill to a $10k/month vector database bill, here’s the real math behind RAG in 2026.
#1792: Google's Native Multimodal Embedding Kills the Fusion Layer
Google’s new embedding model maps text, images, audio, and video into a single vector space—cutting latency by 70%.
#1784: Context1: The Retrieval Coprocessor
Chroma's new 20B model acts as a specialized "scout" for your LLM, replacing slow, static RAG with multi-step, agentic search.
#1779: AI Memory Is a Mess: Files, Vectors, or Cloud?
Why your AI forgets your instructions and what the battle over portable memory means for the future of agents.
#1777: Claude Called My Prompt "Rambling" and I'm Not Okay
When an AI coding tool critiques your prompt's literary quality, it raises a massive technical question about engineered personality.
#1765: The Agentic Internet: A Clean Web for Machines
We explore the tools building a parallel, machine-readable web—from SearXNG to Tavily.
#1764: Vector Databases as a Single File
How to give AI agents instant memory of your entire project—without cloud costs or complex infrastructure.
#1762: Testing AI Truthfulness: Beyond Vibes
Stop trusting confident AI. We explore the formal science of testing LLMs for hallucinations and knowledge cutoffs.
#1753: AI Makes Coding Harder, Not Easier
Claude Code writes the syntax, but you need more technical knowledge than ever to guide it.
#1740: Chatterbox TTS: Open Source vs. ElevenLabs
We dissect Resemble AI's Chatterbox to see how its open-source TTS compares to commercial giants like ElevenLabs.
#1739: AI Just Designed a New Life Form
Meet Evo: the 40B parameter AI that writes DNA, designs novel CRISPR systems, and is reshaping synthetic biology.
#1737: Nous Research: The Decentralized AI Lab Beating Giants
Meet Nous Research, the decentralized collective outperforming billion-dollar labs with open-source AI and the self-improving Hermes-Agent framework.
#1736: Why OpenClaw Eats 16 Trillion Tokens
OpenClaw is processing 16.5 trillion tokens daily, dwarfing Wikipedia. Here’s why it’s #1.
#1734: You vs. Your Digital Twin: Who Wins?
Your AI clone is getting scarily good. We explore the tech behind high-fidelity digital twins and the uncanny valley of your own voice.
#1733: Digital Ghosts in the Machine
AI agents are forming neighborhoods, economies, and hospitals in server-side simulations that mirror real human behavior.
#1732: The AIOS Kernel: An Operating System for Agents
AIOS aims to be the Linux for AI agents, managing memory, scheduling, and tools in one open-source kernel.
#1731: Why Deep Research Agents Are Being Forgotten
Specialized research agents outperform general orchestrators by 40-60% on verification tasks, yet developer hype is fading. Here's why.
#1730: Are Multi-Agent Coding Frameworks Obsolete?
MetaGPT, SWE-agent, and OpenHands promised a team of AI devs. But in 2026, are they still useful, or has raw model power made them obsolete?
#1729: Why Is AI Code So Hard to Read?
AI writes code faster than ever, but the output is often a cryptic mess. We explore why and how to fix it.
#1728: How Two AIs Collaborate Without Code
CAMEL AI lets two agents role-play to solve tasks autonomously. No complex code—just emergent teamwork.
#1727: LSP: The Universal AI Coding Interface
Explore how the Language Server Protocol is being repurposed to integrate AI directly into code editors, unifying development workflows.
#1723: Why Agentic AI Needs a Hive Mind, Not a Single Brain
The single monolithic AI model is dying. Meet the new native multi-agent architectures that think like a team, not a solo genius.
#1717: The AI Framework Name Game
Why are there thousands of "AI frameworks" on GitHub? We unpack the naming mess and the cost of semantic inflation.
#1713: Why Native AI Search Grounding Still Fails
Native search grounding is expensive and flaky. Here’s why bolt-on tools still win for accurate, real-time AI answers.
#1710: Two Hundred Years of Calling Sloths "Miserable Mistakes"
Why did early naturalists mistake sloths for bears, monkeys, and giant rats?
#1709: Standard Deviation: The Map Without a Scale
Why the average number alone is misleading—and how standard deviation reveals the true story behind the spread.
#1708: Why Your AI Agent Forgets Everything (And How to Fix It)
Learn how Letta's memory-first architecture solves the AI context bottleneck for long-term agents.
#1705: Microsoft's Small Models, Big Play
Microsoft is pushing small language models like Phi for agentic AI. Here’s why that strategy matters for speed, cost, and edge computing.
#1702: Roleplay Models Aren't Just for NSFW—They're Creative Co-Processors
Forget GPT-4 for scripts—specialized roleplay models like Aion-2.0 are better at character consistency and dialogue.
#1700: Can LLMs Learn Continuously Without Forgetting?
We explore a new approach: micro-training updates every few days to keep AI knowledge fresh without constant web searches.
#1698: Can AI Models Represent Nations in Diplomacy?
Real projects are building AI agents trained on national laws and diplomatic archives to simulate negotiations.