Microsoft Build 2026: Everything New in Azure Integration Services

Microsoft Build 2026 landed on June 2nd, and for anyone working in Azure Integration Services, it was worth paying attention to. Six announcements across Logic Apps, API Management, and a brand-new SKU — all pointing in the same direction: the integration layer is becoming the production infrastructure for AI agents. Here’s a full breakdown of what was announced, what it actually means, and where it fits.

1. Azure Logic Apps Automation — A New SaaS SKU

The headline announcement: Azure Logic Apps Automation (public preview), available now at auto.azure.com. This is a new SKU, not a replacement for Logic Apps Standard. It sits on top of the same reliable runtime — same connectors, same durable execution — but wraps it in a SaaS-style experience built for fast onboarding and the agentic era.

The pitch is low barrier to entry, built for production. Sign in, describe what you want in plain language, and the built-in AI Assistant drafts the workflow for you — configuring actions, writing expressions, generating inline code. Elastic scale to zero means you pay only for vCPU-seconds consumed. No annual commitment, no per-seat license, no infrastructure to manage.

Governance is handled through a two-level hierarchy: Projects (security and governance boundary) and Applications. Admins set networking policies, connector policies, and approved AI models once at project scope — every application inherits them. This is the model I’d expect enterprises to want: developer speed without sacrificing central control.

Agents are first-class here — agent-loop orchestration, Foundry Hosted Agents directly from the canvas, and a managed sandbox for agent harnesses like GitHub Copilot with shell access. JavaScript expressions replace the DSL. Knowledge as a Service is built in (more on that below).

When to use it: When your team wants the fastest path to running automations in production without touching infrastructure. If you need VNet integration, custom connectors, or bring-your-own compute, Logic Apps Standard is still the right choice — VNet support is on the Automation roadmap, not yet available.

Available regions at launch: East Asia, Sweden Central, Australia East, North Central US, UK South, Southeast Asia, West US. Currently in public preview — verify feature availability before committing to production workloads.

2. Write Logic Apps in C# — The Logic Apps Standard SDK

For those of us who think in code rather than canvases, Microsoft shipped the Logic Apps Standard SDK (Microsoft.Azure.Workflows.Sdk) — a NuGet package that lets you build workflow definitions using a fluent C# API. This is not a new runtime. Workflows written with the SDK compile to the same JSON definitions that run on the existing Logic Apps Standard runtime.

workflow
  .AddTrigger(WorkflowTriggers.BuiltIn.Request())
  .Then(WorkflowActions.BuiltIn.ParseJson(...))
  .Then(WorkflowActions.Managed.Office365.SendEmail(...))
  .Then(WorkflowActions.BuiltIn.Response());

Type safety and IntelliSense. Real Git diffs. Code reviews on workflow changes. A compilation step that catches errors before runtime. Control flow constructs (Condition, ForEach, Switch, Until, Scope) are first-class. A CustomCode action lets you drop real C# methods inline. Error handling uses run-after conditions — same model as the designer, just written in code.

The one angle Microsoft calls out explicitly — and I think is genuinely interesting — is that coding agents are significantly better at generating type-safe imperative code than declarative JSON. If you’re using AI coding agents to generate or maintain Logic Apps workflows, the SDK gives them a structured, compilable surface to work with.

Current preview limitations: Service Provider connectors not yet supported. Managed identity authentication still in development. Custom code limited to callback methods only.

When to use it: Your team prefers code-first workflows, you want Logic Apps definitions in your existing Git repo alongside application code, or you’re generating workflows with AI coding agents. Requires Logic Apps Standard VS Code extension v5.961.10 or later.

3. New AI Gateway Capabilities in Azure API Management

Multi-model, multi-protocol AI applications are becoming the norm — teams mixing OpenAI, Anthropic, and Vertex AI, exposing tools through MCP, wiring agents together with A2A. The Build 2026 API Management updates address exactly this reality.

Unified Model API (Preview)

Clients speak one format — OpenAI Chat Completions — and API Management transforms requests to the backend provider (currently OpenAI or Anthropic Messages API). This gives you standardized observability, security, and governance regardless of which model sits behind the gateway. Model aliases decouple client-facing model names from actual backend deployments, making model upgrades, A/B tests, and vendor swaps invisible to clients. A /models endpoint lets clients discover available models. Currently in preview — verify before committing to production.

Anthropic and Vertex AI (GA)

AI gateway policies, semantic caching, token controls, logging, tracing, and observability now work with Anthropic and Google Vertex AI — not just Microsoft Foundry and OpenAI. Token metrics for cached, reasoning, and thinking tokens are now logged across all these providers via Application Insights (preview).

Content Safety for MCP and A2A (GA)

The llm-content-safety policy now covers MCP tool-call arguments, MCP response text, and A2A payloads — not just LLM traffic. New window-size and window-overlap-size attributes handle messages exceeding 10,000 characters. This is the right answer to the question of how you govern agent-to-agent traffic at enterprise scale.

A2A APIs (GA)

Agent-to-Agent API support is generally available, now extended to classic tiers in addition to v2 tiers. Supports mediating JSON-RPC runtime operations, managing agent cards, and logging traces using OpenTelemetry GenAI semantic conventions.

4. Azure API Center — GA with Agent Support

Azure API Center is now generally available, and it’s grown well beyond a catalog for REST APIs. At Build 2026, Microsoft added agent registration, agent assessment, and a data plane MCP server — making it a centralized registry for the entire AI asset landscape.

Agent registration and assessment: Register AI agents and evaluate them using an LLM-as-a-Judge framework that checks for safety, reliability, and behavioral completeness. Agent definitions can be synchronized from Git, fitting them into existing DevOps workflows.

API Center data plane MCP server (GA): This is the capability I’d highlight most for enterprise architects. API Center now exposes a unified MCP endpoint — a single connection through which any AI agent or developer tool can discover registered MCP servers, APIs, agents, and AI assets in your organization’s approved catalog. In practice, this is how you prevent agents from self-discovering and calling arbitrary external services — you give them a governed discovery endpoint instead.

Platform enhancements (GA): Premium v2 now supports multiple custom domains. Premium v2 and Standard v2 support wildcard custom hostnames.

5. Knowledge as a Service for Azure Logic Apps

Building a production-quality RAG pipeline — parsing, chunking, embedding, vector storage, query rewriting, retrieval — is a non-trivial engineering investment. Knowledge as a Service (KBaaS), now in public preview, handles the full pipeline as a managed service integrated directly into Logic Apps agentic workflows.

Upload documents (DOC, DOCX, HTML, MD, PDF, PPT, PPTX, TXT, XLS, XLSX). KBaaS ingests, parses, chunks, summarizes, and vectorizes them automatically. When an agent queries the knowledge base, KBaaS rewrites the query, executes semantic search, and returns relevant chunks — no custom code, no vector database to operate.

In the Automation SKU, you upload documents and the entire knowledge layer — vector store, models, pipelines — is managed on your behalf. Currently in public preview.

When to use it: Any agentic workflow that needs to answer questions grounded in a document corpus — HR policy documents, product manuals, support knowledge bases, regulatory documents, contracts. The key value is eliminating the operational burden of a RAG pipeline in production.

6. Build Agents in Microsoft Foundry, Automate with Azure Logic Apps

The last announcement is less a discrete feature and more an architectural statement: Foundry and Logic Apps now work as a single agentic stack. Foundry is where agents are built — models, instructions, tools, knowledge, evaluation. Logic Apps is where they’re triggered, orchestrated, and connected to enterprise systems.

What’s new in practice:

• Create and invoke Foundry Agents directly from the Logic Apps designer — no custom integration code.
• Trigger Foundry Agents with any of the 1,400+ Logic Apps connectors. A ServiceNow incident, a Jira ticket, a SAP IDoc, or a Teams message can all fire an agent the moment work arrives.
• Logic Apps connectors are now available as native tools for Foundry Agents — update the CRM, file tickets, send approvals, post messages, all directly from an agent.
• Invoke entire long-running workflows as agent tools — including multi-step approvals that wait days for a human response, webhook callbacks, and orchestrations that pause and resume on external events.

That last point is significant. It bridges the gap between fast agent reasoning (milliseconds to seconds) and slow human-in-the-loop business processes (hours to days). An agent can now hand off to a durable Logic Apps workflow, trust it to complete, and resume — correctly and durably — when the human step resolves.

The Bigger Picture

The thread connecting all six announcements is the same: Microsoft is repositioning Azure Integration Services as the production infrastructure layer for AI agents. API Management governs and secures AI traffic. API Center provides a governed discovery endpoint for the entire AI asset catalog. Logic Apps — whether Standard, Automation, or through the new C# SDK — provides the orchestration layer that connects agents to real enterprise systems, human processes, and durable state.

What’s notable is that these aren’t experimental AI features bolted onto an integration platform. They’re production-grade capabilities — GA where it matters, with honest preview labels where the work isn’t done yet. That’s the right approach, and it’s worth acknowledging.

If you’re architecting integration platforms for enterprise clients right now, the Foundry + Logic Apps combination and the API Center MCP server endpoint are the two capabilities I’d prioritize understanding first. They define how agents get triggered, governed, and connected to real systems — which is ultimately the problem that makes or breaks agentic automation in production.

Quick Reference