Artificial Intelligence (AI) now drives decisions across enterprise operations, for autonomous systems—yet much of this decision-making remains a “black box.” AI Decision Observability is an emerging paradigm that transforms opaque model behavior into traceable, explainable, and auditable decision pathways. This session introduces a unified framework that combines AI Decision Observability with Decision Intelligence—linking how decisions are made, measured, and improved across human-AI systems.
Building on our AI Decision Automation Framework, we explore the technical and organizational capabilities required to move from decision outputs to decision systems: continuous, observable pipelines where every inference, rule, and outcome can be traced back to its origin. We discuss key methodologies—comprehensive logging, data and model lineage tracing, model introspection, counterfactual and causal analysis—and how these integrate into enterprise observability stacks.
The session also showcases tools and architectures that operationalize observability, alongside real-world case studies from regulated domains like finance, healthcare, and autonomous mobility.
We’ll conclude with a forward-looking view on how Decision Observability fuels Decision Intelligence—enabling enterprises to build trusted, adaptive, and compliant AI ecosystems where decisions are not just made but understood, improved, and governed.
Key Takeaways:
How to architect AI systems for full decision traceability and governance
Integrating Decision Intelligence with AI Decision Observability for continuous learning
Practical frameworks for scaling decision transparency and automation across the enterprise
AI That Argues With Itself: Building Self-Debating Systems That Catch Their Own Bugs
Shreya Singhal · AI Applied Scientist, Claritev
Modern AI systems are incredibly capable and confidently wrong.
In this talk, we explore a new architectural pattern: AI systems that argue with themselves. By orchestrating multiple AI agents with opposing perspectives, we can uncover hidden bugs, reduce hallucinations, and dramatically improve output quality without adding human reviewers to the loop.
I’ll demonstrate how to design and implement a self-debating AI system using real-world examples: debugging code, validating architectural decisions, and stress-testing product requirements. We’ll explore when AI disagreement is useful, when it fails, and how to measure improvement beyond “it feels better.”
Autonomous Infrastructure: Building AI Agents for Global-Scale Capacity Efficiency
Tommy Tran · Software Engineer, Meta
Efficiently managing compute capacity is a multi-dimensional optimization problem that has outpaced human-in-the-loop systems.
This presentation details the development of an agentic ecosystem used to optimize Meta’s global infrastructure.
We delve into the design of tooling that identifies inefficiencies in workload placement and resource allocation, utilizing AI agents to execute complex rebalancing tasks autonomously.
We will share the results of these implementations, specifically how we recouped tens of megawatts of power and the lessons learned in building trust in autonomous infrastructure tools.
Beyond SQL Generation: How to Teach Agents What Your Database Actually Means
Kris Jenkins · Lead Developer Advocate, Snowflake
Coding agents like Claude struggle to get meaningful information from databases. Even though they're good at writing correct SQL, they fall short where it matters - fetching the right answers. When asked a complex question, they consistently fumble their way through the schema catalogs and table descriptions, and then make best-guesses about how to join them, hoping to find some data that looks reasonable.
The reason for this is simple - they don't know your domain. It's like hiring an expert in database syntax and expecting them to know how your company works. The solution is equally simple - teach the agent what the data means. Give them a guide to how your database is laid out, how its joined, what column names mean and what kind of queries make sense. All the folk knowledge that that expert hire would eventually acquire in their first 6 months.
The technique for teaching agents the meaning of a schema is called a semantic model, there's an open standard that's easy to stick to, and the results are pretty terrific. A single file can take an agent from burning tokens to hallucinate an answer, to one-shotting the correct results.
In this talk we'll go through the details of semantic models and the standard, why it's worth using the standard rather than rolling your own, and techniques for creating effective semantic models quickly. All in the service of a simple outcome - making a scalable database analyst that's effective from day one.
Bluesky's Open Source Moderation Tools: LLM-based Event Detection in Python
Alex Garnett · Developer Relations, Bluesky
Bluesky is a decentralized social media application built on top of the AT Protocol. One way that Bluesky supports decentralization, and empowers users in the Atmosphere community to run their own unique AT apps, is through open source moderation tools. We do this through two primary parts of our stack: *Osprey*, an event stream decisions engine and analysis UI designed to investigate and take automatic action; and *Ozone*, a labeling service and web frontend for making moderation decisions.
Osprey is written in Python, and was designed and open sourced in collaboration with Discord. Osprey is a library for processing actions through human written rules and outputting labels, webhooks back to an API and other sinks. It evaluates events using structured logic, user-defined functions, and external signals to assign labels, verdicts, and actions. Some of these, such as our Toxrank model for toxicity detection, make use of fine-tuned LLMs and other classifiers that expose their own web endpoints to Osprey. We also utilize image OCR and hashing to create actionable moderation metadata, which can be automatically actioned, surfaced to moderators via Ozone, and in turn helps shape our Discover feed algorithms.
Although some of our internal heuristics are private, Osprey and Ozone are designed to be deployed and run by other app hosts with their own custom rules and moderation practices, whether they are reimplementing the Bluesky Lexicon and feature set or running a different kind of Atmosphere app with a different set of content. In this talk, you’ll see a demo of both applications, learn about our rules engine and other architectural features, and leave with enough knowledge to integrate our open source moderation tools into your own stack.
Chat with Your Data: From Natural Language to SQL
Alper Ebicoglu · Co-founder, Volosoft
This session shows how to build a .NET application that lets users generate reports simply by chatting. I’ll walk through my hands-on experience that reads your database schema, understands user intent, creates secure SQL queries, executes them, and exports results to Excel and charts automatically. You’ll see how LLMs can deliver real value in everyday enterprise apps, how to handle schema discovery, query validation, and prompt design, and how to create an intuitive UX for both developers and non-technical users. Attendees will leave with practical patterns, architectural guidance, and code examples they can apply immediately to bring natural-language data access into their own systems.
Closing the Visibility Gap: Lessons from Safety Critical Agentic Systems
Vivek Pandit · Principal Engineer, Cadence
AI agents are moving to production, revealing a "visibility gap" traditional monitoring can’t bridge. This talk shares lessons from shipping agentic AI in safety-critical workflows where agents reason, plan, and execute actions. We’ll explore building observable systems that provide high signal telemetry into non-deterministic decision making.
We’ll examine production agent architecture, combining LLMs with structured reasoning and guardrails, and how to instrument test time compute to track iterative refinement. The session covers designing interoperable tool interfaces that emit rich execution traces, orchestrating specialized agents with reliable handoffs, and building auto-correction loops that parse feedback to adapt in real-time.
Finally, we address evaluation, why traditional metrics fail and how to design domain aware benchmarks that treat reasoning traces as a first class observability primitive. Drawing from production deployments, we’ll discuss how observability helps agents uncover system issues missed by humans and why the future of software depends on agent native infrastructure.
Compute for your AI model: GPUs, LPUs, TPUs and beyond..
Kushaagra Goyal · Tech Lead, Rubrik
In the rapidly evolving landscape of computing, Graphics Processing Units (GPUs), Language Processing Units (LPUs), and Tensor Processing Units (TPUs) play pivotal roles in accelerating complex tasks, particularly in machine learning and artificial intelligence.
GPUs are renowned for their parallel processing capabilities, making them ideal for rendering graphics and handling large datasets. LPUs are specialized for optimizing natural language processing tasks, enhancing efficiency in understanding and generating human language. TPUs, developed by Google, are tailored specifically for training and inference of machine learning models, offering significant performance advantages for large-scale AI applications.
As we explore these technologies, we'll also look at emerging processing units designed for specific AI use-cases and the future of computational advancements.
Join me to dive into the intricacies of these processing units, their applications, and what lies ahead in the world of computing technology.
Context Engineering Kung Fu
Carl Lapierre · Tech Lead and AI Engineer, Osedea
When agents fail, it’s rarely because the model is weak, it’s because the context is weak. LLMs behave like pure functions: what goes in determines what comes out. That makes context the true battleground, and mastery of it a form of kung fu.
Context Engineering Kung Fu is about developing precision, restraint, and control over what a model sees. This session goes teaches the fundamentals: how to write clean instructions, select only what matters, compress information without losing force, and isolate signals so they don’t interfere with each other. You’ll learn how context decays over time, why bloated prompts make agents slower and less reliable, and how to recognize when a model is overwhelmed rather than underpowered.
We’ll also cover advanced techniques: when memory strengthens an agent and when it quietly sabotages one, how to structure context so it remains stable under iteration, and how to break complex problems into smaller, deliberate moves that models can execute with confidence.
Developer Liability in the AI Agent Era: Building Responsibly
Alla Barbalat · Lead Organizer, PyLadies San Francisco
Developers are releasing AI agents into the wild. Who is responsible when AI agents cause harms such as publishing false claims about a person or using tools without proper authorization?
In this talk, we'll start by exploring ideas of how deploying AI agents can result in liability under legal doctrine. Then we'll shift gears by diving into practical and hands-on solutions for deploying agents designed to avoid causing harms relating to two specific scenarios: (1) defamation, and (2) unauthorized actions. Finally, we'll walk through some code examples that reflect thoughtful developer practices.
Don’t kill my Vibes - Simple Steps to Stay Secure when Vibe Coding
Isaac Evans · Co-founder & CEO, Semgrep
The rise of vibe coding, AI-generated code, and low-/no-code tools is changing how software is built. Traditional DevSecOps assumptions (full code review, manual security gates, “shift left”) no longer cleanly apply yet prompting an LLM for “secure code” does not guarantee safe handling of data, correct auth logic, or secure outcomes in general.
This session will provide examples of how successful teams have addressed this issue and highlight the concept of using secure guardrails that notify (but don’t block) developers in their native workflow and promote the generation of secure code. Find out how to replace brittle security gates with automated guardrails, continuous checks and feedback loops that don’t slow developers. Attend to understand why security is becoming a question of intent and outcomes, not line-by-line code inspection.
Fast, Cheap, and Accurate: Optimizing LLM Inference with vLLM and Quantization
Legare Kerrison · AI Developer Advocate, Red Hat
Running large language models at scale can get expensive fast, but the right optimizations can cut latency and GPU costs dramatically.
We’ll walk through how to serve models efficiently using vLLM, an open-source, high-performance inference engine. Then and generate and test quantized models, expose them through vLLM’s OpenAI-compatible API, and tune runtime flags to balance throughput, latency, and accuracy on different GPUs.
We’ll benchmark performance live, inspect token-throughput metrics, and discuss real-world deployment trade-offs.
From Cloud Native to Multi-Cloud Native: Write Once, Deploy Anywhere
Sandeep Pal · Principal Member of Technical Staff, Salesforce
While "Cloud Native" promised portability, that promise often stops at the boundary of a single infrastructure provider. The traditional definition of Cloud Native rarely addresses the reality of multi-cloud environments, leaving enterprises with deep vendor coupling through fragmented SDKs, distinct authentication flows, and proprietary APIs. It is time to evolve to Multi-Cloud Native, a development paradigm where applications are designed from day one to be agnostic to the underlying provider.
In this session, I will explore the architectural principles required to build truly portable applications using driver-based design patterns. I will demonstrate how these patterns are implemented in the ecosystem today, focusing on MultiCloudJ (Salesforce’s open-source Java SDK) and Go Cloud (Google’s open-source Go library). These libraries provide consistent programming models that decouple business logic from cloud providers, enabling a true "write once, deploy anywhere" capability.
Drawing from Salesforce’s real-world journey operating hyper-scale services across AWS, GCP, and Alibaba Cloud, I will share the engineering challenges that necessitated this shift. Finally, we will examine the role of AI in this transition: specifically, how the Model Context Protocol (MCP) can analyze SDK usage patterns to automate the refactoring of legacy, vendor-specific code into modern, multi-cloud native standards.
From Firefighting to Force Multiplication with AI
Daniel Murphy · Head of SRE, PwC
Engineers are drowning in alert fatigue, repetitive toil, and late-night pages. But what if you could flip the script using AI? In this talk, we explore how a solo engineer empowered their practice by building an AI-driven ChatOps bot and anomaly detector—automating the triage of alerts, generating root-cause hints, and triggering runbooks autonomously
From Idea to Production with AI: Agentic Development in Practice
Daniel Ostrovsky · AI Architect, Payoneer
In this hands-on, full-day workshop, we'll take a bold app concept and ship it together — from blank slate to running application — using today's agentic AI tooling (Claude Code, Codex, and peers). You'll see how to move from idea to product plan, set up a database, build a NestJS backend, and deliver a React frontend, all driven by AI agents rather than manual coding.
No slides, no theory overload - just real development with real tools. We'll work with skills, rules, sub-agents, and multi-agent workflows to move fast, stay focused, and skip the tedious parts. You'll leave with a working app and a practical mental model for how agentic development changes the way software actually gets built.
By the end of the day, working with AI won't feel like a novelty - it'll feel like your new default. Let's build something cool (and maybe blow your mind a little).
Headroom: A Context Optimization Layer for LLM Applications
Tejas Chopra · Senior Software Engineer, Netflix
Large Language Models are expensive. With context windows expanding to 200K+ tokens, a single API call can cost several dollars—and in production systems handling thousands of requests, these costs compound quickly. Most optimization efforts focus on model selection or prompt engineering, but there's an overlooked dimension: the context itself often contains massive redundancy.
Headroom is an open-source Python library that sits between your application and your LLM provider, transparently optimizing context before it reaches the model. The core insight is simple: LLM contexts—especially in agentic workflows—are filled with repetitive tool outputs, verbose JSON arrays, and boilerplate that consumes tokens without adding proportional value.
What makes Headroom different?
Traditional compression destroys information irreversibly. Headroom introduces CCR (Compress-Cache-Retrieve), a reversible compression architecture.
The compression itself is content-aware. Code gets AST-parsed to preserve signatures while compressing function bodies. JSON arrays undergo statistical analysis—we identify outliers, errors, change points, and representative samples rather than blindly truncating. Markdown preserves headers and structure. Each content type gets specialized handling.
Real-world results:
- 50-90% token reduction on typical agentic workloads
- Drop-in integrations for LangChain, OpenAI, Anthropic, and any OpenAI-compatible provider
- Zero code changes required when using the proxy server
Know Your Enemies: Live Exploit of a PHP Engine Security Breach
Alexandre Daubois · CTO, Les-Tilleuls.coop
All programming languages have their foundations: the engine that interprets your code and makes everything run. In PHP, this is the Zend Engine, a critical piece of software that powers millions of applications worldwide. When everything works, you don’t even think about it. You deploy to production, and the engine does its magic behind the scenes.
But what happens when something goes wrong in that core? What if a subtle bug opens the door to a full security breach? Suddenly, the invisible foundation becomes the most important part of the story.
Let’s shine a light on two such cases: a recent, real vulnerability in the PHP engine (which has since been patched), and a backdoor that, just a few years ago, actually made it into the release candidate and allowed remote code execution. We’ll walk through how each issue could be exploited and, most importantly, what lessons developers can draw from them. And yes, there will be live, local, sandboxed demos of both exploits in action. Ready to dive in?
Look What Java Can Do Now: Live-Coding a GenAI MCP Server with the JAQ Stack
Suren Konathala · Director of Engineering, Portfolio Manager, Capgemini
For years, a common bias has held that serious AI development is best left to other ecosystems. This session is here to change that perspective with a live, hands-on demonstration. It’s time to show the world what enterprise Java can really do in the age of AI.
With the release of Helidon MCP, it allowed us to explore and challenge this old narrative. We can now build high-performance, GenAI-native MicroProfile (MCP) servers from scratch. This is a "fresh perspective" on modern Java, proving that you can build secure, powerful, and scalable AI applications entirely within the JVM ecosystem you already know and trust.
This session introduces the JAQ Stack, a novel technology pattern for this new reality:
J (Java/Helidon MCP): We’ll use Helidon to build a blazing-fast, lightweight, and cloud-native server, perfect for handling enterprise workloads.
A (AI/Ollama): We'll integrate a local LLM via Ollama, solving one of the biggest real world enterprise problems: 100% data privacy and security.
Q (Query/LangChain4j): We'll use this powerful Java-native library to build a sophisticated RAG (Retrieval-Augmented Generation) pipeline and orchestrate our AI logic.
This is not a slide heavy talk. This is a dynamic, live coding session, delivering deep technical insights for developers. Attendees will see, step-by-step, how to solve a common business problem with a 100% Java-native stack. And because the JAQ Stack is batteries included and comes with pre-built applications, they'll leave with a blueprint that is incredibly easy to get started with.
Merging at Scale: From Broken Builds to Green Mainline
As engineering organizations scale, merging code into a shared codebase becomes a major productivity bottleneck. Thousands of engineers changing code continuously can overwhelm build systems, slow feedback loops, and erode trust in the mainline.
This talk explores how large teams keep builds green while maintaining high developer throughput by treating code integration as a systems problem. We’ll introduce the core ideas behind speculative merging, including dependency graphs, speculation trees, and invalidation, and show how predicting likely future states of the codebase enables parallelism without sacrificing correctness.
We’ll examine why naive approaches don’t scale, how combinatorial explosion and finite CI resources shape real-world designs, and what tradeoffs are required to make speculation practical. Finally, we’ll share lessons learned from evolving SubmitQueue over several years, highlighting how build stability, fast feedback, and merge confidence directly impact engineering productivity.
Microservice Cognitive Index for Deploy Diagnosis and Change Impact
Sachin Gupta · Member of Technical Staff 2, eBay
Modern cloud native systems often span hundreds of microservices, thousands of endpoints, and fragmented telemetry across logs, traces, metrics, deployments, and service catalogs. Even with strong observability, engineers still struggle to answer two high impact questions fast: why did this deployment fail, and if I change this service or API, what breaks.
This industry session presents an AI powered Microservice Cognitive Index, an intelligence layer on top of existing observability. It builds a canonical evidence graph by ingesting telemetry, deriving runtime topology from traces, clustering incident signatures from normalized logs, correlating regressions with deployments, and propagating change impact through dependency and contract signals. It combines graph based reasoning with machine learning and large language models to summarize evidence, rank likely causes, and explain blast radius with confidence. Unlike chat with logs approaches, it enforces tool grounded answers with evidence references, confidence scoring, and refusal policies when data is incomplete or confounded, making results auditable and safer for operations.
Modern Angular 🤝 Modern CSS
Ankita Sood · Sr. Principal Engineer, Secureworks
Ever wondered how the powerful combination of Modern Angular APIs and Modern CSS styling techniques can empower you to build lightning-fast, highly performant, and maintainable applications? Angular and CSS are constantly evolving, and keeping up can feel like daunting. This session is packed with real-world examples and actionable insights, empowering you to architect Angular applications with modern CSS, no matter the complexity.
Together, we will explore practical applications of the View Transitions API, discover simple yet scalable techniques for theming, learn how to leverage CSS Custom Properties, Container Queries, and much more! We will see several examples of how these modern CSS techniques seamlessly integrate within Angular component architecture and application design.
Let us unlock the full potential of this powerful combination and build Angular apps that are as beautiful as they are performant!
Netflix's Quiet Period: The Race Day Rule That Protects Holidays, Live Sports & Cloud meltdowns
As the golden race day rule goes, do nothing new on race day. In other words, don't change what's already working. At Netflix, we follow this same principle through Quiet Period, our automated strategy for protecting production during the moments that matter most.
When live sports events capture enormous global audiences, when holiday viewership breaks all records, and when your cloud provider experiences a meltdown that sends half the internet into chaos—that is precisely when Netflix enacts its Quiet Period. This isn't merely a deployment freeze; it's a form of intelligent governance that poses one essential question: Is this truly the right moment to push something new into production?
In this session, we aim to take you inside Netflix's battle-tested playbook for high-stakes moments. You'll discover how we built systems that automatically protect production across multiple scenarios—from planned holiday peaks to emergency cloud outages. We'll explore the architecture that governs deployments across Streaming, Ads, and Gaming, and how we removed the "trust me, this is critical" problem that plagues every engineering organization under pressure.
You'll learn about our evolution from a manual policy to an intelligent adaptive system that knows when you're racing and refuses to let you experiment.
Every organization has race days. The question is: do you know when yours are, and are you disciplined enough to follow the rule?
Optimizing consumption and cost of AI APIs in the enterprise
Derric Gilling · VP & GM, API Platform, WSO2
This talk focuses on strategies for businesses to efficiently manage their AI products through API governance and observability. It covers methods for reducing costs and optimizing consumption, ensuring effective and scalable AI integration within enterprise environments.
public void saveMoney(AI): The Developer's Guide to Unit Economics
We usually treat cloud costs as an infrastructure problem - something to be solved with better budgets or Reserved Instances. But in a world of serverless and containers, your bill is a direct reflection of your code's efficiency. A memory leak isn't just a bug anymore; it’s a monthly recurring expense. A "chatty" frontend isn't just slow; it’s a self-inflicted DDoS attack on your own wallet.
This lightning talk shifts the FinOps conversation to where costs actually start: the IDE. We’ll trace a single request through a standard GCP stack—from an Angular frontend, through Java services on GKE, and down into Cloud Spanner.
Instead of high-level theory, we’ll look at the specific code-level anti-patterns that wreck unit economics. You’ll see how "polite" frontend code helps GKE bin-packing density, how Java serialization impacts Dataflow costs, and how specific query patterns can quietly destroy a budget. You'll leave with a developer-centric checklist to stop the bleeding in production.
Red Teaming Your LLM App -- A Hands-On Threat Model You Can Reuse
Saloni Garg · Senior ML Engineer, Adobe
users start pushing the system. This session focuses on spotting those risks early by thinking through how an LLM app can be misused or broken.
We’ll discuss common attack patterns like prompt injection, data leakage, tool abuse, and jailbreaks, using familiar setups such as RAG pipelines, agents, and function calling. We’ll also talk about how teams intentionally test these scenarios, what usually gets missed, and which defenses actually help in production.
Attendees will have a simple, reusable threat-modeling approach and a practical checklist they can apply to their own LLM applications, without slowing down development or overcomplicating security.
Reinventing Incident Response with AI Agents and MCP
Jayant Tyagi · Lead Member of Technical Staff, Salesforce
When a critical service goes down at 2 AM, every second counts. But traditional incident response is a maze of manual steps: hunting through logs, correlating GitHub commits, pinging teams on Slack, and piecing together timelines while customers are impacted.
At Slack, we solved this by building AI agents that think like our best senior engineers, but work at machine speed. Using custom MCP tools integrated directly into Cursor, our system transforms a simple incident alert into a complete investigation: automatically surfacing relevant logs, identifying suspect commits, mapping blast radius, and even drafting incident communications. This production-grade automation is already saving our team multiple hours per week and dramatically improving our escal response. This session will be useful for anyone building developer productivity tools who wants to see AI deliver measurable operational impact.
Responsible AI Architecture with Zero Trust Agents
Ashok Prakash · Staff ML Engineer, Apple
As we shift from simple chatbots to long-running agents, we face a critical engineering challenge. The risk is no longer just bad output. It is memory poisoning. This occurs when malicious data permanently corrupts your vector database, causing agents to hallucinate or leak private information indefinitely.
This session will present a Zero Trust architecture for Responsible AI starting prompt injection until agent isolation. We will dissect a reference stack built entirely on open source standards that treats your vector storage as a high-security vault.
Attendees will walk away with practical techniques to: Replace risky API keys with cryptographic verification using SPIFFE and SPIRE, ensuring only valid code can access long-term memory.
Use policies to write security rules as code, separating your safety logic from your application logic. Block sensitive data and malicious prompts before they are ever stored using tools like Microsoft Presidio.
Join me to learn how to build agents that are resilient, audit-ready, and secure by design.
SecurePrompt: Building a Pre-Flight Security Layer for Agentic AI
Ravi Sastry Kadali · Tech Lead, Samsung
As enterprises deploy agentic AI, everyone's building capabilities—but who's building the guardrails? When an autonomous agent generates a prompt containing AWS credentials, or a compromised data source injects malicious instructions, what stops that payload from reaching the LLM?
This session reveals how I built SecurePrompt, a pre-flight security scanner that intercepts prompts before they're sent to any AI model—addressing the critical blind spot at the boundary of autonomous AI systems.
You'll learn:
1. Real-world scenarios where credentials leak, prompt injections propagate, and PII compliance fails
2. Why I chose Go and rules-based detection for sub-10ms latency
3. Parallel scanning architecture for secrets, injection attacks, PII, and data exfiltration
4. Policy-as-code profiles for enterprise risk tolerances
5. HMAC-signed audit logs with causal traceability
6. Evolving from deterministic rules to LLM-powered semantic analysis
Leave with practical patterns for implementing security at the prompt boundary—the layer nobody else is building.
Securing AI Agent Infrastructure: Identity, Attestation, and Trust at Scale
Abdel Fane · Founder, OpenA2A
AI agents are moving from demos to production. They're accessing databases, calling APIs, orchestrating workflows—but most lack basic security primitives that we've required for human users for decades.
This talk covers the security infrastructure layer every AI agent deployment needs:
The Challenge
- Agents run with API keys: no identity, no audit trail, easy to leak
- MCP servers proliferate without verification—shadow IT for the AI era
- No visibility into what agents are doing or what they're connecting to
The Solution: Three Pillars
- Cryptographic Identity: Ed25519 keypairs give agents unforgeable identity. Not credentials that can be shared—proof of who they are.
- MCP Server Attestation: Verify every MCP server before connection. Detect configuration drift. Know when tools change.
- Behavioral Trust Scoring: Static allow/deny isn't enough. Trust scores adapt based on agent behavior over time.
Live Demo
I'll secure an agent from scratch: generate identity, connect to attested MCP servers, enforce capability policies, and show the audit trail.
You'll leave with patterns you can implement whether you use our open-source platform (AIM) or build your own. The concepts apply to LangChain, CrewAI, AutoGen, or any MCP-based system.
20 years of enterprise security lessons, applied to the AI agent era.
Ship 10x Faster: AI-Powered Development with Claude Code and MCP Tools
Viktoria Semaan · Principal Technical Evangelist, Databricks
In this session, I'll share how I used Claude Code and the Databricks AI Dev Kit to build an entire Agentic and course — something I'd been postponing for years. With AI coding assistants and MCP (Model Context Protocol) tools, I went from idea to shipped product faster than I ever thought possible.
This isn't about replacing developers. It's about amplifying what you can accomplish.
I'll walk you through the practical reality of AI-powered development: how to set up your environment, connect AI assistants to real infrastructure through MCP servers, and leverage skills-based knowledge to teach AI your organization's patterns and best practices.
You'll see real examples of how AI handled everything from SQL execution to pipeline creation, while I focused on architecture decisions and quality control. We'll explore the balance between speed and governance — because shipping fast means nothing if you ship broken.
Whether you're a solo developer with a side project or an enterprise team looking to accelerate delivery, you'll leave with actionable techniques to integrate AI coding assistants into your workflow.
The path to Staff Engineer and beyond - staying on the IC train
Graham Gilbert · Senior Staff Engineer, Airbnb
From the early steps that set me onto this path, to the challenges of mentorship and leadership roles, I'll discuss what it means to thrive as an Individual Contributor (IC) in a world that often pushes for management. This talk will not only reflect on my personal experiences but also provide insights and strategies for engineers who aspire to make a meaningful impact while staying true to their technical passions.
The Productivity Illusion: What AI Really Changed for Developers
Fatih Kadir Akın · Developer Relations, WordPress
Everyone says AI made developers faster. But did it really? This session dives into the hidden layers of AI-assisted development: How it affects focus, flow, and trust. Drawing from real-world experience building AI tools and observing developer behavior, We'll reveal what we gained, what we lost, and what we must redesign to make productivity human again.
The spectrum of agentic coding: From vibe coding to high-quality software engineering
YK Sugi · Developer Experience Manager, Eventual
After spending over a billion tokens on AI-assisted coding over the past two and a half years - from creating one of the first agentic coding tools (Kaguya) to daily production use - I've realized that vibe coding and traditional software engineering are not opposites. They exist on a spectrum.
This talk introduces a four-level framework for agentic coding:
1. Vibe coding - let AI go wild, forget the code exists
2. Agentic coding with discipline - version control, file-level understanding, basic testing
3. Agentic software engineering - CI, pre-commit hooks, function-level understanding
4. High-quality software engineering - line-by-line understanding, interactive code reviews, indistinguishable from handwritten code
You'll learn when to use each level, how to level up your agentic coding practices, and why the real problem with "slop" isn't AI - it's not putting enough thought and effort into the process. The key insight: more tokens spent doesn't have to mean more garbage. It can mean higher quality code, better research, and deeper understanding.
Vibe Coding Accessibility
Karl Groves · Accessibility Consultant, AFixt
This session explores how today’s most powerful AI-based coding tools are shaping the future of accessible technology. With tools like GitHub Copilot, ChatGPT, and other AI code assistants becoming mainstream, developers face both new opportunities and new risks. This session will provide a candid overview of the leading AI coding platforms and evaluate how well they support accessibility—from generating accessible code patterns to avoiding common pitfalls that exclude users with disabilities. We’ll also discuss their role in remediation: Can AI help fix inaccessible code, or does it introduce new challenges? To ground the discussion, we’ll showcase real-world examples of accessible web and native mobile products built with the help of AI tools. Attendees will walk away with practical insights on what AI coding tools can (and can’t) do today, best practices for ensuring accessible outcomes, and a vision for how accessibility professionals and developers can “vibe” with AI to build more inclusive digital experiences.
Your next customer won’t be human
Benjamin Smith · Staff Developer Advocate, Stripe
With a global daily user base in the hundreds of millions, AI agents are rapidly becoming a primary interface for how people discover, evaluate, and purchase products. Enabling those products to be listed and paid for directly through agents opens an entirely new, and enormous, commerce channel. The Agent Commerce Protocol (ACP) and Shared Payment Tokens provide a secure framework for agent-driven commerce within Stripe’s ecosystem, without exposing payment data or sacrificing user control.
This session walks developers through the complete implementation: setting up Stripe integration, creating permission-based payment tokens, interacting with ACP endpoints, and designing trustworthy user experiences. You'll learn how to enable your agents to transact safely and predictably, handling everything from checkout flows to error scenarios and webhook events.
