Skip to content
07How vendors approach governance

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 way

Principles 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.

Distinctive strengths
  • 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
You still build
  • 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.

Distinctive strengths
  • 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
You still build
  • 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.

Distinctive strengths
  • 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
You still build
  • 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.

Distinctive strengths
  • 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
You still build
  • 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).

Distinctive strengths
  • 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
You still build
  • 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)
The universal gap

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.

Challenge by challenge

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.

Provide a governed alternative employees prefer, see all AI usage, and put data controls in the path — coaching before blocking.

What any enterprise needs
  • Enterprise AI tool with no-training terms, SSO, and logging
  • AI app discovery across network and browser
  • Inline DLP on prompts and uploads with tenant restrictions
  • Acceptable-use policy tied to training and access
Architectural approaches in the market
  • Paved road: sanctioned assistant + progressive blocking of the long tail
  • Endpoint/browser DLP with real-time coaching (measurably reduces personal-account use)
  • Zero-PII architectures for the highest-sensitivity flows
ProviderImplementation, per their documentation
Google CloudGemini Enterprise as the sanctioned surface; Chrome Enterprise Premium browser DLP over any AI site; Workspace AI controls honor labels and IRM; SCC discovers AI assets cloud-side.
Microsoft / AzureM365 Copilot with Purview DSPM for AI: discovers usage including third-party AI, applies DLP and sensitivity labels inline, extends eDiscovery to AI interactions.
AWSNo employee-assistant estate of its own (Q Business aside); relies on network/endpoint tooling; Bedrock terms give the no-training baseline for internal builds.
OpenAIChatGPT Enterprise workspace controls plus the Compliance API for DLP/eDiscovery integration with third-party tools; consumer-tier leakage remains a network-control problem.
AnthropicClaude for Work with admin controls, IP allowlisting to block personal instances, and a Compliance API; browser-level DLP comes from the customer's stack.
Ask any vendor
  • Can you distinguish and block personal accounts of your own product on our network?
  • What exactly is retained from employee prompts, and who can read it?
  • How do your controls extend to AI tools that are not yours?

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.