The Video Signal

Topic

AI Agents

All digests tagged AI Agents

Access all Gemini models with the Interactions API thumbnail

· 1:24

Access all Gemini models with the Interactions API

The Gemini Interactions API is now generally available, providing a unified, single-interface gateway for accessing all Gemini models and agents. This stateful, agent-first ecosystem allows developers to build complex AI applications with persistent memory by passing previous interaction IDs, supporting multimodal inputs like voice notes and images.

Key takeaways

  1. Interactions API General Availability

    The Interactions API is now generally available for use, simplifying access to Gemini models.

  2. Unified Model Access

    It serves as a single interface gateway for all Gemini models and agents, eliminating complex AI workflow setups.

  3. Stateful Memory Support

    The API is stateful, allowing applications to build upon previous interactions by passing the prior interaction ID.

Watch on YouTube Full article

Sandboxing, Agent Harnesses, and Agent Teamwork thumbnail

· 1:19:54

Sandboxing, Agent Harnesses, and Agent Teamwork

The discussion explores the evolution of AI agents from simple task execution to sophisticated SRE (Site Reliability Engineering) capabilities. The core argument is that true value lies not in faster triage (Mean Time To Resolve - MTTR), but in building an agent that learns and compounds operational memory across an organization's entire stack. Key architectural shifts include moving beyond rigid, deterministic tools toward non-deterministic problem solving, requiring advanced techniques like sandboxing, environment simulation, and establishing governance structures for multi-agent teams.

Key takeaways

  1. The Value Shift: Learning over Triage 20:05

    AI agents' primary value is shifting from simply reducing MTTR to building an agent that learns from every investigation. The goal is creating a compounding operational memory, allowing the system to improve its decision-making process and predict failure modes rather than just reacting to alerts.

  2. Harnesses Define Agent Capability 3:25

    The 'harness' is defined as everything between the user and the LLM—including prompts, skills, file systems, and tools. The challenge is balancing necessary guardrails (to prevent agents from doing wrong things) with enough freedom to allow for complex, non-deterministic problem solving.

  3. The Need for Cross-Environment Testing 23:55

    Because every company's infrastructure (e.g., Gojek vs. Uber) is unique, agents cannot simply be trained on general knowledge. Durable development requires simulating and testing agent performance across diverse, idiosyncratic production environments.

  4. Future State: Agent Teams and Governance 1:03:22

    The next frontier involves multi-agent systems (e.g., a Coding Agent working with an SRE Agent). These teams require defined governance structures, similar to a RACI matrix, ensuring agents know their roles and how to share context without losing isolation.

Watch on YouTube Full article

Jack Wotherspoon - Humans vs. Slop: Rewriting the Rules of Open-Source - AI Native DevCon thumbnail

· 32:17

Jack Wotherspoon - Humans vs. Slop: Rewriting the Rules of Open-Source - AI Native DevCon

The rise of powerful AI agents is fundamentally changing open-source development by making code generation nearly free and abundant, leading to a flood of low-quality contributions ('AI slop'). This shift threatens the traditional human-to-human social contract of open source. Maintainers must implement new governance models—such as requiring issues before pull requests (PRs), rate limiting external contributors, and utilizing automation—to manage the influx of code while preserving quality and accountability.

Key takeaways

  1. The Open Source Shift 2:00

    Open-source development is moving from a human-to-human experience to one involving AI agents. The core challenge is that while generating code is cheap (sometimes free), reviewing, maintaining, and trusting the generated code remains expensive and difficult.

  2. Guardrails Against Slop 6:25

    To combat 'drive-by PRs' (where users submit fixes without prior discussion) and uncontrolled agent activity, maintainers should require contributors to file an Issue before submitting a Pull Request. This is cited as eliminating approximately 90% of drive-by PRs.

  3. Rate Limiting Contributions 7:00

    Implement rate limits on external contributors (e.g., limiting the number of active PRs) to prevent automated swarms of nonsensical code submissions, which can overwhelm maintainers.

  4. Trust and Governance Systems 9:40

    New systems are emerging to restore trust: 'Vouch' acts as a referral system for contributors, while 'Open Source Vacation' allows projects or solo maintainers to temporarily halt contributions when needed. Projects should also use context files (like `agents.md`) to guide all AI tools.

  5. Codifying Best Practices with Skills 11:20

    Implementing 'agent skills' (e.g., PR creator, docs writer) into the repository helps enforce best practices—such as running tests and following templates—for both human and AI contributors, thereby raising the overall quality bar.

Watch on YouTube Full article

Edouard Maleix - How AI-First Dev Teams Build Collective Intelligence — One Attributed Mistake at thumbnail

· 32:31

Edouard Maleix - How AI-First Dev Teams Build Collective Intelligence — One Attributed Mistake at

The talk outlines a comprehensive workflow for transforming isolated agent mistakes and learnings into reusable, attributable collective intelligence within development teams. Instead of relying on simple documentation or context window stuffing, the proposed system introduces several primitives—Identity, Diary, and Knowledge Packs—to ensure that every incident, fix, and decision is captured, linked, validated, and made available to future work, thereby accelerating team learning beyond human pace.

Key takeaways

  1. The Problem with Isolated Learning 1:42

    Agents' small discoveries and incidents often remain trapped within a single session (e.g., closed PRs or chat history), leading to the evaporation of corrections and preventing knowledge from becoming reusable.

  2. The Need for Structured Knowledge Capture 3:58

    Teams need more than just a wiki; they require a 'knowledge factory' that catches mistakes, interruptions, and turns them into validated guidance. This knowledge must be constantly evolving (live, die) rather than static.

  3. The Importance of Agent Identity 14:15

    Giving agents a unique identity with signed commits and access rules solves the problem of attribution masking. It establishes a clear actor boundary, preventing agents from operating under human permissions.

  4. The Diary Primitive 15:30

    The 'Diary' serves as the central home for all discoveries and decision-making ('what the F moment'). It allows work/decisions to be linked to specific entries, providing reasoning beyond just diffs and commit messages.

  5. Creating Reusable Knowledge Packs 21:45

    The process involves capturing an incident (Entry) $ ightarrow$ grouping related Entries into a 'Pack' $ ightarrow$ rendering the Pack into usable markdown/context for the agent. This ensures lessons are traceable back to the original failure.

  6. Validation and Evaluation (Evals) 27:20

    To ensure quality, two types of evaluation are necessary: checking if the Pack is 'true to the entries' (fidelity) and running a task that reproduces the original incident using the knowledge pack to measure improvement (usefulness).

Watch on YouTube Full article

May Walter - From Blind Spots to Merged PRs: Runtime Intelligence for Continuous Agentic Performance thumbnail

· 31:16

May Walter - From Blind Spots to Merged PRs: Runtime Intelligence for Continuous Agentic Performance

The talk details implementing a runtime intelligence layer for coding agents to enable continuous performance optimization in mature codebases. The approach moves beyond reactive bug fixing by running sensors in production to capture deep forensic context (e.g., function execution frequency, failure modes). This allows agents to proactively surface high-ROI fixes—such as N+1 queries or missing database indexes—scored by complexity and impact, enabling tech leads to prioritize improvements before sprint planning.

Key takeaways

  1. Automating the Investigation Phase 17:52

    Instead of waiting for performance degradation to become a crisis (a 'leaky bucket' problem), the goal is to automate the investigation phase. This allows teams to identify potential optimizations and their estimated impact/cost without dedicating unpredictable engineering time.

  2. Prioritizing Impact over Task Completion 25:30

    The focus shifts from merely generating pull requests (PRs) to identifying the highest impact, lowest risk changes. The system must provide human-readable context that justifies attention, preventing 'PR fatigue' from agents.

  3. Defining Business Context 22:00

    Effective agentic workflows require more than just code analysis; they need business context. The system must map production activity (endpoints, event consumers) to function-level context to understand the true impact of a potential fix.

Watch on YouTube Full article

Get started with the Interactions API thumbnail

· 8:51

Get started with the Interactions API

The Interactions API is now generally available and serves as a unified interface for interacting with various Gemini models and agents. It simplifies complex interactions—ranging from synchronous model calls to multi-step agent workflows in remote environments—by providing a single API endpoint. The API supports stateful operations by allowing users to pass the previous interaction ID, enabling iterative refinement of outputs (e.g., image editing) without re-uploading source data.

Key takeaways

  1. Unified Model Access 0:10

    The Interactions API provides easy access to all Gemini models and agents through a single interface, simplifying development across various Google AI capabilities.

  2. Stateful Interactions 4:05

    The API is stateful; developers can pass the previous interaction ID to build upon prior results, which is crucial for iterative processes like image editing or complex data processing.

  3. Advanced Capabilities 0:18

    New features include managed agents, background execution tool improvements, Deep Research, and media generation (e.g., Nano banana for images, Lyriq 3 for music, TTS for speech).

Watch on YouTube Full article

Codex vs Fable: Which AI Agent Picked the Better Problem? thumbnail

· 12:08

Codex vs Fable: Which AI Agent Picked the Better Problem?

The video compares two advanced AI agents, Codex and Fable, on an open-ended challenge: identifying and automating a high-leverage problem within a business process. The core finding is that while both agents successfully generated automation ideas, Fable demonstrated superior strategic thinking by identifying a more impactful pain point (pre-pipelining ideas). However, the speaker emphasizes that the true breakthrough is not just the AI's ability to suggest a problem, but the development of an advanced 'auto magic button' skill. This skill allows users to guide the AI to audit complex business processes across multiple data sources and build a complete, secure automation solution.

Key takeaways

  1. AI Agents Must Pick the Problem

    The challenge for modern AI agents is moving beyond simply executing a given prompt or tool. The goal is to have the agent inspect a user's entire workflow (e.g., local files, Slack) and autonomously define the most valuable problem requiring automation.

  2. Codex vs. Fable Performance 7:00

    Codex was noted for being fast, dependable, and completing tasks successfully by picking a bounded, safe problem (e.g., improving handoff packages). Conversely, Fable demonstrated superior strategic sense, identifying a higher-leverage opportunity related to pre-pipelining ideas.

  3. The Need for Strategic Automation Skills 11:20

    To solve the 'open claw problem' (knowing what automation is needed), a specialized skill is required. This skill guides the AI to audit complex business processes, understand multiple levels of causation, and recommend not just a fix, but a complete, secure tool.

Watch on YouTube Full article

Peter Wilson & Davide Eynard - cq - Stack Overflow for Agents - AI Native DevCon June 2026 thumbnail

· 31:32

Peter Wilson & Davide Eynard - cq - Stack Overflow for Agents - AI Native DevCon June 2026

The session introduces CQ (Mozilla.ai's proposal), a system designed as a 'Stack Overflow for agents.' Its core purpose is to standardize and share knowledge units (KUs) across autonomous AI agents—locally, within an organization, or publicly. This prevents agents from repeating mistakes, wasting tokens, and ensures that lessons learned by one agent can benefit all others, thereby improving the reliability of complex automated workflows.

Key takeaways

  1. Knowledge Unit (KU) Standardization 17:09

    A KU is a standardized knowledge artifact (stored in JSON format) capturing solutions to novel problems. It includes domains, insights, actions taken, summaries, and metadata (languages/frameworks).

  2. Agentic Context Management 6:15

    Effective agent performance relies heavily on context injection. The system aims to move beyond simple memory files by allowing agents to query a centralized knowledge base for relevant solutions before starting a task.

  3. Layered Sharing Model 20:40

    CQ supports three levels of knowledge sharing: local (SQLite database, no review), private/team (requires user authentication and human-in-the-loop review), and public commons (CQ Exchange).

Watch on YouTube Full article

Omnigent: Composition, Control, and Collaboration for AI Agents thumbnail

· 58:17

Omnigent: Composition, Control, and Collaboration for AI Agents

The AI development landscape is shifting from focusing solely on large language models (LLMs) to building sophisticated meta-harnesses and agent frameworks. The core challenge addressed by tools like Omnigent is managing complexity, ensuring model portability, and controlling escalating costs (tokenomics). This architectural shift requires developers to treat agents as stateful systems that rely heavily on external memory (databases) and advanced orchestration patterns like 'debating' or 'forking' conversations to achieve robust results.

Key takeaways

  1. The Meta-Harness Layer 20:40

    Meta-harnesses, such as Omnigent, sit above individual models (e.g., Claude Code, Codex, Pi) and harnesses, allowing developers to compose different components without rebuilding the entire context or workflow.

  2. Agentic Workflow Patterns 6:05

    Advanced agent techniques include having agents debate each other to surface unknown questions, and 'forking' conversations to explore parallel threads while maintaining shared original context.

  3. Tokenomics as DevOps 1:42

    AI spend is repeating the CapEx-to-OpEx shift. Governance must be pushed down to developers (giving them visibility into token usage) while retaining central policies for cost control and approval.

  4. The Importance of State 39:40

    Agents require cheap, stateful memory. This has led to a resurgence in the use of traditional databases like Postgres, Lakebase, and serverless options for persistent context.

Watch on YouTube Full article

James Moss - Using skills to pay the bills: graduating from solo hacks to a team workflow - DevCon26 thumbnail

· 32:39

James Moss - Using skills to pay the bills: graduating from solo hacks to a team workflow - DevCon26

The talk addresses the challenge of 'skill sprawl'—the uncontrolled proliferation and management of AI coding agent skills within large organizations. While skills are powerful because they encode domain-specific logic into an agent's context, their current lack of standardized versioning, review, and centralized governance creates significant technical debt. The speaker advocates for treating skills as first-class software assets, requiring dedicated practices like decomposition, mandatory registries, automated reviews, and formal lifecycle management (CDLC) to ensure reliability and scalability.

Key takeaways

  1. Manage Skill Sprawl with a Centralized Registry 17:33

    Due to the low barrier to entry for creating skills, organizations face an 'insane amount' of them (2 million+ on GitHub alone). A centralized registry is crucial for visibility, preventing overlap, and ensuring all teams use approved versions. This also helps mitigate non-technical users needing access without requiring full developer seats.

  2. Adopt the Context Development Life Cycle (CDLC) 27:50

    Just as code requires a Software Development Lifecycle (SDLC), skills and context require their own CDLC. Practices like skill reviews, automated testing, and version control must be applied to maintain quality and prevent 'rot' (skills going out of sync with the codebase).

  3. Decompose Skills for Modularity 20:40

    Instead of creating monolithic skills, break complex functionality into smaller, interconnected plugins. This allows agents to activate specific components and makes the skill set easier to maintain and debug.

  4. Enforce Governance via Registries 22:30

    Using a registry provides a single source of truth, allowing organizations to enforce policies (e.g., 'approved skills only,' minimum release age) and integrate security scanning tools like Snyk.

Watch on YouTube Full article

Put an Agent Inside Your App in 10 Minutes or Less with the GitHub Copilot SDK - Daniel Ward thumbnail

· 57:28

Put an Agent Inside Your App in 10 Minutes or Less with the GitHub Copilot SDK - Daniel Ward

This talk demonstrates how to rapidly embed custom AI agents into existing applications using the GitHub Copilot SDK. The session covers agent architecture—defining an agent as an LLM augmented with tools and a looping mechanism—and provides two coding demos (in C#) showing basic functionality like weather queries, streaming responses, and creating custom tools. For build engineers, the focus is on advanced use cases such as automated incident response (generating suggested fixes and opening Pull Requests from production logs) and building comprehensive daily briefing systems that integrate multiple enterprise services (Jira, Teams, GitHub).

Key takeaways

  1. Agent Architecture 17:53

    An AI agent is fundamentally an LLM combined with external tools and a looping mechanism. The LLM handles the creative analysis, while the tools allow it to perform deterministic actions (e.g., fetching web data or querying APIs).

  2. Copilot SDK Functionality 3:35

    The Copilot SDK is an open-source library that allows calling GitHub Copilot (or other LLMs like Anthropic/OpenAI) from code. It supports multiple languages (TypeScript, Python, Go, C#, etc.) and provides granular control over sessions, including event handling (`onEvent`) for streaming responses.

  3. Automated Incident Response 51:01

    A powerful use case is connecting production errors to automated fixes. The process involves the SDK collecting logs, using Copilot to suggest a fix based on stack traces, and then programmatically opening a draft Pull Request (PR).

  4. Reliability vs. Prompting 53:21

    For repeatable, mission-critical workflows (like daily reports), using deterministic code with the SDK is significantly more reliable than relying solely on prompt chaining, as failures in a chain compound exponentially.

Watch on YouTube Full article

Let's build an AI agent - Phil Nash - NDC Copenhagen 2026 thumbnail

· 49:59

Let's build an AI agent - Phil Nash - NDC Copenhagen 2026

This talk demystifies AI agents by building one from scratch, demonstrating how Large Language Models (LLMs), tools, and memory work together in a continuous loop to achieve goals. The core mechanism involves an agent runtime that orchestrates function calls—allowing the LLM to interact with external systems like file systems or calculators. Advanced concepts covered include the Model Context Protocol (MCP) for standardized tool interaction and 'Skills' for progressive disclosure of capabilities, enabling agents to perform complex tasks like self-refactoring.

Key takeaways

  1. Agent Architecture 17:03

    An agent fundamentally runs tools in a loop to achieve a goal. This process requires an LLM, external tools (functions), and an orchestration layer (the 'harness') that manages the interaction.

  2. The Agent Loop 28:10

    The core agent functionality is implemented in a loop: The model generates function calls $\rightarrow$ The harness executes those functions (awaiting results) $ ightarrow$ The results are fed back to the model for the next step, continuing until the goal is met.

  3. Standardization via MCP 36:00

    The Model Context Protocol (MCP) provides a standardized way for agents to interact with services. It separates concerns into Server components (tools, resources, prompts) and Client components.

  4. Progressive Disclosure with Skills 40:05

    Skills allow for progressive disclosure of capabilities. Instead of loading all tool declarations at once, the agent only loads a skill's header initially and can request more details (resources, scripts) as needed.

Watch on YouTube Full article

CoreWeave ARIA: The autoresearch loop for continuous improvement thumbnail

· 5:16

CoreWeave ARIA: The autoresearch loop for continuous improvement

CoreWeave ARIA is an AI Research and Iteration Agent designed to automate the full autoresearch loop for continuous model and agent improvement. The demonstration shows how ARIA autonomously forms hypotheses, analyzes prior run results (including raw system metrics and plots), sets filters, and executes new training jobs via Weights & Biases Launch, allowing human users to focus on high-level problem definition.

Key takeaways

  1. Autonomous Research Loop

    ARIA autonomously manages the research process by forming hypotheses, running experiments, evaluating results, and executing optimal next actions without constant human intervention. This capability helps models and agents improve continuously.

  2. Run Analysis and Filtering 1:44

    ARIA can analyze complex run data—including plots, tables, and raw system metrics—to determine what worked best. It can also set UI filters based on previous sweeps (e.g., setting a filter for 'auto research runs').

  3. Parallel Experimentation 1:18

    Users can run multiple ARIA instances in parallel to accelerate the workflow, allowing simultaneous management of different research tracks (e.g., running two distinct ARIA variants).

Watch on YouTube Full article

When millions of AI agents meet thumbnail

· 42:38

When millions of AI agents meet

This discussion explores the shift from traditional Large Language Models (LLMs) to autonomous AI agents capable of executing multi-step plans, transacting, and delegating tasks. The concept of an 'agentic economy' suggests a future where intelligence is distributed across specialized agents rather than residing in single systems. Key technical challenges discussed include managing agent failure rates, preventing automation bias, securing the system against malicious 'agentic traps,' and developing robust orchestration protocols for complex, real-world workflows.

Key takeaways

  1. Agent vs. Language Model 0:35

    An LLM merely provides continuation or a reply to a prompt; an AI agent observes a state of the world and performs actions in an environment (e.g., purchasing tickets, sending emails). Agents use LLMs under the hood but are wrapped in a harness that enables multi-step planning and automation [0:35].

  2. Distributed Intelligence 28:40

    The future may not be defined by Artificial General Intelligence (AGI) as a single entity, but rather by 'distributed intelligence'—a 'society of specialists.' This model suggests that specialized, smaller models are cheaper to run and more reliable than one massive generalist model [17:20].

  3. Agentic Security Risks 22:26

    The deployment of agents at scale introduces significant cybersecurity risks. These include 'agentic traps' (malicious code or prompts in the environment) and 'dynamic cloaking,' where web pages display different content for humans versus agents, potentially inducing jailbreaking [1:50].

Watch on YouTube Full article

Logs Are All You Need: Rethinking Observability with AI Agents thumbnail

· 46:40

Logs Are All You Need: Rethinking Observability with AI Agents

Sherwood Callaway introduces Sazabi, an AI-native observability platform designed to disrupt traditional tools like Datadog by focusing on logs as the primary source of truth. The core philosophy is that in the age of coding agents, engineers should interact with production data via natural language chat rather than complex dashboards. Key technical innovations include using Git for persistent agent memory across multiple threads and implementing a read-only sandbox environment to safely execute investigative tasks.

Key takeaways

  1. Logs are Sufficient: Rethinking Observability 22:20

    The traditional 'three pillars' (metrics, logs, traces) are considered overkill for modern agentic workflows. By focusing solely on logs, instrumentation becomes significantly simpler, requiring only basic logging statements, as the platform can reconstruct metrics and traces from log data.

  2. AI Agents Generate Alerts, They Don't Evaluate Them 28:00

    Instead of using AI to triage noisy alerts (alert fatigue), Sazabi autonomously generates actionable alerts directly from logs and codebase analysis. The agent determines what is meaningful to the user at runtime.

  3. Agent Memory via Git for Shared State 34:05

    Sazabi maintains persistent, shared memory across multiple parallel sub-agents and threads by committing findings (e.g., issue lists, facts) to a dedicated Git branch within the sandbox environment. This allows agents to benefit from collective findings.

  4. Sandbox Isolation and Read-Only Access 30:30

    The platform operates in a read-only system with no public internet access, ensuring security. All actions are routed through an isolated sandbox environment (e.g., using `bash` tools) to prevent data exfiltration or unauthorized changes.

Watch on YouTube Full article