AI-Driven PHP Flaws Threaten 70% of Web as Legacy Systems Stall Fixes
IBM
Automated AI auditing tools uncover runtime vulnerabilities faster than underfunded open-source maintainers can patch them, forcing organizations into costly modernizations to prevent remote takeovers of fragile infrastructure.
AI-assisted summary of AI exposes a major web security flaw, plus a new kind of voice model — original source. Check the original for full context.
Source published:
Key ideas
- Security researchers using AI systems discovered PHP2Shell, a critical remote code execution vulnerability impacting PHP, which powers approximately 70% of websites worldwide. (0:00)
- Block subsidiary Dessa unveiled a full-duplex conversational voice model trained directly on raw speech without text tokens, enabling natural human backchanneling and interruptions. (13:58)
- Cohere's Cultural Riddles benchmark reveals that current LLM evaluation rubrics penalize models for admitting ignorance, creating a mathematical incentive to hallucinate or guess. (25:00)
- At IBM Tech Exchange, IBM Data CTO Kyo Gabriel introduced the 'Streamhouse' architecture, shifting lakehouse workloads directly into Apache Flink streaming frameworks to support sub-second operational AI agents. (32:15)
Detailed notes
## Background Published by IBM on their web and RSS podcast feed on October 30, 2026, this episode of Mixture of Experts features host David Zax alongside Ash Minhas, Judith Aquino, and Jessica Nahulan. According to the show description, the panel discusses how AI is stressing critical digital systems, examining the PHP2Shell vulnerability, aging software maintenance, and modern AI model evaluation.
## TL;DR The panel opens by exploring the PHP2Shell vulnerability, examining how AI-driven exploit discovery places immense pressure on brittle legacy infrastructure and understaffed open-source maintainers. They next scrutinize Block and Dessa's textless full-duplex voice model, debating whether realistic conversational interruptions compensate for severe hallucination risks and a lack of grounding. Shifting to AI testing, the group explores Cohere's Cultural Riddles benchmark to illustrate how wordplay and flawed scoring metrics trip up traditional language models. The episode concludes with a field dispatch from IBM Tech Exchange, where IBM Field CTO Q Gabriel explains the emergence of 'Streamhouse' architectures designed to supply real-time streaming data context to autonomous software agents.
## Atmosphere & style The discussion carries a lively, collegial roundtable atmosphere, balancing deep technical analysis with dry engineering humor about 1990s hobbyist code and models fixated on calling every user 'Reynaldo.' David Zax guides the conversation with inquisitive energy, allowing panelists to challenge corporate hype and unpack software archaeology through relatable, vivid analogies. The broadcast transitions from spirited, critical debates on model architecture to a grounded, pragmatic field dispatch that captures the operational realities of modern enterprise computing.
## Bulletin - `00:00` Security researchers using AI systems discovered PHP2Shell, a critical remote code execution vulnerability impacting PHP, which powers approximately 70% of websites worldwide. - `13:58` Block subsidiary Dessa unveiled a full-duplex conversational voice model trained directly on raw speech without text tokens, enabling natural human backchanneling and interruptions. - `25:00` Cohere's Cultural Riddles benchmark reveals that current LLM evaluation rubrics penalize models for admitting ignorance, creating a mathematical incentive to hallucinate or guess. - `32:15` At IBM Tech Exchange, IBM Data CTO Kyo Gabriel introduced the 'Streamhouse' architecture, shifting lakehouse workloads directly into Apache Flink streaming frameworks to support sub-second operational AI agents.
## Key takeaways - `00:00` PHP underpins roughly 70% of global web infrastructure despite the PHP Foundation operating with only a single full-time employee, highlighting severe open-source maintenance risks. - `05:00` AI vulnerability discovery tools are finding software exploits faster than legacy web organizations can patch them without breaking delicate dependencies. - `02:37` Remote code execution flaws in server runtimes compromise internal databases and network boundaries, rendering perimeter defenses like WAFs and DMZs ineffective. - `05:00` Generative AI disrupts the software industry's historical 'build and abandon' habit by accelerating the need for proactive tech stack modernization. - `10:00` Decades of technological abstractions piled on top of 1990s hobbyist codebases can now be decoded and rewritten more effectively using modern AI tools. - `13:58` Block's Dessa model operates in full duplex, listening and generating conversational cues like laughs or 'hmm' simultaneously rather than waiting for silent pauses. - `16:40` Bypassing text token training in voice models severely restricts their world knowledge grounding, leading to increased factual hallucinations. - `20:00` Interactive voice models require an entirely new evaluation paradigm focused on conversational hesitation and interruption dynamics rather than standard text benchmarks. - `23:05` Cultural riddles disrupt conventional LLM pattern matching because metaphorical and creative wordplay cannot be resolved by standard literal training. - `25:00` Traditional AI benchmark scoring rubrics inadvertently reward random guessing over answering 'I don't know' due to positive expected payoffs. - `30:00` The operational data exhaust generated by fleets of autonomous agents is forcing mid-sized enterprises to adopt high-throughput streaming systems. - `32:15` The Streamhouse data pattern shifts analytical lakehouse operations leftward into streaming engines like Apache Flink to feed autonomous agents real-time context. - `34:55` Generative AI lowers the steep barrier to stateful stream processing by automatically converting lakehouse batch queries into real-time streaming jobs. - `36:45` Agentic deployments necessitate a fundamental rethinking of identity architecture from static human credentials to short-lived machine credentials.
## Detailed walkthrough ### `00:00` Introduction and the PHP2Shell Threat
Host David Zax opens the show by marveling at the humble origins of PHP, noting how remarkable it is that a piece of software originally written by someone just to avoid writing code for their personal homepage has expanded into an engine powering roughly 70% of the entire internet. Zax welcomes listeners to *Mixture of Experts*, IBM’s weekly AI news podcast, introducing the week’s expert panel: Ash Minhas, Practice Manager for Technical Content; Judith Aquino, Staff Writer at *IBM Think*; and Jessica Nahulan, Master Inventor and Lifecycle Management Team Lead for IBM Business Automation Workflow. Later in the episode, the panel will also hear from Q Gabriel, IBM Field CTO for Data, reporting live from the floor of IBM Tech Exchange—the company's annual conference for hands-on demonstrations, builders, and engineers.
Before previewing upcoming discussions on a textless conversational voice model from Block (Dessa) and a cultural riddle benchmark designed to stump large language models, the conversation turns immediately to breaking cybersecurity news: the emergence of "PHP2Shell." Security research firms recently leveraged AI systems to uncover severe vulnerabilities inside PHP itself. When asked to lay out the critical stakes, Judith Aquino explains that because PHP undergirds roughly seven out of every ten websites, an exploit permitting remote server takeover is catastrophic. The core dilemma lies in remediation: organizations running older versions cannot simply apply a patch, because doing so risks breaking fragile, interconnected legacy applications. While the exploit chain is complex to execute, Aquino underscores the broader implication:
> “The somewhat good news, as our friends at Security Intelligence mentioned, is that the exploit chain isn't exactly easy to take advantage of, but it still shows how vulnerable we are as given the fact that these security flaws were found with AI models, which are making it easier to find vulnerabilities to exploit.”
- **Episode Lineup:** PHP2Shell and AI-assisted vulnerability discovery; Dessa (Block's voice-to-voice model trained without text); the Cultural Riddles benchmark; and field reports from IBM Tech Exchange with Q Gabriel. - **PHP Scope:** Powers approximately 70% of all websites globally. - **Core Risk:** Potential remote code execution (RCE) leading to full server takeover, complicated by legacy dependencies that make immediate upgrading dangerous for existing infrastructure.
---
`02:37` The Architecture of Remote Code Execution and Network Exposure
David Zax asks why PHP2Shell broke out of standard developer circles and reached front-page news, given that software bugs surface every week. Ash Minhas explains the mechanics that make remote code execution on internet-facing web servers particularly lethal. A typical web architecture links the front-facing web server directly to backend databases and internal resources to handle incoming user queries. If an attacker gains arbitrary code execution privileges on that machine, they immediately inherit access to internal networks and privileged credentials that were never meant to be publicly accessible. Minhas illustrates the sheer intrusion by comparing it to walking into private quarters:
> “So, in essence, it's like having the keys to someone else's hotel room, for example, long after you should have and being able to do whatever you like there.”
Minhas points out that large enterprise environments may have specialized network architects who segregate web servers within a demilitarized zone (DMZ) or protect them behind web application firewalls (WAFs). However, even robust perimeter defenses fail to neutralize vulnerabilities embedded directly within the server runtime itself. For smaller organizations, personal blogs, or small businesses lacking enterprise-grade topology, the situation is far worse: their systems sit completely exposed on the public internet as open targets.
```mermaid flowchart TD accTitle: Attack Flow of PHP2Shell Remote Code Execution accDescr: Diagram showing how an internet attacker exploits the PHP runtime on an exposed server to reach internal networks and databases.
subgraph External ["Public Internet"] Attacker["Remote Attacker / AI Agent"] end
subgraph Perimeter ["Perimeter Defenses"] WAF["Web Application Firewall (WAF)"] DMZ["DMZ / Network Boundary"] end
subgraph Target ["Target Server"] Runtime["Compromised PHP Runtime<br/>(PHP2Shell Vulnerability)"] Credentials["Stored Credentials & Secrets"] end
subgraph Internal ["Internal Resources"] DB[("Backend Databases")] IntNet["Internal Network Systems"] end
Attacker -->|"Bypasses / Passes Through"| WAF WAF --> DMZ DMZ --> Runtime Runtime --> Credentials Runtime -->|"Unauthorized Access"| DB Runtime -->|"Pivots to"| IntNet ```
- **Threat Scope:** Attackers gain arbitrary command execution, enabling them to misuse the compromised host, inspect database records, and harvest system credentials. - **Architectural Failure:** Standard protections such as WAFs and DMZ segregation are insufficient against flaws native to the language runtime executing the application. - **Disproportionate Impact:** While enterprises may have mitigation layers, smaller sites and individual owners lack complex network topologies and remain defenseless "sitting ducks."
---
`05:00` The Developer Dilemma: From "Set and Forget" to Forced Modernization
Zax contrasts PHP2Shell with typical application-level bugs—such as a security flaw in Microsoft Word that can be patched with an automatic background update—noting that PHP constitutes the underlying infrastructure of the web itself. Turning to Jessica Nahulan, an IBM Master Inventor who has built and deployed web systems, Zax asks how hands-on software practitioners are processing the revelation. Nahulan observes that the industry has long operated under a "build, deploy, and abandon" mentality: businesses launch a web application, verify it functions, and subsequently reassign or downsize the maintenance teams because the software appears stable.
The rise of generative AI and automated vulnerability tooling disrupts this model entirely. AI can now systematically scan the open web, identify legacy dependencies, inspect open-source libraries that have a single maintainer updating code once every two months, and probe for exploitation paths at machine speed. Consequently, the industry faces an unavoidable, costly reckoning across full technology stacks:
> “Before modernizing was almost like this nice to have. Now everyone is forced to modernize so that we are ready to pick up the latest versions of these fixes and these dependencies without breaking our infrastructure.”
- **The Legacy Workflow:** Solutions were historically deployed and left unattended without ongoing oversight as long as they remained functional. - **The AI Acceleration:** Automated agents can scan abandoned websites, identify archaic PHP frameworks, and pinpoint vulnerable dependencies far faster than humans can audit them. - **Shift in Engineering Priority:** Modernizing tech stacks has transformed from an optional operational enhancement into an urgent defensive necessity to allow continuous patching without service disruption.
---
`07:29` AI Probing and the Open-Source Maintenance Crisis
David Zax turns to the unusual circumstances surrounding the discovery and disclosure of the vulnerability. While components of the underlying bugs were known in earlier years, their severity was heavily underestimated. During the summer, security firm Wiz and another security research group independently aimed AI models at PHP codebases to surface obscure flaws. Both groups converged on the critical vulnerabilities and initiated coordinated disclosure with the PHP Foundation—the entity tasked with maintaining the core language of the web. Zax highlights an astonishing operational mismatch: despite PHP running 70% of the web, the PHP Foundation employs only a single full-time employee.
Ash Minhas validates this concern, noting that ubiquitous content management systems like WordPress and Joomla are the primary reason PHP dominates the internet. Having set up those platforms for friends, family, and past projects himself, Minhas points out that society has developed a complacency toward open-source infrastructure: people assume that if code works and is free, someone else will handle the maintenance and security response. As autonomous agents accelerate the rate of exploit discovery, the disparity between volunteer maintainers and AI-driven adversaries threatens to collapse open-source sustainability:
> “And with the advent of generative models and AI agents and finding vulnerabilities and exploits quicker than a human being can without an equal level of investment in that time and money, okay, and resource, it will be very difficult for us to sort of like try to close that gap between discovering something and being able to resolve it.”
- **Discovery Timeline:** Wiz and peer researchers directed AI systems to probe PHP source code over the summer, uncovering severe exploit paths that previous human audits had overlooked. - **The Maintenance Mismatch:** The PHP Foundation oversees the engine of 70% of the web with only one full-time employee on staff. - **The Open-Source Paradox:** Millions of individuals and enterprises consume free open-source software (WordPress, Joomla, runtime libraries) without reinvesting resources back into long-term maintenance and patch management.
`10:00` Software Archaeology, Abstraction Layers, and Modernizing Legacy Code
Ash Minhas and David Zax dive into the origins of PHP, noting that Rasmus Lerdorf originally built it back in 1994. Although Lerdorf was a skilled programmer, he famously joked at the time that he wasn't a "real programmer" and merely threw the software together so he would have to write less code for his personal homepage. Zax finds it astonishing that something thrown together to avoid writing code now powers roughly 70% of the modern internet. He offers an analogy: it is like waking up to discover that all the concrete underpinning the skyscrapers of New York City was mixed in someone’s backyard while playing with Play-Doh, only for everyone else to say, "Give me some," and proceed to build an entire metropolis on top of it.
```mermaid flowchart TD accTitle: The Fragile Software Abstraction Stack accDescr: Diagram illustrating how modern technology piles abstraction layers on top of 1990s hobbyist code, creating systemic security and architectural risks.
subgraph UserFacing ["Modern Ecosystem"] App["Modern Applications & Services"] Dep["Libraries & Blind Dependencies"] end
subgraph LegacyFoundation ["Archaeological Layers"] Abs["Decades of Abstraction Layers"] Kernel["1994 Quick Hack / Hobbyist Code<br/>(e.g., PHP Personal Home Page)"] end
App --> Dep Dep --> Abs Abs --> Kernel ```
When Zax asks whether drilling down into software "archaeology" and finding a cludged-together 1994 kernel is an actual cause for concern, Ash responds from his own hands-on experience, emphasizing how developers routinely pile abstraction layers upon abstraction layers rather than questioning their fundamental components:
> “The world of technology is layers upon layers upon layers of abstraction.” — Ash Minhas
Minhas notes that developers rarely stop to apply first principles; instead, they simply pull in dependencies and run libraries because they do what is needed in the moment, lacking the mental bandwidth to interrogate where the code came from, why it is being used, or whether it can be trusted. Zax draws a comparison to civil engineering, wondering why software does not consistently modernize its foundational layers the way a road outside someone's home is structurally re-engineered over time.
Jessica Nahulan clarifies the gap between standard best practices and day-to-day engineering realities. While teams aspire to completely re-architect fragile, thirty-year-old systems, deadlines, budget limitations, and ongoing maintenance force engineers into "sticking glue and tape and everything on top of your little broken bucket." However, Nahulan sees an upside in modern artificial intelligence tools, arguing that AI allows current engineers to understand and rewrite ancient codebases even when the original creators from decades ago are no longer around:
> “This news article exposes an issue that now we are finding issues faster than ever, but we're also capable of fixing them faster than ever.” — Jessica Nahulan
---
`13:58` Jack Dorsey's Block, Dessa, and the Voice-Native Model
David Zax introduces the segment's second story, turning to Block—the Jack Dorsey-helmed company responsible for Square, Cash App ("the other payments processor for cooler people"), and the music streaming service Tidal. Zax recalls that roughly five or six years prior, Dorsey acquired an artificial intelligence firm called Dessa. The startup gained widespread attention in 2019 for creating an eerily accurate deepfake of podcaster Joe Rogan's voice. After years of quiet development, Dessa announced a novel voice model trained strictly on voice conversations rather than text tokens.
```mermaid flowchart LR accTitle: Turn-Taking vs Full-Duplex Audio Models accDescr: A comparison between traditional conversational models that require silence to process text and fully duplex audio-native models that listen and respond simultaneously.
subgraph StandardModel ["Standard Voice Assistants"] direction TB S1["User Speaks"] --> S2["Model Waits in Silence"] S2 --> S3["Model Responds"] end
subgraph DuplexModel ["Full-Duplex Architecture (Dessa)"] direction TB D1["User Speaks"] <-->|"Simultaneous Audio Stream / Interruption / Backchanneling"| D2["Model Listens & Emits Sounds"] end ```
Judith Aquino explains what makes Dessa's demonstration sound so strikingly natural and uncanny. Unlike traditional voice assistants that sit in dead silence waiting for a speaker to finish their turn, this model operates in a full-duplex manner—it can listen and speak at the same exact time:
> “From the demos, you could hear it interrupting people, even with just like a laugh or like the things that we tend to do when trying to show that we're engaged in a conversation.” — Judith Aquino
Judith highlights that the model effortlessly performs human "backchanneling"—emitting natural conversational cues like saying *"hmm"* or chiming in with socially graceful timing. This dynamic interaction represents a major engineering leap achieved by training natively on raw audio. However, she cautions that Dessa has not yet published an academic research paper or open-sourced the methodology, leaving observers with only web demos to evaluate.
---
`16:40` Duplex Benchmarking, Hallucinations, and the "Reynaldo" Glitch
Zax points out that fully duplex conversational models—capable of streaming bidirectional audio—can theoretically be measured against standard tests like "DuplexBench," yet Dessa declined to release any benchmark scores or empirical performance figures. Ash Minhas voices deep skepticism regarding the decision to bypass text training entirely. Ash argues that eliminating text dramatically curtails the model's overall grounding and breadth of world knowledge:
> “The fact that they're saying that they didn't train it on any text suggests to me that the amount of world knowledge that this model has is more limited.” — Ash Minhas
Minhas notes that because a pure-audio model relies strictly on recorded spoken conversations, it is starved for the massive, structured knowledge bases available in text corpora. Consequently, much like early transformer architectures, it is prone to severe hallucinations. Ash questions how such models can even be systematically evaluated, given that industry-standard benchmarks like MMLU or established coding tests are built for text-based frontier models rather than spontaneous, continuous audio streams. For now, critical operational challenges around controllability, evaluation frameworks, and hallucination suppression remain completely unresolved.
Zax underscores these real-world evaluation quirks with a humorous anecdote from an early demo: the model apparently developed an odd fixation on addressing users as "Reynaldo," regardless of what their actual name was. As Zax quips, the system performs impeccably well if the interlocutor happens to be named Reynaldo, effectively acing the "Reynaldo talking to Reynaldo benchmark," but leaves significant questions about how it was trained and how it operates in broader contexts.
`20:00` Duplex Voice Models, Hallucinations, and the Challenge of New Evaluation Criteria
The panel continues examining the newly unveiled full-duplex voice technology coming out of Block, reacting with both amazement and sharp skepticism. David Zax notes his surprise that major AI announcements were coming out of Block at all, observing that they were hardly on anyone's radar as a frontier research lab, yet their demo delivered an undeniable technical impression. Jessica Nahulan admits that while listening to an agent converse in true full-duplex mode is immediately compelling, learning how little text data went into the training immediately raised red flags for her: “Honestly, echoing Ash in that the first thing I, as soon as I read that they, how much text they essentially trained this model on, my thoughts were, well, then it's everything I dislike in a model.” When a voice model lacks extensive grounding, it sacrifices factual reliability and basic accuracy, meaning users are primarily faced with hallucinations.
At the same time, Jessica ponders whether hallucinations might paradoxically serve a purpose in conversational audio by injecting the spontaneous quirks of an authentic human personality. She humorously frames the concept of conversational interruption: “It can speak to you, but it can now interrupt you. That sounds great. I totally want to be interrupted by my LLM while I'm trying to ask it something.”
This shifts the conversation into an evaluation dilemma. Traditional models like Anthropic's Claude or standard LLMs are graded on precision, factual correctness, and consistency. But an interactive conversational agent introduces entirely different performance metrics: - Detecting conversational hesitation, such as identifying when a speaker pauses and mutters, “what was that movie like...” - Correctly deciding when to interrupt versus when to yield the floor. - Accurately processing human conversational noise, cadence, hesitation tokens, and subtle facial or tonal expressions.
David notes that for now, the system remains a restricted research preview and private beta undergoing security testing rather than a finished commercial product.
```mermaid flowchart TD accTitle: Paradigm Shift in LLM Evaluation accDescr: Contrasting traditional LLM benchmarking criteria with new full-duplex interactive voice evaluation criteria.
subgraph Traditional["Standard LLM Benchmarks (e.g., Claude)"] A1["Factual Accuracy"] A2["Logical Reasoning"] A3["Output Consistency"] end
subgraph Duplex["Full-Duplex Voice Benchmarks"] B1["Interruption Timing"] B2["Hesitation Detection ('um', 'uh')"] B3["Conversational Nuance & Cadence"] B4["Acceptable Personality Quirks"] end
Traditional -.->|"Shifts paradigm to"| Duplex ```
`23:05` Why Cultural Riddles Break Traditional Model Pattern Matching
Turning to the episode's final topic, David introduces an unusual benchmark focused on culturally specific riddles. He demystifies the term for listeners by describing a benchmark as an SAT test for AI models—a standardized battery of difficult math, logic, or reasoning problems used to grade performance across labs. However, testing models with culturally distinct riddles introduces two separate challenges: the nature of riddles themselves and the cultural bias baked into large language models trained on massive, English-dominated internet corpuses.
David invites Judith Aquino to explain why AI researchers have turned to riddles—a practice dating back before ChatGPT's release—rather than sticking exclusively to straightforward academic exams. Judith explains that riddles are uniquely brutal tests for artificial intelligence because they disrupt simple pattern matching: “One of the reasons is that riddles are... especially for models, can be incredibly difficult to solve since it's not just about pattern matching. You need creative thinking and wordplay to solve most riddles.”
David illustrates this with the classic mythological riddle of the Sphinx solved by Oedipus: what walks on four legs in the morning, two legs at noon, and three legs in the evening? Answering “man” or “humankind” requires stretching linguistic definitions beyond literal machine classification. “Morning” represents infancy crawling on all fours, “day” represents walking upright in adulthood, and “night” represents leaning on a cane in old age. Historically, observers assumed algorithmic models would fail to grasp such fluid metaphorical language.
`25:00` Cohere's Cultural Riddles, Flawed Incentive Structures, and the "Spell-Casting" Power of Prompts
Ash Minhas shares that listeners can visit Cohere's Cultural Riddles paper website directly to run through an interactive quiz against an AI, sharing with a laugh that he scored around 80% and managed to beat the machine. Beyond the novelty of riddles, however, Ash argues that the benchmark exposes a fundamental flaw in how AI is evaluated across the board. Under standard scoring conventions, models earn one point for a correct answer, zero points for an incorrect answer, and zero points for saying "I don't know." This creates a perverse mathematical incentive:
$$\text{Expected Score}_{\text{guess}} > \text{Expected Score}_{\text{"I don't know"}} = 0$$
If asked a user's birthday, an LLM faces a 1-in-365 chance of guessing correctly by picking a random date, yielding a non-zero expected payoff, whereas admitting ignorance guarantees zero points. As Ash puts it: “We need to rethink benchmarking in totality in regards to how we evaluate these models.” Furthermore, Ash emphasizes that human culture is an ever-shifting target; without ultra-fast training runs and continuously updated local training data, static models inevitably lag behind living societal contexts.
Closing out the discussion, Jessica Nahulan reflects on the linguistic mechanics behind the study, comparing prompt phrasing to casting spells. A single term holds an internal representation that unpacks into a massive operational request: - A prompt requesting a "PRD" expands into an extensive Product Requirements Document, yet the structure and meaning of a PRD vary wildly across tech organizations. - In the same way, words and concepts expand completely differently across geographic locales, languages, and cultures. - If organizations deploy models globally, they must validate them against the local idioms and cognitive frameworks people use to navigate their world.
`30:00` The Shift from AI Hype to Mature Infrastructure at IBM Tech Exchange
Wrapping up the regular panel discussion with a laugh about model prompts and *Expecto Patronum*, host David Zax transitions to a special bonus segment recorded on October 29th, the final day of IBM Tech Exchange in Atlanta. He is joined by Kyo Gabriel, CTO for Data at IBM. David observes that Kyo had framed the event around an unexpected premise: that what used to be considered "boring" enterprise infrastructure is actually where the most transformative, mature innovations are occurring.
Kyo reflects on attending the major industry conferences over the prior three years, tracing the distinct hype cycles that drove the sector—first retrieval-augmented generation (RAG) and raw large language model (LLM) training, followed over the previous eighteen months by autonomous agents and coding assistants. At Tech Exchange, however, the industry reached an inflection point where organizations are finally getting their hands around fundamental operational mechanics: agent identity, process orchestration, and monitoring. As Kyo Gabriel puts it: “The way that we have to do these in an agentic world has changed in many cases. I would go so far as saying fundamentally.”
Historically, massive data architectures capable of handling continuous real-time streams were the exclusive domain of tech giants like Uber or Netflix. Today, however, the proliferation of autonomous agents generates a relentless volume of "data exhaust." As a consequence, enterprises that previously had modest data requirements now suddenly require hyper-scalable, real-time data platforms.
- Over the past three years, AI industry hype evolved through distinct waves: foundational LLM training, retrieval-augmented generation (RAG), and agentic workflows. - Operational necessities that were historically standard—such as identity management, monitoring, and orchestration—now demand completely redesigned patterns to accommodate autonomous software agents. - High-volume data exhaust created by fleets of concurrent agents is compelling mid-sized companies to adopt streaming infrastructure once reserved strictly for hyperscalers.
---
`32:15` Introducing Streamhouse: Bridging Lakehouses and Real-Time Agentic Data
David asks Kyo to demystify the "Streamhouse" architecture unveiled at the conference and explain why existing paradigms fall short. Kyo walks through the evolution of enterprise data storage: data warehouses historically prioritized rigid structure and archival integrity, whereas data lakes emerged as a catch-all repository where organizations dumped raw, unstructured data to figure out later. The data lakehouse was created to synthesize the best of both worlds by supporting structured and unstructured formats while decoupling compute from storage.
However, modern enterprise data estates remain messy and highly distributed. Because lakehouses were fundamentally engineered for analytical querying rather than sub-second operational loops, they cannot supply context rapidly enough for autonomous agents. To solve this, the Streamhouse model applies a "shift left" strategy, pulling operations traditionally executed downstream in the lakehouse directly into streaming frameworks like Apache Flink. By processing and contextualizing data directly in motion, agents receive low-latency context to act immediately.
```mermaid flowchart TD accTitle: Evolution of Data Architectures to Streamhouse accDescr: Diagram tracing the historical progression from Data Warehouses to Data Lakes, Lakehouses, and finally the real-time Streamhouse architecture.
subgraph Hist["Historical Storage Paradigms"] DW["Data Warehouse<br/>(Structured & Archival)"] DL["Data Lake<br/>(Unstructured Raw Repository)"] end
subgraph Lake["Decoupled Storage & Compute"] LH["Data Lakehouse<br/>(Analytical Compute Separated from Storage)"] end
subgraph Stream["Operational Real-Time Tier"] FL["Streamhouse (Apache Flink)<br/>('Shift Left' In-Flight Processing)"] AG["Autonomous AI Agents<br/>(Real-Time Context & Execution)"] end
DW --> LH DL --> LH LH -->|"Shift Left processing into stream"| FL FL -->|"Sub-second context & state"| AG ```
- **Data Warehouse:** Optimized for strictly structured data and historical/archival analysis. - **Data Lake:** Scalable, centralized dump for structured and unstructured data without upfront governance. - **Data Lakehouse:** Blends both paradigms by separating compute from storage, yet remains inherently tuned for batch and analytical workloads rather than real-time operational execution. - **Streamhouse:** Shifts lakehouse processing into real-time streaming engines (such as Apache Flink) to feed operational agents dynamic context in real time.
---
`34:55` How AI Lowers the Barrier to Stateful Stream Processing
Turning to the technical hurdles of adoption, Kyo addresses why streaming architectures have historically seen slower enterprise uptake compared to standard request-response designs. For decades, developers and software engineers were trained on request-response patterns: applications periodically poll an endpoint, run a database query, and submit an update. Streaming architectures are vastly more resource-efficient and provide seamless, organic responsiveness, but stateful stream processing has a notorious reputation for extreme developer complexity.
Kyo highlights the paradox of modern AI: while agentic workloads create the massive data scale that necessitates streaming, generative AI simultaneously solves the skill barrier that kept developers away. Developers can now direct an AI to generate complex, stateful streaming jobs effortlessly or translate existing lakehouse batch logic directly into streaming code. Reflecting on this turning point, Kyo Gabriel remarks: “The request response architecture, I understood it. That's why I built it. But now I can actually build what I really wanted, which was a better solution for many problems in small and large businesses.”
- Request-response paradigms dominate legacy web and mobile development because stateful stream processing historically presented a steep learning curve. - Streaming architectures dramatically reduce infrastructure resource consumption while providing instantaneous real-time updates across applications. - Generative AI models eliminate the development barrier by translating existing lakehouse pipelines into stateful streaming processing jobs on command. - Organizations that previously never faced massive concurrency challenges are being pushed by autonomous agents into real-time architectural requirements.
---
`36:45` Rethinking Agent Identity and Bridging Builders and Operators
The conversation shifts to the broader architectural ripple effects caused by AI agents, particularly in identity management. Traditional identity infrastructure was built around human beings authenticating with static credentials. Autonomous agents, by contrast, operate at a scale that is orders of magnitude larger, requiring dynamic, short-lived credentials and stringent machine-to-machine boundaries.
Kyo shares feedback from a meeting at Tech Exchange with a major insurance carrier, where enterprise leaders noted that the Streamhouse and agent infrastructure represented capabilities they had sought for years. Beyond data pipelines, AI is beginning to heal the longstanding cultural rift between the teams who build software and the infrastructure operators who run it. Using AI diagnostic and translation tools, operators can inspect precisely how software utilizes underlying systems, while developers gain clear visibility into the downstream operational strain their code introduces. As Kyo Gabriel observes: “It could transform the way that you actually execute your job and the way you actually work with other people. It's very transformative to relationships and the organization.”
David wraps up the segment by thanking Kyo for the live dispatch from Atlanta and bids farewell to listeners, closing out the episode alongside regular co-panelists Ash Minhas, Jessica Nahulan, and Judith Aquino.
- **Agent Identity Dynamics:** Autonomous software entities require an order-of-magnitude increase in programmatic identity handling, relying heavily on ephemeral, short-lived access credentials. - **Operator-Developer Alignment:** AI observability bridges operational divides, allowing system operators to understand application workloads and developers to recognize the systemic footprint of their software. - Host David Zax concludes the episode with a sign-off to panelists Ash Minhas, Jessica Nahulan, and Judith Aquino, inviting listeners to return for the next installment of *Mixture of Experts*.
## Notable quotes > `05:00` Before modernizing was almost like this nice to have. Now everyone is forced to modernize so that we are ready to pick up the latest versions of these fixes and these dependencies without breaking our infrastructure. — Jessica Nahulan
> `10:00` The world of technology is layers upon layers upon layers of abstraction. — Ash Minhas
## Mentioned David Zax, Ash Minhas, Judith Aquino, Jessica Nahulan, Q Gabriel, Kyo Gabriel, Rasmus Lerdorf, Jack Dorsey, Joe Rogan, PHP, PHP Foundation, PHP2Shell, Wiz, Security Intelligence, Block, Dessa, Square, Cash App, Tidal, IBM, IBM Think, IBM Tech Exchange, IBM Business Automation Workflow, WordPress, Joomla, Claude, Anthropic, Cohere, Apache Flink, Streamhouse, Uber, Netflix, DuplexBench, MMLU
## Video description Visit Mixture of Experts podcast page to get more AI content → https://www.ibm.com/think/podcasts/mixture-of-experts This week on Mixture of Experts, host David Zax is joined by Ash Minhas, Judith Aquino and Jessica Nahulan to discuss how AI is testing the systems we rely on, from cybersecurity to model evaluation. First, the panel examines PHP2Shell and what happens when AI can find vulnerabilities faster than organizations can fix them. Can our aging software infrastructure keep up? Next,...
[Source](https://cdnapisec.kaltura.com/p/1773841/sp/177384100/playManifest/entryId/1_0bsajwek/format/download/protocol/https/flavorParamIds/0/name/media.mp3)