Most of what sounds complicated about building with language models comes down to a handful of decisions. Who owns the control flow, your code or the model? When does a capability deserve to be an agent, and when is it just a well-designed set of tools? What does it actually cost to put something in the context window, and who pays for it on every turn?
Build with the Azure OpenAI API is the podcast companion to the course of the same name. Each episode takes one salient point, one technique, or one new technology from the course and gives it ten to twelve minutes of clear, conversational attention. The mental model that makes agents make sense. Why you don't need an agent for that. The Decisions API and the end of parsing. The economics of context, retrieval that grew up, MCP without the mystique, and skills as the specialist who doesn't need a desk. It closes where regulated firms have to: evaluation as a control, prompt injection as a property to contain, and approval as an architecture.
The point of view is an architect's, with the cost, latency, security and governance angle on everything. But if you're an engineer, a technical lead, or anyone trying to build something real on these APIs, you'll find the ground is the same. Every number and every claim traces back to the course, which cites its sources. The audio is AI generated.
Million-token context windows were supposed to make retrieval obsolete. The prediction keeps not coming true, and the reasons why are the design constraints of any knowledge architecture you'll build. This episode covers what good retrieval looks like now, the quiet breakthrough of fixing chunks instead of queries, and the genuinely new decision: should your code drive the search, or should the model?
11 Nov 2026
The Economics of Context
Model prices get the headlines, but architecture decides the bill. Two systems on the same model can differ in cost per request by a factor of fifty. This episode explains the unusual shape of language model pricing, then walks through the three levers that move cost and latency more than any model choice: prompt caching, routing, and context discipline. Plus the one dynamic value that silently makes your prompt cost ten times more.
11 Nov 2026
Approval is an Architecture
For a decade, "human in the loop" was a reassuring phrase on a slide. That era is over, because the machines now act, and US regulators have noticed. This episode walks through what FINRA, the banking supervisors and Treasury now expect of firms running agents, how the approval checkpoint is becoming standard protocol plumbing through MCP elicitation, and the subtle failure the protocol doesn't solve for you: proving that what executed is what the human actually approved.
11 Nov 2026
The Specialist Without the Headcount
Every new procedure arrives looking like a case for a new specialist agent. Skills are the industry's answer, and they arrived fast: Anthropic released the format in late 2025, opened it as a standard, and within weeks OpenAI, Microsoft and GitHub had adopted it. This episode explains what a skill actually is, how progressive disclosure makes expertise nearly free until it's needed, and why a skill gives you most of what a specialist agent promised without the second loop, the second context, or the network hop.
11 Nov 2026
MCP Without the Mystique
Few acronyms have traveled from a vendor blog post to board-level slides as fast as MCP. Most of what firms believe about it is myth. This episode strips the Model Context Protocol back to what it actually is, plain plumbing with a network effect, busts the three myths that distort architecture decisions, and explains why the newest revision quietly removed the one complaint that was true.
11 Nov 2026
The End of Parsing
For their first few years, language models communicated in the one format no contract can bind: prose. Strict structured outputs change that at the decoding level, turning a text generator into a typed component. This episode explains how constrained decoding works, the one thing it can't promise you, and why a schema is what finally makes AI steps composable with everything else you run.
11 Nov 2026
The Decision Layer
Everyone pictures language models generating text. The less famous half of the technology is judgment, and it's about to change where models belong in your architecture. This episode is about the Decisions API: a model that doesn't write anything, just picks from options you define, in about two hundred milliseconds, with calibrated probabilities you can govern. It competes with your rules engine, not your chatbot.
11 Nov 2026
You Don't Need an Agent for That
The reflex in every AI program is to make each new capability an agent. The companies that build these models say don't. In this episode we get to the one question underneath the whole agent-versus-workflow debate, learn why a business domain doesn't need to be a conversational agent, and walk away with the four limits that make autonomy safe to run in production.
11 Nov 2026
The Brain and the Hands
Almost everyone starts with the wrong picture of what an AI agent is, and that picture quietly shapes how they build, secure and govern these systems. In this opening episode we fix it with a single sentence, trace one real question all the way through the machine, and discover that the mysterious "orchestration layer" everyone keeps drawing on whiteboards doesn't exist.
Contact Build with the OpenAI API
Guest appearances
Does not typically book guests
Based on episode analysis; this does not confirm that the show is currently accepting guests.
Host of Build with the OpenAI API?
Claim your podcast to manage its listing and keep your show details accurate.
Pod Engine is an independent podcast discovery and analytics service and is not affiliated with or endorsed by this podcast. Artwork and show content belong to their owners. Full legal notice.
Explore this show Podcast research with Pod Engine
