Speaker Notes

AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team

The Model Context Protocol (MCP) establishes an open standard for connecting AI models to external tools and data sources, while modern software engineering transitions from static codebases and manual workflows to agent-driven factories powered by local models and dynamic tool discovery.

AI Engineer · 8:37:51 · YouTube ↗

Talk · conference MC, organizer, and tech executive  Intermediate · conference talks and live demo

Highlights

34 clips · 37 min of 518 min
    • Automated newsletters like AI News can be built using repeated scraping, planning, and summarization loops.
    • Generalizing this pipeline leads to the SPA model: Sync, Plan, Analyze/Reduce.
    • Outputs can be channeled into knowledge graphs, structured formats, or code artifacts like canvases.
    • Development is moving from pair programming (sidekick) to peer programming (teammate).
    • The software factory is evolving into an agent factory focused on behaviors rather than binaries.
    • Models are moving from pure cloud dependencies to running locally on edge devices.
    • You can assign a GitHub issue directly to Copilot to automatically generate missing documentation.
    • The coding agent operates independently in a branch and runs tests until the task is complete.
    • This frees developers from tedious maintenance chores to focus on architecture.
    • Fine-tuning models on domain-specific production interactions yields dramatic quality improvements.
    • Synthetic fine-tuning provides modest gains, but real user interaction data is far more effective.
    • The Dragon healthcare copilot achieved an 83 percent character acceptance rate using 650,000 interaction logs.
    • Synthetic tuning yields minor quality gains, but real user interaction feedback scales performance.
    • A leading healthcare co-pilot achieved an 83% character acceptance rate using 650,000 interaction loops.
    • Code functions exceptionally well for LLMs due to structured text and deterministic test validation.
    • Heavy research investments into coding benchmarks significantly accelerated developer tool maturity.
    • Human tolerance for failure drops sharply as task latency and operational autonomy increase.
    • Building augmentation co-pilots first provides a more reliable path than forcing full end-to-end automation.
    • Cursor outexecuted competitors on UX without inventing core models.
    • First-mover advantage in basic wrappers easily gets crushed.
    • Execution speed and product experience matter more than raw model ownership.
    • Mistral Small 3 fits in roughly 20GB RAM while maintaining high capabilities.
    • Smaller parameter counts allow running coding assistants and IDEs locally simultaneously.
    • Developers constantly copy context manually between external tools and chat interfaces.
    • MCP provides a standardized open-source protocol for models to reach into the outside world.
    • Model agency and external tool interaction represent the next stage of LLM utility.
    • Assume far more MCP servers than clients in the ecosystem
    • Deliberately push architectural complexity down to the client
    • Optimize server developer experience to accelerate ecosystem growth
    • Use a shared gateway infrastructure for a single point of entry
    • Automate OAuth and credential management centrally to secure integrations
    • Return a standardized SDK client session via simple URL-based routing
    • Exposing too many tools simultaneously confuses models and degrades performance
    • Dynamic discovery lets servers inject context-specific tools on the fly
    • Stateful applications can reveal specialized actions only when relevant conditions are met
    • Servers can dynamically expose or hide tools based on the current context and state.
    • In a MUD game example, combat tools appear only when a monster is present.
    • Reduces token clutter and model confusion by keeping irrelevant tools out of context.
    • Sampling allows an MCP server to request language model completions back through the client.
    • Includes built-in user permission dialogs to govern server access to the LLM.
    • Enables progressive enhancements like summarizing resources or formatting fetched websites into markdown.
    • VS Code provides a built-in dev mode and console output for all MCP servers.
    • Allows direct breakpoint attachment and stepping through server code for Python and Node.
    • Solves the friction of debugging servers spawned by external client host processes.
    • Directly wrapping an existing OpenAPI spec into MCP tools produces poor results.
    • Language models struggle to reason about raw, large JSON payloads built for traditional APIs.
    • Tool parameters and responses must be intentionally designed for agent consumption.
    • Translating API responses directly into structured Markdown yields better agent performance.
    • If a human can easily read and reason about the response structure, the language model can too.
    • Helps avoid the brittleness of forcing models to parse complex, verbose JSON trees.
    • OpenAPI lacks native support for dynamic tools that change during execution.
    • MCP provides essential features like streaming logging during tool execution and sampling.
    • Standard I/O subprocess execution makes MCP vastly more flexible than REST-based OpenAPI.
    • Sampling allows MCP servers to make requests back through the client to the LLM.
    • It eliminates the need for remote servers to configure separate LLM access.
    • The client proxies the request, receives the response, and forwards it to the server.
    • Putting detailed query logic and schemas inside tool descriptions bloats the main agent's context window.
    • Executing inference inside the MCP server handles complex processing locally.
    • The main agent stays lightweight by only receiving the final formatted output.
    • Traces represent atomic operations made up of hierarchical steps called spans.
    • Spans capture duration and arbitrary metadata for each step in a call graph.
    • Centralized syncs collect telemetry data across systems using open standards.
    • Extracting current span context on the client allows passing it along to the server.
    • Shuttling trace data through the protocol's metadata payload connects distributed call graphs.
    • This technique enables open-source tracing solutions to stitch client and server spans together.
    • OpenAPI fails at scale because loading thousands of tool definitions exceeds context windows.
    • MCP dynamic tool discovery allows clients to pull tools on-demand based on workflow needs.
    • VS Code and Claude Desktop recently added native support for dynamic tool discovery.
    • Developers can wrap external MCP servers or APIs as actors and handle monetization themselves.
    • Parent MCP servers can nest child MCP servers to build rich, multi-tier ecosystems.
    • This approach scales the marketplace rapidly without requiring direct third-party cooperation.
    • Strands shifts developer focus from hardcoding agent steps to defining prompts and tools.
    • The name reflects DNA strands connecting the two core agent pieces: models and tools.
    • It simplifies building and deploying production-ready agents in minimal lines of code.
    • Putting thousands of tools directly into a single model context window is impractical.
    • A semantic retrieval tool stores tool descriptions in a knowledge base for dynamic lookup.
    • Agents query the knowledge base to pull only relevant tools into the active context.
    • Putting thousands of tool descriptions into a single context window degrades model performance.
    • Store tool descriptions in a knowledge base and use a semantic search tool to fetch only relevant tools dynamically.
    • Moving beyond local standard IO enables remote, scalable MCP server deployments.
    • AWS Lambda functions can host MCP servers using streamable HTTP protocols.
    • Session state and authorization can be managed using DynamoDB and custom authorizers.
    • MCP servers can be scaled remotely by deploying them as AWS Lambda functions using streamable HTTP.
    • Combine API gateway auth and DynamoDB session tables to maintain secure, stateful agent connections in the cloud.
    • Modern AI coding assistants rely on a shared timeline between human and AI to track every action across the workflow.
    • Evolution spans from single-line autocompletes to multi-file edits, background research, and terminal execution.
    • Off-the-shelf frontier models are insufficient for the messy, non-linear reality of real-world software engineering.
    • Training dedicated engineering models using end-to-end PR benchmarks and conversational coding tasks yields high performance.
    • Critical technical integrations claimed to take months can be completed in a single day by treating them as intensive problem sets.
    • Reject arbitrary institutional constraints and leverage parallel coding efforts to bypass standard organizational slowdowns.
    • Identify unnecessary overhead by thinking from first principles instead of accepting arbitrary constraints.
    • AI acceleration makes cutting traditional development constraints and bottlenecks highly viable.
    • Turing proposed building child machines that learn rather than writing explicit rules by hand.
    • Machine learning solves problems that human programmers cannot explicitly understand or code.
    • Engineers and researchers experience friction due to different error visibility and system assumptions.
    • Entering AI labs requires technical humility and deeply listening before altering system abstractions.
    • Codebases should be structured to match the lopsided strengths of AI models rather than humans alone.
    • Writing small, well-tested modules allows models to reliably fill in implementation details and run tests.
    • Mixture of experts architectures effectively utilize idle DRAM when hardware resource ratios are mismatched.
    • Flexible software design can compensate for imperfect hardware provisioning in large data centers.

Questions this video answers

47 · every answer cites the moment it was said
01 How do we define standard models for AI engineering? 2 sources · 28:07

Standard models help guide our thinking in AI engineering similarly to MVC or CRUD in traditional software. Examples include architectural designs, software development life cycles, and agent interaction frameworks.

02 How can I structure an AI-intensive application using recursive processing? 2 sources · 33:31

You can generalize repetitive scraping and summarization tasks into a pattern called SPA, which stands for sync, plan, and analyze or reduce. This model allows you to execute thousands of AI calls to serve a specific application purpose efficiently.

03 How is GitHub Copilot evolving beyond simple code completion? 2 sources · 38:27

GitHub Copilot is transitioning from a sidekick into an actual peer programmer that operates directly within your branch. Because it is grounded in your codebase and patterns, it can run tests, understand team domains, and handle tasks until completion.

04 How do I quickly answer questions about a new codebase using AI? 2 sources · 41:31

You can use Copilot Spaces to create a dedicated workspace grounded in specific project files and instructions. This tool allows you to query the project in natural language and receive factual answers complete with direct code references.

05 What is the signals loop pattern for improving production agents? 2 sources · 45:52

The signals loop involves fine-tuning off-the-shelf models using real user interaction data and rigorous A/B testing. Platforms like Azure AI Foundry leverage this continuous loop to dramatically boost task acceptance rates and overall agent quality.

06 Why do we need local model deployment instead of relying entirely on the cloud? 2 sources · 57:40

Certain enterprise use cases like healthcare and industrial monitoring require local execution due to strict compliance, privacy, and latency constraints. The platform architecture should allow agents created in the cloud to seamlessly run and reason locally at the edge.

07 Why did coding agents succeed so rapidly compared to other verticals? 2 sources · 1:13:13

Code is structured logical text containing heavy boilerplate, making it ideal for LLMs to process. Furthermore, it features deterministic validation where automated tests and compilers can instantly verify if generated code works.

08 What actually drives defensibility in AI applications? 2 sources · 1:21:58

Execution speed forms the real moat rather than first-mover advantage or base model ownership. Companies like Cursor succeed by outexecuting competitors and shipping polished user experiences rapidly.

09 How can I evaluate dozens of new LLM releases without relying solely on flawed leaderboards? 2 sources · 1:25:42

Developers can create custom functional benchmarks, like generating SVG code for impossible scenes, to test model reasoning and coding limits. Running automated matchups and ELO rankings offers a practical alternative to standard benchmark numbers.

10 Can I run GPT-4 class models locally on consumer hardware? 2 sources · 1:27:30

Meta's 70-billion parameter models fit into standard high-end consumer RAM and deliver capabilities comparable to much larger proprietary models. This allows developers to run powerful models locally without relying entirely on cloud APIs.

11 What are the economic implications of recent open-weights model releases? 2 sources · 1:29:10

Major labs have demonstrated that highly effective open-weights models can be trained for a fraction of the cost previously expected. This disruption has driven down token pricing significantly and lowered barriers for local deployment.

12 How do I maintain control when AI models automatically inject unwanted context memory? 2 sources · 1:34:34

Advanced memory features can pull in historical context automatically, which sometimes compromises user intent and artistic control. Power users can disable these features to ensure complete control over the inputs provided to the model.

13 How can I fix extreme sycophancy and flattery in LLM outputs? 2 sources · 1:39:06

Excessive flattery can occur when system prompts encourage matching the user's vibe too closely. You can fix this behavior by updating the system prompt to explicitly avoid ungrounded flattery and demand directness.

14 Why is combining reasoning models with tool use so powerful? 2 sources · 1:42:01

Reasoning models can dynamically execute, evaluate, and iteratively refine tool calls like web searches until they achieve the desired result. This feedback loop represents one of the most powerful techniques in current AI engineering.

15 What specific workflow pain point led to the creation of Model Context Protocol? 2 sources · 2:29:56

Developers frequently suffered from copy-and-paste fatigue while moving context between isolated applications and AI chat windows. MCP was created to give models standardized agency to reach out and fetch context from the real world.

16 Why did Anthropic create the Model Context Protocol? 2 sources · 2:33:59

MCP was created to give LLMs model agency, allowing them to reach out beyond their context window and interact with the real world. The co-creators wanted to eliminate the friction of constantly copying and pasting context from external tools like Slack and error logs.

17 How does MCP handle the complexity trade-off between clients and servers? 2 sources · 2:40:34

The protocol intentionally optimizes for server simplicity and better server tooling since there are expected to be many more servers than clients. Consequently, implementation trade-offs push complexity down to the client builders.

18 How do we solve integration chaos when scaling MCP inside an organization? 2 sources · 2:58:02

Organizations can deploy an MCP gateway as a shared piece of infrastructure providing a single entry point and URL-based routing. This gateway handles centralized credential management like OAuth, rate limiting, and observability so apps do not implement them repeatedly.

19 What are the pitfalls of treating MCP servers as simple API wrappers? 2 sources · 2:45:37

Wrapping API endpoints one-to-one can lead to quality problems because models get confused by too many tools, mixed domains, and excessive execution steps. A better approach utilizes the full protocol, including dynamic tool discovery and semantic resources.

20 How does dynamic tool discovery adapt an agent's capabilities? 2 sources · 3:09:41

Dynamic tool discovery lets an MCP server add or remove tools on the fly based on the current application state. For example, a battle tool only appears in a dungeon crawler when a monster is actually present. This reduces the number of active tools and prevents AI confusion.

21 Why should servers use resources instead of raw file dumps? 2 sources · 3:10:26

Resources provide a semantic context layer rather than dumping giant files onto the server. This allows LLMs and users to follow up on references or understand specific environment settings. It makes interactions more dynamic and stateful out of the box.

22 What is sampling and why is it useful in MCP? 2 sources · 3:11:51

Sampling is a primitive that allows an MCP server to request LLM completions directly from the client. It enables progressive enhancements like summarizing resources or formatting websites into markdown. Despite its confusing name, it provides powerful capabilities when implemented.

23 How does VS Code simplify MCP server debugging? 2 sources · 3:13:27

VS Code introduces a dev mode toggle that attaches a debugger directly to the MCP server process. Because VS Code runs both the client and host, it can easily catch breakpoints and step through code. This works out of the box for both Python and Node.

24 What authentication challenges arise when building remote MCP servers? 2 sources · 3:25:11

Building remote MCP servers requires handling OAuth 2.1, a specification that very few systems support out of the box. Developers often need to use shims or proxy solutions, like Cloudflare workers, to handle client registration and authentication flows.

25 Why can't you just wrap a raw OpenAPI spec as MCP tools? 2 sources · 3:26:07

Directly proxying OpenAPI endpoints as tools leads to poor results because models cannot reason about giant, untailored JSON payloads. Developers must thoughtfully design tools and use formats like markdown to help language models comprehend the output.

26 How do tool payloads impact token costs and model performance? 2 sources · 3:32:01

Returning unconstrained payloads can drastically increase token costs, turning a cheap call into an expensive one. Furthermore, models face token limits on tool descriptions, requiring developers to carefully constrain and optimize what they send.

27 Why should developers focus on building agent architectures with MCP? 2 sources · 3:21:33

MCP functions fundamentally as a pluggable architecture for agents, giving developers greater control over tool calls, prompts, and results. Building full agent services allows teams to handle complex workflows and ensure responsibility for execution success.

28 Why do we need MCP instead of just using OpenAPI for tool calling? 2 sources · 5:11:47

OpenAPI cannot handle dynamic tools, streaming logging, or subprocess execution over standard IO. MCP introduces primitives like sampling, allowing a remote server to leverage the client's LLM without managing separate model configurations.

29 How does running inference inside an MCP tool protect the main agent's context window? 2 sources · 5:20:21

By offloading complex prompt logic and execution details to the tool server, you avoid bloating the main agent's context with excessive instructions. The tool performs the sub-task and returns a concise, structured response, such as XML, back to the main agent.

30 How do we solve the observability blind spots introduced by MCP in distributed agent systems? 2 sources · 5:30:26

Modern agent systems can use OpenTelemetry to standardize tracing across different domains. By propagating trace context from the client to the server via lower-level protocol metadata, monitoring systems can stitch distributed spans back together.

31 What are semantic conventions and why are they important for agent observability? 2 sources · 5:41:01

Semantic conventions provide standardized attributes for spans so monitoring syncs can recognize specific events like MCP tool errors or HTTP requests. Without them, observability platforms cannot reliably interpret user-defined attributes across different agent systems.

32 How do AI agents discover tools in large registries without exceeding context limits? 2 sources · 5:49:26

Dynamic tool discovery allows clients to connect to an MCP server and query tools on demand instead of loading thousands of definitions at once. This solves OpenAPI context limit issues by fetching only what is needed for the current workflow.

33 How can developers monetize third-party tools within an MCP marketplace? 2 sources · 5:54:27

Developers can publish actors or wrapped MCP servers by providing their own credit card and account details to third-party services. The marketplace handles the billing and charges the end user, allowing the creator to get paid while covering external costs.

34 What is the benefit of graph rag in retrieval systems? 2 sources · 7:12:11

Graph rag combines unstructured text chunks with structured knowledge graphs to find entities like people, places, and themes. This enables multi-hop querying where models can discover non-obvious connections between different data sources.

35 How does Neo4j support early-stage AI projects? 2 sources · 7:14:36

Neo4j offers a startup program designed to help developers build AI applications on their technology stack. Participants receive Aura credits and a free way to utilize cloud infrastructure.

36 How does the Amazon Q CLI agent interact with documentation? 2 sources · 7:21:26

The CLI agent brings a chat experience directly into the terminal and integrates natively with MCP. It connects to an official AWS documentation MCP server to fetch accurate, grounded responses.

37 What is the Strands Agents SDK and how does it simplify agent creation? 2 sources · 7:23:30

Strands Agents is an open-source Python SDK designed for model-driven workflows and rapid agent development. It relies on capable language models to handle reasoning, planning, and action execution rather than manual scripting.

38 How can agents manage thousands of tools without exceeding context windows? 2 sources · 7:26:21

Agents can utilize semantic search over a tool repository using a retrieve tool. This architecture stores tool descriptions in a knowledge base and pulls only the most relevant tools into the active context window.

39 How do I run an MCP server remotely on AWS? 2 sources · 7:29:54

You can decouple standard IO MCP servers by deploying them as AWS Lambda functions using streamable HTTP. By placing them behind an API gateway with session storage backed by a DynamoDB table, you can scale and connect remote clients securely.

40 What makes Windsurf's AI coding assistant feel like it's reading my mind? 2 sources · 7:36:52

Windsurf relies on a shared timeline between the human and the AI that tracks every action across both coding and external surfaces. This architecture allows the agent to ingest context, execute terminal commands, and perform background research across thousands of files directly inside the editor.

41 Why train a custom model specifically for software engineering? 2 sources · 7:44:47

Off-the-shelf frontier models often focus narrowly on token-in-token-out code generation rather than messy, real-world engineering workflows. Training a specialized model allows it to handle conversational tasks, mid-workflow interruptions, and diverse tool usage at a fraction of the cost.

42 How can first-principles thinking help bypass long enterprise timelines? 2 sources · 7:58:01

Challenging arbitrary constraints and standard operational overhead allows teams to compress months of work into days. For example, early Stripe engineers completed a complex bank technical integration in 24 hours by treating it like a college problem set and working around rigid vendor timelines.

43 How should I structure my codebase to get the most out of AI coding models? 2 sources · 8:19:06

You should structure your code into smaller, well-tested modules with tests that run very quickly. This matches the lopsided strengths of models, allowing them to fill in details and run tests thousands of times. Ultimately, building your codebase as if for junior developers maximizes model utility and maintainability.

44 How do we handle checkpointing for long-horizon agents when training runs take days? 2 sources · 8:22:10

As rollouts extend from seconds to days, you must think hard about snapshotting state and checkpointing caching mechanisms to avoid recomputing everything. Because language model state is explicit, it can be stored, though stateful external tools pose recovery challenges. Ultimately, models are smart enough to handle minor graph wiggles if a restart occurs.

45 How do we design AI infrastructure for both high-compute reasoning workloads and low-latency real-time apps? 2 sources · 8:25:42

While a naive approach uses two kinds of purpose-built accelerators for compute versus latency, predicting exact resource ratios is difficult and risks leaving parts of the fleet useless. However, techniques like mixture of experts help utilize idle DRAM parameters for extra efficiency if resource balances skew. Homogeneity of accelerators remains a safe default, though hyper-optimizing purpose-built hardware is becoming reasonable as capex scales.

46 What are the current scaling bottlenecks for frontier models like GPT-6? 2 sources · 8:27:22

The primary scaling bottlenecks span compute, data, algorithms, power, and money. Basic research has returned as an important long pole alongside compute and data as algorithms become critical for scaling progress. While priorities shift day-to-day, maintaining a balance across all these pillars is essential for future advancement.

47 How will the development process change as domain-specific agents become capable? 2 sources · 8:31:13

The evidence points toward a menagerie of different models rather than a single giant AI, leveraging inference costs and distillation. This enables a diversity of domain-specific agents utilizing short-term and long-term memory, reasoning, and tools. The ultimate goal is to multiply economic output tenfold and lower the barrier to entry across complex fields like healthcare and education.

Section-by-section summary

86 parts

Record-breaking enterprise AI adoption is driving real value

The 2025 AI Engineer World's Fair highlights massive scale with over 3,000 attendees and 250 speakers. Real-world traction is evident through massive consumer adoption of ChatGPT and enterprise deployment of GitHub Copilot and cloud AI services.

Establishing standard models for AI engineering

AI engineering is maturing past the derided wrapper phase, prompting the search for enduring standard models akin to MVC or CRUD. Frameworks like software development lifecycles and agentic loops help organize complex multi-step workflows into repeatable patterns.

Microsoft introduces the open agentic web and Foundry

The AI platform landscape is shifting from monolithic models to diverse reasoning engines operating seamlessly across cloud and edge. Microsoft's Foundry platform and GitHub Copilot extensions provide the industrial-grade backbone for this new era.

GitHub Copilot evolves into a proactive peer programmer

Copilot has shifted from a reactive autocompletion tool to an active teammate operating directly within codebase branches. New capabilities like Copilot Spaces and codebase-grounded reasoning allow developers to query architecture and automate maintenance tasks.

Live demonstration of Copilot Spaces and machine learning agents

Live demonstrations showed how Copilot Spaces answer architectural questions grounded in project files and autonomously resolve issues. Additionally, specialized agents like Amaly can collaborate within the IDE to reason through machine learning tasks and fix code errors.

Continuous feedback loops drive agent quality improvements

Platform data shows that fine-tuning models with real user interaction signals dramatically increases character acceptance rates in production health care co-pilots.

Multi-agent systems execute complex multi-step workflows

A live demo showcases an event planner application using specialized sub-agents to research attendees, draft personalized emails, edit images, and publish to LinkedIn simultaneously.

Edge deployment is essential for secure agent architectures

Real-world enterprise applications like hospital systems and industrial plants require agents to execute and reason locally while interfacing securely with the cloud.

AI applications deliver massive value despite implementation difficulties

Venture investing data reveals that while AI product engineering is significantly harder than anticipated, successful startups are scaling to tens of millions in ARR faster than ever.

Rapid capability gains and tumbling inference costs

Reasoning models and expanding multimodality are unlocking sophisticated business workflows, while open and proprietary model competition drives inference costs down rapidly.

Code-first success provides a playbook for vertical apps

Coding tools like Cursor achieve massive growth because code offers structured text and deterministic validation, establishing a repeatable pattern for software wrappers that capture domain workflows.

Conservative industries adopt AI faster than expected

Low-tech vertical markets like legal and customer service are rapidly embracing AI co-pilots, proving that flawless execution and domain-specific UX matter more than fearing model provider encroachment.

Execution speed forms the true AI moat

Execution is the primary moat because product experience and shipping speed determine adoption. First-mover advantage in basic prompt wrappers fails quickly when foundational models improve.

Tracking model releases with creative benchmarks

Tracking thirty significant model releases requires practical, repeatable benchmarks rather than unreliable leaderboards. A custom SVG generation task provides a creative test for non-image models.

Open weights and low-cost deployment economics

Amazon Nova and Llama 3.3 brought high-capability models down to consumer hardware and low cost. DeepSeek V3 demonstrated that massive open-weights models can be trained far more cheaply than expected.

Open-source reasoning models disrupt expectations

DeepSeek R1 reasoning models surprised the market by matching proprietary performance under strict trade restrictions. Smaller local models like Mistral Small 3 deliver high performance within tight memory footprints.

Hybrid reasoning and token pricing deflation

Claude 3.7 introduced hybrid reasoning while OpenAI's GPT-4.5 proved that scaling purely through training cost hits diminishing returns. Overall token pricing has collapsed by orders of magnitude over recent years.

Multimodal releases and context memory friction

Google's Gemini 2.5 and OpenAI's native multimodal image generation drove massive user adoption. However, automated context memory features can reduce user control by injecting unwanted persistent data.

Finding cost-effective point releases for production

While early Llama 4 releases proved difficult to run locally, OpenAI's GPT-4.1 models provide high-performance and low-cost defaults for API workflows. Point releases often yield the most practical production upgrades.

Automated ELO leaderboards for output evaluation

Automated ELO rankings derived from pairwise LLM judgments offer a scalable way to evaluate subjective model outputs. This approach replaces manual inspection with programmatic comparison pipelines.

Quirky model bugs from sycophancy to whistleblowing

Model bugs reveal quirky failure modes, such as excessive sycophancy or autonomous whistleblowing when prompted to follow ethics. Prompt engineering often requires explicit instructions to remain direct and ungrounded.

Combining reasoning with tool use in AI engineering

Combining reasoning models with tool execution represents a powerful paradigm in AI engineering. However, architectures accessing private data face severe risks like prompt injection and data exfiltration.

Evaluating AI risks through science fiction lenses

Science fiction tropes offer a useful lens for examining the ethical boundaries and risks of autonomous AI systems. Graph technology provides foundational grounding to address these architectural challenges.

Conference track layout and logistic overview

The conference splits into specialized tracks covering MCP, tiny teams, graph rag, leadership, and infrastructure. These sessions provide targeted deep dives into specific engineering challenges.

Tool calls are becoming the new clicks

The explosion of tool usage points to tool calls becoming the new clicks across the internet economy. Connecting fragmented developer workflows prevents the friction of manual copying and pasting.

MCP origin story and eliminating copy-paste hell

Model Context Protocol originated from the need to eliminate manual copy-pasting between external tools. Standardizing integrations through an open-source protocol enables models to achieve true agency.

Overcoming early skepticism through ecosystem adoption

Initial launches faced questions about why a new protocol was needed, but adoption by IDEs like Cursor turned MCP into an industry standard. Today, major AI labs and platforms have rallied around the open-source protocol.

Optimizing protocol design for server simplicity

MCP architecture deliberately pushes complexity down to the client while optimizing for server simplicity. Recent spec additions like streamable HTTP support better birectionality and agent communication.

High-opportunity areas for building MCP startups

The ecosystem heavily needs higher-quality servers across diverse business verticals rather than simple API wrappers. Founders should focus on server hosting, testing tooling, and developer experience.

Eliminating integration chaos with internal standardization

Rapid AI development leads to custom endpoints and fragmented integrations across organizations. Standardizing on MCP internally prevents duplication and lets engineers focus on core business value.

Using an MCP gateway for centralized auth and routing

Anthropic built an internal MCP gateway to provide a single entry point with URL-based routing and automatic OAuth handling. This architecture secures credentials and simplifies client code across internal services.

Unlocking advanced capabilities beyond basic tool wrappers

Many developers treat MCP as a simple API wrapper, missing out on rich stateful interactions. VS Code's full spec support highlights how advanced features enable more powerful agent workflows.

Full MCP spec support unlocks rich stateful interactions

Implementing the complete MCP specification allows clients and servers to move beyond simple tool execution into dynamic, context-aware agent workflows. VS Code provides full spec support to leverage these advanced primitives out of the box.

Dynamic tool discovery adapts agent capabilities on the fly

Servers can dynamically update tools, prompts, and resources based on workspace changes or application state. This ensures agents only see relevant tools, such as enabling combat actions only when encountering an enemy.

Resources provide semantic context instead of raw file dumps

Resources establish a semantic layer that exposes references, screenshots, or environment settings to both the LLM and the user. This avoids returning giant file payloads and enables dynamic customization based on project frameworks.

Sampling allows servers to request LLM completions from clients

The sampling primitive lets an MCP server request completions from the client's LLM with user permission dialogs. It facilitates progressive enhancements like summarizing resources or formatting web content into markdown.

Integrated debugging transforms MCP server development

VS Code introduces a dedicated dev mode that automatically captures server console logs and attaches debuggers for Python and Node. This eliminates the difficulty of debugging child processes managed by external host applications.

Active participation in draft specs drives ecosystem stability

Draft specifications for enterprise authentication, streamable HTTP, and elicitations rely heavily on developer feedback. Engaging with open RFCs and filing issues ensures SDKs and clients evolve to support robust production patterns.

MCP functions as a pluggable architecture for enterprise agents

Building enterprise MCP servers, such as Sentry's bug-fixing integration, treats the protocol as a pluggable architecture for cloud services. This bridges traditional B2B SaaS applications directly into developer editors like VS Code and Cursor.

OAuth 2.1 implementation introduces unexpected authentication hurdles

Setting up secure remote MCP servers requires modern authentication standards like OAuth 2.1. While tools like Cloudflare workers can proxy authentication flows, navigating strict client registration requirements adds initial friction.

Direct OpenAPI proxies fail because models need tailored tool design

Automatically proxying raw OpenAPI endpoints into MCP tools yields poor results because models cannot reason about massive JSON payloads. Developers must consciously design tools and error messages specifically for agent consumption.

Markdown responses improve language model comprehension of tool output

Translating API responses into structured Markdown gives language models a cleaner interface to pattern match. Designing outputs for human readability naturally optimizes them for LLM reasoning and reduces parsing errors.

Managing token costs requires careful constraint of tool payloads

Unconstrained tool responses can exponentially increase token costs and hit client length limits. Developers must continuously monitor and iterate on their server implementations to keep token consumption manageable.

Agent architectures provide greater control than basic tool wrappers

Exposing higher-level agents through MCP rather than raw database or API wrappers gives developers control over prompts and multi-step reasoning. Although lacking streaming tool responses currently, agent-based MCP servers represent the future of B2B integration.

MCP serves as a unifying protocol for complex agent systems

Framework creators emphasize that MCP streamlines autonomous agent development by standardizing tool calling and communication. It eliminates the need to invent custom agent-to-agent protocols for Python applications.

Specialized primitives make MCP superior to raw OpenAPI

OpenAPI fails to address the complex requirements of autonomous agents, such as dynamic tools, execution logging, sampling, and tracing. MCP bridges these gaps while offering robust subprocess execution over standard input and output.

Sampling allows remote MCP servers to leverage client LLMs

Remote servers often need LLM capabilities but worry about cost and configuration overhead. Sampling enables an MCP server to make requests back through the client to access its LLM seamlessly.

Inference inside MCP tools protects main agent context windows

Passing raw data processing instructions and detailed schema descriptions directly to a central agent bloats its context window. Delegating this work to an MCP server executing a specialized tool keeps the main agent lightweight.

MCP adoption creates significant observability blind spots

As AI agents incorporate multiple third-party tools via MCP, end-to-end execution paths become opaque. Without proper instrumentation, debugging production failures and security issues becomes exceedingly difficult.

OpenTelemetry standardizes observability across distributed agent systems

AI agents operating with MCP servers form distributed systems that can leverage OpenTelemetry principles. Using standard traces, spans, and centralized syncs allows developers to monitor agent execution across different platforms.

Context propagation stitches distributed MCP traces together

When clients and servers operate across different administrative domains, tracing requires propagating context. Shuttling trace context through protocol metadata allows observability syncs to reconstruct the complete call graph.

Intelligence emerges from the interactions of individual entities

Biological neural networks and economic markets demonstrate that complex intelligence arises from decentralized units pursuing individual goals. Computing systems will similarly achieve general intelligence through multi-agent interactions over communication meshes.

Apify marketplace of software actors

Apify operates a marketplace of 5,000 containerized Docker tools called actors. These standardized units with clear inputs and outputs provide a robust foundation for automated web scraping and data extraction.

Dynamic tool discovery solves OpenAPI limits

Traditional OpenAPI specifications fail when scaling to thousands of tools due to context window limits. MCP tool discovery solves this by letting clients dynamically load only the tools required for the current task.

Autonomous agents require payment capabilities

While tool registries exist, agents still lack native ways to find and pay for services autonomously. Without payment mechanisms, agents remain tightly bound to human developers for service provisioning.

Comparing agent payment models

Initial approaches like direct agent subscriptions are impractical due to CAPTCHAs and identity requirements. Centralized payment networks face steep chicken-and-egg marketplace adoption challenges.

Centralized MCP stores with wrapped monetization

Apify proposes wrapping external MCP servers and APIs into monetized actors. Developers handle payment credentials on behalf of the service, enabling rapid ecosystem scaling without vendor approval.

Demonstrating dynamic tool discovery in Claude

A recorded demo showcases Claude Desktop querying Apify's MCP server for event venues. The agent dynamically searches for and invokes the appropriate web scraping actor to answer the prompt.

Wrapping third-party services without permission

Demonstrating ecosystem extensibility, Apify wrapped a competitor's MCP server without their knowledge. The agent successfully used this wrapped server to execute complex browser actions like filling out forms.

Rapid commercial growth for actor creators

Apify's creator ecosystem is paying out hundreds of thousands of dollars monthly to developers. Publishing tools to this marketplace instantly exposes them to all integrated AI clients.

Conference intermission and music

The conference stream transitions through an intermission with music before resuming the afternoon keynotes.

Reviewing MCP dynamic tool discovery and keynotes

Lorie Voss recaps highlights from the MCP track, including VS Code Insider support and dynamic tool discovery. The afternoon proceeds with closing keynotes on Graph RAG, cloud scale, and AI engineering.

Agentic memory and graph rag foundations

Neo4j presents graph rag and agentic memory as critical components for improving LLM context and reasoning. Knowledge graphs bridge unstructured document chunks with structured entities and themes.

Automated knowledge graph creation from text

Neo4j demonstrates an LLM graph builder that ingests Wikipedia articles and chunks text. The system extracts people, places, movies, and themes to construct an interconnected graph database.

Querying multi-hop connections in graphs

A built-in graph chat interface successfully queries relationships and shared themes between distinct entities. This demonstrates how graph structures uncover non-obvious connections across disparate documents.

Neo4j launches startup cloud program

Neo4j announces a new startup program to help developers build AI applications on their cloud platform. The program offers Aura credits and free resources alongside open-source community editions.

Reimagining enterprise experiences at cloud scale

AWS emphasizes that customer experiences will be reinvented through AI agents. Amazon's massive deployment of agents powers reimagined services like Alexa Plus across hundreds of millions of devices.

Rapidly building Amazon Q CLI agents

AWS developed and shipped the Amazon Q CLI agent in just three weeks. The CLI integrates with MCP to query official documentation and assist developers directly in the terminal.

Strands Agents Python SDK for model-driven workflows

AWS introduces Strands Agents, an open-source Python SDK using a model-driven approach. It connects models and tools seamlessly, allowing developers to focus on agent goals rather than manual orchestration steps.

Semantic tool retrieval for massive toolsets

Strands includes over 20 pre-built tools and semantic retrieval capabilities. For agents managing thousands of tools, descriptions are stored in a knowledge base to dynamically pull only relevant tools into context.

Expanding MCP beyond standard IO on AWS

AWS provides numerous MCP server implementations tailored for cloud architectures. Moving past local standard IO requires deploying servers via remote communication protocols.

Hosting MCP servers inside AWS Lambda

To scale and connect remote MCP servers, you can deploy them as Lambda functions using streamable HTTP. Integrating DynamoDB for session data and adding an authorizer ensures secure and stateful agent interactions.

AI code editors rely on a shared timeline

The secret sauce of modern AI coding assistants is maintaining a shared timeline between the human and AI. This allows the system to seamlessly track edits, terminal commands, and background research across the entire software development lifecycle.

Expanding AI agents beyond the IDE

Advanced developer agents must read context from external sources like Slack, Google Docs, and Figma via MCP. Furthermore, they need to execute actions across the full lifecycle, including browser previews, PR creation, and one-click deployments.

Training specialized models for software engineering

Off-the-shelf frontier models often struggle with messy, real-world engineering workflows. Training a specialized software engineering model on end-to-end tasks and conversational coding benchmarks yields near-frontier results at a fraction of the cost.

Learning to code from first principles

Self-teaching through building practical projects offers immediate, tangible feedback compared to abstract theory. By focusing on creating functional software rather than long-term proofs, developers can quickly ship real-world impact.

Bypassing enterprise bottlenecks with first-principles execution

Critical integrations that traditionally take months can often be compressed into hours by treating them as intense problem-solving exercises. Rejecting arbitrary organizational constraints allows small teams to achieve massive velocity.

Compounding knowledge through independent study

Immersing oneself in deep, self-directed study allows motivated learners to rapidly compress years of education. Pushing through initial hurdles and exploring genuine passions builds a strong foundation that compounds over time.

Turing's child machine vision realized

Alan Turing's 1950 concept of a learning child machine anticipated modern deep learning. Neural networks bypassed decades of brittle rule-based AI by learning directly from data.

Bridging engineering and research friction

Successful AI labs require deep harmony between research ideas and large-scale systems engineering. Engineers must approach research environments with technical humility to navigate differing failure modes.

Vibe coding evolves into legacy migration

While initial vibe coding focused on spinning up greenfield apps, the paradigm is shifting toward complex enterprise tasks. AI is now tackling legacy codebases, migrations, and tedious maintenance.

Structuring codebases for AI models

Maximizing code generation models requires structuring codebases into small, well-tested modules. Designing code for junior developers or models yields better maintainability and higher output.

Checkpointing state for long-horizon agents

Training long-horizon agents and multi-step reasoning workflows requires robust state checkpointing. Systems must handle intermittent failures and restore complex execution trajectories seamlessly.

Balancing infrastructure for dual workloads

AI infrastructure must handle contrasting workloads ranging from compute-heavy reasoning to ultra-low latency real-time interactions. Purpose-built accelerators and mixture-of-experts architectures help balance mismatched hardware ratios.

RL and algorithms drive scaling progress

As raw compute and data scaling face new bottlenecks, algorithmic innovations and reinforcement learning have returned as primary drivers. The RL paradigm specifically addresses reliability and reasoning gaps.

Domain agents expanding economic output

The future features a menagerie of specialized domain agents powered by foundation models. This ecosystem will dramatically lower barriers to entry and multiply overall economic productivity.

0:00 / 8:37:51
k play/pause · f fullscreen · m mute
n next · p previous clip · t highlights/full
< > slower/faster · / search what was said
  • Model Context Protocol145× · first 21:49

    An open protocol for connecting AI models to external tools and data sources.

  • Foundry8× · first 45:34

    A Microsoft platform used to build and support agentic applications and tooling.

  • Copilot Spaces1× · first 41:27

    A feature that lets you ground an AI assistant in specific project files and instructions.

  • Signals Loop2× · first 45:54

    A continuous feedback loop that fine-tunes models using real-world interaction data to personalize outcomes.

  • Agentic Rag13× · first 19:46

    A multi-shot retrieval-augmented generation approach that iterates, evaluates, and plans instead of using naive single-shot search.

  • Llama 3.3 70B1× · first 1:27:23

    A meta open-weights model capable of running on consumer hardware while matching larger model performance.

  • DeepSeek R12× · first 1:29:32

    A reasoning model released with open weights that rivals proprietary alternatives.

  • Graph RAG9× · first 19:46

    A graph-based methodology for improving data grounding and retrieval in AI models.

  • Pelican benchmark10× · first 1:26:03

    A custom visual generation test using SVG code to evaluate LLM capabilities.

  • MCP gateway3× · first 2:58:08

    A shared infrastructure service providing a single entry point, auth management, and routing for MCP servers.

  • Dynamic tool discovery2× · first 3:09:41

    A protocol feature allowing servers to provide or alter agent tools on the fly based on context.

  • Tools112× · first 29:06

    MCP primitive for performing well-defined actions and mapping to function calling.

  • Resources11× · first 1:13:43

    MCP primitive that provides semantic context and references instead of raw file dumps.

  • Sampling10× · first 2:55:52

    MCP primitive allowing a server to request LLM completions from the client.

  • OAuth 2.16× · first 2:58:37

    Modern authorization specification required for enterprise-grade remote MCP authentication.

  • OpenAPI8× · first 51:40

    Standard API specification that cannot be directly proxied as tools without tailored design.

  • Markdown5× · first 3:12:34

    Structured response format used to improve language model comprehension of tool outputs.

  • Pydantic3× · first 5:08:18

    Popular Python data validation library and ecosystem creator extending into agents and observability.

  • OpenTelemetry1× · first 5:37:08

    A vendor-neutral standard for collecting and managing distributed traces and telemetry data.

  • Apify Actors15× · first 2:34:34

    Self-contained pieces of software based on Docker that act as tools or web scrapers within a marketplace.

  • Actor15× · first 2:34:34

    A self-contained Docker-based software unit with defined inputs and outputs published on a marketplace.

  • LLM Graph Builder1× · first 7:11:27

    A tool that ingests unstructured text sources to automatically construct and query knowledge graphs.

  • Amazon Q2× · first 7:20:45

    An AI code assistant and agent integrated into the CLI to help developers debug and query documentation.

  • Strands Agents8× · first 7:23:30

    An open-source Python SDK for building model-driven AI agents and multi-agent workflows.

  • AWS Lambda5× · first 7:30:00

    A serverless compute service used to host remote MCP servers at cloud scale.

  • Sweet 12× · first 7:45:57

    A proprietary software engineering model trained to handle developer workflows rather than just code generation.

  • Codex5× · first 1:42:49

    An AI coding assistant system used to generate code and handle pull requests internally.

  • Mixture of Experts1× · first 8:26:29

    An architecture that utilizes idle DRAM parameters to gain extra machine learning compute efficiency.

  • Reinforcement Learning3× · first 8:09:49

    A training paradigm used to solve reliability problems and improve model consistency.