Stop Hoarding Your Prompts: AI Engineering Is a Team Sport

Building a great AI capability is valuable, but the real impact comes when other developers can discover it, use it, improve it, and build on the ideas behind it. Too often, though, those capabilities stay on one developer's laptop, get copied between repositories, or disappear into a wiki or chat thread.

In this session, we'll explore how to turn individual AI customizations into shared team capabilities. We'll look at practical approaches for packaging and distributing skills, agents, and instructions, making them discoverable through an internal marketplace, and applying familiar engineering practices such as pull requests, automated validation, versioning, and releases.

You'll leave with a practical architecture and lifecycle for moving from isolated AI experiments to a shared engineering ecosystem where useful ideas can become capabilities the whole team can build upon.

Beyond the Prompt: Building and Operating AI Agents

Building an AI agent is the easy part. Deciding how to host it, how much control you need over its behavior, how to extend it with tools, and how to understand what it is doing at runtime is where things get interesting.

In this developer-focused session, we’ll use Microsoft Foundry to explore the engineering decisions involved in moving an agent beyond the prototype. We’ll compare prompt-based agents with code-based hosted agents, examine when greater control is worth the additional complexity, and use Microsoft Agent Framework to build and deploy a code-based agent.

We’ll then extend our agents with tools and dig into runtime observability by tracing requests, inspecting tool calls, debugging unexpected behavior, and understanding how an agent reached a result.

Through code and practical demos, you’ll leave with a clearer mental model for choosing an agent architecture and the techniques needed to build, extend, debug, and operate agents beyond the initial prompt.

Agents That Survive Failure: Building Durable AI Systems

AI agents can reason, collaborate, and act, but what happens when one runs for hours, encounters a failure, waits for human approval, or needs to survive an application restart?

In this session, we’ll explore durable execution patterns for building reliable, stateful agent systems. Through practical demos, we’ll build agents and multi-agent workflows that can maintain state, recover from failures, pause and resume, and coordinate long-running work without starting over.

Examples will use Microsoft Agent Framework and Azure, but the focus is on broadly applicable patterns for durable agents, human-in-the-loop workflows, failure recovery, and observability.

You’ll leave knowing when agents need durable execution and how to design systems that keep working through failures, restarts, delays, and human intervention.

AI Agent Workflows with Azure Functions (and Friends)

AI agents are moving beyond demos into real production systems, but reliability quickly becomes the hard part. Long-running work, retries, coordination between agents, and external dependencies demand more than simple prompt-driven flows.

In this session, you’ll learn how to build durable, production-ready agent workflows using familiar Microsoft tools. We’ll use Azure Functions as the serverless foundation, Durable Agents with the Microsoft Agent Framework to orchestrate multi-step AI behavior, and .NET Aspire to simplify service composition and improve the developer experience.

We’ll explore how multiple AI agents collaborate, recover from failures, and make decisions over time while remaining scalable, deterministic, and maintainable. We’ll also discuss key trade-offs and when agent-based workflows make sense (and when they don’t).

- Updated version of "Agent Workflows with Azure Functions and Friends".
- Target audience: Software engineers and architects interested in building reliable AI-driven systems using serverless and distributed workflow patterns.

Building AI Agents with the Microsoft Agent Framework

AI agents are rapidly becoming a powerful architectural pattern for building intelligent applications that can reason, take actions, and collaborate with other services. Microsoft’s Agent Framework provides a developer-friendly model for building these agents using familiar .NET and Python patterns while integrating with modern AI services.

In this session, we’ll take a developer-centric look at the Microsoft Agent Framework and explore how to build and run your first agent. We’ll walk through the core concepts of the framework, including agents, tools, middleware, and workflows.
By the end of this session, you’ll understand how the Microsoft Agent Framework enables developers to build production-ready agent-based applications on Azure.

Building Resilient Durable Agents with Microsoft Agent Framework

AI agents can reason, collaborate, and act - but what happens when an agent workflow runs for hours, encounters a failure, requires human approval, or must survive an application restart?

In this session, you’ll learn how Azure Durable Functions, Azure Durable Task Scheduler, and Microsoft Agent Framework work together to provide a resilient foundation for production-grade agent systems. We’ll begin with a brief introduction to Microsoft Agent Framework, then explore how Durable Agents and Durable Workflows apply durable execution patterns to long-running, distributed, and multi-agent applications.

Through practical demonstrations, you’ll see how to recover from failures, manage long-running workflows, and observe execution across a distributed system. We’ll also use .NET Aspire and Azure Durable Task Scheduler to create a streamlined local development experience and deploy an agent solution built to run reliably at scale on Azure.

You’ll leave with an understanding of the architecture, tools, and patterns needed to move agentic applications beyond prototypes and into production.

First presented at Global Azure Columbus on April 18, 2026.

Target audience: .NET developers interested in AI agents and Microsoft Agent Framework hosted on Azure.