Discover
Pop Goes the Stack
Pop Goes the Stack
Author: F5
Subscribed: 1Played: 16Subscribe
Share
© 2026 F5
Description
Explore the evolving world of application delivery and security. Each episode will dive into technologies shaping the future of operations, analyze emerging trends, and discuss the impacts of innovations on the tech stack.
70 Episodes
Reverse
AI agents are no longer “features,” they’re becoming enterprise citizens with identities, permissions, runtimes, and a very real need for governance. In this episode of Pop Goes the Stack, Lori MacVittie and Joel Moses unpack Microsoft 365’s emerging agent ecosystem, including the idea of an “agent OS,” execution containers, agent frameworks, and identity initiatives like Entra Agent ID. The promise is clear: give enterprises a structured way to manage autonomous work before it spirals into entropy. F5's Chief Digital Officer Alvina Antar joins the conversation to challenge a single-vendor worldview. As enterprises operate in hybrid, multi-cloud environments, they need neutrality, model choice, and a shared AI foundation that can evolve as new models and capabilities appear weekly. The discussion highlights why governance can’t be bolted on after the fact, and why security, semantic layers, routing, and prompt protections must be part of the foundation, not an afterthought. The episode also reframes “shadow AI” and “shadow agents” as a discovery and rationalization problem, not just something to shut down. When everyone can build agents through low-code tooling, IT can’t simply say no. Instead, organizations need visibility, guardrails, and controls that enable safe innovation across the business. A key takeaway is that agent identity is only the start. Enterprises must treat agents like employees from an IT lifecycle perspective, with structured onboarding, ownership, least-privilege permissions, time-boxed access, approvals for risky actions, and real offboarding to avoid orphaned agents and service-account style breaches. Ecosystems can help you start, but most organizations will still need to build their own path to interoperable, governed autonomy.
Vibe coding is moving fast, but is it moving software forward or just piling up a new kind of debt. In this episode of Pop Goes the Stack, F5's Lori MacVittie and Joel Moses are joined by Narayan Veeramani to dig into what happens when AI-generated code lands in real production environments, long after the demo passes and the pull request looks “clean.”They break down how today’s coding assistants can produce working code at unprecedented speed, while humans still have to read, review, and maintain it at human speed. The result is what the team calls comprehension debt: code that appears correct, ships quickly, and then becomes a 3 a.m. incident because no one truly understands its assumptions, its architecture, or its operational impact.The conversation also highlights why green tests can be misleading when AI generates tests from its own code instead of from the spec or requirements, reinforcing incorrect assumptions like a US-only interpretation of “Thanksgiving promotions.” Joel adds an architectural cautionary tale where “beautiful” async logic passed mocks but hammered a production database with inefficient query patterns.The takeaway is practical and direct: vibe coding doesn’t eliminate engineering rigor, it changes where the rigor must happen. Bring context into prompts, generate tests from specifications, review continuously instead of in a big-bang PR, and ensure someone accountable can explain the code in an audit or an outage. AI can handle the mechanical work, but teams still own what they ship.
AI outputs may be polished, but in this episode of Pop Goes the Stack, F5's Lori MacVittie, Joel Moses, and returning guest Ken Arora focus on what happens when confidence meets real-world access. The discussion moves past model capabilities and into the operational reality that many organizations are already granting agents serious privileges, including direct read/write access to production databases and automated triggers into external SaaS systems. From there, the team tackles the uncomfortable truth: governance is arriving late. Retrofitting controls onto agents that are already running in production is difficult, and sometimes dangerously naïve, especially when teams assume simple technical guardrails are enough. Ken shares an example where limiting agents to GET requests still allowed unintended “write” behavior via legacy web patterns, underscoring how easy it is for controls to miss the real intent of an action. The conversation also challenges familiar analogies. Treating agents like functions-as-a-service can help frame lifecycle management, logging, and permissions, but agents aren’t deterministic and they aren’t truly stateless. Add natural language instructions and goal-seeking behavior, and you get a new class of risk: the system you’re trying to govern will actively work around restrictions to accomplish its task. They wrap with a practical mindset shift: governance isn’t a brake on AI adoption, it’s what enables safe scale. But getting there will require better behavioral detection, clearer boundaries, and an honest look at the cost and complexity of controlling “cron jobs with a brain” before hallucinations turn into production incidents.
AI may be rewriting workflows and reshaping infrastructure, but this episode of Pop Goes the Stack argues that the future still depends on an old, unglamorous constant: DNS. F5's Lori MacVittie and Joel Moses are joined by Griff Shelley to unpack why “it’s always DNS” is more than a running joke when you’re building and operating AI systems at scale.The conversation breaks down how modern AI stacks lean on DNS everywhere, from Kubernetes service discovery to reaching storage endpoints, analytics APIs, vector databases, and external model providers. As agentic traffic grows, the issue isn’t just more lookups, it’s a different traffic profile entirely. Agents behave like software, not people, producing bursts of legitimate, high-speed requests that can overwhelm assumptions built on caching and human-paced interaction. The result is that small DNS latency spikes can compound into visible stutter in chat experiences, slow agent workflows, and cascading bottlenecks across clusters.Joel and Griff also explore how DNS is evolving from a simple directory into a potential carrier for trust and discovery, including emerging ideas like AI Agent Discovery, alongside more advanced routing needs such as global load balancing and selecting the best available compute resources.The practical takeaway is straightforward: treat DNS as critical AI infrastructure. Know where your DNS lives across clouds and Kubernetes, measure its performance, and make it a priority before it becomes the hidden limiter of everything you’re trying to accelerate.
AI is everywhere, but success metrics and security controls haven’t quite caught up. In this episode of Pop Goes the Stack, hosts Lori MacVittie and Joel Moses are joined by Lee Ennis to unpack “agentic fingerprints,” the behavioral traces AI agents leave behind as they move through applications and networks. AI agents aren’t your typical bots, and they’re definitely not “fast humans.” They’re tireless, API-hungry systems that optimize relentlessly, ignore UI conventions, and can blow past policies and rate limits without even noticing. The conversation explores how modern fingerprinting shifts from identifying a single device to recognizing workflows, cadences, and decision paths. Lee explains how patterns in form-filling, sequencing, and even language structure can help distinguish one model family from another, and why that matters for both security and governance. The team also digs into the practical upside: fingerprinting isn’t just a defensive measure, it’s a powerful debugging and improvement loop for non-deterministic systems, helping teams trace undesirable outcomes back to a few key decisions and eliminate entire branches of failure. They close with a clear call to action: start with observability. Capture the right traces in a safe sandbox, cluster and analyze behaviors, and use the data to make AI systems more explainable, controllable, and resilient before they go fully wild in production.


