Skip to content
Sign in
Artwork for The AI Practitioner Podcast
TechnologyEducation

The AI Practitioner Podcast

by Lina Faik

Real-world AI, explained simply — with code, use cases, and zero fluff.

aipractitioner.substack.com
Play
Open in
  • 20 episodes
  • fortnightly
  • Avg 10 min
  • English

Episodes 20

NewestOldestLongest
All20Unplayed20In progress0Played0
  • September 23 · 12 min

    PODCAST — GraphRAG vs. Vector RAG: Better Retrieval or Expensive Overengineering?

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Standard RAG works well when the answer is contained in one place. But when a question requires connecting facts across several documents, vector retrieval can start to struggle. GraphRAG adds explicit structure around entities and their relationships, making multi-hop retrieval easier, but also more complex and expensive. In this episode, the focus is on how GraphRAG works, how the main approaches differ, and whether the added complexity is actually worth it. You’ll learn: * Why does vector retrieval struggle with multi-hop questions? Exploring why semantic similarity alone is often not enough when an answer requires connecting several entities and facts across documents. * How do the main GraphRAG architectures differ? Breaking down community-based approaches like Microsoft GraphRAG, entity-relation systems like LightRAG, PageRank-based retrieval such as HippoRAG, and recursive summarization with RAPTOR. * Is GraphRAG actually worth the additional cost? Looking at benchmark results, retrieval quality, token usage, latency, and practical implementations of NaiveRAG, LightRAG, and Microsoft GraphRAG. 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • September 9 · 12 min

    PODCAST — Inside TabFM: How In-Context Learning Enables Prediction on Unseen Tables

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Most tabular machine learning workflows start the same way: clean the data, engineer features, tune hyperparameters, and train a new model from scratch. Google Research’s TabFM proposes a very different approach: treat the dataset itself as context and make predictions in a single forward pass, without task-specific training. In this episode, the focus is on how zero-shot foundation models for tabular data actually work, why tables require a different architecture from text, and how TabFM compares with the models that came before it. You’ll learn: * Why is in-context learning harder for tabular data? Exploring how permutation invariance across rows and columns makes standard sequence modeling a poor fit for tables. * How do TabPFN, TabICL, and TabFM solve the problem differently? Breaking down three architectural approaches to the same challenge and the key ideas that distinguish them. * How do you run these models in practice? Using TabFM, TabPFN, and TabICL on real tabular datasets and looking at the kind of predictive performance you can expect from them. 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • September 2 · 12 min

    PODCAST — LLM Cost Prediction: From Single Prompts to Agentic Systems

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. LLM costs are easy to calculate after execution, but estimating them before a prompt or agent actually runs is a much harder problem. In this episode, the focus is on predicting LLM and agent costs before execution, from estimating output length for a single model call to reasoning about the much more variable execution paths of AI agents. You’ll learn: * What can be predicted from a prompt before execution? Exploring how token consumption, output length, and model cost can be estimated before sending a request to an LLM. * Can an agent’s cost be estimated before execution? Understanding the additional uncertainty introduced by multiple model calls, tool calls, retries, reasoning steps, and variable execution trajectories. * What Python tooling is available today? Reviewing practical libraries and approaches for estimating and calculating LLM and agent costs, including LiteLLM, genai-prices, tokencost, and tiktoken. 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • July 30 · 14 min

    PODCAST — Evaluating Google ADK Agents: From Execution Traces to Regression Tests

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Building agents that take real-world actions is impressive, but ensuring they continue to behave correctly as they evolve is a much harder challenge. Manual reviews of execution traces and subjective “vibe checks” quickly become a development bottleneck. In this fourth episode of the Google ADK series, the focus moves from deployment to evaluation and quality assurance. You’ll learn: * What should be evaluated in an agent system? Distinguishing final-response quality from tool use, execution trajectories, state handling, and end-to-end task success. * How Google ADK represents evaluations. Understanding eval sets, evaluation cases, invocations, evaluation configs, and the metrics that operate on them. * How to create, run, and inspect ADK evaluations. Recording evaluation cases, configuring metrics, executing evals from the CLI or Python, and interpreting the resulting scores and reports. 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • July 10 · 15 min

    PODCAST — Deploying Google ADK Agents: From Local Script to a Managed Cloud Runtime

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Multi-agent systems become valuable when they can reason and coordinate, but they become even more valuable when they are production-ready and can run reliably as a service. In this third episode of the Google ADK series, the focus moves beyond agent design and orchestration to deployment. Using the same multi-agent writing pipeline from the previous articles, this podcast explores how to turn an ADK agent into a cloud-native service with durable state, secure credentials, observability, authentication, and a clear path for client applications. You’ll learn: * How to choose between Agent Engine, Cloud Run, and GKE for hosting an ADK agent * How to externalize sessions, artifacts, memory, secrets, and model access for production * How to test the deployed service, stream responses, configure CORS, and connect a frontend 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • July 2 · 12 min

    PODCAST — Google ADK Multi-Agent Orchestration: Delegation, Human-in-the-Loop, Callbacks, and Plugins (Part 2)

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Multi-agent systems become powerful when they can adapt, but they become production-ready only when that adaptation is controlled. In this episode, we continue our Google ADK series and explore how ADK brings flexibility, structure, and reliability to multi-agent execution. We move beyond static workflows into dynamic orchestration: letting an agent decide which agent should act next, when a tool should be called, when a task should be escalated, and how the full execution path can be observed. You’ll learn: * How agents delegate work dynamically, including when to introduce Human-in-the-Loop review * How to build orchestration logic beyond built-in workflow agents, using custom agents, agent-as-tool patterns, and callbacks * How plugins help apply shared rules and behaviors across every agent in a system 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • June 25 · 11 min

    PODCAST — Google ADK Explained: Building Multi-Agent Systems With Google's Agent Development Kit (Part 1)

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Agent frameworks promise to make AI systems easier to build. But the hard part isn’t just creating agents, it’s coordinating them. Writing, reviewing, debugging, and deploying agentic systems requires clear roles, shared state, observability, and control over how work moves between components. In this episode, we explore Google ADK, Google’s code-first framework for building, evaluating, and deploying multi-agent systems. Rather than treating agents as prompt chains, ADK models them as software components: agents are objects, tools are regular functions, and workflows are composed through explicit orchestration primitives. You’ll learn: * Where ADK fits in the agent framework ecosystem * What happens under the hood: how ADK models agents, tools, sessions, state, and memory, and how sequential, parallel, and loop agents express most real-world workflows. * What a real workflow looks like in practice: through the example of an automated writing assistant, we’ll see how a theme agent, writer agent, and critic agent collaborate to draft, review, revise, and stop when the output is ready. 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • June 9 · 13 min

    PODCAST — Claude Dynamic Workflows: Scaling Complex Work Through Orchestration

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. LLMs excel at individual tasks. But most valuable work isn’t a single task, it’s a coordinated process. Writing a research report, reviewing a large codebase, or evaluating conflicting evidence requires multiple stages of analysis, validation, and synthesis without losing rigor along the way. In this episode, we explore Claude Dynamic Workflows, the multi-agent orchestration framework Anthropic released on May 28, 2026. Rather than forcing everything through a single conversation, Claude generates a JavaScript workflow that defines the phases of work, determines what can run in parallel, and routes information between stages. You’ll learn: * Where dynamic workflows fit on the coordination ladder: why single agents often struggle with laziness, self-preferential reasoning, and goal drift, and when a workflow outperforms a skill, a subagent, or a full agent team. * What happens under the hood: how Claude transforms a prompt into an inspectable execution script, how isolated agents fan out to investigate different aspects of a problem, and how six recurring workflow patterns power most real-world use cases. * What a real workflow looks like in practice: through the example of a deep-research workflow on developer productivity, we'll see how Claude spawned 27 agents, spent roughly $5, and used an independent verification phase to explain a genuine conflict in the literature instead of averaging it away. If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox: aipractitioner.substack.com Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • June 4 · 11 min

    PODCAST — SkillOpt Explained: From Prompt Engineering to Skill Training

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Skills have become a core building block for AI agents, packaging expertise and workflows into reusable instructions. But despite their growing importance, most teams still create them through trial and error: write a skill, test it, revise it, and hope it performs better. In this episode, we explore SkillOpt, a framework that treats skills not as static prompts but as trainable artifacts. Instead of manually rewriting instructions, SkillOpt uses evaluation, feedback, and optimization loops to systematically improve a skill over time. You’ll learn: * How SkillOpt reframes prompt engineering as skill training: why skills can be treated as trainable external state and how optimization happens without changing model weights. * What the experiments reveal about skill optimization: where the largest gains appear, why skill transfer works across models, and the practical limits of optimizing instructions instead of model parameters. * How to apply SkillOpt yourself: reproducing the workflow on SearchQA, training skills on your own datasets, and evaluating whether optimization delivers measurable improvements over baseline prompting. By the end, you’ll understand when skill optimization is worth the additional compute, where it outperforms traditional prompt engineering, and why training instructions may become as important as training models in future agent systems. If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • May 20 · 15 min

    PODCAST — Score-Based Causal Discovery with LLMs

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Constraint-based methods discover causal graphs by testing independences. Score-based methods take a different route. They treat causal discovery as a model selection problem, scoring candidate graphs and searching for the one that best balances fit and complexity. In this episode, we explore how score-based algorithms learn causal structure, why they hit the same identifiability ceiling as constraint-based methods, and how LLMs can be plugged into the search itself rather than just bolted on at the end. You’ll learn: * How score-based methods differ from constraint-based ones: why framing causal discovery as model selection changes both the search procedure and the kinds of errors the algorithm makes. * Where LLMs can intervene in score-based pipelines: the five integration points, from hard constraints to iterative agentic loops, and which ones are recoverable when the LLM is wrong. * How to pick the right algorithm and LLM integration strategy: comparing priors, post-hoc orientation, and score augmentation on the Adult Census Income dataset, and what each one is worth in practice. By the end, you’ll have a clear view of where score-based methods sit relative to constraint-based ones, and a practical map of how to combine statistical search with LLM-derived priors without letting the LLM override the data. If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • May 7 · 11 min

    PODCAST — LLMs in Causal Discovery: A Deep Dive into Constraint-Based Algorithms

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Most ML models answer one question: what is likely to happen? The harder question is what will change if you intervene. That gap is where causal reasoning begins. In this episode, we explore how constraint-based algorithms learn causal structure directly from data, and how LLMs can step in to resolve what statistics alone cannot. You’ll learn: * How PC, FCI, and RFCI discover causal graphs using conditional independence tests, and what assumptions each one makes. * How to encode domain knowledge as hard constraints, so the algorithm stops producing edges that are statistically plausible but practically nonsensical. * How LLMs can review and refine the output graph, resolving ambiguous orientations with domain reasoning when the data runs out of signal. By the end, you’ll have a clear picture of a three-layer pipeline that combines statistical discovery, expert constraints, and LLM review into a coherent approach to causal graph learning. If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • March 10 · 5 min

    PODCAST — Building Claude Skills: A New Paradigm for Interacting with LLMs

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Large language models are powerful, but relying on prompts alone quickly becomes fragile and difficult to scale. As teams try to operationalize LLMs in real workflows, traditional documentation and ad-hoc prompting start to break down. In this episode, we explore a new paradigm introduced with Claude Skills: packaging workflows, instructions, and resources into reusable capabilities that LLMs can execute. You’ll learn: * Why traditional documentation is poorly suited for LLMs and why workflow-first instructions are more effective. * How Claude Skills structure tasks using a concise SKILL.md file that points to supporting files and scripts loaded on demand. * How teams can design and deploy skills to turn LLMs into reliable task executors rather than prompt-driven tools. By the end, you’ll understand how skills move us from prompt engineering to designing AI-native workflows. If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • March 5 · 5 min

    PODCAST — Understanding User Intent Through AI Bot Traffic: A Practical Framework

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. AI assistants are quietly reshaping how people discover products and documentation online. But most analytics systems treat AI bot traffic as noise, filtering it out instead of learning from it. In this episode/article, we explore how to uncover real user intent hidden inside AI assistant traffic and turn bot logs into actionable insights for product and SEO teams. You’ll learn: * Why AI assistant traffic is fundamentally different from traditional bot traffic, and why filtering it out creates a major blind spot in modern analytics * How prompts sent to tools like ChatGPT, Claude, or Perplexity translate into bot visits, and what these patterns reveal about real user questions, product research, and integration needs * A practical framework for analyzing AI bot logs, helping teams extract user intent signals that can inform documentation improvements, product decisions, and SEO strategy If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • February 10 · 6 min

    PODCAST — Long-Term Memory: Unlocking Smarter, Scalable AI Agents

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Most agent systems reason well in the moment but fail to improve over time because they forget everything once execution ends. In this episode, we explore how to design long-term memory for LangGraph agents, moving beyond short-term context toward durable, structured memory that remains transparent and controllable. You’ll learn: * Why long-term memory is an architectural problem, not a prompt-engineering trick, and how different memory types (working, semantic, episodic, procedural) interact in agent systems * What LangGraph provides out of the box for memory management—and where it stops, especially when building agents that must persist, update, and reason over memory across sessions * How to implement schema-driven long-term memory with Trustcall, enabling safe extraction, controlled updates, and debuggable memory writes inside LangGraph nodes If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • Nov 27, 2025 · 7 min

    PODCAST — Scaling LangGraph Agents: Parallelization, Subgraphs, and Map-Reduce Trade-Offs

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Agent systems break down when simple workflows evolve into tangled 30+ node graphs with unclear dependencies and sequential bottlenecks. In this episode, we explore how to scale LangGraph architectures through strategic parallelization, modular subgraphs, and dynamic task distribution. You’ll learn: * When to use parallel execution vs. sequential flows and how to manage concurrent state updates with reducers? * How to structure multi-agent systems using subgraphs with either shared or isolated states? * When dynamic map-reduce patterns outperform static parallelization for variable workloads If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • Nov 20, 2025 · 7 min

    PODCAST — Human-in-the-Loop Agents: Steering AI with LangGraph’s Streaming, Breakpoints (Part 3)

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Autonomous agents promise efficiency, but without visibility and control, they risk costly mistakes before anyone can intervene. In this episode, we explore how to transform AI agents from opaque black boxes into steerable, inspectable systems using LangGraph’s human-in-the-loop capabilities. You’ll learn: * How streaming exposes an agent’s reasoning in real-time, from token generation to state transitions, building trust through transparency * How breakpoints enable surgical intervention at critical decision points, allowing humans to approve, reject, or correct actions mid-execution * How time travel lets you rewind to any prior state, fork alternative reasoning paths, and explore “what-if” scenarios without restarting from scratch If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • Nov 6, 2025 · 5 min

    PODCAST — Beyond the Demo: Building AI Agents Remember, Recover, and Scale (Part 2)

    Prefer reading instead? The full article is available here. Demo agents are easy to build, until they crash mid-execution, lose conversation context, or explode your token budget. In this episode, we explore the three critical mechanisms that transform fragile prototypes into production-grade AI systems. You’ll learn: * How to optimize state with reducers and caching — managing growing state efficiently through composable update functions and skipping expensive recomputation through intelligent caching strategies. * How to implement persistence and memory — maintaining state across sessions, preserving conversation history, and ensuring agents remember what they’ve already done to avoid redundant work * How to build fault-tolerant systems with checkpointers — saving state at every step, resuming execution from any point, and recovering gracefully from failures without losing progress If you’d rather read than listen, the full article (with code examples, implementation patterns, and debugging strategies) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • Oct 28, 2025 · 7 min

    PODCAST — From Chains to Graphs: Smarter and Safer Agentic Systems with LangGraph (Part 1)

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Linear AI chains fail the moment reality gets messy: when APIs break, reasoning loops infinitely, or context is lost between steps. In this episode, we dive into how LangGraph reimagines agent design with stateful, graph-based reasoning that mirrors how scientists actually think. You’ll learn: * Why linear chains can’t handle non-linear thought or adaptive reasoning * How graph-based agents recover from failures using state, loops, and conditional logic * How LangGraph Studio and LangSmith provide full observability—from local debugging to production monitoring If you’d rather read than listen, the full article (with diagrams, code examples, and implementation details) is available on Substack: 👉 Enjoyed this episode? Subscribe to The AI Practitioner to get future articles and podcasts delivered straight to your inbox. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • Oct 7, 2025 · 10 min

    PODCAST — AgentOps: Operational Frameworks for LLM-Powered Agent Systems

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Real-world AI agents fail differently than traditional software, silently, with confident hallucinations instead of error codes. In this episode, we explore how AgentOps adapts DevOps principles to handle the unique challenges of LLM-powered systems. You’ll learn: * Why agent systems require fundamentally different operations than traditional ML models * How the AgentOps lifecycle handles probabilistic reasoning and semantic failures * How to implement production-grade observability using MLflow’s tracing, prompt management, and evaluation capabilities If you’d rather read than listen, the full article (with code, implementation details, and comprehensive examples) is available on Substack: 👉 Like this kind of content? Subscribe to get future articles and episodes delivered straight to your inbox as soon as they’re published. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

  • Jul 31, 2025 · 7 min

    PODCAST — Balancing Conflicting Goals: A Practical Guide to Multi-Objective Optimization with Pymoo

    Prefer reading instead? The full article is available here. The podcast is also available on Spotify and Apple Podcasts. Subscribe to keep up with the latest drops. Real-world decisions often involve conflicting objectives, like boosting sales while avoiding overstock. In this episode, we explore how multi-objective optimization (using NSGA-II with the pymoo library) can model and solve such dilemmas. You'll learn: * Why traditional dispatch strategies fall short * How Pareto fronts reveal optimal trade-offs * How to apply ASF and Pseudo-Weights to guide final decisions If you’d rather read than listen, the full article (with code, charts, and detailed examples) is available on Substack : 👉 Like this kind of content? Subscribe to get future articles and episodes delivered straight to your inbox as soon as they’re published. Get full access to The AI Practitioner at aipractitioner.substack.com/subscribe

Showing 1–20 of 20 episodes