The Speed Paradox: How Adversaries Exploit Streaming Data Pipelines

You built for speed. They exploit at speed. Streaming architecture closes the batch pipeline attack surface. It introduces a new one: the speed paradox. An agent that receives real-time context, decides in milliseconds, and acts immediately has no natural friction. If an adversary triggers a wrong decision, the harm propagates at machine speed—faster than any human can intervene. This talk exposes the speed paradox as an attack surface, demonstrates how an adversary exploits the governance gaps in streaming AI infrastructure, and presents the architectural mitigations that close them: action intent events, policy-as-code enforcement, and immutable audit trails embedded in the event stream. Attendees leave with a governance framework—define boundaries, embed enforcement, instrument accountability, assign ownership—that doubles as both defense and adversary detection.

Data Pipeline Attacks: A New Frontier for Offensive AI

Nobody audits the pipeline. Everyone audits the model. That's the problem. Batch pipelines create five predictable failure modes in AI agents. Each is also an attack surface—exploitable today, no zero-day required. This talk exposes them: the extraction window, the fragmented timeline, ghost credentials, silent degradation, and amplified incidents. For each: the architecture that enables it, the exploit pattern that weaponizes it, and the fix that closes it. Attendees leave with a five-question audit and the architectural patterns to harden their AI infrastructure at the layer most security assessments miss. Stop auditing just the model. The data pipeline may well be the attack vector.

Testing for the Failures That Models Don't Cause

Most AI agent failures in production get blamed on the model. In practice, the data pipeline is often the culprit—and standard AI monitoring stacks are blind to it. They track model accuracy and infrastructure utilization. They don't track data freshness, event sequence completeness, ghost records, silent schema changes, or cross-agent coordination conflicts.

This talk walks through five specific detection techniques that expose the failure modes hiding beneath the model layer. How to measure the time delta between an event's occurrence and the agent's receipt of it. How to verify event sequence completeness across batch window boundaries. How to correlate agent actions against change data capture logs to detect decisions made on deleted records. How to catch silent schema changes before they degrade agent decisions. And how to cross-reference agent action logs to identify conflicting remediations before they cascade.

Each technique is presented with the failure mode it detects, the signal it looks for, and the open-source tooling that implements it. Attendees will leave with a testing framework they can integrate into their existing evaluation pipelines immediately.

The Deployment Fallacy: Why Leaders Keep Betting on the Wrong AI Problem

Most AI projects fail to reach production. The failure rate dwarfs that of traditional corporate IT initiatives, and the financial toll persists despite rapid advances in model capability. The standard explanations—bad data, talent shortages, unclear business cases—are not wrong. But they obscure a deeper failure that no amount of model improvement can fix.

The failure is conceptual. Most organizations treat AI as a software deployment problem: select a model, train it on your data, integrate it into your application stack, and go live. This is the Deployment Fallacy—the mistaken belief that the infrastructure which serves human-run operations can also serve autonomous ones. It cannot. Human operators tolerate stale data. They bring context. They notice anomalies. AI agents do none of these things. They act on what they receive, when they receive it.

This talk provides leaders with three diagnostic questions that expose the Deployment Fallacy in their own organizations. Is your data infrastructure built for human operators or autonomous agents? Is your network optimized for users or AI workloads? If an AI agent makes a wrong decision at machine speed, what stops it? Each question addresses a specific infrastructure gap that the Deployment Fallacy causes leaders to overlook.

The organizations that will lead the next phase of enterprise AI are not those with the most sophisticated models. They are those whose leaders have the discipline to ask three questions that most of their peers are not asking. The model is not the bottleneck. The infrastructure is. And infrastructure is not a technical decision—it is a leadership decision that most leaders have not realized they need to make.

The Cost Trap: Why TCO Fails for AI

Organizations are making multimillion-dollar infrastructure decisions for AI workloads using a financial framework that was never designed for AI. Total Cost of Ownership (TCO) captures hardware, software, energy, cooling, and staffing—the full lifecycle cost of operating infrastructure. It treats all compute cycles as equal. It ignores whether an inference produced a correct or incorrect result. It treats latency as a performance metric rather than an economic variable. The result: leaders routinely choose infrastructure options that appear cheaper on spreadsheets but destroy far more value than they save.

This talk introduces Total Cost of Intelligence (TCI)—a decision framework that evaluates AI infrastructure not by what it costs but by what it produces. TCI incorporates three dimensions that TCO systematically ignores: model accuracy as a cost driver (cost per successful inference, not cost per inference attempt), latency as a revenue factor (the dollar value of every millisecond of delay), and business outcome per dollar spent (the ultimate measure of infrastructure effectiveness).

The talk walks through a real-world decision scenario where TCO favored a cheaper cloud deployment—and TCI revealed that an edge deployment would generate significantly more business value by reducing latency-related failures. Attendees will leave with a practical framework they can apply to their own infrastructure decisions: classify workloads, apply the TCI calculation, and make decisions based on value generated rather than cost incurred. The content is grounded in direct practitioner experience advising enterprises on AI infrastructure economics.

When an Autonomous Agent Makes the Wrong Call: A Security Post-Mortem

In mid-2025, an autonomous network triage agent made a decision that extended an outage by 22 minutes and triggered $12.5 million in SLA penalties. The model was functioning correctly. The data was fresh. The coordination worked. The failure was in the governance layer—or rather, its absence.

This talk is a technical post-mortem of that incident. It walks through exactly what happened: what the agent knew, what it decided, what it did, and why the infrastructure had no mechanism to stop it.

The talk then demonstrates what would have prevented the incident: policy-as-code enforcement embedded in the agent execution framework. It shows how an action intent event would have signaled the agent's plan before execution. How a policy engine would have blocked the prohibited action. How an immutable audit trail would have captured the attempt with causal context. And how clear accountability assignment would have closed the trust model void that made the failure possible.

Attendees will leave with a governance framework—define boundaries, embed enforcement, instrument accountability, assign ownership—and a clear understanding of why agent security is not a model problem. It's an infrastructure problem that most organizations haven't realized they need to solve.

When Agents Collide: A Coherence Framework for Multi-Agent Systems

Single-agent demos are convincing. Multi-agent production is where agents collide. When multiple autonomous agents operate on the same infrastructure—each making decisions in parallel, each consuming from its own data stream—the failures aren't caused by any single agent. They're caused by the interactions between them. One agent reroutes traffic. Another changes DNS. A third modifies a firewall rule. Each decision is individually sound. Together, without coherence, they create an incident worse than the one they were fixing.

This talk presents a coherence framework for multi-agent systems built on three mechanisms already proven in the streaming community. Causal consistency preserves cause-and-effect ordering without requiring global synchronization, ensuring that agents who need to coordinate see events in the same causal order while independent agents operate without waiting for each other. Bounded staleness treats data freshness as a controllable per-relationship parameter—an edge agent performing local inference can lag seconds behind the cloud, while one executing a remediation order requires millisecond precision. Shared event streams provide the durable, ordered, replayable log that serves as the system's shared memory, enabling every agent to access the same history and the same versioned state.

This talk connects streaming infrastructure to the hardest unsolved problem in agentic AI: making distributed agents think together while operating apart.

The Missing Layer: A Governance Framework for Agentic Network Operations

The technology to build autonomous network operations is no longer the bottleneck. AI agents can detect anomalies, diagnose root causes, and execute remediation faster than human engineers. The missing layer is governance: the guardrails, accountability frameworks, and operational controls that determine whether autonomous agents reduce risk or multiply it.

This talk examines three governance gaps that must be closed before agentic operations can be safely deployed at scale.

First, the trust model void: vendors are shipping autonomous agents without the rollback frameworks or accountability structures that operators need.

Second, the governance vacuum: autonomous agents require explicit boundaries—what actions are permitted, what requires human approval, what is off-limits—and most organizations have not assigned ownership of these policies.

Third, the speed paradox: the same streaming architecture that enables real-time context also enables real-time errors, making governance mechanisms such as action intent events, idempotency keys, and lightweight leases essential architectural components embedded in the event stream itself.

Attendees will leave with a practical governance framework—define boundaries, embed enforcement, instrument accountability, assign ownership—that they can apply immediately to their own agent deployments.

The Five Failure Modes That Break AI Agents in Production

Most AI agent failures in production get blamed on the model. Retrain it. Fine-tune it. Swap it for a bigger one. In practice, the model is rarely the problem. The data pipeline feeding it is.

This talk walks through five specific, documented failure modes that systematically undermine AI agents connected to batch data pipelines: stale data, where agents diagnose from outdated snapshots that no longer reflect reality; memory gaps, where batch windows strip away the history needed to detect patterns; delete blindness, where ghost records cause agents to act on data that no longer exists; schema fragility, where silent field loss degrades decisions without any failure signal; and coordination failure, where multiple agents consuming inconsistent snapshots execute conflicting remediations that cascade.

Each failure mode is presented with its mechanism, real-world consequence, and the streaming-first architectural remedy that eliminates it. Attendees will leave with a diagnostic framework they can apply immediately to their own agent deployments and a clear understanding of the architectural prerequisites for reliable agentic systems.

Timeline for NFV and SDN Transformation

This panel, featuring Shazia Hasnie and other industry leaders, explored the timeline and impact of SDN/NFV transformation. They concluded that while current networks are connectivity-centric with static, closed, and hardware-dependent infrastructure, evolving networks will be service-centric. This new model enables abstraction, multi-vendor interoperability, and on-demand, pay-per-use services. A key insight is that delivering innovative, dynamic services is impossible without full end-to-end automation across the service lifecycle. Tomorrow's network will be driven by applications, reshaping itself on demand—fundamentally changing networking from providing connectivity to supporting applications.

Panel Discussion
Carrier Network Virtualization Conference, Palo Alto, California
December 2014

Mastering Network Function Virtualization with Intelligent Orchestration

This presentation defines intelligent orchestration as an evolution of service provisioning that enables dynamic, real-time network configuration with contextual awareness. Key market drivers include the shift from reactive, piecemeal service models to proactive, on-demand delivery. Existing challenges—such as CLI limitations, integration tax, data inconsistency, and long provisioning times—hinder agility. The proposed solution requires a fully automated, open NFV-MANO framework with key attributes: model-driven service/device views (using YANG), transaction-oriented ACID compliance (via NETCONF), real-time/predictive analytics, and interoperability via open northbound APIs. The presentation concludes with a migration path from intelligent orchestration to full SDN/NFV adoption.

Session Keynote
Carrier Network Virtualization – Palo Alto, California​
December 2014​

SDN – A Promise for Better Network Monetization​

This presentation addresses why service providers need SDN to better monetize their networks amid challenges of controlling costs, scaling capacity, and innovating services. Current OSS systems are slow, fragmented, and manual. SDN promises CAPEX/OPEX savings, operational simplification, service innovation, a single orchestrated touch point, and business intelligence. The architecture requires abstraction of control and data planes with a logically centralized, programmable controller and open APIs. The evolution from today's networks to a revolutionary SDN model will be gradual. Key challenges include maturing OpenFlow, missing service control software, lack of open northbound APIs, managing control traffic, and defining boundary functions between SDN domains and legacy networks.

Session Keynote
Broadband World Forum, Amsterdam, Netherlands
October 2013​

The Convergence of Carrier Ethernet, Could and SDN: Opportunities, Challenges, and the Work Ahead

In this 2013 presentation at the Carrier Network Virtualization conference, Shazia Hasnie (Senior Director at Megapath) explores the convergence of Carrier Ethernet, Cloud, and SDN. She summarizes the virtualization benefits for future networks, identifying key deployment challenges. The talk highlights opportunities for more agile, efficient infrastructure while addressing the real-world hurdles operators face. Furthermore, she details the critical work being undertaken by various global organizations to overcome these obstacles, providing a strategic roadmap for the industry. The presentation focuses on bridging the gap between promise and practical implementation, offering guidance for network professionals navigating this complex technological shift.

https://www.youtube.com/watch?v=F8Swg7M4ZOw
Session Keynote
Carrier Network Virtualization conference
2013