エピソード

  • AI Agents for Bayesian Data Science

    AI Agents for Bayesian Data Science
    2026/09/01
    Thomas Wiecki, Founder, PyMC Labs, is the author of PyMC, one of the most popular frameworks for Bayesian modeling, and the founder of PyMC Labs, a Bayesian AI consultancy. He holds a PhD in Computational Cognitive Neuroscience from Brown University and previously served as VP of Data Science and Head of Research at Quantopian Inc., where he built and led a team of data scientists to develop a hedge fund leveraging insights from a crowd-sourced pool of 300,000 researchers.In this episode, we explore how AI agents have made Bayesian methods more accessible to non-experts. Bayesian models are useful for both forecasting and decision-making under uncertainty. These models can act as scenario simulators, making it possible to ask what-if questions about marketing, seasonality, or health interventions while exposing the mechanisms behind an outcome.We also discuss how agentic engineering has finally helped deliver on some of the original promises of data science, how to effectively embedding agents in tools like Slack or Discord to democratize access to company information, and what parts of data science still require talking with humans to understand the problem.Full episode notesTranscriptChapters(00:00) - Agentic engineering meets Bayesian decision science(05:27) - Bayesian models versus black-box prediction(10:22) - Confounders and causal mechanisms(12:41) - From notebooks to model-aware agents(15:41) - The rise of agentic interfaces(19:18) - Alchemize and verified code translation(29:49) - Agentic data science beyond the silo(34:25) - Daimon and collaborative multiplayer AI(37:43) - Verification and unsettled methods(42:53) - Parallel agents and PyMC Forecast(51:08) - The Bayesian method of software engineering(53:59) - Agents as software's primary users(57:08) - Institutional knowledge and bus-factor risk(01:03:56) - Faster research and open source(01:12:05) - Causal models for AI's future⠀Links from the show--------------------Master Agentic Data ScienceShow Us Your Agent SkillsPyMCPyMC LabsBayesian modelingcausal questionsmedia mix modelingDaimonAlchemizePyMC Forecastprior data fitted networksNumPyro ForecastStanJAXPyTorch⠀Guests-------Thomas Wiecki, Founder, PyMC LabsWebsiteLinkedInGitHubTwitter⠀Follow the podcast-------------------LinkedInThreadsInstagramTikTok⠀Follow Dan Gerlanc-------------------XLinkedInThreadsBluesky
    続きを読む 一部表示
    1 時間 14 分
  • Search is Eating AI

    Search is Eating AI
    2026/08/25
    Dan is joined by Hugo Bowne-Anderson and Doug Turnbull. Hugo is an independent data and AI scientist who has advised and taught teams at Netflix, Meta, and Amazon. Doug is an independent consultant and search expert with experience at Shopify, Reddit, and Wikipedia, and the author of "Relevant Search" and "AI Powered Search." In this episode, they discuss what agentic search actually means and the 3 primary ways to implement agentic search. Hugo argues that search is becoming a core skill because agents can handle questions that require repeated retrieval and synthesis. To improve agentic search, most teams should start with evals. Establish a retrieval baseline, find areas for improvement, and iterate. Defining a “good” retrieval baseline is product-specific as a healthcare assistant may need its first result to be correct, while an e-commerce system may succeed by offering several useful options. Doug and Hugo argue that the lack of good training examples means its often useful to read and write your own search code. As to other code, Hugo describes the "dark factory" pattern, where code is written by AI agents but cannot be directly read by humans. How do we design systems for a world where the primary consumers of code are AI agents, not humans? Full episode notes Transcript Chapters (00:00) - Agents, engineers, and reverse centaurs(01:24) - Three paths for agentic search(05:32) - Teaching production-ready enterprise agents(07:06) - Why search is eating AI and data(10:24) - Start with evals and retrieval baselines(16:08) - Writing code to build judgment(18:45) - Learning and building beyond code(24:39) - Verification in a world of abundant code(29:52) - Resisting agent-driven feature sprawl(33:38) - Specialized models and better agent interfaces ⠀ Links from the show -------------------- Build Production-Ready AI Agents for the EnterpriseVanishing Gradientsretrieval-augmented generationBM25NDCGTerence Taodark software factorieslights-out manufacturingUnix philosophyOpenClawSimon Willison ⠀ Guests ------- Hugo Bowne-Anderson, Independent Data and AI Scientist WebsiteLinkedInXGitHubBluesky ⠀ Doug Turnbull, Principal, SoftwareDoug WebsiteLinkedInXGitHubBluesky ⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok ⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky
    続きを読む 一部表示
    41 分
  • The Handoff Packet for Local Agentic AI

    The Handoff Packet for Local Agentic AI
    2026/08/18

    Paul Everitt is a Python and Web Developer Advocate at JetBrains. He previously co-founded Zope Corporation, helped bootstrap the Python Software Foundation and Plone Foundation, and served as a US Navy officer who started www.navy.mil in 1993.

    Paul and Dan discuss how local agentic AI could reshape software engineering, from smaller models supported by static analysis and better tool calling to workflows built around specs, tests, and focused handoff packets. They compare local, cloud, and hybrid model setups and examine what happens when agents work with less supervision.

    The episode's titular handoff packet sits at the center of a three-level workflow. A large model understands the project, a medium model creates an execution plan, and a small local model carries out a tightly scoped task. The packet gives that smaller model the context, constraints, tools, and success criteria it needs.

    They also discuss spec drift, Markdown debt, community-maintained Python training data, and the responsibility developers retain to read, test, and own the code they ship.

    Full episode notes

    Transcript

    Chapters

    • (00:00) - A profession changing by the hour
    • (02:54) - Why Python still matters with humans in the loop
    • (04:37) - Static analysis for small local models
    • (11:51) - DwarfStar and the local inference stack
    • (17:28) - Apple's on-device AI push
    • (23:29) - Why unsupervised agent runs fall apart
    • (28:46) - The big brain, medium brain, little brain
    • (41:19) - Spec drift and Markdown debt
    • (47:45) - Pyrefly and duck typing for agents
    • (51:22) - Better tool calling for local coding models
    • (01:00:10) - Community-maintained Python training data
    • (01:03:42) - Bring back the engineering

    ⠀

    Links from the show

    --------------------

    • arXiv
    • Pydantic AI
    • LM Studio
    • OpenRouter
    • DeepLearning.AI spec-driven development course
    • Spec Kit
    • Superpowers
    • Pyrefly
    • Mellum
    • Flower
    • Liquid AI

    ⠀

    Guests

    -------

    Paul Everitt, Python and Web Developer Advocate at JetBrains

    • Website
    • LinkedIn
    • DeepLearning.AI: Spec-Driven Development with Coding Agents

    ⠀

    Follow the podcast

    -------------------

    • LinkedIn
    • Threads
    • Instagram
    • TikTok

    ⠀

    Follow Dan Gerlanc

    -------------------

    • X
    • LinkedIn
    • Threads
    • Bluesky
    続きを読む 一部表示
    1 時間 6 分
  • How AI Agents Change the Work of an ML Engineer

    How AI Agents Change the Work of an ML Engineer
    2026/08/11
    Dan and Niels Bantilan discuss how AI agents are changing Niels's work on two open-source projects, Flyte and Pandera. Flyte began as an MLOps orchestrator and is evolving into an AI runtime for the code, compute, and execution systems around models and agents. Pandera remains a smaller, community-focused data-validation project. Niels finds agents most useful in mature codebases with strong structure, linters, type checks, and tests. He estimates that his coding velocity has increased at least threefold. Local models handle small fixes, while commercial tools perform better on longer tasks that require broad codebase analysis. Pull requests and code review remain central, with reviewers checking for code smells, security problems, and performance issues. Agents now participate in Niels's debugging loop inside live Kubernetes clusters. Through Flyte's MCP server, an agent can inspect logs, identify an out-of-memory error, update the Flyte configuration, and retry the workload. In one case, an agent found an off-by-one error in tensor loading within five minutes, fixing a model that had been emitting garbage symbols. The experience also exposed a risk: Niels has started skimming the agent's report instead of reconstructing every bug himself. At Union, internal agents have narrow responsibilities and return reviewable artifacts. Nody handles customer requests to change node-pool limits and opens pull requests for engineers to review. Doxy monitors SDK changes and proposes documentation updates. Niels applies the same pattern to PRDs, go-to-market writing, and code examples. Agents should have clear access boundaries and produce work that people can inspect. Niels imagines Flyte letting agents assemble workflows instead of following fixed DAGs. Typed tasks define the available building blocks, while Pydantic Monty safely runs the control-flow code an agent writes. Flyte can move files between pods, route heavy work to suitable compute, and resume a 100-step pipeline at step 98 instead of starting over. Niels sees this as the foundation for an AI runtime that combines agents with training, inference, and reinforcement-learning rollouts. Agents have also made it easier for Niels to maintain Pandera while raising a young family. He is exploring validation schemas for vectors, images, and tensor containers, with Narwhals and LanceDB as possible paths into multimodal data. The design remains open. Pandera's concise plain-text errors work well for agents, while HTML reports may better serve people. Across both projects, Niels sees a continuing human responsibility: understand enough of the system to decide whether an agent's output is worth keeping. Full episode notes Click here to view the episode transcript. Chapters (00:00) - How agents are changing Flyte and Pandera(01:29) - Why agents work best in mature codebases(05:38) - Local models for small fixes, Claude for longer tasks(08:44) - Agents triple coding velocity(11:39) - Flyte MCP keeps Kubernetes out of the debug loop(13:53) - From model training to inference and rollouts(17:17) - Flyte's role in reinforcement-learning workloads(22:08) - Moving tensors between pods and GPUs(23:48) - An off-by-one bug made the model output garbage(25:48) - The risk of losing technical understanding(30:39) - Nody and Doxy: agents with narrow permissions(37:20) - When to move an agent from a terminal into Flyte(45:26) - Agents build execution graphs from typed tools(48:06) - Flyte as a durable AI runtime(51:02) - The case for human ML engineers(52:31) - Extending Pandera to vectors and images(55:10) - Narwhals opens a path to multimodal validation(57:45) - Plain-text errors for agents, HTML reports for people ⠀ Links from the show -------------------- FlytePanderaUnion AIPydantic MontyNarwhalsLanceDBKubernetesRustFS ⠀ Guests ------- Niels Bantilan, Chief Machine Learning Engineer, Union LinkedIn ⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok ⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky
    続きを読む 一部表示
    1 時間 1 分
  • Reducing Entropy in Agentic Software

    Reducing Entropy in Agentic Software
    2026/08/04
    Dan and Jacob Young discuss what technical due diligence looks like when software teams use coding agents. Best practices have not settled, so Jacob looks less for a particular model or tool than for convergence: whether a team and its agents keep moving toward the same grounded idea of what the software should be. Shared standards, existing abstractions, language servers, linters, hooks, tests, and code review all help, but the most useful constraints arrive during development rather than after a huge pull request. The conversation turns to documentation, where Jacob sees a recurring failure mode. Teams create architecture and API documents, then let them drift out of date within weeks. Documentation helps only when the code remains the source of truth and some system can regenerate or update the documents when the code changes. He also argues that security checks belong inside the development and review workflow. Agents can apply codified OWASP practices, but they cannot be trusted to choose cryptographic parameters or recognize a subtle misuse of encryption without expert oversight. Jacob’s broader thesis is that coding agents can increase software entropy. They can quickly turn a cohesive codebase into one with duplicated logic, inconsistent abstractions, and many ways to do the same thing. He is exploring measurements that combine code size, dependency structure, cyclomatic complexity, and duplication, while acknowledging that no universal score exists. Programming-language choice becomes one practical lever. Jacob sees Go’s conventions, standard library, tooling, and small dependency surface as unusually friendly to agents, while Rust’s expressive type system is powerful but still often underused by models at the abstraction level. At the developer level, agents amplify existing judgment. Experienced engineers know what tends to go wrong and can constrain an agent before it creates trouble. Developers without production experience can use the same tools to multiply bad patterns, skip understanding, and drag down a whole team. Jacob recommends that junior developers still write code by hand, learn the fundamentals, and use models as tutors that generate quizzes, flashcards, and problem sets rather than as answer machines. The episode closes on the limits of autonomy. Jacob sees smaller teams gaining leverage by removing toil, but not teams of one replacing every specialist. Models respond best to expertise, while much of what experts know comes from undocumented failures and experience that never entered the training corpus. Working across many agent sessions can also be more tiring because the engineer must watch for many ways things can go wrong. The useful future is still human-centered: people make the decisions and outsource bounded cognitive labor while keeping their hands on the wheel. Full episode notes Click here to view the episode transcript. Chapters (00:00) - What Due Diligence Looks Like in Agentic Development(02:32) - Convergence as a Team Practice(04:19) - Codifying What Good Looks Like(06:30) - Hooks, Linting, and Feedback Timing(08:06) - When Architecture Documentation Drifts(11:19) - Security Reviews and Cryptographic Failure Modes(17:50) - Software Entropy and Measuring Complexity(25:42) - Why Go Works Well with Coding Agents(33:38) - Rust, Abstractions, and Model Limitations(37:50) - Experience as a Force Multiplier(44:16) - Using Agents to Learn, Not Just Produce(52:54) - Greenfield Autonomy versus Brownfield Reality(56:48) - Smaller Teams Still Need Specialists(01:04:12) - The Cognitive Cost of Managing Agents ⠀ Links from the show -------------------- CodexClaude CodeLanguage Server ProtocolOWASP Top 10pandascyclomatic complexityentropyDon't Repeat YourselfKubernetesAndy Matuschak ⠀ Guests ------- Jacob Young, CEO & Founder, Sancho Studio WebsiteLinkedIn ⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok ⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky
    続きを読む 一部表示
    1 時間 7 分
  • Unharness Your Agents

    Unharness Your Agents
    2026/07/28
    Dan and John Berryman discuss why today’s terminal- and IDE-centered agent harnesses are too narrow. John argues that agents should be able to see and act across the applications, websites, files, and physical environments that make up a person’s life. His Rook project is an attempt to make those contexts addressable while allowing people to keep using the agent harnesses they already trust. The conversation turns to a future in which websites expose agent-facing capabilities and applications reshape themselves around conversations. John imagines an assistant that can combine a person’s notes and shopping list with location, store inventory, and aisle information. He says feasibility is the major barrier that recently moved into reach, while security, transparency, trust, and standardization remain unresolved. That tension becomes concrete in the discussion of permissions and sandboxing. John expects people to begin with constrained, read-only access and gradually grant more authority, with dry runs, approvals, and reversibility helping determine when an agent can act on its own. He also points to emerging conventions such as skills files, AGENTS.md, and llms.txt as ways for agents to discover what they can do in a given domain. John’s strongest practical advice is to replace bespoke workflow code with skills written in plain English whenever the model is capable enough to follow the instructions. He describes building a Zoom assistant and a candidate-vetting workflow this way, arguing that subject-matter experts may eventually be able to read and rewrite the software directly. In his view, the agent is increasingly just a loop around a model and tools, with frameworks such as LangGraph becoming less necessary for many applications. The discussion of memory is more skeptical. John argues that chunking old conversations and retrieving them by textual similarity does not reproduce the way human experience turns mistakes into procedural knowledge and taste. For now, he prefers explicit, visible review of a completed task followed by packaging the generalized process as a skill. That approach is also his answer to the limits of AI-generated writing: agents can remove ums, edit dead space, and produce polished drafts, but they still do not know what a particular person considers good. Looking ahead, John expects more agentic applications, just-in-time custom software, and world models that simulate environments for robotics. He is optimistic but clear-eyed about the risks, closing with a plea to direct the technology toward useful and humane outcomes rather than dystopia. Full episode notes Click here to view the episode transcript. Chapters (00:00) - Why agents should be unharnessed(03:32) - Rook and context-aware agents(13:23) - Agent-facing applications and trust(18:23) - Sandboxing, dry runs, and reversibility(21:29) - The new programming language is English(30:28) - Why bespoke agent frameworks are fading(34:13) - What agent memory gets wrong(42:50) - Explicit memory through skills(51:07) - Taste as the final frontier(57:49) - World models and the future ⠀ Links from the show -------------------- Arcturus Labs BlogThe AI Product Era You're Building For Might Already Be OverUnharnessed Agents Power the Future of AI ProductsRelevant SearchPrompt Engineering for LLMsAgent Client ProtocolOpenClawHermesPiLangGraphPydantic AITailscaleOpenStreetMapModel Context Protocol ⠀ Guests ------- John Berryman, Founder, Arcturus Labs WebsiteLinkedInXYouTube ⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok ⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky
    続きを読む 一部表示
    1 時間 6 分
  • The AI Skill Flip

    The AI Skill Flip
    2026/07/21
    Sheamus McGovern founded ODSC roughly twelve years ago and now splits his time between the conference business and a role as venture partner and Head of AI at Cortical Ventures. His book, The AI Skill Flip, came out of a pattern he kept hitting: data scientists and software engineers coming to him asking whether AI was going to take their jobs and what they should do about it. He wanted to write something that sat between the doom narrative and the utopian one, both of which he thinks are wrong. The "flip" in the title is the observation that the balance of skills has shifted rather than disappeared. Five years ago a software engineer spent most of their time writing raw code. Now much of that time goes to judging and evaluating what the model produced and thinking further up the stack. The same flip applies in marketing, where the skill becomes knowing what good looks like and what persona you're targeting rather than producing the asset yourself. Asked what separates people who get real value from AI from people who don't, Sheamus lands on three things. First is passion, the plain will to get a good outcome, which he compares to what separates a strong startup founder from an average one. Second is creativity, which he argues AI increases rather than eliminates, because models are sycophantic and will happily build exactly what you asked for. His example is watching people reach for Replit, Base44, or Lovable and build a dashboard, when the real question is whether a dashboard is even the right artifact in a world of agentic workflows. Dan pushes the point further, noting that dashboards existed because software was expensive to build, so you built one thing and maintained it. Third is judgment. AI is excellent at producing output and terrible at judging its value, which Sheamus frames as another instance of the automation paradox. On whether judgment can be taught, Sheamus starts at the engineering level with evaluations. Traditional numeric metrics still apply, but open-ended evaluation is the hard part, and he watched engineers struggle with it while building his first RAG and QA systems. His QA team's honest response was that the system was generating text all the time and they had no idea how to test it. Above the engineering layer, judgment comes down to domain expertise and knowing what good looks like. He tells a story about generating a thirty-page contract with Claude Code, sending it to his lawyer for a quick review, and getting billed ten hours anyway, because the lawyer still had to read every word and apply their own judgment. The other half of teaching judgment is teaching people how AI actually works, so they neither trust it completely nor dismiss it. Once you see it as sophisticated pattern recognition rather than magic, the failure modes become predictable. It works well on established APIs and badly on new libraries. He'd asked Perplexity that morning for the top twenty personal AI frameworks and got Gemini and other Google products instead of OpenClaw and the other recent entrants. Dan asks whether prompt design still matters now that agentic loops can ask their own clarifying questions, and both agree the vocabulary has moved faster than the practice. People stopped talking about context engineering and started talking about the harness, but skills and memory are still context engineering wearing different clothes. Sheamus's view is that prompt engineering, context engineering, and skills are all the same underlying muscle, and the people who learned the first are quick at the third. Most teams are still doing a poor job of it, partly because the models are good enough to paper over sloppy input and hand back generic, unoptimized, expensive results. He describes users bouncing from the $20 plan to the $100 plan and still running out of tokens with no idea where they went. The deeper problem, and the one he spends a chapter on, is that knowledge work is both open-ended and unstructured. You get stuck debugging, a five-minute task becomes two hours, and workflows you assumed were deterministic turn out not to be. His own research pipeline pulling papers from Google Scholar and arXiv keeps hitting that wall, because author institutions appear below the names on one paper, on the left-hand side of another, and not at all on a third. His own use of AI changed substantially over the two and a half years he spent writing the book, which included interviews with about thirty people. The first version of Cortical's VC sourcing pipeline was hand-architected, with AI slotted into specific stages, ChatGPT or Claude to read reports and Perplexity to search. Now a single agent with the right skills and system prompts can do the whole thing end to end. He runs a personal assistant built from Claude Code and a bit of Codex that pulls attachments from his Google Calendar, cross-references his CRM and the Crunchbase API, and prepares the monthly list of two hundred startups he has to review. What...
    続きを読む 一部表示
    1 時間 3 分
  • The New Sport of Programming

    The New Sport of Programming
    2026/07/14
    Matthew Rocklin is an open-source software developer best known for creating Dask, a Python library for scalable parallel and distributed computing. He has contributed to projects including Toolz, SymPy, and Theano, worked at Anaconda and NVIDIA on the RAPIDS ecosystem, and founded Coiled, a company focused on running Dask in the cloud. He has a PhD in computer science from the University of Chicago. Dan and Matthew discuss how Coiled changed after Matthew stepped away from its ambitious, VC-backed growth path. The company went from roughly fifty people at its peak to three part-time engineers, while making more money and operating more smoothly. Matthew now connects agents to Slack, email, QuickBooks, the bank, the calendar, the codebase, and company context, which lets them spot problems that cross disciplines. Matthew describes a lightweight operating system for the company. The structure is simple, a Git repository of Markdown files records customers, employees, systems, and his own context. Agents answer ad hoc questions, produce a daily brief, and run a separate monthly cadence for close and overages. They remain read-only for now. Matthew is willing to have them issue invoices when asked, but not to cut checks or reboot virtual machines on their own. The conversation turns to the personal cost of this new leverage. Matthew does not miss writing every line of code, but he has had to reshape his attention around seven parallel agent sessions and long-running turns. He compares agentic programming to a new sport. The work demands more inspiration and creates a more addictive waiting state, so walks, breaks, and deliberate distance from the screen matter as much as technical skill. Agents have fovever changed the culture of OSS. Matthew expects conservative open source projects to protect stability while more experimental projects split off and evolve quickly. His own Frisky project rebuilds parts of Dask in Rust, runs about a hundred times faster in his early testing, and exposes telemetry so agents can understand distributed state. It is promising but still breaks often, which makes it a useful example of the stability and speed trade-off. Matthew argues that software has no intrinsic value. It matters because it cures a disease, helps someone find a home, or automates a useful outcome. When agents make implementation cheap, programmers must let go of much of the craft they built and focus on problem selection, system design, and judgment. He sees the same opening in front-end work, where agents helped him explore TypeScript, visual design, and user workflows that he had previously avoided. Dan and Matthew discuss strategies for verifying agentic output. Matthew gives agents tests, benchmarks, telemetry, line-count signals, and independent reviews, then asks them to demonstrate that his specific concerns are handled. He says the bottleneck is now his own ability to make decisions across many threads, not agent intelligence. Good context and feedback systems matter more to him than a more capable model, and he ends by encouraging programmers to play, take bigger swings, and build their own things. Full episode notes Click here to view the episode transcript. Chapters (00:00) - Coiled after the VC-backed growth phase(04:01) - A repository of context and a daily company brief(07:25) - Opportunity cost in a high-churn era(10:29) - Rewiring attention for agentic programming(15:43) - Seven sessions, long turns, and more walks(18:34) - What happens to work relationships(21:49) - Open source stability versus AI-driven change(23:56) - Frisky and the Rust rewrite of Dask(25:40) - What software is worth when it is cheap to build(29:31) - Why Matthew started building front ends(32:58) - Languages matter less than the user experience(36:08) - Higher-level programming and formal verification(38:12) - Ambition, inhibition, and larger agent tasks(40:41) - Feedback systems for checking agent work(45:04) - Context and feedback beat raw model intelligence(49:17) - AGENTS.md, documentation, and learning with local models(57:48) - Build your own things ⠀ Links from the show -------------------- DaskCoiledFriskyQwen 3Vitepy-spyformal verification ⠀ Guests ------- Matthew Rocklin, Founder & CEO, Coiled Computing WebsiteLinkedIn ⠀ Follow the podcast ------------------- LinkedInThreadsInstagramTikTok ⠀ Follow Dan Gerlanc ------------------- XLinkedInThreadsBluesky
    続きを読む 一部表示
    56 分