Skip to main content
All posts
AI & Data25 min read

Enterprise AI Agent Platform: 2027 Reference Architecture

A one-page reference architecture for enterprise AI agents: seven layers, Azure, AWS and open-source options, and a build-vs-buy score for each layer.

Published Updated: 15 November 2026

On 20 October 2026, Gartner published its strategic technology trends for 2027 and grouped four of them, AI context platforms, AI coding agent harnesses, AI agent identity and autonomous exposure remediation, under one theme: govern the autonomous agent platform. Sixteen months earlier, the same firm predicted that more than 40% of agentic AI projects would be cancelled by the end of 2027 because of escalating costs, unclear business value or inadequate risk controls. The deadline for that prediction is now inside next year's budget.

Between those two statements, every major vendor shipped the parts, and the protocols matured. What most organisations lack is the one-page picture that says which piece goes where, which ones they buy and which ones they still have to build. This poster is for the people who have to put that picture in front of a board: CTOs, chief architects, CISOs and platform leads.

TL;DR / Key takeaways

  • Seven layers, not one product. Experience, orchestration, context, tools/MCP and models sit on the request path. Trust and operations cut across all of them. Every vendor diagram we have seen leaves at least one of the seven out.
  • Orchestration is commoditised; trust and context are not. In our scoring of 28 capabilities, all three stacks score 88% on orchestration. The spread is widest in trust (Azure 88%, AWS 63%, self-run open source 25%) and context.
  • Pick the platform by identity and data, not by agent SDK. Azure-native covers 80% of the capabilities, AWS-native 75%, open source 63%. The SDK is the easiest layer to change later; your directory and your data estate are the hardest.
  • Five capabilities nobody sells you yet. Human approval in the channel, a semantic layer, regulatory evidence, cost attribution per agent and a cross-vendor kill switch. Budget for them, because that is where governance actually happens.
  • Put a gateway in front of every tool and every model. MCP 2026-07-28 and A2A 1.0 make agents interoperable, which also makes them reachable. The gateway is where you enforce identity, policy, quotas and logging.
The enterprise agent platform 2027. Five request-path layers and two cross-cutting layers, with Azure, AWS and open-source options per layer and a build-vs-buy coverage badge on each cell.
The enterprise agent platform 2027. Five request-path layers and two cross-cutting layers, with Azure, AWS and open-source options per layer and a build-vs-buy coverage badge on each cell.

Download: Editable draw.io file · Open in diagrams.net · A2 poster (PDF) · Chart data (CSV)

Why the platform question lands now

Two numbers frame the board conversation. Gartner predicted in August 2025 that up to 40% of enterprise applications would include task-specific AI agents by the end of 2026, up from less than 5% in 2025. And in June 2025 it predicted that more than 40% of agentic AI projects would be cancelled by the end of 2027. Together: agents arrive whether you plan for them or not, and the survivors will run on something governable.

The platforms caught up in the same window:

  • AWS made Amazon Bedrock AgentCore GA on 13 October 2025, in nine regions including Frankfurt and Ireland. Policy and Evaluations followed in March 2026, the AWS Agent Registry in August.
  • Microsoft renamed Azure AI Foundry to Microsoft Foundry in November 2025, then made Foundry Agent Service and Foundry Evaluations GA on 16 March 2026, Agent 365 on 1 May and Foundry IQ knowledge bases on 2 June. Entra Agent ID is GA as well.
  • The protocols grew up. A2A reached 1.0, with more than 150 supporting organisations by April 2026. MCP published its most significant revision since remote servers launched on 28 July 2026, and now sits in the Linux Foundation's Agentic AI Foundation.

The question is no longer "can we build an agent?" but "on which platform do hundreds of them run, and who controls them?" That decision has a five-year tail.

The seven layers, one by one

The numbers match the poster's callouts. For each layer: what it does, the three options in November 2026, and the decision that matters.

① Experience: where people and systems meet the agent

Every surface through which a request reaches an agent: suite chat, an assistant in your own app, a voice line, an inbox or another system's API call.

  • Azure. The strongest channel story, because Microsoft owns the suite. Publishing Foundry agents to Microsoft 365 Copilot and Teams is generally available, Copilot Studio covers low-code agents, and Voice Live went GA at Build 2026.
  • AWS. Amazon Quick Suite (GA October 2025) is AWS's own agentic workspace, and Amazon Connect is the contact-centre channel. AgentCore Runtime has supported the AG-UI protocol since March 2026 for agents embedded in your own front ends.
  • Open source. AG-UI and CopilotKit for embedded agent UIs, Open WebUI for an internal chat front end, LiveKit Agents or Pipecat for voice.

The decision that matters is not the chat window but where a human approves an action. Every stack has building blocks; none ships an approval experience tied to your policy engine with an audit record. It is one of the five gaps below.

② Orchestration: the runtime that plans, calls tools and hands off

Orchestration is the agent loop: a model picks the next step, calls a tool, reads the result, then continues, hands off or waits for a human. Around it sits a runtime that isolates sessions and scales to zero.

  • Azure. Foundry Agent Service, built on the OpenAI Responses API, with hosted agents for container-based agents written in Microsoft Agent Framework or a third-party SDK. Microsoft Agent Framework 1.0 unifies Semantic Kernel and AutoGen in one open-source SDK; we covered it in depth in our Agent Framework 1.0 architecture guide.
  • AWS. AgentCore Runtime runs agents built with any framework, including Strands Agents, LangGraph, CrewAI or the OpenAI Agents SDK, against any model inside or outside Bedrock.
  • Open source. LangGraph (1.0 since October 2025) or Microsoft Agent Framework for the agent graph, Temporal where workflows run for days and must survive anything.

This is the most commoditised layer in our analysis: all three options score 88%. So do not pick your platform because of its agent SDK. SDKs are the cheapest thing to swap, and with A2A 1.0, integrated in Azure AI Foundry, Copilot Studio and AgentCore Runtime, agents in different frameworks can already delegate to one another. The remaining gap is durable execution across days with human waits, where Temporal or LangGraph checkpointing still lead.

③ Context: knowledge, memory and meaning

Context is everything the agent knows that is not in the model: documents, structured data, memory and a curated layer of business meaning. Most bad agent answers we review are context failures, not model failures.

  • Azure. Foundry IQ knowledge bases (on Azure AI Search) went GA in June 2026 with agentic retrieval, citations, activity logs and document-level security. Memory in Foundry Agent Service is still in public preview.
  • AWS. Bedrock Knowledge Bases for retrieval, and AgentCore Memory for session and long-term memory, which has added structured filtering, direct ingestion and time-to-live through 2026.
  • Open source. PostgreSQL with pgvector, Qdrant or OpenSearch for vectors, Neo4j where relationships matter, and a memory library such as Mem0.

The decision that matters is permission trimming. An agent that retrieves a document the user could not open has created a data breach with a friendly tone. Foundry IQ handles document-level security out of the box; elsewhere, propagating source ACLs into the index is your job. The other open part is the semantic layer: the definitions of "customer" or "net revenue" that make answers consistent, which no vendor can ship for you. Our explainer on AI context platforms goes deeper.

④ Tools and MCP: governed access to systems of record

Tools are where agents start acting: reading the CRM, creating a ticket, changing a firewall rule. In 2027 almost all of that goes through MCP, with A2A for agent-to-agent calls.

The protocol changed this summer. The MCP specification of 28 July 2026 removed the session handshake, added Mcp-Method and Mcp-Name headers so gateways can route without parsing bodies, required clients to validate the authorisation server's issuer (RFC 9207) and deprecated dynamic client registration in favour of Client ID Metadata Documents.

  • Azure. Azure API Management can expose existing REST APIs as MCP servers and govern MCP endpoints (GA since November 2025), with Azure API Center and the Agent 365 registry as the catalogue. A dedicated AI gateway tier of API Management was still in public preview when we checked.
  • AWS. AgentCore Gateway turns APIs and Lambda functions into MCP tools, connects to existing MCP servers and supports IAM and OAuth. The AWS Agent Registry is GA, and since October 2026 also available in Frankfurt.
  • Open source. agentgateway, which joined the Agentic AI Foundation on 4 June 2026, proxies MCP, A2A, LLM and ordinary API traffic in one data plane.

AWS scores highest here (100%) because AgentCore Policy evaluates every tool call that passes through the gateway against Cedar policies, including the call's arguments, and denies by default once attached. That is the closest any vendor has come to "least privilege per call". The rule we apply on every stack is simple: no agent calls a tool directly. Every MCP and A2A call crosses a gateway that knows the agent's identity, enforces policy and writes a log line.

⑤ Models: inference, routing and residency

We put models fifth on purpose: in a mature platform they are interchangeable components behind a router, and what matters is routing, residency and cost.

  • Azure. Foundry Models with Azure OpenAI and partner models. For European data residency, Data Zone Standard deployments keep processing inside the EU Data Zone, which follows the Azure EU Data Boundary.
  • AWS. Amazon Bedrock with its model catalogue, EU regions, and the AWS European Sovereign Cloud, which became generally available on 14 January 2026 in Brandenburg with Bedrock among the services at launch. We could not confirm that AgentCore itself is offered there yet.
  • Open source. vLLM or KServe to serve open-weight models, LiteLLM-style routers for cross-provider fallback.

Open source scores highest here (88%) because routing and self-hosting are mature open-source categories; AgentCore Gateway only added model fallback in October 2026. Our default: a gateway router in front of at least two deployments, with residency enforced by deployment type, not by policy documents.

⑥ Trust: identity, authorisation, guardrails and data protection

Trust decides whether the CISO signs. It has four parts: agent identity, per-call authorisation, guardrails, and protection of the data the agent can reach.

  • Azure. The most complete set today. Microsoft Entra Agent ID gives agents first-class identities with blueprints, sponsors, access packages and Conditional Access templates for both autonomous and on-behalf-of agents. Azure AI Content Safety Prompt Shields addresses prompt injection, and Purview DSPM for AI covers oversharing.
  • AWS. AgentCore Identity handles inbound and outbound auth, token vaults and on-behalf-of token exchange (added April 2026). AgentCore Policy enforces Cedar rules at the gateway, and Bedrock Guardrails handles content and, since July 2026, can be evaluated through Policy as well.
  • Open source. SPIFFE/SPIRE or Keycloak for workload identity, OPA or Cedar for policy, NeMo Guardrails or Llama Guard for content. All of them work, and all of them are yours to integrate, tune and run, which is why open source scores 25% here, the lowest cell on the poster.

Two things matter more than the product. First, each agent needs its own identity, distinct from its user and from a generic app registration, so you can scope and revoke it; our agent identity and token-exchange guide walks through the flows. Second, guardrails are a layer of defence, not a perimeter. No classifier solves prompt injection, so per-call authorisation at the gateway matters more than input filtering. The agentic AI threat model maps where each control breaks which attack.

⑦ Operations: see, test, cost and switch off

Operations turns a pilot into a service: traces, evaluations, cost per agent and an inventory with an off switch.

  • Azure. Foundry Control Plane and tracing into Application Insights, Foundry Evaluations (GA March 2026) for offline and continuous evaluation, and Agent 365 as the registry with enable and disable controls.
  • AWS. AgentCore Observability on CloudWatch, compatible with OpenTelemetry and external tools such as Datadog and Langfuse, and AgentCore Evaluations (GA March 2026).
  • Open source. OpenTelemetry instrumentation, Langfuse for traces and prompts, promptfoo or similar for evaluations, OpenCost for the Kubernetes share of the bill.

One caveat for anyone standardising on telemetry: the OpenTelemetry GenAI semantic conventions, including agent spans, are still marked "Development". Use them, but expect attribute names to change. The gaps are cost per business case, which needs your own tagging model, and a cross-vendor inventory: Agent 365's registry sync with AWS and Google Cloud was public preview in Microsoft's May 2026 announcement.

A request through the layers

The poster is a map. This is the route a single request takes across it, with the cross-cutting layers doing their work at every hop.

Loading diagram...

The gateway sees every model and tool call, so it is the natural home for identity checks, per-call policy, quotas, residency routing and the audit log. If you fund one shared platform component in 2027, fund that one. Our AI gateway pattern on Azure shows one way to build it. How we rate the gateway and the other building blocks for 2027 is in our 2027 enterprise tech radar.

What the numbers say: build-vs-buy per layer

To turn the poster into a decision, we scored each layer. The method is deliberately simple and fully published in the CSV:

  • 28 capabilities, four per layer, that a production enterprise agent platform needs. Examples: "per-call authorisation policy on tool arguments", "enterprise retrieval with document-level permissions", "cost attribution per agent".
  • Three stacks. Azure-native managed services, AWS-native managed services, and a self-run open-source stack.
  • Scores of 0, 1 or 2. 2 means a generally available first-party service, or a mature and widely used open-source component, covers the capability. 1 means partial, preview only, or substantial integration work. 0 means there is nothing to adopt.
  • Sources. Vendor documentation, release notes and announcements, checked on 15 November 2026. Preview features count as 1, never 2.

This is expert judgement, not a benchmark. Every score and its rationale is in the CSV, so you can disagree cell by cell. The value is in the pattern.

Build-vs-buy coverage per layer for Azure-native, AWS-native and self-run open-source stacks
Build-vs-buy coverage per layer for Azure-native, AWS-native and self-run open-source stacks

Three readings stand out. Orchestration is flat at 88% across all three stacks. It is the layer vendors talk about most and differentiate least. Trust has the widest spread, from 88% on Azure to 25% for open source, and context follows it. Those are the layers that bind you to a platform, because they sit on your directory and your data. Tools and MCP are where AWS leads, mainly thanks to Cedar-based per-call policy in the gateway.

Overall coverage of the 28 capabilities by stack, including the best of all three
Overall coverage of the 28 capabilities by stack, including the best of all three

Taking the best option per capability across all three stacks only raises coverage to 91%. Five capabilities are partial everywhere:

#Capability nobody sells you yetWhy it stays with youWhere it lives
1In-channel human approval of agent actionsApproval must be tied to your policy, risk thresholds and audit trail① Experience + ⑥ Trust
2Semantic layer of business definitionsYour definitions of customer, contract and revenue are your organisation③ Context
3Audit trail mapped to regulatory evidenceLogs exist; mapping them to AI Act, NIS2 or DORA evidence does not⑥ Trust
4Cost attribution per agent and use caseToken metrics exist; showback per business case needs your tagging model⑦ Operations
5Cross-vendor agent inventory with a kill switchEvery registry is strongest on its own cloud⑦ Operations

Budget for these five explicitly, with owners, from the first increment. They are small next to the platform, but they are exactly what an auditor, a works council or a board will ask about.

A warning on shelf life: these scores describe 15 November 2026, and vendors ship agent features monthly. We will update the CSV and the poster as cells move.

In a recent engagement…

This year we helped a European industrial group review its agent estate before committing to a platform. Discovery was the eye-opener. Agents existed in four places: a Copilot Studio tenant run by the business, two teams with Python agents on containers, a vendor-supplied service-desk agent and a proof of concept on a second cloud. None of them shared an identity model. Several used a single service principal with broad API permissions. Nobody could say how many agents existed, let alone what each could change.

The board wanted a platform decision. We filled in the seven-layer picture twice, for "what we have" and "what we need". The answer was not a single product. Identity and context decided the anchor platform, because the group's directory, documents and collaboration suite were already in one ecosystem. Orchestration stayed plural: teams kept their frameworks, and A2A became the contract between them. The real investment went into two shared pieces, a gateway that every model and tool call must cross and a registry that every agent must appear in before it gets credentials.

The hardest conversation was not technical. It was agreeing who may approve an agent's access to a system of record: the system owner, the agent's sponsor or the platform team. Once that was written down, the technical controls were straightforward.

The decision table

This is the part to screenshot. For each layer: when to buy, when to build or assemble, and what we default to.

LayerBuy (managed) when…Build or assemble when…Our default for 2027
① ExperienceYour users live in Microsoft 365 or an existing contact-centre platformThe agent is part of your own product UISuite channels for employees; AG-UI for product surfaces
② OrchestrationYou want session isolation and scale-to-zero without running clustersWorkflows run for days and must survive anythingManaged runtime, framework of each team's choice, A2A between them
③ ContextYour documents already sit in the cloud's search or knowledge serviceYou need cross-estate retrieval with your own ACL modelManaged retrieval with document-level security; own semantic layer
④ Tools/MCPAlways, for the gatewayYou must govern several clouds through one control pointOne gateway for all MCP and A2A traffic; nothing calls tools directly
⑤ ModelsYou need frontier models under enterprise terms and EU residencySovereignty, cost or latency justify self-hosting open weightsTwo deployments behind a router; EU data-zone or EU-region pinning
⑥ TrustYour directory offers first-class agent identitiesYou run a multi-cloud estate without a common directoryAgent identity per agent, per-call policy at the gateway, sponsor per agent
⑦ OperationsTracing and evaluationCost per business case and a cross-vendor inventoryPlatform telemetry on OpenTelemetry; own cost model and registry of record

Three anti-patterns: choosing by SDK, agents sharing a service principal, and guardrails standing in for authorisation.

Governance for European enterprises

The platform does not make you compliant, but it decides how expensive compliance is. For EU organisations in 2027, these are the regimes that genuinely touch an agent platform.

EU AI Act (Regulation (EU) 2024/1689). AI literacy (Article 4) has applied since 2 February 2025. The transparency duties in Article 50 have applied since 2 August 2026: people must be informed that they are interacting with an AI system unless that is obvious, and AI-generated content must be marked where the article requires it. That lands squarely in layer ① Experience. The high-risk obligations for stand-alone Annex III use cases, such as recruitment, worker management or creditworthiness, were deferred to 2 December 2027 by Regulation (EU) 2026/1744, which entered into force on 27 July 2026. Deferred is not cancelled. If an agent supports one of those use cases, the logging, human oversight and record-keeping it will need belong in layers ⑥ and ⑦ now.

GDPR. Agent memory is a new personal-data store with retention and erasure duties; list it in your records of processing like any database. Where an agent's output drives a decision with legal or similarly significant effect, the Article 22 limits on solely automated decisions apply, and agents with broad data access usually warrant a DPIA under Article 35.

NIS2 and DORA. For essential and important entities, Article 21 of NIS2 asks for risk management measures that include access control and supply-chain security. Agents with credentials to production systems fall squarely into both. For financial entities, DORA adds the register of ICT third-party arrangements and exit planning, which the agent platform, its model providers and its MCP servers all join.

Data Act. The cloud-switching rules in Chapter VI of the Data Act have applied since 12 September 2025, and under Article 29 switching charges, including data egress for the switch, disappear entirely from 12 January 2027. Parallel use of several clouds is the exception: egress charges for it may continue at cost. That makes portability practical, provided your agents, prompts, evaluation sets and context pipelines are actually portable.

The useful habit is the same across all of them: write down which layer implements which control, keep the evidence, and make sure every agent has a named human sponsor.

A pragmatic adoption path

  1. Weeks 1–3: inventory. Find every agent that exists today, including low-code ones and vendor-supplied ones. Record its owner, identity, data access and tools.
  2. Weeks 3–6: choose the anchor. Decide the anchor platform by trust and context: where your directory, your documents and your collaboration suite live. Write down which layers you will buy, assemble or build, using the decision table above.
  3. Months 2–3: build the spine. Stand up the gateway for model and MCP traffic, agent identities with sponsors, and tracing into your existing observability stack. Nothing new goes live without passing through all three.
  4. Months 3–5: migrate two real agents. Move one employee-facing agent and one process agent onto the spine, with evaluation sets in CI and an approval step for every write action. Measure cost per agent from day one.
  5. Month 6: fill the five gaps and publish the poster. Build the semantic layer for the first domain, the evidence mapping for your regulatory regime, cost showback and the registry of record with an off switch. Then publish your filled-in poster internally, so every team knows where it plugs in.

The verdict

No single product is your agent platform in 2027, and any vendor diagram that claims otherwise is missing a layer. The parts are now real and increasingly interoperable. But the parts vendors compete on most, SDKs and runtimes, matter least for the long-term decision.

Our view: choose the anchor platform by identity and data. Put a gateway in front of every model and tool. Give every agent its own identity and a human sponsor. Budget for the five capabilities nobody sells you, because that is where control happens. Do this and you land on the right side of Gartner's 40% prediction. Skip it and you will discover your agent estate during an incident.

If you want this picture filled in for your estate, our AI architecture team runs a fixed-scope platform review: we map your agents onto the seven layers, score build-vs-buy for your context and leave you with a board-ready decision paper. The A2 poster is free to print and pin up.

FAQ

What are the layers of an enterprise AI agent platform?

We use seven. Five sit on the request path: experience (the channels where people meet agents), orchestration (the runtime and SDK that plan and call tools), context (retrieval, memory and business meaning), tools and MCP (governed access to systems of record) and models (inference, routing, residency). Two cut across all of them: trust (agent identity, authorisation, guardrails, data protection) and operations (tracing, evaluation, cost and the ability to switch an agent off).

Should we build our agent platform on Azure, AWS or open source?

Start from where your identity, data and collaboration suite already live, because those decide the trust and context layers, which are the hardest to move. In our November 2026 scoring, Azure-native services covered 80% of 28 platform capabilities, AWS-native 75% and a self-run open-source stack 63%. The gap is in trust and context; orchestration scores the same everywhere.

What is the difference between Microsoft Foundry Agent Service and Amazon Bedrock AgentCore?

Both are managed agent runtimes with tools, memory, identity and observability around them. Foundry Agent Service went GA on 16 March 2026, is built on the OpenAI Responses API and leans on Entra Agent ID, Foundry IQ and Microsoft 365 as channels. AgentCore went GA on 13 October 2025 as a set of composable services (Runtime, Gateway, Memory, Identity, Observability, Browser, Code Interpreter) and has since added Policy, Evaluations and an Agent Registry. AgentCore is more modular; Foundry is more integrated with Microsoft's identity and productivity stack.

Which parts of an agent platform do we still have to build ourselves?

In our analysis five capabilities were only partially covered by any stack: in-channel human approval of agent actions, a semantic layer of business definitions, an audit trail mapped to regulatory evidence, cost attribution per agent and use case, and a cross-vendor agent inventory with a kill switch. Budget for them explicitly.

Does the EU AI Act apply to our internal AI agents?

Partly, and it depends on the use case rather than the platform. Article 50 transparency duties have applied since 2 August 2026, so people must be told when they interact with an AI system unless it is obvious. AI literacy under Article 4 has applied since February 2025. High-risk obligations for Annex III use cases, such as HR or credit decisions, were deferred to 2 December 2027 by Regulation (EU) 2026/1744. Build logging and oversight now.

Is MCP ready for enterprise production in 2027?

Yes, with a gateway in front of it. The 2026-07-28 specification made the protocol stateless, added Mcp-Method and Mcp-Name headers so gateways can route and rate-limit without parsing bodies, and tightened authorisation, including issuer validation and Client ID Metadata Documents in place of dynamic client registration. Azure API Management, AgentCore Gateway and the open-source agentgateway all govern MCP traffic. Do not let agents call MCP servers directly.

Sources

All sources checked on 15 November 2026. Coverage scores are our own analysis; the full scoring with a rationale per cell is in the CSV.

Tier A: primary, vendor documentation and regulatory

Tier B: research and analysis

Tier C: vendor and news, directional

Topics

enterprise AI agent architectureAI agent platform reference architectureagentic AI platformMicrosoft Foundry Agent ServiceAmazon Bedrock AgentCoreMCP gatewayAI agent governancebuild vs buy AI agents

Frequently Asked Questions

We use seven. Five sit on the request path: experience (the channels where people meet agents), orchestration (the runtime and SDK that plan and call tools), context (retrieval, memory and business meaning), tools and MCP (governed access to systems of record) and models (inference, routing, residency). Two cut across all of them: trust (agent identity, authorisation, guardrails, data protection) and operations (tracing, evaluation, cost and the ability to switch an agent off).

Expert engagement

Need expert guidance?

Our team specializes in cloud architecture, security, AI platforms, and DevSecOps. Let's discuss how we can help your organization.

Get in touchNo commitment · No sales pressure

Related articles

All posts