The good news is that most enterprise AI pilots work perfectly. The bad news: Most production deployments do anything but. The problem starts beneath the model, at the infrastructure layer. When AI agents link decisions across systems, every weak point in the data architecture is tested at every step. Stale vector indexes, disconnected graph databases, and governance written out in a policy doc instead of being active in the pipeline: Each of these points is a failure mode that melts a successful demo into a production problem.

In this session, Ravi Marwaha, COO and Chief Product & Technology Officer at Arango, walked through the six architectural requirements that distinguish AI systems stuck in the pilot phase from those that are operating reliably at scale: semantic clarity, entity resolution and relationships, temporal awareness, auditability and governance, agentic integration, and unified persistence. Each requirement is grounded in real production patterns, including how financial services and clinical research organizations have used a contextual data layer to compress manual work that once took weeks into minutes.

You’ll leave with a concrete framework for evaluating whether your current architecture can support the agents you’re building or whether you’re building on a foundation that was never designed to carry them.

Most teams solve slow, imprecise AI search the same way: retrieve a large candidate set and send it through a bigger model to rerank it into shape. It works, until the dataset, the traffic, and the model bill all grow at once, and the fix that used to work becomes the most expensive line in the stack. The deeper problem sits earlier in the pipeline. No reranker, however capable, can recover a relevant result that retrieval never surfaced in the first place. If the right passage isn’t in the candidate set, ranking it well was never on the table, whether the thing reading the results is a person or an agent deciding what to do next.

In this session, Bonnie Chase and Kristian Aune from Vespa.ai walked through how to design retrieval as a funnel instead of a single expensive pass: efficient candidate generation first, progressive narrowing through lexical, vector, and hybrid retrieval, and the most expensive ranking models reserved for the candidates where they can actually change the outcome. You will find out where teams get this boundary wrong in production and how the tradeoffs between latency, compute, and relevance actually get decided at each stage.

AI is changing the speed of attacks. SOC teams now face a practical challenge: how do you use AI to investigate and respond at the same speed, without giving up the control and oversight security operations require?

This session answers that question from two angles. First, Carly Page sat down with Oren Saban (Co-Founder & CPO, Mate Security) for a candid conversation about what security leaders are actually prioritizing and where they’re holding back when it comes to AI in the SOC.  Then Zach Christensen, founding solutions engineer from Mate Security put those decisions into practice showing when AI can own actions, when human control is required, and what changes as you give AI more autonomy.

You’ll leave with a practical framework for AI autonomy in your SOC, where human control still matters, and how to increase autonomy as trust grows.

WHOOP handles sensitive health data for millions of users, on an IPO track, so a missed vulnerability isn’t a minor incident. For WHOOP’s security team, a critical vulnerability used to mean three days and four engineers tracking down where it lived, confirming what was actually exposed, and coordinating the fix by hand. , most of it without anyone opening a ticket.

At this virtual event, TNS host Jennifer Riggins talked with WHOOP Staff Engineer Vinay Raghu and Datadog Senior Product Manager Amber Tunnell about how that shift happened. Vinay walked through the workflow itself, built with Datadog Bits AI and Workflow Automation, and the technical, operational, and trust decisions WHOOP had to make along the way.

You’ll leave with WHOOP’s actual before-and-after, straight from the engineer who built it: a real model for what to automate in vulnerability response, and where a person still needs to be the one making the call.

AI agents write code faster than any team can review it. Pull request volume is up nearly 2x. Bugs are up 54%. Incidents per pull request have nearly tripled. The instinctive response from most teams has been to add more review or to have AI review AI’s own work but neither fixes the problem, because the reviewer and the code came from the same training data, with the same blind spots.

In this session, The New Stack’s Viktor Farcic sat down with John Bristowe, Principal Developer Advocate at Octopus Deploy, for an unscripted conversation about why code review is breaking down under AI-generated volume and what a pipeline that verifies every deployment against a defined set of rules actually looks like in practice, regardless of whether a human, an AI agent, or a very determined intern wrote the code.

Expect a debate on where review still earns its keep and where it needs to step aside for the pipeline. You’ll will walk away with a practical model for drawing that line on their own teams, plus access to an exclusive companion resource built specifically for this session.

A retrieval layer serving human queries is one thing. A retrieval layer serving hundreds of concurrent agents, each potentially retrieving, reasoning, reformulating, and retrieving again, is a very different system. This isn’t a conventional concurrency problem; agent workloads multiply retrieval demand while raising the bar for freshness, relevance, and latency all at once. Most retrieval architectures weren’t built for this operating model. This session explores what happens when they encounter it, and why “add more caching” or “throw a bigger vector database at it” doesn’t solve the underlying problem.

Whit Walters, author of GigaOm’s Defeating the Integration Tax, and Bonnie Chase from Vespa.ai walked through the specific failure modes that show up when retrieval has to serve agent workloads instead of human ones: latency stacking, stale context, relevance drift under concurrent load, and the operational overhead of a fragmented stack trying to keep up. You’ll find out what a retrieval architecture actually looks like when it’s under that kind of pressure and what changes when it’s built as a unified layer instead of a bolted-together pipeline.

If you’re building agent systems and haven’t hit this wall yet, you will. We’ll show you where it is before you find it in production.

At scale, most observability platforms force a tradeoff: alert on everything and pay exponentially, or limit what you monitor and accept the blind spots. This session is a live technical deep dive for SREs and platform engineers who’ve hit the wall on alert rule sprawl, false positive fatigue, and siloed notification routing. We covered two OpenSearch capabilities, PPL (Piped Processing Language) and The Unified Alert Manager, that directly address these problems and everything shown runs under Apache 2.0, with no feature tier, no licensing negotiation, and no ingestion ceiling where it stops being cost-effective to alert on something.

The New Stack Host, Charles Humble, and Joshua Bright, an OpenSearch project maintainer at Amazon, walked through both the architecture and the operational workflow hands-on. 

Most access strategies weren’t designed for non-human identities. Traditional PAM tracks admin sessions and VPNs grant broad network entry. Zero trust frameworks assume you can verify identity upfront, which gets complicated fast when your principal is a CI/CD job, a service account, or an AI agent making tool calls across your infrastructure.

In this session, Tailscale’s Solutions Engineer Kartik Bharath and Product Manager XingLu Wang worked through what a unified access architecture actually covers today: human developers, contractors, pipelines, and AI agents, under one consistent policy model, without adding IT overhead or slowing down engineering teams. They illustrated Tailscale’s stack, including Border0+Tailscale for privileged access and Aperture for AI agent controls, and walked through real architectural decisions and the tradeoffs involved.

SecOps teams are caught in a never-ending alert-fatigue cycle. More detection rules generate more alerts, more alerts overwhelm analysts, and overwhelmed analysts miss the threats that matter. Meanwhile, the pressure to expand data collection keeps growing; from compliance requirements, from AI tools that need telemetry to function, and from leadership that equates coverage with visibility.

Breaking that cycle means rethinking three things at once: how you model detection, how AI fits into the actual workflow, and how you manage the data underneath it all.

In this session, Chas Clawson, VP of Security Strategy at Sumo Logic, shared a practical framework for SecOps teams working to get control of their signal-to-noise problem with specific guidance on where AI makes the biggest operational difference.

Distributed systems observability is a solved problem until AI agents enter the picture. They degrade, hallucinate, over-consume, and make tool calls in sequences you didn’t anticipate, none of which maps neatly to the log-metric-trace model your stack was built around. What most teams are missing isn’t more tooling; it’s a unified architecture that treats AI agent observability as a first-class problem, and OpenSearch combined with OpenTelemetry is increasingly where that architecture lives. In this session, Dotan Horovits (AWS & OpenSearch Ambassador) and Rekha Thottan (AWS) walks through full-stack observability across both layers: a live troubleshooting simulation using correlated logs, metrics, and traces, followed by how agent traces flow through the same OTel pipelines as your standard services and how Agent Health, an open-source evaluation framework, gives you a structured pre-production benchmark before rogue agent behavior becomes a production incident.