Microsoft Build 2026 brought a cascade of AI announcements, but one of the most developer-friendly reveals came from the Azure Functions team: a serverless agents runtime, now in public preview. With this new runtime, developers can define, deploy, and run AI agents using nothing more than a markdown file—.agent.md—hosted on the same event-driven, auto-scaling Azure Functions platform that millions already trust for cloud workloads. The move signals a deliberate push to lower the barrier for building agentic software by marrying the simplicity of documentation-style configuration with the power of serverless infrastructure.

What Are Serverless Agents?

A serverless agent is an AI-driven piece of logic that reacts to events—HTTP requests, new messages on a queue, timer ticks, or file uploads—and carries out multi-step tasks by reasoning, calling tools, and interacting with external services. In the Azure Functions model, an agent is just another function type, but with built-in support for large language model (LLM) orchestration, prompt management, and tool integration. Instead of writing reams of orchestration code, developers describe the agent’s behavior, its triggers, its connected tools, and its model configuration directly in markdown. Azure Functions handles the hosting, scaling, and monitoring.

The preview introduces a new runtime stack within Azure Functions specifically optimized for agent workloads. It’s likely an extension of the existing Node.js or .NET worker, or perhaps a purpose-built agent runtime that supports multiple languages. Crucially, the agent definition is declarative: the .agent.md file acts as both the configuration and the entry point, stripping away the boilerplate that typically surrounds copilot or agentic applications.

The Markdown-First Agent Definition

At the heart of the announcement is the .agent.md file—a single markdown document that defines the entire agent. Think of it as an evolution of Azure Functions’ traditional function.json configuration, but far more human-readable and purpose-built for AI. The markdown likely uses a YAML-like front matter for metadata (triggers, bindings, model selection, environment variables) and free-text markdown for the agent’s instructions and prompt templates.

A hypothetical preview example might look like this:

---
trigger: http
route: order-assistant
authLevel: anonymous
model:
  provider: azure-openai
  deployment: gpt-4o
  temperature: 0.7
tools:
  - mcp: database-query
  - connector: sap-inventory
  - mcp: send-email
---

Order Assistant Agent

You are a helpful order assistant. When a user asks about order status, use the database-query tool to look up the order. If the customer wants to cancel, check the SAP inventory connector for stock levels and then use the send-email tool to confirm cancellation.

Always respond in the user’s language.

This design reflects a broader industry shift toward markdown as configuration—a trend popularized by modern static site generators, GitHub Actions workflows, and even infrastructure-as-code tools. For developers, it means agent logic lives alongside documentation, and the entire agent is version-controllable, diffable, and reviewable just like any other code file. The Azure Functions tooling in Visual Studio Code, Visual Studio, and Azure CLI will likely recognize .agent.md and provide dedicated authoring support, though it’s unclear if all features are available at preview launch.

MCP Tools and Enterprise Connectors

One of the most intriguing tags accompanying the announcement is "MCP tools," a strong hint that Microsoft is embedding the Model Context Protocol (MCP) into Azure Functions serverless agents. MCP, an open standard originally popularized by Anthropic, provides a uniform way for LLMs to discover and invoke external tools. By supporting MCP natively, Azure Functions could become a plug-and-play host for any MCP-compliant tool server—whether it’s a database query engine, a code interpreter, or a custom business API.

In the .agent.md example above, mcp: database-query suggests that the agent can declare which MCP servers it needs, and the runtime will automatically connect to them. This eliminates the need to write HTTP client code or SDK boilerplate. Alongside MCP, the preview introduces "enterprise connectors," pre-built integrations for common SaaS and Microsoft ecosystem products. Announcements name-dropped connectors for SAP, Salesforce, and Microsoft Graph, but the pattern is extensible. A connector is essentially a managed identity-aware, authenticated proxy that an agent can call without injecting secrets or managing complex OAuth flows.

The combination of MCP tools and enterprise connectors means an agent defined in a few dozen lines of markdown can securely query a live production database, send a Teams message, and update a CRM record—all without the developer ever writing a single line of traditional integration code. That is a compelling value proposition for organizations that want to deploy AI assistants quickly while adhering to IT governance and network controls.

How It Fits in the Azure Functions Ecosystem

The serverless agents runtime does not replace existing Azure Functions; it sits alongside them. Developers can still write HTTP triggers, Timer triggers, and Blob storage triggers in C#, Python, Node.js, and other supported languages. An agent function becomes a new trigger type (or perhaps a new worker extension) that interprets the .agent.md file and sets up the necessary LLM pipeline. Under the hood, the runtime likely uses durable functions to manage long-running agent conversations, checkpointing the conversation state so that scaling out does not lose context.

This approach capitalizes on the mature Azure Functions infrastructure: auto-scaling from zero to thousands of instances, integrated monitoring with Application Insights, built-in authentication with Microsoft Entra ID, and the consumption-based pricing model (and soon, Flex Consumption plan support). For enterprises already running workloads on Azure, adopting serverless agents will feel like a natural extension rather than a brand-new paradigm to learn.

Moreover, the existing Azure Functions developer experience evolves to support the new agent definition. The Azure Functions Core Tools will likely scaffold an agent project with a single command (func init --agent), and the Azure portal will provide a dedicated "Agents" blade to view, test, and monitor agent functions. Because the agent is just another function, it can be mixed into existing function apps, allowing developers to incrementally add agent-driven features to existing services.

For the Windows Developer

Windows developers have long been at home with Azure Functions. Visual Studio, Visual Studio Code, and even the Azure CLI all provide first-class experiences on Windows, and the same will hold for serverless agents. The .NET ecosystem, in particular, stands to gain: .NET developers can use their favorite language to extend agents with custom tools if needed, while still benefiting from the low-code markdown definition for the core agent logic.

The preview announcement also mentioned PowerShell support, hinting that Windows sysadmins and IT pros could define agents in .agent.md and hook them into Azure Automation or Windows Server events via Event Grid. While the initial preview might focus on the most common languages (Node.js and .NET), the long-term strategy appears to be polyglot, with the markdown definition serving as the universal interface.

Integration with Windows native services is another exciting angle. For example, an agent triggered by a new file in a SharePoint document library could analyze the document with Azure OpenAI, extract metadata, and update the file’s properties using a Microsoft Graph connector—all defined in a markdown file that anyone on the IT team can read and modify. This blurs the line between traditional scripting and AI automation, putting sophisticated AI within reach of power users and pro developers alike.

Early Impressions and Caveats

Because the public preview just launched at Build 2026, real-world feedback is still emerging. Early adopters on Windows-focused developer forums have praised the simplicity of the markdown approach, noting that it echoes the success of GitHub Actions YAML workflows. The ability to version-control an agent alongside the application code is seen as a major win for collaboration between ops, security, and development teams.

However, some concerns have been raised. The declarative markdown model, while simple, may not suit complex agents that require dynamic branching, custom state management, or third-party libraries that cannot be expressed as an MCP tool. Critics argue that for such scenarios, a full-code SDK like Semantic Kernel (or even manual orchestration in Python) offers more flexibility. Microsoft appears to anticipate this by allowing developers to override the markdown-generated pipeline with custom code in certain function types, though the preview documentation does not detail these escape hatches yet.

Security and compliance are other areas where the preview will need to mature. Because the agent definition lives in plaintext markdown, secrets must never be stored in the file. Azure Functions already offers integration with Azure Key Vault references in configuration, and the agent runtime will likely support the same pattern. Furthermore, the enterprise connectors tout strong authentication, but IT administrators will want fine-grained policy controls over which agents can access which data—a capability that may not be fully implemented at preview.

Pricing was not detailed at the announcement, but given that it’s a preview, consumption-based pricing similar to standard Azure Functions might apply, with potential additional costs for LLM usage and connector calls. The Flex Consumption plan, which provides a balance between pay-per-use and reserved capacity, could be a sweet spot for agents that need predictable performance.

Getting Started with the Preview

Developers eager to try the serverless agents runtime can sign up for the public preview through their Azure subscription. The preview likely requires enabling the feature flag on a function app in a supported region, then creating a new function with the agent trigger type. The Azure Functions Core Tools will need an update, and the Visual Studio Code extension will gain a new project template.

To build the hypothetical order assistant agent from earlier, a developer would:

  1. Scaffold an agent function app using func init myagents --worker-runtime agent.
  2. Create a new agent function with func new --name order-assistant --template "Agent trigger".
  3. Edit the generated .agent.md to define the trigger, model, tools, and instructions.
  4. Run locally with func start and test the HTTP endpoint.
  5. Deploy to Azure with func azure functionapp publish <app-name>.

Azure AI Foundry will complement the experience by providing a testing playground for the agent’s prompt and tool integration before publishing. The Azure portal’s new agent monitoring dashboard will show invocation counts, token usage, latency, and success rates. Because the agent function is still a standard function, Application Insights can be configured to trace every tool call and LLM interaction, giving developers deep observability.

The Bigger Picture: Agentic Cloud Computing

Microsoft’s move to merge serverless computing with agentic AI is not just about a new feature; it’s a statement of direction. By making AI agents as easy to deploy as a web endpoint, Azure Functions is positioning itself as the universal runtime for intelligent automation. The combination of markdown definitions, MCP tooling, and enterprise connectors creates a low-friction on-ramp for organizations that have been hesitant to dive into full agentic frameworks.

This aligns with the broader industry vision of agentic cloud computing, where the cloud platform itself handles the heavy lifting of state management, security, and scaling so that developers can focus on business logic expressed in natural language. Azure Functions serverless agents sit at the intersection of several major trends: the rise of LLM-native development, the maturation of serverless platforms, and the standardisation of agent-tool protocols like MCP.

For Windows enthusiasts and developers, the preview is a tangible step toward a future where intelligent assistants are not separate applications but lightweight, event-driven functions that can be added to any project with a single markdown file. As the preview evolves, expect more connector types, deeper integration with Azure AI services, and refinements based on community feedback. The year 2026 might well be remembered as the year serverless agents stopped being an experiment and started being an infrastructure primitive.