Europe 2026

Remoby is a progressive web application designed to bring terminal workflows, specifically those utilizing tmux, to mobile devices. It aims to allow users to manage and interact with their AI agents and development environments from their phones without altering their existing desktop setup. The core idea is to extend the power and customization of a terminal-based workflow to a mobile context.

This talk introduces OpenClaw, an open-source project for building and securing AI agent control planes. It highlights a new feature, trusted proxy authentication mode, which enhances security and user experience by eliminating the need for manual token entry and device pairing for web socket connections. The presentation also demonstrates how OpenClaw can be integrated into development workflows, enabling live coding and rapid prototyping of AI-powered applications.

This talk addresses the proliferation of AI tools and provides guidance on selecting the appropriate ones for specific tasks. It emphasizes understanding the capabilities and limitations of various tools to make informed decisions in AI development and product building. The core thesis revolves around strategic tool selection to enhance efficiency and effectiveness.

The developer role is shifting from solely writing code to designing and managing complex systems, augmented by AI tools. This evolution means developers are becoming more efficient, acting as orchestrators rather than just coders. The core idea is to leverage AI to scale development efforts, enabling individuals to achieve significantly higher productivity while maintaining control through robust guardrails.

This talk explores the evolving landscape of AI-driven game development, moving beyond simple prompt-based game generation to more sophisticated and dynamic experiences. It highlights how AI tools are lowering the barrier to entry for game creation, enabling individuals with diverse skill sets to build games. The presentation emphasizes that while AI can facilitate game creation, achieving a high-quality, standout game still requires artistic cohesion, thoughtful design, and a deep understanding of player experience, particularly with the advent of runtime LLMs that can dynamically alter gameplay.

This talk addresses the discrepancy between the perceived capabilities of AI agents and their actual performance in real-world applications. The core argument is that the difference lies not in the agent's inherent ability, but in the feedback loop and the agent's ability to verify its own actions. Without robust verification mechanisms, agents may produce seemingly correct output that is actually flawed, leading to user frustration and distrust.

This talk details the process of training AI coding agents to perform tasks within spreadsheets, aiming to match their proficiency in programming languages. The project began with a 50% accuracy rate on financial analysis benchmarks and ultimately achieved 92% accuracy. The presentation covers the challenges of representing spreadsheet data to AI, various approaches explored, and the breakthroughs that led to significant improvements.

This talk addresses the common issue where AI coding agents, despite appearing to complete tasks, often produce outputs that fail upon execution or do not meet specifications. The core argument is that the value is shifting from the agent's ability to generate code to the developer's ability to design and implement robust verification systems, or harnesses, that ensure the agent's output is reliable and deterministic.

This talk details the creation of an AI system capable of generating YouTube videos explaining chess games. The system combines large language models (LLMs) with specialized chess tools to analyze games, identify key moments like blunders and brilliant moves, and then produce narrated video content. The core challenge addressed is bridging the gap between AI engines that play chess well but cannot explain it, and LLMs that can explain but cannot play effectively.

This talk outlines a production AI playbook, a framework designed to guide the deployment of AI systems at an enterprise scale. It addresses common pitfalls encountered when moving AI from demos to production, emphasizing the need for structured approaches to evaluation, observability, data foundation, orchestration, and governance. The framework aims to ensure AI systems are measurable, accountable, and reliable in real-world applications.

This talk addresses the common issue of Large Language Models (LLMs) fabricating information, particularly when attempting to access real-time web data. The core problem stems from LLMs being programmed to please users, leading them to generate plausible but incorrect answers rather than admitting they cannot fulfill a request. This is exacerbated by increasing web-based anti-bot measures, such as CAPTCHAs and AI-detection systems, which prevent LLMs from accessing accurate, up-to-date information.

This talk explores techniques to accelerate diffusion models for image and video generation, addressing the challenge of high latency in practical applications. The core thesis is that by employing methods like quantization, caching, and distillation, developers can significantly reduce the number of diffusion steps required, thereby improving performance and enabling real-time generation without sacrificing quality.

This talk explores the technical reasons behind the double iFrame implementation used by ChatGPT and other MCP (Meta-Conversational Platform) applications to render third-party UIs. It delves into the security implications of Content Security Policy (CSP) and sandboxing, explaining why direct iFrame embedding or using source-doc attributes are problematic. The presentation highlights the double iFrame approach as a solution to isolate third-party code while enabling necessary functionalities.

This talk addresses the challenge of accessing and answering business-related questions within an organization, particularly for non-technical teams. It introduces "Studio," an internal workspace developed at WorkOS, designed to empower employees to build tools and dashboards for self-service data analysis. Studio leverages AI agents to interact with various data sources, enabling users to ask questions and generate reusable data visualizations and reports without direct engineering intervention.

This talk introduces WebMCP, a proposed web standard designed to simplify how AI agents interact with websites. Instead of agents relying on brittle methods like screen scraping, WebMCP allows websites to expose their functionalities as structured tools. This approach aims to significantly improve the performance and reliability of AI agents performing actions on behalf of users, ultimately creating better user experiences.

This talk argues that AI agents are no longer the primary bottleneck in developer productivity; human attention is. While agents can scale infinitely and handle complex tasks with verification, human cognitive limits remain the hard constraint. The presentation suggests strategies for developers to manage their attention, leverage agents effectively, and maintain balance in an increasingly powerful AI-assisted workflow.

This talk challenges the assumption that larger AI models are always superior, particularly for enterprise use cases requiring reliability and security. It presents research demonstrating that a smaller, 4-billion parameter model, when fine-tuned with Reinforcement Learning (RL) and high-quality data, can outperform a significantly larger 235-billion parameter model on a tool-use task for financial analysis. The core thesis is that focusing on improving model behavior and tool discipline through targeted data and training can yield substantial performance gains, often more effectively and efficiently than simply increasing model size.

This talk introduces Google DeepMind's Gemma family of open models, highlighting their capabilities and the benefits of using open-source AI for greater ownership and customization. The presenters emphasize that while proprietary models like Gemini offer cutting-edge performance, open models like Gemma provide crucial advantages for specific use cases, such as running models on local hardware, handling sensitive data, and adapting models to unique requirements.

This talk introduces a pipeline designed to automate the process of turning product observability data into actionable code changes. Instead of engineers manually reviewing dashboards and creating pull requests (PRs) for issues, the system aims to automatically detect product signals, diagnose problems, and generate PRs for review or even direct merging. The ultimate vision is a product that can largely build and maintain itself by learning from user interactions and data.

This talk introduces RunPod's Flash, a Python SDK designed to streamline the development and deployment of AI models on GPU infrastructure. The core thesis is that developers can significantly reduce iteration time by deploying functions directly to the cloud from their local IDE, eliminating the need for manual commits, Docker builds, and server configuration. This allows for rapid testing and iteration on GPU-accelerated workloads.

This talk challenges the notion that Retrieval Augmented Generation (RAG) is obsolete, arguing instead that hybrid, tool-rich retrieval is becoming the standard for sophisticated agentic search. While simple RAG, often equated with basic vector search, was effective in early AI development, more advanced applications now leverage agentic search. This approach involves agents iteratively reasoning over context using a suite of tools, including vector search, full-text search, and other filters, to progressively refine their understanding and complete tasks.

This talk explores advancements in AI audio processing, focusing on Google DeepMind's Gemini models. The core thesis is that Gemini's sophisticated audio understanding capabilities enable richer transcription, robust reasoning, and more nuanced speech generation, moving beyond simple speech-to-text to a more comprehensive audio comprehension and synthesis system.

This talk details Together AI's research into training large context models, specifically aiming to break the 5 million token barrier. The core challenge lies in overcoming memory and computational bottlenecks inherent in standard transformer architectures when dealing with extremely long sequences. The research explores and combines various techniques to enable efficient training at unprecedented context lengths.

This talk explores the counterintuitive finding that providing more context to AI agents can sometimes lead to dumber or less effective results. The core thesis is that current LLMs tend to focus on the initial and final parts of a given context, often ignoring or "purging" information in the middle. This phenomenon, termed the "U-curve" effect, necessitates a shift from simply dumping more data to optimizing context strategically.

This talk introduces Eval++, a new compute primitive designed to enhance the development and deployment of AI agents. The core idea is to leverage Cloudflare's stateful serverless technology, specifically Durable Objects, as an ideal execution environment for agents. This approach enables long-running processes, persistence, and efficient scaling, fundamentally changing how developers can build and interact with AI-powered applications.

This talk introduces a platform for LLM observability, evaluation, and experimentation, emphasizing that building AI systems is fundamentally an engineering discipline. It highlights the importance of understanding what an AI system is doing (observability), how to measure its performance (evaluation), and how to systematically improve it (experimentation). The core thesis is that these processes, while complex in the non-deterministic world of AI, can be managed and eventually automated through robust engineering practices and tooling.

This talk introduces RunPod as a cloud AI infrastructure platform designed to simplify GPU access and model deployment for developers. The core thesis is that managing complex infrastructure, especially GPU hardware, is a significant hurdle for builders, and RunPod aims to abstract this away. The platform allows users to bring their own code and models, whether private or open-source, and deploy them quickly, focusing on enabling developers to build applications rather than manage hardware.

This talk explores building self-maintaining data collection pipelines using Large Language Models (LLMs) and specialized tools. It addresses the challenge of collecting large-scale data from websites, particularly those with anti-bot measures, by shifting from direct LLM parsing of every page to an agent-driven approach that builds and maintains scrapers. The core idea is to empower LLMs with the ability to create and manage the tools needed for data extraction, thereby saving significant computational resources and development time.

This talk introduces Model Context Protocol (MCP) apps, which enable server tools to return rich, interactive components directly within chat interfaces. MCP apps enhance user experience by allowing direct interaction with generated UIs, moving beyond simple text or emoji responses. This technology facilitates complex tasks like data exploration and e-commerce within a chat environment, improving efficiency and engagement.

This talk critiques the current state of AI model evaluations, arguing that while flawed, they remain essential tools for development. The speaker proposes a three-stage approach to using evals effectively: leveraging external evals, using them to improve internal agents, and building custom evals for specific use cases. The core message is to use evals pragmatically, understanding their limitations while still employing them for iterative improvement.

This talk addresses the critical need for secure payment infrastructure in an increasingly autonomous economy, where AI agents will act as economic actors. It highlights the inherent risks of agents transacting online, such as purchasing from incorrect vendors, selecting the wrong items, or spending unintended amounts. The core thesis is that while discovery and exploration benefit from non-determinism, financial transactions require strict determinism to ensure safety and prevent fraud.

This talk introduces Chrome DevTools for Agents, a purpose-built debugging tool for AI agents, drawing parallels to the widely used Chrome DevTools for human web developers. The core thesis is that agents, as a distinct user class, require specialized interfaces and debugging capabilities to overcome their limitations, such as processing vast amounts of data or understanding complex tool descriptions. The presentation emphasizes engineering lessons learned from building and deploying this tool, focusing on effectiveness, efficiency, discoverability, and trust.

This talk explores the rapid development and deployment practices within the OpenClaw project, likening the process to a "dark factory" that ships code at an unprecedented velocity. It argues that the sheer speed of development necessitates a shift from traditional code review to a more managerial approach, where engineers oversee swarms of autonomous agents. The core thesis is that effective engineering in this new paradigm relies on process, intuition, and managing agent workflows rather than solely on individual coding prowess.

This talk explores building AI systems that understand conversations beyond simple transcription. It highlights the importance of identifying who spoke, when they spoke, and even how they spoke to gain deeper insights. The presentation introduces speaker diarization as a core technology for this purpose and discusses the challenges and advancements in achieving accurate speaker-attributed transcription.

This talk introduces text diffusion, a forward-looking research area in AI that offers an alternative to traditional autoregressive text generation. Unlike models that generate text one token at a time, text diffusion models start with a noisy sequence and iteratively refine it to produce clean output. This approach promises significant advantages in inference speed and enables unique capabilities such as bidirectional reasoning and in-place editing.

This talk addresses the growing gap between the capabilities of AI agents and the methods used to evaluate them. It argues that while progress is evident in areas like coding agents, current evaluation benchmarks are falling behind, creating hesitation in deploying these agents in high-stakes environments. The presentation outlines key principles for building effective benchmarks, distinguishing between the scientific rigor required for measurement and the artistic vision needed to shape the future of AI development.

This talk details the practical lessons learned from evaluating coding agents on real-world software engineering tasks using the rebench leaderboard. It emphasizes the critical need for robust evaluation beyond gut feelings or limited testing, especially as models are deployed to production. The presentation highlights the challenges and methodologies involved in creating and maintaining a "fresh" and "real-world" benchmark, focusing on the complexities of software engineering tasks that require understanding repository structures, writing and running tests, and handling multi-turn interactions and tool use.

This talk explores the evolution of generative UI for Multi-Component Platform (MCP) applications, moving beyond static components to more dynamic and collaborative interfaces. It posits that current AI models are capable of generating sophisticated UI code, prompting a re-evaluation of how users interact with AI-powered applications. The core thesis is that the future of generative UI lies in collaborative experiences rather than just component-based outputs.

This talk explores the effectiveness of semantic code retrieval for AI coding assistants, specifically benchmarking it against traditional grep-based methods on Claude Code. The core thesis is that while grep is simpler and often sufficient, semantic search, powered by vector embeddings, can significantly improve precision and the agent's ability to locate relevant code, especially for complex tasks. This approach offers a form of cached compute, reducing redundant processing and potentially leading to better accuracy and user satisfaction.

This talk addresses the challenge of maintaining consistency and understanding in software development, particularly with the advent of AI agents. It proposes a system for capturing and enforcing decisions using established documentation practices like Architecture Decision Records (ADRs), Product Requirements Documents (PRDs), and Behavior-Driven Development (BDD). The core thesis is that by formalizing why and how decisions are made, developers and AI agents can operate more effectively and consistently.

As AI applications mature, companies increasingly turn to fine-tuning models for improved performance and cost efficiency. This talk explores the transition from using frontier APIs to custom model development, highlighting the emerging middle ground that simplifies fine-tuning and deployment. It suggests that differentiated products naturally evolve towards domain specificity, prompting a reevaluation of when custom models become necessary and feasible.

This talk explores the critical role of task quality in the performance of AI models, particularly in agentic tasks. The core thesis is that data quality and task quality are fundamentally intertwined, and improving task quality directly leads to better model training outcomes and performance uplifts. The research validates this by comparing model performance on high-quality versus low-quality tasks, demonstrating a significant difference in learning efficiency.

This talk details Lovable's approach to continuous learning and self-improvement for AI agents, aiming to prevent repeated mistakes. The core thesis is that by systematically identifying and learning from user friction points, AI systems can become more robust and user-friendly, particularly for non-technical users. The presentation outlines two primary methods Lovable employs to achieve this: a "Lovable Stack Overflow" for learning from solvable issues and a "venting tool" for agents to report unsolvable problems.

This talk challenges the conventional understanding of "state-of-the-art" AI models, arguing that relying solely on public leaderboards or internal manual evaluations can lead to suboptimal choices. It emphasizes that true state-of-the-art is context-dependent and that efficiency, not just raw quality, is a critical factor in model selection for practical applications. The core thesis is that a more nuanced approach to benchmarking, considering specific use cases and efficiency metrics, reveals a landscape of multiple specialized, high-performing models rather than a single dominant one.

This talk proposes a shift in how we conceptualize sandboxes for AI agents, suggesting the network itself can serve as the sandbox. Instead of relying on traditional methods like API keys or OAuth within a VM or container, the approach leverages network-level identity and permissions. This allows for granular control over agent access and behavior directly at the network layer, enabling more secure and observable AI agent deployments.

This talk explores the rapid prototyping and viral success of an AI-powered app that allows users to converse with statues. The speaker, Joe Reeve from ElevenLabs, details how the app was built in just two hours using existing APIs, highlighting the power of "vibe coding" and the importance of storytelling in product development. The discussion also touches upon the broader implications of AI in creative fields, user interaction patterns, and the future of voice interfaces.

This talk addresses the quality of code generated by Large Language Models (LLMs) for enterprise use. While LLMs show high functional correctness on standard benchmarks, they often produce code that is verbose, complex, insecure, and difficult to maintain. The presentation introduces an evaluation framework and a proposed agent-centric development cycle to address these shortcomings and ensure LLM-generated code meets engineering standards.

This talk introduces the concept of spec-driven testing for AI agents, arguing that simply using larger models or extensive datasets is insufficient for ensuring agent safety and reliability. It proposes a more comprehensive approach to defining and testing agent behavior by specifying not just expected outputs but also the context, rules, domain knowledge, and robustness requirements relevant to the agent's intended task.

This talk explores how to improve AI agent performance by reducing complexity and focusing on verifiable outcomes. The speaker advocates for enforcing actions through structured pipelines rather than relying on agent instructions alone. By minimizing unnecessary agent skills and implementing robust verification mechanisms, developers can achieve better results and reduce errors. The core idea is to shift from trusting agents to demanding proof of their work.

This talk details the process of training Zeta2, an edit prediction model for the Zed code editor. The core thesis revolves around using distillation from frontier models and leveraging opt-in production data to create a specialized, fast model for predicting user edits. The training pipeline emphasizes data processing, prompt engineering for teacher models, and a novel approach using "settled data" to generate high-quality training examples.

Building AI agents presents unique challenges compared to traditional software development. Instead of acting as traffic controllers with predefined rules, engineers now function more like dispatchers, defining goals for agents without dictating every step. This shift requires embracing the non-deterministic nature of AI, treating errors as inputs, and moving from rigid unit tests to broader evaluations of agent reliability and success rates.

This talk introduces Reachy Mini, an open-source robot designed to be affordable and hackable, making advanced robotics accessible to hackers, researchers, and students. The project aims to democratize interaction with robots, moving beyond human-like imitation to foster creative new forms of engagement. Reachy Mini is presented as a platform for exploring expressive, voice-interactive robotic experiences.

This talk introduces context graphs as a method to enhance AI agent decision-making beyond simple document retrieval. Context graphs store not only factual information but also past decision traces, precedents, and causal chains. This allows agents to make more informed and explainable decisions by understanding the reasoning behind previous choices, acting with a form of subject matter expertise.

This talk details the process of reverse-engineering a legacy Viking VOIP phone's protocol using Claude Code to enable connection with a modern conversational AI agent. The primary challenge was the phone's outdated Windows XP-compatible software, which posed setup difficulties for engineers using Mac operating systems. The solution involved leveraging Claude Code to discover communication ports, identify and brute-force two-letter command codes, and ultimately decipher a proprietary protocol, including a one-byte checksum encryption.

This talk differentiates traditional observability from agent observability, arguing that agents' non-deterministic nature and complex data structures necessitate a distinct approach. Traditional observability focuses on uptime and technical performance metrics like latency and error rates, using established tools. Agent observability, however, must also account for qualitative aspects of agent performance, such as grounding, tool usage, and adherence to brand standards, which require handling vast amounts of semi-structured and unstructured data.

Most enterprise agentic AI projects are destined to fail due to fundamental tensions between traditional enterprise structures and the demands of machine-speed AI development. Enterprises, built for human pace with layers of control and process, struggle to adapt to the rapid iteration and emergent behaviors characteristic of AI. This talk outlines five key tensions—speed, value, delivery, trust, and moat—and offers a framework for navigating them to achieve successful AI adoption.

This talk introduces context graphs as a method to enhance AI agents' decision-making capabilities. By integrating knowledge graphs with AI agents, the goal is to move beyond simple knowledge provision to enabling agents to understand and act upon rules and policies, thereby making more informed decisions. This approach aims to fill the gap in AI agents' reasoning by providing them with the necessary context and decision-making frameworks.

This talk emphasizes that the most significant benefit of AI in large codebases is not code generation, but comprehension. The speaker shares personal experience using AI, particularly Claude, to navigate complex codebases at Sentry. The core argument is that AI acts as an invaluable teammate for understanding code, which is crucial for maintaining quality and avoiding technical debt, especially when working on projects that are critical to one's livelihood.

This talk argues that Rust is a superior language for agentic coding, often referred to as vibe coding, despite conventional wisdom favoring languages like Python and TypeScript. The speaker contends that while dynamic languages are easier for LLMs to generate initially, this ease comes at the cost of increased error potential. Rust's strict compiler and numerous constraints, though posing a steeper learning curve for LLMs, provide deterministic guardrails that significantly reduce bugs and improve code reliability.

This talk outlines the maturity phases of running evaluations for AI agents, emphasizing that evals are crucial for ensuring agent quality, mitigating risks, and understanding performance improvements. The speaker suggests a progression from initial human-based assessments to more automated and complex evaluation strategies as agent complexity increases. The core idea is to systematically build confidence in agent behavior before and after deployment.

This talk explores the challenges and opportunities of running advanced AI models locally on consumer hardware. The core thesis is that significant advancements in performance and efficiency are achievable by optimizing the entire AI stack, from hardware and software to model architecture, rather than solely relying on cloud-based solutions. The presentation advocates for a future where powerful AI can be accessed privately and affordably at home.

This talk explores four key patterns observed in effective AI agents, drawing inspiration from existing tools like Cursor, Claude, and Harvey. The core thesis is that by studying and adapting these successful patterns, developers can build more capable and user-friendly agents. The presentation emphasizes learning from successful designs to improve agent development.

This talk addresses the challenge of agents lacking necessary context, forcing engineers to act as the "context engine." It proposes that instead of babysitting agents, a dedicated context engine is needed to provide agents with comprehensive, runtime-relevant information. This engine should understand organizational specifics, resolve conflicts, and deliver token-optimized responses, ultimately enabling agents to produce code and actions that reflect deep team integration.

This talk addresses the challenges of AI evaluations, which are currently scattered, quickly become outdated, and often lack transparency and verifiability. The speakers propose solutions to democratize the evaluation process, enabling a broader community to contribute to and benefit from robust AI benchmarking. Their work aims to foster more equitable AI development by allowing diverse expertise to shape evaluation standards.

This talk challenges the notion that generative AI agents exclusively belong to data scientists or machine learning engineers. It argues that while these roles bring valuable expertise in model understanding and rigorous testing, the nature of modern AI agents—built upon pre-trained models and adaptable through natural language inputs—opens the door for broader team involvement. The core thesis suggests that successful agent development benefits from diverse skill sets, including product engineers and subject matter experts, to effectively bridge the gap between complex technology and real-world problem-solving.

This talk explores the evolving relationship between humans and large language models (LLMs), particularly in the context of agentic systems. It argues against the hype surrounding rapid AI advancements, emphasizing that core LLM capabilities have not fundamentally changed. Instead, many current tools act as temporary fixes for inherent model limitations like data inefficiency and a lack of continuous learning. The core thesis suggests that understanding and leveraging these limitations through self-imposed constraints and diverse representation structures can lead to more effective and creative AI applications.

This talk discusses Google DeepMind's approach to building and scaling agentic software. It highlights the Antigravity framework as an integrated IDE and agent management platform, showcasing its capabilities in code generation, task execution, and human-in-the-loop feedback. The discussion also touches upon the challenges and strategies for managing agentic systems at scale, including resource allocation, cost efficiency, and robust evaluation methods.

This talk addresses the challenge of managing and interacting with coding agents, a problem termed FOMAT (Fear of Missing Agent Time). The core thesis is that current agentic workflows often require constant oversight and can lead to developers being blocked or unable to effectively manage multiple agent sessions, especially when away from their development machines. The presented solution, Command and Control, aims to provide a unified interface for monitoring, interacting with, and launching agent sessions from any device.

This talk proposes a shift from homogeneous AI systems, which rely on scaling single models across identical hardware, to a new paradigm of heterogeneous intelligence. This approach leverages the inherent complexity of real-world problems by decomposing them into sub-problems that can be addressed by diverse models, workflows, and hardware working in concert. The core thesis is that this heterogeneity, when properly orchestrated, leads to more efficient, faster, and cheaper AI systems.

This talk introduces WebMCP, a system that enables agents to interact with web content directly within the browser. It explores how existing browser primitives can be leveraged to transform websites into interactive canvases for AI agents, moving beyond simple chat interfaces to richer, embedded experiences. The core idea is to make web content accessible and actionable for agents, similar to how humans navigate and interact with websites.

This talk explores the concept of a software factory, defined as the incremental removal of humans from the Software Development Life Cycle (SDLC) to achieve automated workflows. It highlights that while runtimes, orchestration, and triggers for agents are largely solved, agent coordination remains a significant challenge. The presentation suggests that breaking down the SDLC into micro-steps and developing robust coordination mechanisms are crucial for realizing truly autonomous software development.

This talk introduces Google DeepMind's latest advancements in generative AI, focusing on the Gemini family of models and their applications. The presentation highlights the multimodal capabilities of Gemini, its cost-effectiveness, and its integration into tools like AI Studio for building applications. It also touches upon the development of specialized models for generative media, including image, video, and music creation, and the increasing accessibility of powerful AI models for on-device and local execution.

The talk "Fast Models Need Slow Developers" by Sarah Chieng of Cerebras argues that the advent of significantly faster AI coding models necessitates a fundamental shift in developer habits. While models like Codex Spark can generate code at 1,200 tokens per second, up to 20 times faster than previous generations, developers must adapt their workflows. Without this adaptation, the increased speed will simply lead to the rapid generation of low-quality code and technical debt, rather than unlocking new capabilities.

This talk demonstrates how to run OpenClaw, an open-source coding agent, within containers, from local development environments to Kubernetes clusters. The core thesis is that containerization provides a reproducible, secure, and portable way to deploy and manage AI workloads like OpenClaw, simplifying development, onboarding, and scaling.

This talk introduces Gemini Nano, Google's on-device AI model for Android, and the ML Kit GenAI APIs that provide access to it. The presentation emphasizes the benefits of on-device processing, including enhanced privacy, offline capabilities, and cost savings, while also outlining hybrid approaches that leverage cloud models when necessary. The goal is to provide developers with a comprehensive offering for building intelligent experiences across a range of Android devices.

This talk explores how AI agents can be integrated into the VS Code environment to enhance developer productivity. It categorizes agents into local, background, and cloud types, each suited for different tasks. The core thesis is that VS Code can serve as a unified interface for managing and utilizing these diverse AI agents, streamlining workflows and reducing cognitive load for developers.

This talk explores the challenges and solutions for scaling open-source AI agents, particularly within the Kubernetes ecosystem. It introduces ACP (Agent Client Protocol) as a standardized way for human users to interact with agents, aiming to reduce duplicated effort in building client integrations. The discussion also covers developing automated workflows for tasks like code review and error reporting, emphasizing the potential for agents to handle complex, multi-step processes.

This talk proposes that AI coding agents should be leveraged for complex AI systems engineering tasks, moving beyond simpler applications. The core idea is to use agents to tackle challenging problems in machine learning engineering and systems design. To enable this, the speaker emphasizes the need for standardized repositories, particularly on platforms like the Hugging Face Hub, which already provide many necessary components.

This talk introduces the concept of "any-to-any" multimodal agents, enabled by Google DeepMind's Gemini API. The core idea is to build agents that can understand and generate across various modalities including text, code, images, audio, and video. The presentation outlines the architecture for such agents, focusing on multimodal understanding and native generation capabilities, and demonstrates how to build a notebook LM clone as an example.

This talk explores the challenges and lessons learned in skilling up coding agents to effectively use tools like Langfuse. It highlights the evolution from complex workflows to more autonomous agents and emphasizes the role of formalized skills as shortcuts for reliability. The core thesis is that by leveraging tracing and structured skills, developers can significantly improve agent capabilities and streamline the integration of complex tools into AI applications.

This talk explores the development and application of small and tiny Large Language Models (LLMs) for on-device AI agents. It highlights the benefits of on-device processing, such as improved latency, privacy, and offline functionality. The presentation introduces the Google AI Edge stack, including MediaPipe and the lighter TLM runtime, and discusses two primary approaches: leveraging system-level GenAI like Gemini Nano and developing App GenAI with customizable tiny LLMs.

This talk explores the concept of AI sovereignty, defined as an organization's ability to design, deploy, and operate AI systems on its own terms. It breaks down sovereignty into four pillars: data, model, infrastructure, and operational control. The presentation highlights the challenges and trade-offs encountered when implementing AI systems under these constraints, particularly when moving from convenience-based SaaS solutions to more controlled, self-hosted environments.

This talk proposes a structured approach to building AI agents, moving beyond the hype to focus on practical maturity. It outlines four distinct levels of agent development, from initial framework experimentation to sophisticated cloud deployment. The core thesis is to slow down, identify solvable problems, and build useful agents by understanding their lifecycle and potential pitfalls.

This talk explores Spotify's approach to personalization in the age of Large Language Models (LLMs), moving beyond traditional recommendation systems. It details how Spotify builds foundational user and content models, integrating them into a steerable, personalized generative system. The core thesis is that by leveraging LLMs and advanced modeling techniques, Spotify can create more relevant and user-controlled recommendations.

This talk outlines an initiative by the No. 10 data science team to radically scale AI engineering and development capabilities within the UK government. The core thesis is that by establishing small, agile, and well-resourced "insurgent units" operating with high political backing and autonomy, the government can overcome traditional bureaucratic hurdles to drive AI adoption and address public service delivery crises. This approach aims to attract top technical talent by offering challenging work and competitive compensation, thereby accelerating innovation and improving efficiency across government functions.

This talk demonstrates how to use Google DeepMind's GenMedia models to create rich multimedia content, such as images, videos, and music, by illustrating a book. The presentation walks through practical examples of generating character images, scene illustrations, video clips, and musical scores, all while emphasizing the integration and capabilities of various AI models. The core idea is to leverage AI to bring creative works to life through diverse media.

This talk explores the evolution of AI agents, focusing on enabling them to run for extended periods, from minutes to hours or even days. It details the challenges of long-running agents, such as context limitations and model judgment, and presents Anthropic's approach to overcoming these through model improvements and harness development. The discussion highlights how co-evolving models and scaffolding have led to more capable and autonomous AI systems.

This talk explores the concept of AI harnesses, defining them as the components surrounding an AI model that provide grounding in reality and ensure reliability. The speaker argues that harnesses are crucial for making AI agents dependable, especially when using rented, black-box models. By building a harness, developers can create stable environments that control agent behavior, regardless of the underlying model's non-deterministic nature.

This talk explores how AI engineers can leverage AI itself to manage the complexity of AI products. It details strategies for using internal tools to understand, debug, and improve AI systems, particularly when dealing with intricate prompt chains and complex decision-making processes. The core thesis is that effective AI development requires applying AI-powered solutions to the engineering and debugging workflows.

This talk argues that the common direct HTTP streaming approach for AI chat applications fundamentally limits user experience quality. The default pattern, often using Server-Sent Events (SSE), creates a single, point-to-point connection between a client and an agent, which breaks down when users switch devices, experience network interruptions, or need to interact with a working agent. The presentation proposes a shift towards a decoupled architecture using durable sessions to enable more resilient, multi-surface, and interactive AI experiences.

This talk explores how to move beyond traditional code coverage metrics to ensure true functionality testing, especially in the context of AI-assisted development. It argues that while AI can increase code output, its true productivity gains are amplified by clean codebases and robust testing. The presentation introduces Playwright as a tool for end-to-end browser testing, demonstrating how it can be integrated with AI agents to accelerate development workflows, particularly within a test-driven development (TDD) framework.

This talk argues that building successful vertical AI products is fundamentally an organizational challenge, not solely a technical one. The core thesis is that effectively integrating domain expertise into AI development processes is more critical than the sophistication of the AI models themselves. The speaker proposes a framework for structuring organizations around domain experts, enabling them to contribute at different levels, from direct input to system design, ultimately leading to more differentiated and effective AI products.

This talk introduces context graphs as a solution to the problem of AI agents and systems lacking comprehensive understanding due to siloed data. It argues that by connecting disparate data sources, previous decision traces, and tool-use reasoning into a knowledge graph, AI can move from controlling engineers to being a controllable tool. This approach aims to provide grounded, complete information for more reliable AI-driven decision-making and application building.

This talk explores a case study at PFF, a sports data company, where they transformed their engineering organization by integrating AI agents. The core thesis is that by shifting focus from optimizing individual engineer output to enhancing agent capabilities, significant gains in deployment frequency and product quality can be achieved. This approach led to a reimagining of traditional engineering processes, moving away from rigid structures like Scrum towards more agile, feedback-driven workflows.

This talk explores how to effectively guide AI agents when they interact with complex products like Superbase. It argues that while agents are capable of many tasks, they require specific guidance to handle novel situations, security protocols, and optimized workflows. The presentation introduces the concept of "skills" as a method to provide this guidance, demonstrating how they improve agent performance and safety, particularly when integrated with tool-calling capabilities.

This talk explores how Intercom leveraged AI, specifically focusing on integrating AI agents into their software development lifecycle, to significantly increase engineering throughput. The core thesis is that by treating AI as a platform and empowering engineers with the right tools and guidance, organizations can achieve substantial productivity gains, potentially doubling output without increasing headcount.

This talk focuses on the practical aspects of evaluating and improving AI agents, moving beyond simple "vibe checks" to implement robust testing frameworks. It emphasizes that effective evaluation is crucial for shipping reliable AI applications, especially agents, which are prone to cascading failures. The session introduces methods for capturing agent behavior through tracing, categorizing failures, and implementing various types of evaluations (code-based, LLM-as-judge, human) to ensure agents perform as expected and to drive iterative improvements.

This talk addresses the critical need for robust observability in AI agents, highlighting the gap between an agent's intended functionality and its actual behavior in production. The presenters introduce the "Mind the Gap" analogy to emphasize the importance of continuous evaluation and monitoring throughout an agent's lifecycle. They advocate for a proactive approach to identify and address discrepancies, ensuring agent reliability, quality, and safety.

This talk introduces a novel approach to building agent harnesses using an event-sourced architecture powered by stream processors. The core thesis is that by treating all agent interactions and state changes as events in a log, debugging becomes significantly easier, and extensibility is greatly enhanced. This event-driven model aims to simplify experimentation with different agent configurations and facilitate composable agent systems.

This talk explores the burgeoning open-source AI agent ecosystem, emphasizing the accessibility and power of open models and tools. It highlights how advancements in Hugging Face's platform, including the Hub, Traces, Skills, and MCP tools, are democratizing the development and deployment of sophisticated AI agents. The core thesis is that open-source AI is rapidly catching up to and even surpassing closed-source alternatives, offering greater control, privacy, and customization for developers.

This talk details the development of an AI-powered chess coach, focusing on how to bridge the gap between traditional chess engines and Large Language Models (LLMs). The core challenge addressed is LLMs' inherent weakness in calculation and reasoning for games like chess, despite their ability to explain concepts. The solution involves a pipeline that leverages strong chess engines for analysis and LLMs for generating human-readable explanations, with an autonomous agent loop for continuous improvement.

This talk argues that traditional Continuous Integration and Continuous Deployment (CI/CD) pipelines are becoming obsolete due to the rise of agentic software development. The core thesis is that the increasing volume and complexity of changes generated by autonomous agents necessitate a shift towards a model of Continuous Compute. This new paradigm focuses on accelerating the entire development lifecycle, from code generation to deployment, by integrating compute and caching more deeply into the workflow.

This talk introduces a framework for building AI agents that can interact with a computer, leveraging the AI SDK. The core thesis is that effective agents require an agent runtime, tools for interaction, and a computational environment like a sandbox file system for state persistence and code execution. The presentation demonstrates how to integrate these components to create more capable and autonomous AI agents.

This talk argues that reinforcement learning (RL) is crucial for moving AI models, particularly large language models (LLMs), from pilot stages to production. The speaker posits that the common failure of GenAI pilots stems from the "myth of the last mile," where initial MVPs built on proprietary models or instruction fine-tuning lack systematic improvement pathways. RL, by its nature, allows for the mathematical integration of feedback, leading to more effective model steering and enabling scaled, cost-efficient, and faster deployments.

This talk argues that traditional static testing methods are insufficient for evaluating adaptive AI systems. As AI applications become more dynamic and intent-driven, evaluation strategies must evolve to become equally malleable. The core thesis is that static benchmarks fail to capture the emergent behaviors and changing user interactions characteristic of modern AI, necessitating a shift towards more adaptive and continuous evaluation approaches.

This talk explores the integration of coding agents, specifically the OpenClaw agent, into products. It emphasizes that coding agents are becoming a fundamental building block for software systems and highlights the Pi framework as an excellent tool for experimentation and development. The presentation demonstrates how agents can be leveraged to automate complex workflows, such as processing sales proposals, by interacting with various tools and systems.

Victor is presented as an AI coworker that integrates directly into Slack, aiming to function like a human employee by participating in discussions and utilizing company tools. Unlike personal agents, Victor is designed as a company-wide asset, inheriting access to a vast array of integrations and possessing a broad, horizontal context across the organization. The system addresses challenges such as memory management for multiple users and the complexity of context across different Slack interaction modes.

This talk introduces MLX, an array framework for Apple silicon, enabling developers to run AI models, including large language and multimodal models, entirely on-device. The core thesis is that on-device AI offers a viable and often superior alternative to cloud-based solutions, providing enhanced privacy, reduced costs, and greater accessibility, especially in areas with limited internet connectivity. MLX aims to democratize AI by making powerful models runnable on everyday Apple devices.

This talk explores the fundamental shift required for AI agents in backend infrastructure, moving from stateless to stateful compute. It proposes two primary methods for achieving durable agents: replay and snapshotting. Replay, an evolution of traditional workflow engines, logs every interaction but can become unwieldy with complex agents. Snapshotting, a newer approach, preserves the entire execution state of a machine, offering a more robust solution for long-running, complex agent sessions.

This talk addresses the critical challenge of context management in AI agents, arguing that context engineering, rather than prompt engineering, is the key to agent success. The core thesis is that effective context management allows agents to retain necessary information while discarding irrelevant details, preventing failures caused by overloaded or insufficient context windows.

This talk argues that effectively integrating AI into products requires more than just one-shot prompting. The core thesis is that building robust feedback loops, enabling detailed tracing, and creating flexible development environments are crucial for iterating on AI features and ensuring they meet user needs. This approach allows for a more magical user experience rather than relying on hope and guesswork.

This talk explores the recent architectural trends in text-to-speech (TTS) models, highlighting their convergence with Large Language Model (LLM) approaches. The core thesis is that TTS is increasingly being treated as a sequence modeling problem, similar to how LLMs process text, enabling more natural and lower-latency speech generation, particularly for agentic interfaces.

The talk explores the current state of voice AI and the challenges in achieving a "Her moment," where AI voices are indistinguishable from humans and seamlessly integrated into conversations. While significant progress has been made in speech-to-text and text-to-speech, true conversational fluency, low latency, and the ability to handle complex tool calls remain major hurdles. The presentation contrasts cascaded systems with end-to-end speech-to-speech models, highlighting the limitations of current half-duplex speech-to-speech models in replicating human conversational nuances like overlapping speech and backchanneling.

This talk explores the evolution of chat agents, arguing that voice is the next natural and accessible interface, surpassing text-based interactions. It introduces Voice Engine, a product designed to easily integrate voice capabilities into existing chat agents, enabling richer, more interactive, and omni-channel experiences. The core thesis is that chat agents will either adopt voice or become obsolete, highlighting voice as a crucial upgrade for conversational AI.

This talk explores the evolution of computer vision models, detailing how transformers, despite lacking inherent inductive biases for vision, ultimately surpassed traditional convolutional neural networks (CNNs). This shift was driven by massive, specialized pre-training techniques and leveraged infrastructure advancements from large language models, enabling transformers to learn visual patterns effectively.

This talk introduces FLUX, an open-source visual AI model developed by Black Forest Labs, and discusses its evolution and the future of visual AI. The presentation highlights FLUX's capabilities in text-to-image generation, image editing, and its progression towards visual intelligence. It also delves into a novel training methodology called Self Flow, designed to improve multimodal generative models by integrating representation learning directly into the generation process, eliminating the need for external encoders.

This talk explores agentic search as a critical component of context engineering for Large Language Models (LLMs). The core thesis is that effective context curation for LLMs relies heavily on sophisticated search mechanisms, moving beyond simple retrieval to agent-driven exploration of diverse information sources. The presentation highlights the evolution from basic RAG to agentic RAG and emphasizes the challenges and strategies for building robust search tools that agents can effectively utilize.

This talk introduces Pydantic AI's agent optimization capabilities, focusing on the Jeppa library for prompt optimization and managed variables for dynamic configuration. The core idea is to systematically improve agent performance by iteratively refining prompts and configurations, demonstrated through a practical example of analyzing political family ties in MP data. The presentation highlights how these tools can lead to more accurate and efficient AI agents.

This talk explores the "Vibe Engineering Effect" by demonstrating how to build applications from scratch using AI agents, focusing on practical development workflows rather than hype. The core thesis is that by structuring projects to leverage AI effectively, developers can significantly reduce manual coding, even for complex library-level tasks. The session emphasizes practical techniques for integrating AI into the development process, particularly when working with new or unfamiliar codebases.

This talk addresses the critical need for agent observability in AI systems, highlighting how traditional testing and evaluation methods are insufficient for non-deterministic and complex agents. It proposes a shift towards a monitoring paradigm, emphasizing the importance of collecting both explicit signals (like error rates and latency) and implicit signals (like user frustration and refusals) to understand and improve agent behavior in production. The discussion also touches upon self-diagnostics as a low-effort method for agents to report their own issues.

This workshop explores the concept and practical application of "skills" in AI agents, presenting them as discrete, composable units of work designed to enhance agentic workflows. The core thesis is that skills provide a structured way to encode essential context, instructions, and behaviors, preventing repetitive information input and ensuring consistent, predictable agent performance across various tasks and projects.

This talk introduces Missions, a multi-agent system designed to tackle complex software development tasks that extend beyond a single agent's capacity. The core thesis is that human attention, not intelligence, is the current bottleneck in software engineering. Missions aims to overcome this by enabling systems to execute tasks autonomously for extended periods, allowing human engineers to focus on higher-level strategic decisions.

This talk introduces MCP apps, a standardized way for tools and companies to send their user interfaces directly into chat applications. Instead of relying on text-based responses, which can be suboptimal and strip away brand identity, MCP apps allow for interactive UI components to be embedded within platforms like ChatGPT and Claude. This approach aims to preserve existing UI/UX knowledge and branding while enabling a more seamless integration of external services into conversational AI experiences.

This talk addresses the gap in infrastructure for small model inference, particularly for AI search and document processing. The speaker, Filip Makraduli, shares his journey from overlooking inference to co-founding the open-source Superlinked Inference Engine (SIE). The core thesis is that effective inference for agentic workflows requires a holistic approach combining robust model support with scalable infrastructure, enabling developers to efficiently deploy and manage diverse small models.

This talk focuses on accelerating AI deployment on edge devices, highlighting Google DeepMind's Gemma models and the Lite RT framework. The core thesis is that by optimizing models for edge hardware and leveraging a unified cross-platform architecture, developers can achieve significant performance gains, enhanced privacy, and reduced latency for a wide range of AI applications.

This talk introduces a "demand-driven context" methodology to address the challenge of integrating institutional knowledge into AI agents. The core thesis is that instead of a "push" strategy where all knowledge is pre-loaded, a "pull" approach is more effective. This involves agents actively seeking and documenting information as they encounter problems, gradually building a coherent and useful knowledge base.

This talk provides a hands-on guide to training a transformer-based Large Language Model (LLM) from scratch using PyTorch. It covers the fundamental building blocks of LLMs, including tokenization, model architecture, and the training loop, demonstrating how to implement these components with minimal code. The session emphasizes practical application, enabling participants to train a small model locally or on cloud platforms like Google Colab.

This talk explores how to improve AI agent performance through the use of skills, which are essentially structured folders containing instructions and files for running workflows or providing custom information. The speaker, Pedro Rodrigues from Supabase, details the process of creating, testing, and automating the evaluation of these skills, emphasizing their role in enhancing agent capabilities within products like Supabase. The core idea is to leverage skills for progressive disclosure, allowing agents to access information only when needed, thereby optimizing context window usage.

This talk introduces "Ralph loops," a method for building AI agents that can iteratively improve their own work by repeatedly attempting a task. The core idea is to leverage the ability of modern AI models to self-correct and refine outputs through repeated execution of a prompt or instruction. This approach moves away from complex, brittle orchestration workflows towards simpler, more robust agentic loops that can be applied to various tasks, including coding and content generation.

This talk explores the advancements and applications of tiny Large Language Models (LLMs) and agent skills on edge devices. It highlights how these technologies enable powerful on-device AI experiences, focusing on reduced latency, enhanced privacy, and offline functionality. The presentation delves into the capabilities of Google's Gemma models and the LiteRT-LM runtime, showcasing their potential for building sophisticated AI-powered applications directly on user devices.

This talk introduces the concept of a "context engine" for AI agents, which aims to provide agents with the necessary information to perform tasks effectively without overwhelming them with irrelevant data. The core idea is to move beyond simple access to information and achieve true understanding, enabling agents to operate with the efficiency and insight of a seasoned team member. The presentation debunks common myths about context engines and shares lessons learned from building and implementing such systems.

This talk proposes that context is the new code in software development, shifting focus from writing explicit code to generating and managing contextual information for AI agents. It outlines a "context development life cycle" analogous to the DevOps infinity loop, encompassing generation, testing, distribution, and observation of context. The core idea is that by engineering and refining context, developers can significantly improve the performance and reliability of AI-driven development processes.

This talk demonstrates how to build a human-in-the-loop automation agent using n8n, focusing on managing Gmail and Google Calendar. The core idea is to create an agent that can perform tasks but requires human approval for sensitive or critical actions, ensuring control and preventing errors. The session covers setting up n8n, integrating AI models, defining tools for the agent, and implementing a human review step before execution.

This talk details how an AI agent, specifically Open Claw, was incrementally integrated into an individual's daily life, granting it access to emails, notes, files, calendars, and system automations. The process was gradual, starting with simple chat functionalities and evolving to encompass a comprehensive knowledge base and automated daily operations, ultimately aiming to assist a future self.

This talk posits that as AI capabilities advance, the role of software engineers will increasingly shift from direct code writing to planning and reviewing AI-generated code. This evolution necessitates new approaches to managing workflows, particularly as AI agents begin to run for longer durations, requiring engineers to adopt a more parallel and managerial style of work.

AI companies are experiencing hypergrowth, growing three times faster than traditional SaaS, but this rapid expansion presents significant pricing challenges. Traditional subscription or pure usage-based models are insufficient due to unpredictable external costs and the risk of margin erosion from power users. Pricing must evolve rapidly alongside product development to maintain a competitive advantage.

This talk explores the evolution of AI agents within the tldraw collaborative canvas environment. It begins with early experiments like Make Real, which translated drawings into functional prototypes, and progresses to integrating AI as a direct collaborator on the canvas. The core thesis is that by bringing agents directly onto the canvas, rather than confining them to sidebars, we can unlock more intuitive and powerful forms of human-AI collaboration, especially for creative and development tasks.

This talk focuses on the practical challenges of shipping complex AI applications, moving beyond initial prototypes to robust, production-ready systems. It emphasizes the need for operational rigor, structured workflows, and continuous evaluation, drawing on experiences from Braintrust and Trainline. The core thesis is that while AI models are increasingly sophisticated, the operational practices for deploying and managing them at scale have lagged, creating a significant hurdle for delivering real customer value.

This talk explores the expanding role of AI agents beyond traditional coding tasks, emphasizing their potential to enhance productivity across various business functions. The core thesis is that AI agents are becoming indispensable tools for "everything else," enabling individuals and small teams to achieve significant output by automating complex workflows and reducing manual effort. The speaker highlights personal experiences demonstrating how agents can streamline tasks from design implementation to data management and even purchasing.

This talk introduces the Gemini Interactions API, a new unified API designed to simplify building with large language models and agents. It emphasizes a more developer-friendly interface, akin to industry standards, and introduces server-side state management for improved agent development. The session also showcases the Gemini Live API for real-time conversational AI applications, including audio and video processing, and demonstrates how to build a coding agent with file I/O and bash command execution capabilities.

This talk details how Cursor refactored a complex feature, originally spanning 12,000 lines of code, into a concise 200-line skill. This transformation leveraged existing primitives like agent skills and sub-agents, primarily using markdown to redefine functionality. The refactoring aimed to reduce maintenance overhead and improve user experience for advanced features.

This talk introduces OpenAI's Codex, an AI software engineering agent capable of performing a wide range of tasks beyond just writing code, such as running commands, executing tests, and exploring codebases. It highlights the underlying models, the unified agent harness for managing agent behavior, and the various interfaces through which users can interact with Codex, including a dedicated app, IDE extensions, and CLI. The presentation emphasizes the continuous improvement of Codex through model advancements and the development of features like plugins and automations to enhance developer productivity.

This talk explores building and deploying AI-powered applications, focusing on the capabilities and accessibility of Google DeepMind's latest models and tools. It highlights the multimodal nature of Gemini models, their integration into AI Studio for rapid prototyping, and the potential for creating complex applications with features like code execution, search grounding, and dynamic world generation. The presentation emphasizes practical demonstrations over slides, showcasing how developers can leverage these advancements for diverse projects.

This talk explores the unique challenges and opportunities in training small, frontier AI models, emphasizing that they are not simply scaled-down versions of larger models. The core thesis is that small models, designed for edge deployment, possess distinct characteristics like being memory-bound, having lower knowledge capacity, and being latency-sensitive. Addressing these specific traits requires tailored architectural choices, training methodologies, and problem-solving approaches, particularly for issues like doom-looping.

This talk explores the concept of building a "software factory" using AI agents, moving beyond simple code completion to autonomous systems that can handle complex development tasks. The core idea is to borrow principles from physical factories, such as assembly lines and robust infrastructure, and apply them to software development to increase throughput and consistency. While fully autonomous factories are still aspirational, significant progress can be made by implementing structured primitives, guardrails, and enablers for AI agents.

Building effective evaluation (eval) platforms for AI agents is a complex systems problem, not just a UI challenge. While starting with simple tools like spreadsheets is a valid first step, maturing requires moving towards more robust solutions that facilitate experimentation and integrate with production data. The core difficulty lies in managing the unique characteristics of AI agent traces, which are often large, unstructured, and high-velocity, demanding specialized data infrastructure.

This talk addresses the friction of repeated authentication for Multi-Cloud Platform (MCP) tools, where users must consent to access for each tool individually. It introduces Cross-App Access (XAA), a solution that leverages an Identity Provider (IDP) to act as a trust intermediary. XAA enables MCP clients to obtain credentials for MCP servers without manual user intervention after an initial single sign-on, streamlining the user experience and improving security management for IT.

This talk provides a deep dive into Gemma 4, Google DeepMind's latest family of open-source AI models. The presentation highlights significant architectural improvements and new capabilities, including enhanced multimodal support and optimized performance for both on-device and complex reasoning tasks. Gemma 4 aims to set a new standard for small, open-source models, making advanced AI more accessible to developers.

This talk discusses the challenges and solutions encountered by GitHub in building and scaling their MCP (Multi-modal Communication Protocol) server for AI agents. The core thesis revolves around managing the complexity of tool integration, optimizing context window usage, and enhancing security in agentic systems. The presentation highlights how GitHub has iterated on its server architecture and features to improve agent performance and user experience.

This talk argues that gateways are the essential infrastructure for enterprises adopting Multi-Model Communication Protocol (MCP) tools. While MCPs offer significant potential, enterprises face challenges with observability, access control, and security. Gateways act as a crucial middle layer, abstracting these complexities away from individual MCP server developers and establishing a root of trust for secure and scalable agent deployments.

The talk argues that the current trend of scaling individual developer productivity with AI agents overlooks the inherently collaborative nature of software development. While AI can rapidly implement code, the critical bottleneck has shifted to aligning on *what* to build. Existing tools are ill-equipped for this new paradigm, leading to wasted effort and misaligned projects. The proposed solution involves creating shared, intelligent environments where teams can collaborate on planning and development alongside AI agents.

This talk addresses the challenge of providing AI agents with access to a vast number of APIs, a problem termed the Mega Context Problem (MCP). Traditional methods like bundling all tools into an agent's context window lead to an explosion of tokens, rendering them unusable. The speaker proposes that instead of dumping tools into context, agents should be empowered to write code against APIs, leveraging typed SDKs and secure execution environments.

Agent Craft is an orchestrator designed to enhance human-agent collaboration by drawing parallels from gaming mechanics. The core thesis is that while individual agents are powerful, human orchestration is the current bottleneck. Agent Craft aims to raise this ceiling by providing better visibility, enabling greater agent autonomy, and facilitating seamless human-to-agent collaboration, ultimately transforming how developers work with AI agents.

This talk explores a structured workflow for AI coding, emphasizing that traditional software engineering fundamentals remain crucial when working with AI. The core thesis is that by understanding LLM constraints—specifically their "smart zone" and tendency to forget—developers can build effective AI-powered workflows. The approach focuses on breaking down large tasks into manageable chunks that fit within the LLM's optimal performance window, ensuring better decision-making and code quality.

This talk challenges the perception that AI models are rapidly approaching general intelligence, as suggested by steadily increasing benchmark scores. It argues that despite impressive progress, models still exhibit significant weaknesses, particularly in handling nonsensical or complex, real-world tasks. The presentation introduces a benchmark focused on nonsensical questions and analyzes user dissatisfaction data to reveal areas where models continue to struggle.

This talk argues that fundamental software engineering principles are more critical than ever in the age of AI. The speaker critiques the "specs-to-code" movement, which suggests generating code from specifications using AI, asserting that this approach often leads to deteriorating code quality. Instead, the talk emphasizes that well-structured, understandable, and maintainable codebases are essential for effectively leveraging AI's capabilities and that AI should be viewed as a tactical tool requiring strategic human oversight.

This talk explores the evolution of personal productivity tools and agents, moving from early to-do lists and text files to sophisticated AI assistants. The core thesis suggests that traditional applications are becoming obsolete, replaced by integrated "life OS" systems and AI agents that proactively manage tasks and information. The future likely involves a shift where AI prompts the user, rather than the other way around, fundamentally changing how we interact with computers.

This talk argues that complex AI agents require more than simple chat interfaces for effective collaboration. The core thesis is that as AI agents become more capable of performing complex, end-to-end tasks, the bottlenecks shift from the execution of the work itself to the planning and review stages. To address this, a more sophisticated approach to agent-human interaction is needed, focusing on control and trust within specialized workflows.

This talk provides a behind-the-scenes look at training generative image and video diffusion models at scale. It covers essential aspects from data curation and representation to modeling, architecture, training, sampling, and control mechanisms. The core thesis emphasizes that while diffusion models are powerful, their effectiveness relies heavily on careful data handling, efficient latent representations, and sophisticated sampling techniques like guidance.

This talk explores the evolving landscape of software engineering driven by AI, focusing on the phenomenon of "token maxing" and its implications for developer productivity and company culture. It questions whether current AI tools are truly making engineers faster and discusses how the role of a software engineer is expanding to encompass broader responsibilities.

This talk explores the potential pitfalls of rapid software development fueled by AI, emphasizing the importance of deliberate decision-making and high-quality craft over sheer speed. It argues that while AI tools can accelerate development, they may lead to a proliferation of mediocre or confusing products if not guided by a strong sense of taste and user focus. The conversation highlights the need for engineers to maintain a critical perspective, prioritizing user needs and product quality even as development cycles shorten.

This talk demonstrates how to run large language models, specifically Gemma 4, on an iPhone using the MLX framework. It highlights the efficiency and speed achievable with on-device AI, enabling applications to run locally without an internet connection. The presentation covers the tools and resources needed to integrate these models into iOS and macOS applications, emphasizing the growing ecosystem and ease of implementation.

This workshop introduces a system for automating the creation of technical articles, moving beyond generic AI-generated content. It details the architecture and implementation of a deep research agent and a writing agent, designed to work together to produce high-quality, human-like content. The system aims to augment human writers by handling the research and initial drafting, allowing for more efficient and scalable content production.

Gemma is Google DeepMind's family of open models, designed to be downloadable, runnable on personal infrastructure, and fine-tunable for specific use cases. The latest release, Gemma 4, offers models ranging from 2 to 32 billion parameters, with capabilities extending to on-device agentic tasks, multimodal understanding, and multilingual support. These models are developed with a focus on developer-friendly sizes and an Apache 2.0 license for greater flexibility.

AI engineering represents the successor to web development, poised to shape the next decade of software. Agents are emerging as a new form of software, making previously economically unviable automation tasks feasible. This shift is expanding the scope of what can be automated and increasing the demand for software engineers.

This talk introduces "code mode," an alternative approach to AI agent interaction that moves beyond traditional JSON-based tool calling. Instead of complex back-and-forth with models to select and execute tools, code mode allows AI agents to generate and execute code directly within a controlled environment. This method leverages the inherent capabilities of code, such as looping and state management, and significantly reduces token usage and execution time, especially when dealing with extensive API surfaces.

This talk explores the evolution and future of the Message Communication Protocol (MCP), emphasizing its role in enabling agents to achieve full connectivity. The core thesis is that MCP is a crucial connective tissue, allowing agents to interact with various applications and services, moving beyond simple coding tasks to handle complex knowledge work. The future of agent development in 2026 hinges on seamless integration of MCP with other tools like CLIs and skills to achieve robust functionality.

This talk explores Google DeepMind's research into the next frontiers of AI, focusing on advancements beyond traditional language models. It highlights progress in creating more robust and versatile AI systems, including multimodal embedding models, advanced weather prediction systems, and interactive 3D world models. The core thesis is that significant breakthroughs lie in developing AI that can understand and interact with the world in more comprehensive and nuanced ways, moving towards more general intelligence.

This talk explores the challenges and potential pitfalls of using AI agents in software development, arguing that while these tools offer significant productivity gains, they can also introduce subtle forms of friction that undermine code quality and engineering judgment. The core thesis is that intentionally reintroducing certain types of friction is crucial for maintaining control, ensuring quality, and leveraging human experience in an agent-assisted development workflow.

Peter Steinberger discusses the rapid growth and current state of Open Claw, an open-source AI project he created. He highlights its significant adoption and contributor base, while also addressing the substantial security challenges the project faces due to its popularity and the evolving threat landscape. Steinberger emphasizes the importance of user education and responsible deployment of AI agents.

This talk introduces Harness Engineering, a paradigm shift in software development where AI agents execute tasks guided by human direction. The core thesis is that implementation is no longer the bottleneck; code is abundant and cheap to produce. The focus shifts to systems thinking, design, and delegation, empowering engineers to leverage AI agents for complex, long-horizon work. This approach aims to maximize productivity by automating implementation and freeing human engineers for higher-leverage activities.

This talk critiques the current state of AI coding agents and development tools, arguing that many are overly complex, lack transparency, and introduce "booboos" (errors) that compound over time. The speaker advocates for a shift towards more malleable, self-modifying agents and emphasizes the importance of human oversight, discipline, and understanding in the development process. The core thesis is that developers should regain control of their tools and workflows, prioritizing essential features and human understanding over unchecked agent-driven development.

This talk addresses the escalating sophistication of AI attacks, moving beyond simple prompt injection to complex exploits targeting LLM interfaces, data, and even internal mechanisms. It proposes a practical, low-latency, self-hosted defensive layer built by fine-tuning a modern encoder model, specifically ModernBERT, to act as a guardrail against these threats. The approach emphasizes efficiency and cost-effectiveness, aiming for a defense under a dollar per instance.

Paperclip is an open-source human control plane for AI labor, designed to orchestrate AI agents for accomplishing real-world tasks. It allows users to set up an organizational chart of agents, manage their interactions, and invoke specific preferences to complete work. The system emphasizes user involvement from high-level design to execution, enabling the creation of businesses that can largely run themselves with human oversight.

This talk addresses the chaos arising from multiple teams building AI agents independently, leading to duplicated efforts in security, infrastructure, and deployment. Amplifon's "Amplify" program established a unified approach through an enterprise-grade registry system for MCP (Machine Communication Protocol) and A2A (Agent-to-Agent) agents. This system aims to standardize development, ensure governance, and provide traceability for AI solutions across the organization.

This talk introduces GEPA, a method for building calibrated LLM evaluators that align with human annotations. The core idea is to move beyond generic LLM judges, which often fail in production, by optimizing prompts using algorithms like GEPA. This approach aims to accelerate development cycles by providing reliable signals for both offline evaluations and online monitoring, ultimately contributing to the creation of a data flywheel for continuous AI improvement.

This talk explores how AI is transforming web development, moving beyond simple coding assistance to integrate into every stage of the web application lifecycle. It highlights how AI can aid in debugging, performance tuning, and even how web applications need to adapt to be consumable by AI agents. The presenters emphasize that mastering AI tools and understanding new integration patterns are becoming essential skills for web developers.

This talk explores the practical performance of running large language models (LLMs) locally on the NVIDIA Jetson Spark, a system designed for AI development. It addresses challenges like memory limitations and software stack access that often push AI workloads to the cloud. The presentation emphasizes how local solutions can enhance developer productivity by bringing AI development closer to the user, enabling faster iteration and addressing concerns like cost predictability and data residency.

This talk addresses the significant engineering challenge of extracting actionable business intelligence from messy, low-latency audio streams in contact centers. It proposes a four-stage pipeline to transform raw audio into structured data, aiming to reduce after-call work (ACW) and improve operational efficiency. The core idea is to leverage generative AI to automate summarization and data extraction, thereby reducing operator stress and enhancing customer experience analysis.

This talk introduces OpenRAG, an open-source stack designed to simplify the creation of powerful and customizable Retrieval-Augmented Generation (RAG) systems. It addresses the complexity often encountered in RAG pipelines, from document ingestion and chunking to embedding and search, by integrating existing open-source tools into a cohesive framework. OpenRAG aims to provide a robust baseline that developers can easily extend to meet specific project requirements.

This talk addresses the challenges of scaling multi-agent AI systems beyond a single agent, emphasizing that complexity grows exponentially, turning simple AI problems into distributed systems challenges. It introduces key patterns for coordination, state management, and failure recovery, arguing that robust system design, not just AI capabilities, is crucial for production-grade multi-agent applications. The core thesis is that adopting established distributed systems principles is essential for building reliable and valuable multi-agent systems.

This talk introduces the concept of "cognitive exhaust fumes" – the byproduct of digital activity that, when analyzed across multiple sources, can reveal insights into an individual's cognition, attention, and relationships. The speaker advocates for read-only AI systems, termed "observers," which analyze this exhaust without writing back to the original data sources. This approach is presented as a safer alternative to action-oriented AI agents, mitigating risks and potentially yielding more authentic self-analysis.

This talk focuses on engineering platforms to effectively support both human developers and AI agents. It argues that the challenges developers face in deploying applications and managing infrastructure become more pronounced and limiting when AI agents are involved. The core thesis is that by adopting specific platform engineering best practices, organizations can unlock greater productivity and enable AI agents to function more autonomously and effectively.

This talk addresses the critical need to sandbox AI-generated code, emphasizing that such code should be treated as untrusted. The core thesis is that while AI can accelerate development, running its output without proper security measures is akin to executing code from an anonymous internet source, posing significant risks. The presentation advocates for applying established sandboxing principles, particularly capability-based security, to mitigate these threats.

This talk addresses the critical security and design considerations for Multi-modal Communication Protocol (MCP) servers intended for production environments. It argues that insecure or poorly designed MCP servers are vulnerable to exploitation by agentic AI systems. The presentation emphasizes that robust security and effective design are intertwined, advocating for a product engineering mindset when building interfaces for AI agents.

This talk explores engineering reinforcement learning (RL) environments for language models, enabling them to learn through interaction, exploration, and feedback. It highlights how these environments serve as crucial training grounds for LLM agents, allowing them to develop skills in tool use, code execution, and complex task solving. The presentation introduces Verifiers, an open-source library for building such environments, and demonstrates their application through an experiment transforming a basic tic-tac-toe playing model into a master.

This talk explores strategies for effectively integrating and managing third-party tools within AI agent workflows, specifically focusing on Multi-Call Protocol (MCP) servers. It addresses the common challenges of generic tool descriptions, unexpected agent behavior, and potential performance degradation or security risks when using off-the-shelf tools. The presentation outlines a framework of five best practices to tailor these tools for specific use cases, ensuring agents perform as intended and applications remain stable.

This talk introduces the concept of agentic engineering, shifting the paradigm from merely using AI tools to actively collaborating with them. It highlights the evolution of AI in software development from simple line completion to sophisticated agents capable of executing complex tasks. The core thesis is that understanding and managing AI agents as collaborators, akin to junior developers, is crucial for maximizing their potential and navigating the complexities of modern software development.