The AI Practitioner Podcast

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.What if AI agents could improve their own prompts instead of relying on manual updates? In production, data evolves, models change, and new failures emerge. Keeping prompts effective requires continuous evaluation and refinement, but manually managing this process quickly becomes difficult to scale.TextGrad offers a different approach: it uses natural-language feedback, called textual gradients, to identify errors and automatically update prompts without modifying the underlying model.In this episode, the focus is on how TextGrad works, what a real banking classification experiment reveals about its effectiveness, and the challenges of evaluating prompt improvements when no correct answer exists.You’ll learn:* How can AI agents optimize their own prompts? Exploring how TextGrad turns errors into textual gradients and uses them to automatically update instructions.* Does automated prompt optimization actually improve performance? Examining experimental results, why some updates introduce regressions, and the trade-offs between accuracy, cost, and prompt complexity.* What happens when there is no correct answer? Understanding how LLM judges can guide optimization for open-ended tasks, why their feedback can be misleading, and what reliable evaluation requires.👉 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

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.What if the key to better AI agents isn’t writing better prompts, but making prompts continuously improve?Even carefully designed prompts can fall short in production. Continuous prompt optimization uses real-world execution data, failures, and feedback to refine agent behavior over time, without changing the underlying model.In this episode, the focus is on how continuous prompt optimization works, why static prompts are no longer enough, and how automated feedback loops can improve agent reliability in production.You’ll learn:* Why optimizing text requires a different kind of gradient: How natural-language feedback can play a role similar to numerical gradients in neural network training.* How TextGrad and GEPA optimize prompts offline: How they turn failures into systematic prompt improvements, and the trade-offs between their approaches.* How ACE enables continuous improvement in production: Why repeatedly rewriting prompts can gradually erase useful knowledge, and how incremental updates help preserve it.👉 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

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.What if improving an AI agent’s performance had less to do with choosing a better model and more to do with the system built around it?In one experiment, LangChain improved its coding agent’s benchmark score from 52.8% to 66.5% without changing the underlying model.The difference came from harness engineering: the tools, context management, execution logic, and feedback mechanisms that turn an LLM into a reliable agent.In this episode, the focus is on why harness engineering is gaining attention, how it works, and why it changes the way agent performance should be evaluated.You’ll learn:* Why are better prompts no longer enough? Understanding the challenges of long-running agents, from context degradation and lost progress to unreliable tool use and verification.* What actually makes an agent harness? Exploring the components behind autonomous agents, the approaches used by OpenAI and Anthropic, and the emerging engineering patterns.* Can the same model deliver radically different results? Examining real benchmark experiments, the impact of harness design, and why leaderboard scores may reveal less about model capabilities than they appear to.👉 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

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

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

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

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

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

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

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