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 cover 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, will walk you through both the architecture and the operational workflow hands-on. Bring your alerting questions: the Q&A is open, and there’s no better person to answer them.

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 walk 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. We’ll show you 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.

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 sits 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.

For WHOOP’s security team, a critical vulnerability used to mean an entire team of engineers and days of manual, all-hands triage: tracking down where the vulnerability existed, determining which systems were exposed, and coordinating remediation.  With Datadog, WHOOP built a workflow in a single afternoon that continuously scans vulnerability sources, identifies internal exposure, and initiates remediation with minimal hands-on effort.

At this virtual event, TNS host Jennifer Riggins talks with WHOOP Staff Engineer Vinay Raghu and Datadog Senior Product Manager Amber Tunnell about how WHOOP built this automated vulnerability-response workflow using Datadog Bits AI and Workflow Automation. Vinay will walk through how the workflow operates and share how WHOOP approached the technical, operational, and trust considerations involved in automating a critical security process.

You’ll see how Bits AI and Workflow Automation work together to help engineering teams move from manual, all-hands vulnerability response to a faster, more scalable approach.

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 Jenny Morris from Vespa.ai will walk 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.

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, will walk 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.

Postgres runs everything until it doesn’t. Time-series and high-ingest workloads eventually hit the same wall: index bloat, vacuum overhead, and a query planner that stops cooperating once tables cross a certain size. Most teams’ next move is to rip Postgres out and stand up something new, which is a decision that trades one set of problems for another.

In this session, Tiger Data’s Matty Stratton walks through exactly where vanilla Postgres starts to strain under scale, what changes structurally when you extend it with TimescaleDB, and via a live demo what actually breaks at scale versus what doesn’t. Plus, you’ll leave with a concrete scorecard for your own systems.

An AI agent spins up a service account to finish a task or it inherits a permission set nobody remembers granting. But weeks later, it touches something it shouldn’t have and the incident report has nowhere to point and the identity provider has no record. The audit log has a gap and the team is left reconstructing what happened from Slack messages and guesswork.

That’s the gap most platform and security teams haven’t closed yet. Humans get provisioned access, run through a system built specifically to track who has what and why. Agents get emergent access — permissions they pick up, inherit, or generate on their own, with no equivalent system watching any of it.

In this live session, TNS host Viktor Farcic sits down with CloudBolt’s Shawn Petty (Chief Customer Officer) and Mike Bombard (Director of Global Pre-Sales Engineering) to close that gap: tying agent activity back to your existing identity provider, controlling exactly what agents are allowed to touch, and keeping a full audit trail instead of a black box.

Shawn and Mike will run the actual tracing process live on CloudBolt’s platform, so you can watch an agent’s action get traced back to a real, accountable identity in real time. If your team has agents touching production and no clean answer for who’s responsible when something breaks, this session is built for you.