Same promises, different architectures.
By 2026, three things are table stakes everywhere: no training on business data by default, an ISO/IEC 42001 certificate, and some form of content guardrail. What actually differentiates vendors is where in the stack policy is enforced and how much governance is productized versus left for you to build. This page compares architectures, not checkbox lists — drawn from each vendor's own documentation.
Google Cloud
This site's sponsor — judge us the same wayPrinciples published as frameworks (AI Principles, Frontier Safety Framework, SAIF 2.0 with its three agent rules), then productized as configurable primitives: org-policy model allowlists, Model Armor floors, VPC-SC perimeters, and an agent control plane (identity, registry, gateway, sandbox). Posture: 'shared fate' — secure defaults plus contractual commitments (no training on customer data without permission; generative AI indemnification).
Written down in: AI Principles · Frontier Safety Framework v3 · SAIF 2.0 · AI/ML Privacy Commitment
Enforcement center of gravity: Platform and network layer: org policies in the resource hierarchy, Model Armor inline / at the gateway / at the load balancer, IAM down to agent identity, SCC watching posture across it all.
- Model-agnostic runtime screening with org-wide floor settings (Model Armor)
- The most complete agent governance stack shipped to date: identity, registry, gateway, sandbox, payments mandates
- Data-perimeter depth: VPC-SC, CMEK, Access Transparency, regional ML processing, air-gapped Gemini
- Open-protocol posture: A2A and MCP under the Linux Foundation, AP2 for payments
- Use-case intake/registry workflow (Audit Manager evidences controls; it doesn't run your approval process)
- GenAI drift monitoring — continuous evals must be assembled from the eval service + observability
- Governance for open weights once downloaded (deliberately outside the platform control plane)
- EU AI Act conformity itself: risk classification, FRIAs, and oversight design stay with the deployer
Microsoft / Azure
Governance as an extension of the M365 compliance estate: the Responsible AI Standard v2 internally, and for customers, identity- and data-centric enforcement — sensitivity labels and Purview DLP flow into Copilot, agents get Entra directory identities, and Agent 365 acts as a tenant-wide agent control plane.
Written down in: Responsible AI Standard v2 · Responsible AI Transparency Reports
Enforcement center of gravity: Many layers, many consoles: Purview at the data layer, Entra at identity, Content Safety at model endpoints, Defender for posture, Copilot Control System / Agent 365 at the app and agent layer.
- Deepest data-compliance integration for M365 estates: labels, DLP, eDiscovery over Copilot interactions
- Directory-native agent identity (Entra Agent ID) plus a tenant agent registry (Agent 365)
- Content Safety with Prompt Shields and groundedness detection with auto-correction
- EU Data Boundary complete; in-country Copilot processing in 15 countries
- An operating model across five-plus admin surfaces and the E5/E7 licensing that unlocks them
- Coverage beyond M365: custom-app and non-Microsoft AI governance is newer and partly preview
- Use-case intake/impact-assessment workflow (the RAI Standard describes Microsoft's internal process, not a product for yours)
AWS
Builder primitives over bundled suites: eight responsible-AI 'dimensions', per-service AI Service Cards, and composable governance services — Bedrock Guardrails as a standalone policy engine (ApplyGuardrail works on any model), evaluations as a service, AgentCore for agent infrastructure — assembled by the customer, logged in the customer's account.
Written down in: AWS Responsible AI dimensions · AI Service Cards · ISO 42001 whitepaper
Enforcement center of gravity: Service layer, composable: IAM/SCPs gate model access; Guardrails execute on the inference path (when attached); CloudTrail and opt-in invocation logs land in the customer's own account.
- The formal-verification bet: Automated Reasoning checks mathematically verify outputs against encoded policy (GA Aug 2025)
- ApplyGuardrail: the cleanest bring-your-own-guardrails API across any model, inside or outside Bedrock
- AgentCore: per-session isolated runtime, OAuth token vault, MCP gateway, OTel observability
- First major cloud with accredited ISO 42001; clean surveillance audit 2025
- Enforcement of guardrail attachment (a developer with InvokeModel can bypass unless SCPs force it)
- Audit completeness — invocation logging is off by default
- Any AI use-case registry, intake, or tenant-wide inventory (no Purview/Agent-365 analog)
OpenAI
Model-provider-first: safety invested in the model and its normative spec — the Model Spec's chain of command (platform > developer > user; tool outputs carry no inherent authority), deliberative alignment for reasoning models, the Preparedness Framework for frontier risk — plus a real workspace admin layer for ChatGPT Enterprise. App-layer safety for API builders ships as open-source components the customer runs.
Written down in: Model Spec · Usage Policies (universal, Oct 2025) · Preparedness Framework v2
Enforcement center of gravity: In the model (spec-trained behavior, safety classifiers) and at the account/workspace layer (admin controls, Compliance API). API application-layer enforcement is intentionally the customer's code.
- Published behavior spec (Model Spec) — a public, versioned contract for the instruction hierarchy
- ChatGPT Enterprise admin depth: SSO/SCIM, RBAC, connector controls, Compliance API for eDiscovery/DLP
- Evals platform with trace grading; AgentKit guardrails and Agents SDK as open components
- ISO 42001 coverage for consumer and business products
- Managed inline guardrails for API traffic (open-source components are self-hosted and self-operated)
- In-region inference: residency is largely at-rest; EU-processing needs typically route via Azure OpenAI
- Agent identity, isolation, and registry — no directory or runtime product
Anthropic
Safety-research-first, enforced in the model and in frontier-risk process: Constitutional AI with the full constitution published (CC0, Jan 2026), the Responsible Scaling Policy with ASL-3 protections active since May 2025, and unusually deep enterprise controls for a lab — including Claude Code managed settings developers cannot override. Deliberately ships no standalone guardrails product; runtime filtering comes from cloud partners or gateways.
Written down in: Claude's Constitution (published in full) · Responsible Scaling Policy · Usage Policy
Enforcement center of gravity: In the model (constitutional training, classifiers), at the frontier process level (RSP gates what ships), and at the workspace/admin layer. Inline filtering by design comes from the distribution channel (e.g., guardrails on Bedrock or Vertex, or a gateway).
- The normative layer is inspectable: customers can read the actual constitution that shaped behavior
- Capability-gated deployment policy (ASL levels) with published activation — unique among labs with Google/OpenAI variants
- MCP created and donated to the Linux Foundation, with a formal security best-practices spec
- Enterprise controls beyond its size: managed settings, Compliance API, customer-managed keys
- Runtime filtering, PII redaction, and structured evaluation (no first-party guardrail or managed eval service)
- Residency depth — regional inference arrives via Bedrock/Vertex distribution
- Tenant hygiene separating commercial (never trained on) from consumer tiers (opt-in training since 2025)
No model vendor productizes your use-case registry, intake workflow, and cross-vendor policy enforcement. That is why the AI gateway became the de facto enterprise enforcement point, and why governance platforms exist as a category. Whoever you buy models from, plan to own this layer.
See challenge 7 below for the gateway pattern in detail.
Start from the problem, not the product.
Seven governance challenges customers actually raise. Each opens into: the principle, what any enterprise needs, how the market approaches it, how each vendor implements it — and the questions to ask whichever vendor is in the room.
Vendor capabilities move fast; this comparison is a snapshot (August 2026) built from first-party documentation — links in Sources. Where a capability matters to a deal, verify against the vendor's current docs.