The Video Signal

Channel

NDC Conferences

Digests from NDC Conferences

Aspire 13: One AppHost, Many Languages, Fewer Headaches? - Chris Ayers - NDC Toronto 2026 thumbnail

· 52:34

Aspire 13: One AppHost, Many Languages, Fewer Headaches? - Chris Ayers - NDC Toronto 2026

Aspire AppHost provides a unified orchestration layer for polyglot systems, allowing developers to treat mixed-stack projects (e.g., .NET API, Python worker, Node front end) as a single product rather than multiple disconnected repositories. The system simplifies local development by automating service wiring, managing configuration via environment variables, and providing a centralized dashboard for unified telemetry, logging, and debugging across diverse languages.

Key takeaways

  1. Unified Polyglot Orchestration 2:00

    Aspire AppHost allows developers to declare services, dependencies, and resources in one place, eliminating the need for scattered configuration files (YAML, appsettings.json) and complex manual setup scripts.

  2. Centralized Observability 3:30

    The dashboard provides a single pane of glass to view telemetry, structured logs, traces, and metrics from all connected services, greatly simplifying debugging across different language stacks.

  3. Automated Service Wiring & Discovery 5:40

    Service discovery is handled automatically using conventions (e.g., `services_` or `connections_`), ensuring that services can find and connect to dependencies (like databases) without manual IP/port configuration.

  4. AI-Assisted Development Workflow 9:40

    New agent capabilities allow developers to manage environments, query logs, debug failures, and even suggest code fixes directly within the chat interface (e.g., using VS Code Copilot).

Watch on YouTube Full article

Agents & Arbiters - An Adventurer’s Guide to Multi-Agent Collaboration with LangGraph.js - Guy Royse thumbnail

· 59:56

Agents & Arbiters - An Adventurer’s Guide to Multi-Agent Collaboration with LangGraph.js - Guy Royse

The talk introduces multi-agent collaboration using LangGraph.js as an advanced pattern for building complex, interactive systems that move beyond fragile, scripted logic. Instead of anticipating every user action with nested `if` statements, the system uses autonomous agents (LLMs) to contribute perspectives and make decisions. The architecture is built around a graph structure that orchestrates specialized nodes—including routers, experts, arbiters, and committers—to manage state changes and generate coherent responses.

Key takeaways

  1. Agent Definition 24:28

    An agent is defined as an LLM with a system prompt defining its purpose, coupled with a collection of tools that allow it to interact with the world. These agents are composable within a graph structure.

  2. Graph Workflow Components 34:05

    The system uses an orchestration workflow (router, classifier, agents, arbiter, committer) to manage complex interactions. The router determines which specialized nodes are relevant for a given input, and the arbiter reconciles conflicting suggestions from multiple agents.

  3. Conditional Edges 38:38

    Conditional edges allow the graph's flow to be determined by an LLM's reasoning over the current state, enabling patterns like the Supervisor pattern and the ReAct (Reasoning and Acting) cycle. This is crucial for dynamic decision-making.

  4. State Persistence and Memory 48:50

    To solve context loss, the architecture utilizes a dedicated Agent Memory Server (a library/Docker image) that automatically compacts message history and extracts long-term facts asynchronously, providing continuous memory across sessions.

Watch on YouTube Full article

Why Great Models Fail: Lessons From 9 Years of Deploying ML Models - Megan Robertson thumbnail

· 59:14

Why Great Models Fail: Lessons From 9 Years of Deploying ML Models - Megan Robertson

The talk outlines critical lessons from deploying ML models in production, arguing that model accuracy alone is insufficient for real-world success. Success requires rigorous project scoping, continuous monitoring infrastructure, and ensuring the model's value proposition (Value Ad) significantly outweighs its maintenance cost and potential risks. Key failure points include minimal stakeholder consultation, ignoring data drift, and failing to plan for inevitable changes in the operational environment.

Key takeaways

  1. Stakeholder Value is Paramount 13:20

    The model's value must be quantifiable (KPI) and its contribution must outweigh the cost of maintenance. Stakeholders must guide the project scope, preventing engineers from building technically cool but commercially irrelevant solutions.

  2. Scope Definition is a Multi-Step Process 23:20

    Proper scoping requires defining who is served (stakeholders/end users), clearly articulating the problem, understanding constraints and risks, identifying possible solutions (MVP approach: crawl, walk, run), and planning maintenance.

  3. ML Models Require Continuous Monitoring 58:20

    Since models are trained on a single point in time, they must be monitored for performance degradation. Strategies include tracking data issues (e.g., distribution changes), feature drift, and model-specific metrics (e.g., Mean Absolute Error, F1 scores).

Watch on YouTube Full article

Building a Doom-Like World to Explore Agentic Systems - Alexander Chernov - NDC Toronto 2026 thumbnail

· 52:42

Building a Doom-Like World to Explore Agentic Systems - Alexander Chernov - NDC Toronto 2026

This talk presents an architectural framework for building complex agentic systems using a modified Doom-like game engine as a controlled testbed. The core concept is treating agents as 'semantic mirrors' of the game world state, allowing non-player characters (NPCs) to act autonomously while maintaining strict observability and reproducibility. The architecture emphasizes decoupling AI reasoning from the game loop via specialized components like the MCP Gateway, enabling real-world application of simulation techniques in fields such as pharmaceutical R&D.

Key takeaways

  1. Agentic Systems Architecture 2:00

    The system models agents as autonomous entities that perceive the environment and make decisions. The architecture is designed to be observable, attributable, and reproducible through structured world state changes (the 'semantic mirror').

  2. Two-Tiered Agentic Vision 4:20

    To manage latency, a two-tier vision system is implemented: a fast, deterministic observer swarm (7 Hz) for basic tracking, and a slower, LLM-powered tier using 'Lenses' to extract complex semantic information from the environment.

  3. Architectural Components 5:40

    Key components include the Policy Guard system (defining what agents can/cannot do), the MCP Gateway (Model Context Protocol) for external integration, and a Semantic Cache (Mosquito Dog) to reduce latency and cost by caching LLM responses.

  4. Reproducibility and Validation 7:50

    The design ensures determinism through fixed control loops (e.g., 35 ticks per second), state machine transitions, and structured logging of events (JSONL). This allows for full replay and behavioral regression testing.

Watch on YouTube Full article

Like Having an Intern? The Impact of LLMs on Software Engineering Careers -Tom Sellek & Netta Avnoon thumbnail

· 1:01:27

Like Having an Intern? The Impact of LLMs on Software Engineering Careers -Tom Sellek & Netta Avnoon

The talk analyzes the profound impact of LLMs on software engineering expertise, moving beyond simple productivity metrics. While studies show high adoption rates and immediate gains (e.g., up to 5x increase in lines of code), the discussion highlights significant risks: a potential degradation of core skills, reduced critical thinking, and an over-reliance that impairs long-term learning ability. Experts are cautioned that while LLMs feel like 'interns'—super eager but requiring constant review—this dependency may create a dangerous gap in the junior engineer's ability to independently evaluate or debug complex code.

Key takeaways

  1. High Adoption, Low Trust 23:22

    Despite LLMs showing positive sentiment and high perceived quality (some respondents believe generated code is better than average), a significant portion of developers report low trust in the tool's output, leading to cautious practices like only 8% merging code without human review. This discrepancy suggests a disconnect between perceived capability and actual confidence.

  2. Skill Degradation is Quantifiable 35:05

    Research indicates that LLM use can impair fundamental learning abilities. Studies found that using LLMs for tasks led to a quantifiable impairment in understanding and debugging unfamiliar codebases, suggesting the tool doesn't just set a bad example but actively hinders skill acquisition.

  3. The 'Intern' Analogy 26:45

    LLMs are often compared to an inexperienced intern: highly productive, available 24/7, but requiring constant human oversight. The core risk is that junior engineers may not develop the necessary critical judgment skills required to effectively review and correct LLM output.

  4. Cognitive Surrender 38:25

    The process of over-relying on AI can lead to 'cognitive surrender,' where users are willing to follow the machine's incorrect path, even when it is statistically far less likely to be correct. This goes beyond typical automation bias.

Watch on YouTube Full article

Locknote: Reasons to be Cheerful: 0, 1, 2 - Emmz Rendle - NDC Copenhagen 2026 thumbnail

· 57:04

Locknote: Reasons to be Cheerful: 0, 1, 2 - Emmz Rendle - NDC Copenhagen 2026

The talk presents a highly optimistic overview of technological progress across multiple domains, arguing that advancements in AI, quantum computing, and biotechnology are solving complex global problems. While addressing concerns about job displacement and climate change, the speaker emphasizes that these technologies—such as specialized LLMs (Gemma 4, Qwen 3.6) for code generation or CRISPR for personalized medicine—are tools that enhance human capability rather than replace it entirely. The presentation also touches on hardware advancements like shared memory architectures and post-quantum cryptography standards.

Key takeaways

  1. AI in Diagnostics and Genomics 5:20

    AI models are revolutionizing medicine by analyzing complex data sets, such as MRI scans (sub-millimeter slice images) to flag issues for radiologists. Furthermore, DNA/RNA analysis can detect hereditary disease risks and enable custom per-patient cancer treatments.

  2. Quantum Computing Threat and Solution 12:30

    The advent of powerful quantum computers (e.g., those capable of running Shor's algorithm) will render current classical cryptography (RSA, Diffie-Hellman, EDCSA) obsolete. The industry is responding by adopting post-quantum cryptography standards approved by NIST, specifically mentioning Dilithium and Kyber.

  3. AI for Software Productivity 17:30

    LLMs are not replacing programmers but acting as a new programming paradigm. They can generate functional code that is safe to put into production, allowing developers to focus on engineering the system's logic rather than manual typing.

  4. Advancements in Robotics and Automation 23:20

    Robotics are advancing through LLM-driven operating systems (like Gemini Robotics 1.5) that allow robots to reason through steps necessary for tasks, enabling scalable deployment across multiple units.

  5. Sustainable Energy and Climate Solutions 31:40

    New technologies include solar windows (generating electricity while visible) and 'solar canals,' which use floating panels over irrigation channels to prevent water evaporation and generate power.

Watch on YouTube Full article

The fundamentals of Agentic Coding (AKA Vibe Coding) - Theodor René Carlsen - NDC Copenhagen 2026 thumbnail

· 15:42

The fundamentals of Agentic Coding (AKA Vibe Coding) - Theodor René Carlsen - NDC Copenhagen 2026

The talk demystifies 'agentic coding' by establishing a fundamental baseline for understanding AI-assisted development tools. The core concept is that these systems rely on three components: the models (the brain), the harnesses (the ability to act), and the tools (specific functions). Speakers emphasize that while the ecosystem moves rapidly, understanding this architecture—especially the feedback loop where the harness executes actions based on model intentions—is crucial for practitioners. A key recommendation is maintaining control by favoring open-source, customizable systems over locked-down, proprietary solutions.

Key takeaways

  1. The Three Pillars of AI Coding Tools 4:00

    AI coding tools fundamentally consist of three parts: the models (e.g., GPTs from OpenAI, Claude from Anthropic), the harnesses, and the tools. The model is the 'brain,' but the harness allows it to perform actions beyond text generation.

  2. Understanding Agent Functionality 5:10

    Agents operate using a combination of a configurable system prompt (initial instructions) and defined tools. The model generates an *intention* (text), which the harness executes (e.g., reading files, running terminal commands). The output is then fed back into the model, creating a critical feedback loop.

  3. The Importance of Openness and Control 11:10

    While proprietary tools (like Cloud Code) are powerful, speakers caution against losing control. The ability to customize the harness is vital for a healthy ecosystem; open-source solutions allow introspection and customization.

Watch on YouTube Full article

The Sound of Your Secrets: Teaching Your Model to Spy, So You Can Learn to Defend - David vonThenen thumbnail

· 51:32

The Sound of Your Secrets: Teaching Your Model to Spy, So You Can Learn to Defend - David vonThenen

This talk details acoustic keystroke logging—a method of intercepting typed information purely from sound rather than physical interception. The speaker outlines how deep learning models can be trained using spectrographic images derived from recorded key presses to classify specific letters (e.g., 'S'). While demonstrating the high accuracy of single-keyboard attacks (100%), the presentation shows that multi-keyboard logging is challenging but feasible, especially when combined with context prediction and spell-checking algorithms. The session concludes by emphasizing defensive measures, including two-factor authentication using physical keys and implementing strong, unique, offline password policies.

Key takeaways

  1. Acoustic Keystroke Logging Mechanism 16:22

    The attack relies on machine learning audio classification. Audio files (linear 16 format) are converted into spectrographic images (frequency over time, visualized as a heatmap), which serve as the input for training models like Convolutional Neural Networks (CNNs).

  2. Multi-Keyboard Attack Complexity 28:12

    While single-keyboard classification can achieve 100% accuracy, using multiple keyboards significantly lowers confidence scores. The problem is made solvable by decomposing the text based on space delimiters and employing spell-checking/context prediction (e.g., predicting 'hello people' from partial sound inputs).

  3. Defensive Strategies 40:50

    Defense requires layered security: use physical two-factor authentication keys (like YubiKey) instead of SMS; utilize unique, complex passwords that are not known to the user; and be aware of potential signal interference or noise.

Watch on YouTube Full article

How I Tamed Claude - Emmz Rendle - NDC Copenhagen 2026 thumbnail

· 59:38

How I Tamed Claude - Emmz Rendle - NDC Copenhagen 2026

The talk details a structured methodology for leveraging advanced coding agents, particularly Claude, to achieve production-grade code generation and maintainability. The core principle is moving away from 'vibe coding' by implementing a spec-driven workflow that enforces separation of concerns among multiple specialized AI agents (Orchestrator, Worker, Reviewer). This process emphasizes defining clear requirements, maintaining an auditable development history, and managing context to ensure the final solution is robust and reliable.

Key takeaways

  1. Spec First, Code Second 12:04

    The workflow must begin with a detailed specification (the 'spec'), which acts as the source of truth for the entire project. The speaker recommends using OpenSpec's four phases: Explore $ ightarrow$ Propose $ ightarrow$ Apply $ ightarrow$ Archive [~10:35].

  2. Separation of Agent Powers 30:30

    The system must enforce a clear separation of duties among agents. The Worker writes code, the Reviewer validates it against the spec and design, and the Orchestrator manages commits and pushes; crucially, neither the Worker nor the Reviewer can approve or commit work [~18:30].

  3. Definition of Done (DoD) 40:15

    A rigorous Definition of Done is critical for preventing scope creep and ensuring quality. This includes mandatory checks like all tests being green, achieving good coverage, running `net format` twice, and completing the entire task group [~24:15].

  4. Context Management 52:05

    To prevent agents from becoming confused or hallucinating outdated information, context must be actively managed. Techniques include using Graphify (for code mapping), Context Mode (to summarize raw output and reduce token count by 70-80%), and dedicated MCP services like Context 7 for accessing up-to-date documentation [~31:25].

Watch on YouTube Full article

Global Bias in AI: When Western Data Shapes the World - Masuma Shariff - NDC Copenhagen 2026 thumbnail

· 56:20

Global Bias in AI: When Western Data Shapes the World - Masuma Shariff - NDC Copenhagen 2026

This talk explores systemic bias in AI models caused by uneven global data representation, arguing that when training data overwhelmingly originates from Western nations (the Global North), the resulting systems fail to accurately serve or represent developing populations. The speaker details how biases accumulate across the entire AI pipeline—from data collection and annotation to model deployment—using case studies in image recognition, medical diagnostics, finance, and governance to illustrate real-world consequences like misdiagnosis and financial exclusion.

Key takeaways

  1. Bias is not static; it multiplies across the AI pipeline. 21:42

    Bias does not simply drop into a system; it accumulates and scales at every stage (data collection, labeling, training). The problem is multiplicative, meaning each stage passes the bias forward amplified, like a snowball rolling downhill. This requires mindful design before writing any code.

  2. Global data gaps lead to systemic failures in critical domains. 29:42

    Case studies show that Western-centric standards fail globally: Pulse oximeters missed dangerously low oxygen levels in Black patients due to melanin absorption [~1650]; and automated credit scoring models flagged economically active people as uncreditworthy because they rely on communal assets rather than formal bank accounts.

  3. The AI system is only as good as the data it learns from, which itself is a cultural artifact. 17:03

    Data is not neutral; it reflects the history and blind spots of those who gathered it. The speaker highlights that many global standards (e.g., Fitzpatrick scale for skin tone) were built for limited demographics, leading to non-inclusive outcomes when applied universally.

Watch on YouTube Full article

How Anthropic uses Claude Code: Agentic Software Engineering at Scale - Daisy Hollman thumbnail

· 1:00:25

How Anthropic uses Claude Code: Agentic Software Engineering at Scale - Daisy Hollman

This talk details the engineering challenges and advanced primitives required for achieving agentic software engineering at scale, particularly within large monorepos. The core thesis is that scaling agents requires sophisticated context management—moving beyond simply increasing model size to implementing abstractions like Skills, Sub-agents, and Hooks. Key focus areas include managing limited context windows (currently around 1 million tokens) by ensuring tools and knowledge are only injected when relevant, thereby enabling complex, long-horizon tasks across massive codebases.

Key takeaways

  1. Context Engineering is the New Discipline 21:45

    As agents become better at writing software, teaching them how to do it—managing context—is becoming the primary discipline of software engineering. This involves carefully selecting and injecting relevant information into the model's limited context window (the 'box').

  2. Scaling Requires Abstraction Primitives 26:45

    To handle massive codebases, simple tool definitions are insufficient. Advanced primitives like Skills (lazy system prompts), Sub-agents (out-of-context processing), and Hooks (event-driven execution) are necessary to ensure that only relevant information is consumed by the model.

  3. The Importance of Feedback Loops 17:15

    The fastest way to improve an agent's performance on a codebase is not necessarily a smarter model, but implementing tighter feedback loops (e.g., type checking, linting) that provide immediate, granular error detection during the tool-use process.

  4. Scaling Workflows Beyond Single Sessions 46:45

    For enterprise use, scaling requires managing multiple concurrent agent sessions. Techniques like using dedicated worktrees and visual cues (e.g., color coding) are essential to manage cognitive load and maintain persistent agent identities across different tasks.

Watch on YouTube Full article

From "Trust Me" to "Verify Me" - Tom van den Berg - NDC Copenhagen 2026 thumbnail

· 54:29

From "Trust Me" to "Verify Me" - Tom van den Berg - NDC Copenhagen 2026

The talk details the critical shift in software security from trusting producers to verifying artifacts through cryptographic evidence. Using the SLSA framework as a guide, the speaker demonstrates how build provenance and attestation provide verifiable proof of what was built, how it was built, and that it has not been tampered with. Key tools demonstrated include `cosign` for artifact signing and leveraging OCI registries to store signed artifacts and their associated metadata.

Key takeaways

  1. Supply Chain Attacks are the New Frontier 2:25

    Modern attacks no longer start in application code but in the build pipeline. Examples include the SolarWinds attack (2020) and recent compromises targeting CI secrets via supply chain vulnerabilities.

  2. Digest-Based Signing is Mandatory 6:10

    Relying on tags for artifact signing is dangerous because tags are mutable (can be rewritten). Security must rely on the content digest (SHA-256 hash) to ensure reproducibility and integrity.

  3. SLSA Framework Guides Verification 14:30

    The Open Source Security Foundation's SLSA framework provides a vocabulary of guidelines for securing the entire software development lifecycle, defining requirements for producers and consumers.

  4. Verification Requires Provenance and Attestation 20:05

    Build provenance is verifiable information detailing where, when, and how an artifact was produced. An attestation is a signed statement that verifies claims about the artifact (e.g., confirming successful security scans or build level).

  5. Security Must Be Automated and Enforced 39:10

    To make security actionable, verification must be integrated into CI/CD workflows as a mandatory deployment gate. This includes checking the SLSA build level and verifying all attached attestations.

Watch on YouTube Full article

Designing REST APIs for the age of AI agents - Boyan Mihaylov - NDC Copenhagen 2026 thumbnail

· 43:22

Designing REST APIs for the age of AI agents - Boyan Mihaylov - NDC Copenhagen 2026

The talk argues that REST APIs, originally designed for human developers, must fundamentally adapt to serve AI agents and LLMs as primary consumers. To ensure reliability and discoverability in an AI-driven world, API designers must focus on structured documentation (OpenAPI), robust error handling, maintaining consistency, implementing adaptive rate limiting, and considering new standards like the Model Context Protocol (MCP) for web integration.

Key takeaways

  1. AI Agents are a New Consumer 21:45

    The rise of AI tools means that API consumers are shifting from human developers to autonomous agents. These agents will interact with APIs by generating requests and chaining calls, requiring the API to be machine-readable and reliable.

  2. Documentation is Critical for AI 26:45

    The OpenAPI standard (JSON or YAML specification) is crucial. Beyond simply documenting endpoints, developers must add rich metadata about the API's purpose, constraints, and potential errors to minimize agent hallucination.

  3. Prioritize Error Handling 30:30

    Instead of basic validation messages, provide detailed error information (e.g., specifying the problematic field and supported options) to allow AI agents to self-correct and retry requests effectively.

  4. Adopt Adaptive Rate Limiting 35:05

    Traditional static rate limiting (e.g., fixed quotas per minute) is insufficient for unpredictable AI agent traffic. Implement adaptive strategies that analyze traffic patterns and adjust limits dynamically to maintain service availability.

  5. Consider Web MCP 40:05

    For web-based services, the Model Context Protocol (MCP) is an emerging standard allowing a webpage itself to expose tools and workflows directly to AI agents, making the entire page functional rather than just relying on backend APIs.

Watch on YouTube Full article

Evolving AI chat with MCP Apps - Phil Nash - NDC Copenhagen 2026 thumbnail

· 38:00

Evolving AI chat with MCP Apps - Phil Nash - NDC Copenhagen 2026

The talk introduces MCP Apps, a proposed open standard designed to evolve AI chat interfaces beyond plain text. By integrating rich, interactive web UIs (built with HTML/CSS/JavaScript) directly into the conversation flow, MCP Apps allow agents to render mini-applications for tasks like booking hotels or managing playlists. This approach moves interaction from boring 'walls of text' to engaging, visual experiences, making AI more useful for complex user workflows.

Key takeaways

  1. The Need for Interactive UIs in Chat 18:02

    Traditional chat interactions are limited to text (or code/tool calls), which is insufficient for tasks requiring visual exploration, configuration of multiple options, or viewing real-time data. MCP Apps solve this by bringing web-powered interfaces into the chat environment.

  2. MCP Apps as an Open Standard 22:40

    MCP Apps is a standard inspired by community efforts (like MCP-UI) and commercial SDKs (e.g., OpenAI's Apps SDK), aiming to provide a unified way for agents to render UIs across different model providers.

  3. Core Functionality: Sandboxed Web Views 26:00

    MCP Apps are implemented as sandboxed web applications (HTML, CSS, JavaScript) loaded within an iframe. This isolation keeps the UI safe while allowing it to interact with the agent host via tool calls and a JSON RPC mechanism.

Watch on YouTube Full article

AI Security in Practice: Protecting Your AI-Powered Applications - Olivia Liddell thumbnail

· 55:02

AI Security in Practice: Protecting Your AI-Powered Applications - Olivia Liddell

This talk provides a deep dive into securing AI-powered applications by addressing unique vulnerabilities that traditional security measures often miss. Using a fictional online retailer (ABC Company) as a case study, the presentation outlines three primary AI security risks—Prompt Injection, Data Poisoning, and Improper Output Handling. Mitigation requires implementing layered defenses across the entire application workflow: input validation, model protection, output sanitization, and continuous monitoring.

Key takeaways

  1. AI Attacks are Subtle and Invisible 17:32

    Unlike traditional attacks (e.g., DDoS), AI vulnerabilities can be slow, subtle, and partially invisible to standard firewalls or logging systems, requiring a shift in defensive thinking.

  2. Understand the Three Core Risks 17:32

    The three major risks are: Prompt Injection (tricking the model with disguised instructions), Data Poisoning (manipulating training data over time), and Improper Output Handling (trusting model output without validation).

  3. Implement Layered Defenses 45:00

    Security must be applied at four stages: Input Validation (sanitizing user input before it reaches the model), Model Protection (limiting scope and permissions), Output Sanitization (treating all AI-generated content as untrusted), and Monitoring/Operations (tracking model behavior changes).

Watch on YouTube Full article

Tour of Agent Protocols: MCP, A2A, AG-UI, A2UI - Mete Atamel - NDC Copenhagen 2026 thumbnail

· 53:45

Tour of Agent Protocols: MCP, A2A, AG-UI, A2UI - Mete Atamel - NDC Copenhagen 2026

The talk provides a deep technical overview of four emerging protocols designed to standardize communication and interaction within complex AI agent systems: Model Context Protocol (MCP), Agent-to-Agent Protocol (A2A), Agent-User Interface Protocol (AG-UI), and Agent-to-UI Protocol (A2UI). These standards address the challenges of building interoperable agents that can access external tools, communicate with other agents across diverse frameworks, and generate rich user interfaces.

Key takeaways

  1. MCP Standardizes Tool/Context Access 18:03

    MCP standardizes how Large Language Models (LLMs) access external functions (tools) and data (resources). Instead of one-to-one integrations, tools are wrapped into MCP servers, which can be accessed by an AI application via an MCP client. This architecture supports local (Standard IO) or remote (streamable HTTP transport) deployments.

  2. A2A Enables Inter-Agent Communication 23:50

    A2A is an open protocol defining how agents running on different frameworks communicate. Agents expose their capabilities via a JSON metadata file called the 'agent card,' which details skills (functions), contact methods, and authentication schemes.

  3. AG-UI Standardizes Agent State Streaming 29:40

    AG-UI is an event-based protocol designed to standardize how agent backends stream state updates to frontends, connecting the AI logic layer to the user interface.

  4. A2UI Standardizes Generative UI Output 32:30

    A2UI is a generative protocol that standardizes how agents generate functional User Interface (UI) components (using JSON structures), moving beyond simple text or data output. It defines core messages like `create surface`, `update components`, and `update data model`.

Watch on YouTube Full article

How I helped developers talk about feelings and needs - Gitte Klitgaard - NDC Copenhagen 2026 thumbnail

· 53:34

How I helped developers talk about feelings and needs - Gitte Klitgaard - NDC Copenhagen 2026

While the video metadata focuses on advanced AI security topics like Fine-Grained Authorization (FGA) for Retrieval-Augmented Generation (RAG), the talk itself addresses organizational communication and psychological safety. The speaker emphasizes that effective collaboration requires explicit tools, setting clear 'frames' (rules of engagement), and creating a safe space where developers feel comfortable discussing needs and emotions without fear of judgment or professional facade.

Key takeaways

  1. The Importance of Psychological Safety 17:05

    Psychological safety is defined as feeling secure enough to be oneself, disagree, and bring all of your thoughts to work without fear of ridicule or punishment. This requires active effort, especially in remote settings.

  2. Communication Requires Tools 21:45

    Effective communication is not innate; it requires specific skills and tools (like structured workshops or 'rules of engagement'). Simply working together does not guarantee successful collaboration.

  3. The Power of Framing 34:10

    Setting a clear frame—or set of rules—for a project or meeting is crucial for creativity and open discussion. Constraints, like those used in Lego design, can actually stimulate better ideas.

  4. Addressing AI Misunderstandings 38:20

    When discussing complex topics like Generative AI, teams must ensure they are all talking about the same thing (e.g., distinguishing between different types of 'spam' or AI implementation) to avoid major misunderstandings.

Watch on YouTube Full article

Day1 room4 video6 thumbnail

· 56:48

Day1 room4 video6

This technical critique challenges the prevailing narratives surrounding Generative AI (GenAI), arguing that much of the current hype is based on flawed binary thinking and overblown expectations. The speaker advises build engineers to treat AI claims skeptically, focusing instead on measurable improvements rather than revolutionary declarations. Key concerns include the environmental cost, the risk of data surveillance capitalism, and the practical limitations of concepts like 'human in the loop' when optimizing complex systems.

Key takeaways

  1. Critique of Binary Thinking

    The discussion around AI is often poorly framed using binary oppositions (e.g., good/bad, for/against), which reduces a complex issue to mere tribal classification rather than substantive technical discussion.

  2. AI as an Abstraction 17:15

    Intelligence is an abstraction, not a physical quantity. Comparing machine intelligence directly to human intelligence ('Can we make a machine smarter than humans?') is conceptually flawed because the comparison lacks measurable essence.

  3. The Flaw of 'Human in the Loop' 39:10

    Relying on human verification ('human in the loop') is often a copout designed to diffuse worries about automation. Humans are poor at white-collar quality checkpoints and cannot reconcile the conflicting goals of efficiency and safety.

  4. The Danger of Surveillance Capitalism 51:40

    The true business model for major tech companies is not selling AI services, but selling influence. The ultimate risk involves the collection of intimate data (e.g., retina scans) to modify behavior and opinions.

Watch on YouTube Full article

Vibes Not Vulns: Securing the Era of AI-Written Software - Mackenzie Jackson thumbnail

· 23:21

Vibes Not Vulns: Securing the Era of AI-Written Software - Mackenzie Jackson

The integration of AI tools into software development introduces novel and complex security failure modes that traditional AppSec pipelines are unprepared for. The talk details how 'vibe coded' applications can ship insecure patterns, focusing heavily on prompt injection vulnerabilities within CI/CD workflows and the evolving risks in open-source supply chains (e.g., dependency hallucination). To mitigate these risks, guardrails must shift from simple code scanning to context-aware validation and strict access control.

Key takeaways

  1. AI Code Vulnerabilities 3:50

    AI systems are not perfect; they introduce vulnerabilities because they make assumptions about business logic. While models improve (especially with 'make sure it's secure' prompts), fundamental flaws like business logic errors remain, meaning AI code cannot be fully trusted yet.

  2. Prompt Injection in CI/CD 11:45

    A critical new vulnerability class is prompt injection, which allows an attacker to bypass system and application guardrails. This was demonstrated by exploiting the Gemini CLI tool within a CI/CD pipeline to achieve Remote Code Execution (RCE) and leak secrets from GitHub repositories.

  3. Supply Chain Risks 20:30

    Traditional vulnerability tracking using CVE numbers is fundamentally broken for modern malware attacks, which can spread rapidly. Furthermore, AI hallucination means package managers may suggest non-existent packages or outdated dependencies.

Watch on YouTube Full article

Write Drunk, Edit Sober: Creating Generative Content Responsibly - Matthijs van der Veer thumbnail

· 56:54

Write Drunk, Edit Sober: Creating Generative Content Responsibly - Matthijs van der Veer

The talk addresses the proliferation of 'AI Slop'—low-quality, inauthentic content generated by LLMs—and provides a framework for developers to build automated systems that enforce quality. The core philosophy is shifting focus from merely generating content ('Write Drunk') to defining clear intent and implementing rigorous review processes ('Edit Sober'). Practical solutions involve using structured data inputs (like GitHub Issues) to capture user intent, applying Natural Language Processing (NLP) techniques like lemmatization for stylistic checks, and building automated quality gates that flag common LLM patterns (e.g., excessive emojis, M dashes, or generic corporate tropes).

Key takeaways

  1. Identify 'AI Slop' Patterns 0:23

    Common signs of low-quality AI content include overuse of emojis, the M dash (`—`), bold text, overly positive/generic language, and vague phrasing like 'In an era...' (0:023 - 0:045).

  2. Focus on Intent over Content 2:38

    The most critical step in generating quality AI content is defining the core intent: What do you want the audience to learn? Who should be here? And what can they accomplish? This structured approach guides the LLM (0:158 - 0:236).

  3. Automated Quality Gates are Essential 7:55

    Developers can build tools that enforce quality by implementing deterministic checks. Techniques include using NLP libraries like `spacy` for lemmatization to identify overused or non-standard vocabulary, and running pattern matching against known 'tropes' (0:475 - 1:239).

  4. Mitigate Automation Bias with Metrics 23:10

    To combat the tendency to overly trust machine output (automation bias), systems should provide explicit metrics, such as a confidence score or probability of error, rather than simply offering recommendations. Offering raw information is safer than recommending an action (1:390 - 2:150).

Watch on YouTube Full article