Containerization — The Video Signal

Sep 16, 2026 · 10:08

Docker, Adobe & tldraw: Where Should Your Agent Run?

The discussion explores the critical architectural question of where AI coding agents should execute, presenting four distinct models: Docker advocates for secure microVM sandboxes; Helix ML proposes centralized, dedicated computing resources for each agent; Adobe demonstrates running the agent loop entirely within the browser tab; and tldraw visualizes agents collaborating as characters on an infinite canvas. The consensus highlights the trade-offs between isolation, centralized control, and environmental fidelity.

Key takeaways

MicroVMs for Agent Sandboxes 0:09
Docker recommends using micro VMs instead of traditional containers for agent sandboxes because enterprise security teams view shared kernels as an unacceptable isolation boundary.
Centralized Agent Infrastructure 3:03
Helix ML argues for giving every agent its own dedicated computer on centralized infrastructure (e.g., Kubernetes) to facilitate seamless handoffs of work across global time zones.
Browser-Native Agent Loops 7:33
Adobe demonstrated an agent that runs its entire loop and controls the browser from within the browser tab, showcasing the concept of the 'self-licking ice cream cone' (SLICC).
Collaborative Canvas Agents 6:13
tldraw presents agents as interactive characters on a canvas that can coordinate, plan, and execute tasks as a team, allowing for simultaneous, visible collaboration.

Watch on YouTube Full article

Sep 11, 2026 · 1:13:40

Training Agents 4: From reward functions to environments.

This session details the evolution of agent training from simple functional reward signals to complex, stateful environments. The core concept is the `reset()/step()` contract, which allows agents to interact with a simulated world (the environment) over a sequence of actions. The discussion covers the OpenM framework, which standardizes environment definition, and its integration with TRL (Transformer Reinforcement Learning) using isolated compute environments like Hugging Face sandboxes. This enables training sophisticated agents, such as coding agents (OpenCode), on complex, multi-step tasks while maintaining reproducibility and isolation.

Key takeaways

The Shift to Stateful Environments 1:42
For agents performing sequences of actions (e.g., tool calls, file edits), the reward signal must come from the environment's state after an action, rather than being a simple Python function evaluated once. This requires adopting the standard `reset()/step()` contract, moving from sparse signals to continuous interaction loops.
The OpenM Ecosystem 5:30
OpenM provides a standardized, containerized way to define any task as an environment. It packages the task, the runtime (compute backend), and the grading components (verifiers, rewards) into a single, shareable unit that can be deployed on various platforms (e.g., Hugging Face Spaces, Kubernetes).
Advanced Agentic Training Loops 9:10
Training can be managed by two models: the 'White Box' (where the training framework owns the loop) and the 'Black Box' (where the agent/harness owns the loop). The latter requires a 'capture proxy' to intercept agent calls and send the resulting rollout graph back to the trainer for policy updates.
Reproducibility and Isolation 7:30
Environments are designed to be self-contained applications, often deployed in isolated compute environments (like HF sandboxes). This ensures that training runs are reproducible and prevents the agent from accessing or manipulating the verifiers or task description to 'hack' the reward signal.

Watch on YouTube Full article

Sep 10, 2026 · 8:57

Catch Agent Regressions Before You Ship: Evals for Managed Deep Agents

This session details how to implement robust evaluation (evals) for Managed Deep Agents to prevent performance regressions as the agent's capabilities grow. The process involves using Harbor, which ensures each evaluation runs in a fresh container. Evals are structured into an environment (data/state), a job (instruction), and a check (verifier). The workflow is scaffolded using `mda evals init`, which can be automated by handing the task to a coding agent (e.g., Claude Code). Results and traces are managed and monitored in LangSmith, allowing for continuous evaluation and integration into nightly CI pipelines.

Key takeaways

Purpose of Evals
Evals serve two primary goals: catching regressions (ensuring changes don't break existing features) and 'hill climbing' (actively improving agent capabilities). The focus is on defining and catching regressions.
Harbor's Role in Evaluation
Harbor is bundled into Managed Deep Agents and is crucial because it builds an image around the agent, ensuring every eval runs in a fresh container. It also manages test execution to prevent environment pollution.
Anatomy of an Eval 2:15
An evaluation consists of three parts: the environment (the starting data/state), the job (the instruction, defined in a markdown file), and the check (the verifier that determines if the job was completed adequately).
Automating Eval Scaffolding 2:36
The command `mda evals init` scaffolds the necessary files (e.g., `task.md`, `Dockerfile`, tests). Using the `-i` flag allows the work to be handed off to a coding agent, which generates the initial eval suite.
Production Monitoring
Evals can be managed in production by running them nightly within a CI system. Results are logged into LangSmith, allowing developers to continuously track agent performance and stability.

Watch on YouTube Full article

Sep 1, 2026 · 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

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

Jul 28, 2026 · 55:44

Introducing the SQL MCP Server - Jerry Nixon - NDC Toronto 2026

SQL MCP Server, an open-source component from Microsoft's data API builder, provides a secure and standardized abstraction layer for modern applications, especially those powered by AI agents. It allows external models to interact with enterprise databases (including SQL Server, PostgreSQL, Cosmos DB, and MySQL) without requiring direct T-SQL knowledge or exposing sensitive connection strings. The solution standardizes database access into three endpoints—REST, GraphQL, and MCP—simplifying the development process and significantly enhancing security by enforcing policies at the API layer.

Key takeaways

Unified Data Access Layer 2:00
The SQL MCP Server acts as a single point of entry for all data interactions, supporting multiple database types (SQL, NoSQL) and exposing three standardized APIs: REST, GraphQL, and the specialized Model Control Protocol (MCP). This abstraction layer allows developers to write code against the API surface rather than directly against the underlying schema.
AI Agent Integration via MCP 8:00
For AI agents, which cannot speak directly to a database, the MCP endpoint is critical. It collapses the potential hundreds of CRUD tools (one per table) into a standardized set of seven tools (Describe Entities, Create, Read, Update, Delete, etc.), preventing model overload and ensuring reliable agentic workflows.
Simplified Development & CI/CD 3:00
The solution aims to eliminate the need for boilerplate CRUD API code in a codebase. By using data API builder, developers can significantly reduce complexity and potential errors, streamlining the CI/CD pipeline while maintaining high functionality.
Advanced Security & Policy Enforcement 10:50
Security policies (like Row-Level Security) can be enforced at the API layer, even if structural changes are impossible in the underlying database. Furthermore, it supports advanced authentication methods like OpenID Connect and On Behalf Of (OBO) pass-through authentication.

Watch on YouTube Full article

Jul 25, 2026 · 33:15

Oleg Šelajev - You're absolutely right, it was your home directory! - AI Native DevCon June 2026

The session addresses the security risks posed by autonomous AI agents running locally, noting that these agents can pose significant threats by accessing sensitive data and executing arbitrary code. To mitigate this risk, Docker introduces sandboxing using MicroVMs—a hardware-level isolation primitive superior to traditional containers. This approach allows developers to run powerful AI agents in a restricted environment with controlled access to the filesystem, network, and secrets, enabling high productivity without sacrificing security.

Key takeaways

The Danger of Autonomous Agents 2:00
AI agents are highly autonomous and persistent; if given sufficient access (data, external communication, internet), they can execute malicious actions like stealing SSH keys or cloud credentials, leading to massive security incidents. The stakes are asymmetric: the attacker only needs to succeed once.
MicroVMs for Hard Isolation 6:00
Traditional containers share a kernel and are insufficient for high-stakes AI agent sandboxing due to potential container escaping exploits. Docker's solution uses MicroVMs, providing hardware-level isolation that significantly raises the security boundary.
The Role of Kits (YAML) 10:00
To improve developer experience in isolated environments, 'Kits' are introduced. These declarative YAML files define reusable configurations for a sandbox, specifying required commands, tools (e.g., programming language toolchains), file placements, and network rules.
Controlled Access Mechanisms 8:00
Sandboxes implement critical controls including networking proxies (to block specific domains/services) and secrets injection mechanisms, allowing agents to function without direct access to the host machine's private data.

Watch on YouTube Full article