Agentic AI Foundation Video Summaries

I discuss how AI coding agents are changing software delivery, and why faster code generation does not remove the need to understand and maintain a codebase. The talk connects established software-factory practices with agent workflows, using examples, benchmarks, and tooling patterns.

■ Software factories and code quality
- How traditional delivery pipelines evolve with coding, review, testing, and incident-response agents
- What benchmark research and industry examples examine about maintainability and generated code
■ Practical workflows and infrastructure
- Planning, reviewing changes, helping agents test their work, and incorporating user feedback
- Compute, development environments, harnesses, and control planes for coordinating agent sessions
■ Team practices and next steps
- Improving workflows over time and sharing plans, traces, and architecture context
- Resources and the HumanLayer collaborative workspace

For engineering leaders and developers adopting coding agents, this overview offers practices to consider and areas to investigate further. It focuses on workflows and system design rather than a step-by-step implementation guide; viewers can start by reviewing their planning, agent testing, feedback loops, and session-sharing practices.

I cover enterprise challenges in deploying Model Context Protocol (MCP), from managing shared servers and permissions to supporting adoption across a large workforce. Two keynote speakers outline operational patterns and lessons drawn from their organizations, with examples involving access controls, security, and user workflows.

- NVIDIA: MCP as a Service, reliability, authentication, per-user state, tool selection, and guardrails
- Accenture: enterprise deployment and server acceptance criteria, including security considerations and wrapping servers to limit tool scope
- Adoption: how user communication and support can complement technical controls and policies

For engineering, security, and AI enablement teams planning shared MCP services, this session offers practices to consider and questions to bring back to their teams. The focus is on organizational patterns and examples rather than a step-by-step implementation guide; viewers can use the discussion to review ownership, permissions, and user support for their own deployments.

Mint co-founder and CEO JQ describes how the company builds AI agents that work alongside employees in Slack and connect to business systems. The discussion covers practical use cases and the identity, permissions, monitoring, and memory questions that arise as organizations deploy more agents.

■ Agent use cases and architecture
- How agents support sales, marketing, engineering, procurement, and customer service, with examples from Mint and its customers.
- The shift from individual AI chats to shared agent workflows in Slack, including agent collaboration and human review.
■ Enterprise controls and deployment
- Agent identities, delegated credentials, access policies, tool and data restrictions, audit trails, and sandboxed environments.
- Open questions around dynamic permissions and access to agent memory, including considerations for regulated industries.

For enterprise leaders, developers, and security teams exploring workplace agents, this offers a grounded overview of deployment patterns and governance challenges. Use the examples to identify a bounded workflow to pilot, then define its permissions, human approvals, and audit requirements before expanding access.

I outline how longer-running AI tasks are changing the needs of agent systems, and why connecting agents to the tools and services people use is becoming increasingly important. The talk reviews MCP’s development and the priorities its community is addressing for the years ahead.

- AI agents beyond coding: changing model capabilities and the requirements of knowledge work
- MCP today: industry adoption and the move toward stateless operation
- Next priorities: agent-to-agent messaging and long-running tasks, skills, identity and authorization, plus ways to contribute

For developers, technology leaders, and organizations exploring agent systems, this offers an overview of MCP’s direction and the issues shaping its use. Viewers can use these themes to consider which systems their agents need to connect to and how to contribute through MCP servers, working groups, or the open-source community.

I share lessons from a SoftBank proof of concept for an agent firewall, focusing on how organizations can define trust boundaries and inspect agent-to-agent communication. The presentation also introduces the broader Agent SecOps concept and discusses practical trade-offs in policy enforcement.

■ Agent firewall and trust boundaries
- How the proof of concept identifies communicating agents, checks permissions, and inspects messages
- Why enterprise trust boundaries may need to extend beyond protocol interfaces to agents’ external actions

■ Policy inspection and implementation challenges
- Rule-based checks versus model-based semantic inspection, including latency, cost, and auditability considerations
- Streaming responses, non-deterministic judgments, and the scope of the presentation; MCP, tool calls, and agent data access are excluded

I address engineers and teams designing governance or security controls for AI agents. Use the discussion to review which actions and agents need protection, then prioritize deterministic checks and reserve semantic inspection for cases that require contextual understanding.

I share practical lessons from operating an MCP proxy across many users, clients, and remote servers, focusing on authentication reliability, request efficiency, and visibility into server behavior. The discussion centers on implementation concerns and does not attempt to provide a full walkthrough of OAuth authorization.

■ Authentication and token management
- Refresh-token acquisition, concurrent refresh requests, and recovery from authorization errors
■ Request efficiency and observability
- MCP session and tool-list caching, contextual errors, structured logs, and server health
■ Implementation considerations
- Authentication metadata and endpoint overrides, plus caching discovery results

This is aimed at developers building MCP proxies or servers and teams integrating OAuth providers. I outline areas to plan for and checks to consider, including distributed locking, caching, and clear error reporting.

I explain how Agent Skills can complement MCP tools by providing reusable procedures and domain knowledge, and describe the design of an MCP extension for sharing skills. The talk covers the extension’s resource-based approach and the process behind its development and review.

■ Skills and MCP
- Why tool descriptions alone may not capture workflows, conventions, or specialized knowledge
- How MCP resources expose skill metadata, skill files, and related resources

■ Extension design and development
- The choices considered, the decision to keep the extension minimal, and the standardization process
- Open questions around discovery, progressive disclosure, and folder listing

This overview is for people building agents, MCP servers, or contributing to related specifications. It offers context for evaluating the extension’s design and points interested viewers toward community channels for questions and participation; it does not provide a step-by-step implementation guide.

Uber’s Debug Assist is an AI-assisted system designed to help engineers investigate production issues and move from reports toward actionable fixes. I explain the challenges it addresses, the system’s workflow and architecture, and examples of how it is used at Uber.

■ Problem and workflow
- How Wisdom and Healthline capture issue reports, logs, and diagnostic context; how issues are classified and routed
- Examples involving battery drain and a crash, followed by an overview of root-cause analysis and proposed fixes

■ Architecture and deployment
- The LangGraph-based workflow, deterministic and LLM-powered steps, specialist agents, and safeguards
- Shared infrastructure, pluggable skills, developer review tools, validation, and integration with internal systems

■ Results and discussion
- Reported operational metrics, followed by audience questions about testing strategies and coordinating specialist agents

The presentation focuses on Uber’s approach and architecture rather than offering a step-by-step implementation tutorial. It is intended for software engineers and engineering leaders; viewers can use the workflow and design considerations to assess how AI-assisted debugging might fit their own incident-response processes.

I describe an experiment in using AI agents to operate six vending machines, focusing on what it takes to connect software agents to real-world business operations. The talk covers the system design, operational lessons, and business metrics, rather than a general guide to running a restaurant.

■ Building the operating system
- Connecting vending-machine controls and a custom point-of-sale system to agent tools
- Scheduling agent tasks, verifying results, and managing shared access and business context
■ Operating in the real world
- Setting goals and tasks, providing business context, and using human support for on-site work
- Observations on product selection, pricing, promotion, and revenue
■ Takeaways and next steps
- A simulation lets viewers experiment with models across six machines

For developers and business operators exploring AI agents, this offers concrete examples of integrating agents with physical equipment and highlights questions to consider before testing their own workflows. Viewers can try the simulation and propose an improvement to test in the vending-machine setup.

Autonomy AI co-founder and CTO Tamuz Dubnov explains how the company helps product managers and designers work with existing enterprise codebases, and why simply giving non-developers coding agents can create friction. The conversation covers the product’s approach, a live walkthrough, and questions from the hosts about engineering ownership and risk.

■ Product workflow and demo
- How agents use codebase context, product signals, design systems, and safeguards to support feature work
- A walkthrough of prototyping, preview environments, collaboration, and pull-request creation
■ Adoption and trade-offs
- Enterprise integrations, deployment and model options, and the company’s context engine
- Discussion of task risk, code maintenance, engineering review, and where non-technical contributors fit

For product managers, designers, and engineering leaders evaluating agent-assisted development, this offers an overview of Autonomy AI’s intended use and workflow. Consider trying it on a low-risk task and assessing how its output fits your team’s review and maintenance practices.

Conference keynotes explore how to keep agentic AI infrastructure open, connect agents to services, and apply agents to software development and operations. Speakers share governance approaches, protocol changes, design trade-offs, and organizational examples.

■ Foundation governance
- Project lifecycle stages and open participation in working groups
■ Agent access and protocols
- Stateless MCP transport and migration; choosing among MCP, WebMCP, and CLI
■ Agentic software engineering
- Software factory workflows, code quality, planning, and feedback
■ Operational agents
- Salesforce examples for incident triage and customer briefings

For foundation contributors, product teams, and engineers adopting agents, the talks offer frameworks for selecting an integration approach and shaping team workflows. Viewers can use the examples to identify a focused use case, establish suitable oversight, and plan next steps; the content is not a step-by-step implementation guide.