Azure Functions introduces serverless agents runtime with markdown-first AI agents

Azure Functions Serverless Agents Runtime: How Microsoft’s Build 2026 Update Transforms AI Agent Development

Microsoft put a real stake in the ground at Build 2026 with the preview launch of the Azure Functions serverless agents runtime. This is not just another extension or wrapper—it's a new markdown-first programming model for AI agents that runs natively on every Azure Functions trigger, including the major new surfaces of Teams, Outlook, and SharePoint. For developers and platform teams looking to blend event-driven compute with large language models, this is a direct play: one .agent.md file contains an agent’s instructions, tools, and connections, deployed to serverless endpoints everywhere Azure Functions already runs. Zero new infrastructure required. If you already ship code as a Function, you can run an AI agent—with full access to tool servers, 1,400+ connectors, and the existing scale, billing, and tracing. This runtime changes how AI is wired into the Microsoft cloud.

What is the Azure Functions serverless agents runtime?

The Azure Functions serverless agents runtime is a new public preview feature—announced at Build 2026—that powers smooth hosting and triggering of AI agents across the full range of Azure Functions. The core concept: agents are programmed as .agent.md files, using a markdown-first model that declares everything in one place.

This is a deliberate break from the legacy of physical code files or scattered scripts. With this model, a single, human-readable file defines the agent’s reasoning steps, tools it can invoke, systems it connects to, and any event-driven logic. The markdown is both code and documentation, creating explicit, reviewable agent logic that fits cleanly into existing serverless patterns.

Fundamentally, this runtime is “agent as a function.” The serverless platform handles all scaling, auth, and observability. When a configured event fires—HTTP, messaging, timer, or a new Teams message—the runtime wakes up an environment, loads the agent definition from the .agent.md, and runs the agent using Azure’s underlying compute and AI infrastructure. This turns the existing serverless model into a launchpad for live, event-driven AI.

Right now, the feature is in public preview and integrated directly into the Azure Functions service, with the same operational and billing surface that current users know. No extra “agents tax” and no major infra changes—the difference is in what the function does when it wakes up.

Which Azure Functions triggers support serverless agents?

Direct answer: Every production Azure Functions trigger now supports spawning an AI agent using the new runtime. That includes:

• HTTP triggers: Standard REST or webhook endpoints that start an agent per request.
• Timer triggers: Scheduled AI execution—think automated summarization or report generation on a schedule.
• Service Bus and Event Hubs triggers: Real-time processing of messages from workflows, IoT, or business systems.
• SQL and Cosmos DB triggers: Agents reacting to changes in primary data stores, able to analyze or augment data as it appears.
• Teams, Outlook, and SharePoint triggers (new): Native integration. An agent can wake up to handle a Teams chat, respond to incoming Outlook mail or calendar events, or process SharePoint items.

This is significant. It isn’t just generic event triggers—Teams messages, email, calendars, and SharePoint items are now programmable, managed agent entrypoints. That means an agent can listen and act on enterprise collaboration or communications events in Microsoft 365 natively, without glue code. The full list, per the InfoQ Build 2026 announcement:

[[COMPARE: classic function triggers vs connection-backed triggers for Teams/Outlook/SharePoint]]

This expansion enables true workflow integration—agents not only live beside data but act inside the messaging, calendar, and document flows modern organizations already run on.

How does the .agent.md markdown-first programming model work?

Direct answer: The .agent.md file is a single self-contained markdown document that defines everything about an AI agent: what it should do, which tools it can use, which triggers and connectors it responds to, and how it prompts or interacts.

This model is a deliberate inversion of typical code-scattering. Instead of spreading agent prompts, tool selection, and connector wiring across multiple code files and scripts, developers author one readable document. This is both executable and reviewable—in many cases, approvable by a human who is not deep in code.

A standard .agent.md might declare:

# Customer Support Agent

## Triggers
- Teams messages
- Outlook mail (support@contoso.com)

## Tools
- Knowledge base search
- Ticket system connector (ServiceNow)
- Email sender

## Behavior
When triggered, summarize the message, query the KB, and draft a suggested reply. Escalate if confidence is below 70%.

Key implications:

• Readability: Business teams can read, reason about, and approve the exact logic and integrations.
• Maintainability: All agent customization—prompts, behaviors, new connectors—is a git diff in a single file.
• Auditability/versioning: .agent.md files are tracked like code, subject to real pull request review, and pair naturally with CI/CD.
• Onboarding and collaboration: New devs or collaborators can pick up agent logic without spelunking through disparate scripts.

Anything that can be parameterized or extended—from the agent’s persona to the API scopes it needs—lives in this markdown file. This is both classic “Infrastructure as Code” and a direct extension for AI: “Logic as Markdown.”

What are the agent capabilities and runtime features?

Direct answer: The Azure Functions serverless agents runtime gives agents access to core AI, integration, and operational capabilities out of the box:

• MCP tool servers: Agents can call out to modular tool providers or function calls, offloading complex operations outside their immediate code.
• Sandboxed code and browser sessions via Azure Container Apps: Need to run isolated code (e.g., Python scripts) or process web content as part of an agent’s loop? Dynamic container sessions are spun up as needed.
• 1,400+ managed connectors: Agents can interact with the entire ecosystem—Microsoft 365 (Teams, Outlook, SharePoint), Salesforce, ServiceNow, internal APIs, and more, directly from the agent workflow.
• Built-in chat UI and HTTP chat API: There’s a first-party surface for testing or integrating agents with no code—opt in, and operators, testers, or other systems can chat with the agent directly.
• Operational features:
  • Scale-to-zero with per-second billing: Agents only cost money when active. Zero “agents tax”—pricing is identical to standard Flex Consumption Functions.
  • Managed identity: Secure calling of Microsoft Graph, connectors, or internal APIs—no embedded secrets or manual rotations.
  • Application Insights: Traces, logs, and distributed telemetry—debug and monitor agent flows like any other production code.
• Performance: The Functions team states that agent execution adds no extra cold start overhead compared to regular HTTP triggers. All latency is in model invocation and prompt complexity, not the serverless infrastructure itself.

Table summary:

The upshot: serverless agents become first-class automation endpoints for organizations that want AI in the middle of the flow, not just as an afterthought duct-taped to a webhook.

How to get started with Azure Functions serverless agents today

Direct answer: You can try the Azure Functions serverless agents runtime right now in public preview. The process:

1. Sign up for the preview using the Azure Portal or CLI.
2. Author your agent as a markdown file named .agent.md, using the structure and sections from the official docs or sample templates.
3. Bind your agent to one or more triggers (HTTP, Timer, Service Bus, Teams, Outlook, SharePoint, etc.) when configuring your Function app.
4. Deploy using standard Azure Functions tooling—the same CLI, CI pipeline, or portal workflow as any Function app. No extra steps to “agentify” a deployment.

Example workflow:

# login and select subscription
az login
az account set --subscription <your-sub-id>

# create a function app with agent support
az functionapp create --resource-group <group> --name <agentApp> --runtime python

# deploy .agent.md to your app
func azure functionapp publish <agentApp>

Debugging and monitoring are handled the same way as any Function app:

• Application Insights integration is built in—exceptions, trace logs, and agent decisions go into your standard telemetry dashboards. Useful for both runtime debugging and prompt tuning.
• Preview sample agent templates: The docs and GitHub sample repo (announced at Build) include templates for common agents—Teams assistants, calendar summarizers, incident responders—that can be cloned and modified directly.

Tips:

• Use the markdown structure to keep everything together. Comments and documentation sections are shown inline with executable intent.
• Trigger fine-tuning: bind a single agent to multiple triggers (e.g., both HTTP and Teams) for multimodal presence.
• Monitor cold start and execution times—the serverless infra is not the bottleneck, but prompt/model complexity is.
• Use managed identity—integration with Graph and Office 365 is native, so use this for secure, smooth API calls.

Links: InfoQ announcement, Microsoft docs (see Build 2026 release notes for the updated CLI and template flow).

What does this mean for Azure serverless and AI development?

Direct answer: Azure Functions serverless agents runtime makes AI a drop-in primitive for every event-driven surface on Azure. This turns Teams, email, chat, documents, databases, and custom APIs into directly programmable agent endpoints—no more hacks or integration glue code.

Immediate impacts:

• Velocity: Teams can develop, test, and ship AI automations and bots as markdown, not scattered scripts, with full audit and approvals.
• Integration density: With 1,400+ connectors, virtually any workflow (from SharePoint to Salesforce) can have an agent in the middle—streamlining previously brittle handoffs.
• New patterns: Real incident response, live chat-tutoring, or document automation can be baked into collaboration flows smoothly.
• Roadmap fit: Microsoft is betting hard on agent-based automation as a first-class cloud feature—not a bolt-on.

For the enterprise, this is both a developer productivity enable and a shot across the bow for competing cloud AI platforms.

The takeaway: a true unification of serverless and AI

The Azure Functions serverless agents runtime is not just another code generator. With its markdown-first, all-in-one agent files and wide trigger surface—including deep Microsoft 365 hooks—it gives developers a single platform to author, deploy, and operate AI automations right where compute, data, and users already are. There is no friction layer, no agent tax, and no special infra. The agent is the function. Build, bind, scale, and monitor in the exact workflows you already run.

AI isn't just a bolt-on anymore—it's part of the platform, and it's written in markdown.

[[DIAGRAM: The flow of an event triggering an HTTP, Teams, or Outlook function, which loads a .agent.md file and runs an agent with access to tool servers, connectors, and built-in chat surfaces, all inside the Azure Functions environment.]]