Enterprise AI Architecture · Govern Global

AI Architecture Principles for Adoption, Governance and Operations

A publish-ready enterprise guide that turns AI architecture principles into workflows, controls, evidence, and operating practices. It is written for enterprise architects, solution architects, platform teams, security teams, product owners, and architecture review boards.

Main guidance site ↗
12
Principles
8
Architecture Gates
ADM
TOGAF Aligned
Run
Ops Ready
This guide does not select one vendor stack. It defines the decision model, operating controls, evidence expectations, and lifecycle governance that any enterprise AI solution should pass before production.
🧭

What the principles are for

Architecture decision guide
Adoption
Move from experiments to reusable capability

AI pilots should become governed enterprise services, not isolated tools owned by one team.

Architecture
Create consistent design choices

Teams need repeatable patterns for identity, data, grounding, model access, agent actions, logging, and operations.

Governance
Make ARB review evidence-based

Every use case should present risk classification, architecture, controls, owners, test results, and operating model evidence.

Operations
Run AI as a changing service

AI behavior changes when prompts, models, data, users, or vendors change. Architecture governance continues after go-live.

🧠

Enterprise AI architecture mindmap

Business

  • Named outcome
  • Service owner
  • Success metric
  • Funding model

Data

  • Source register
  • Classification
  • Retrieval access
  • Lineage

Security

  • Identity boundary
  • Least privilege
  • Threat model
  • Audit design

Responsible AI

  • Human control
  • Transparency
  • Contestability
  • Impact review
Enterprise AI
Architecture

Platform

  • Model gateway
  • RAG service
  • Tool allowlist
  • Cost controls

Delivery

  • ADM gates
  • ADR
  • Environment strategy
  • Release criteria

Operations

  • SLAs
  • Telemetry
  • Incident process
  • Change review

Lifecycle

  • Review cadence
  • Revalidation
  • Retirement
  • Exception expiry
🚦

Non-negotiable production bar

Missing itemArchitecture outcomeReason
Named business and service ownerHoldAI cannot be operated or risk-accepted by an unnamed team.
Approved data source registerHoldUngoverned grounding creates misinformation, leakage, and audit risk.
Retrieval-time access enforcementReject for productionApplication-layer access is not enough for RAG. The AI must retrieve only what the user or service is authorised to access.
Human control for material decisions/actionsReject for productionAccountability cannot be delegated to a model or autonomous agent.
Telemetry and incident pathHoldUnobservable AI cannot be governed, improved, or defended after an incident.
Workflow model

From AI idea to governed production service

The workflow below is the practical bridge between architecture principles and delivery. It prevents the common failure mode: building an impressive AI demo that cannot pass security, privacy, operations, or architecture review.

End-to-end enterprise workflow
1. Intake
→
2. Risk tier
→
3. Architecture pattern
→
4. Evidence pack
→
5. Gate review
→
6. Pilot
→
7. Production
→
8. Operate & revalidate
📋

Workflow stages and required decisions

StageDecision to makeMinimum evidenceOwner
1. IntakeIs this a business problem worth solving with AI?Use case, affected users, business outcome, success metric, process ownerBusiness owner / product owner
2. Risk tierIs the use case low, medium, high, or prohibited?Data sensitivity, decision impact, autonomy level, external exposure, legal/compliance triggersRisk, privacy, security, ARB
3. Pattern selectionWhich architecture pattern is safe and supportable?Platform decision, identity pattern, data flow, RAG design, model access, tool/action boundaryEnterprise architect / solution architect
4. Evidence packCan the design prove control readiness?Architecture diagram, threat model, source register, HITL matrix, observability design, ADRSolution architect / product owner
5. Gate reviewApprove, approve with conditions, hold, or reject?Evidence mapped to principles and risk tier; exception record if applicableArchitecture Review Board
6. PilotDoes the solution work safely with controlled users?Pilot metrics, feedback, security events, grounding quality, cost profile, support ticketsProduct owner / platform owner
7. ProductionIs it ready to operate as an enterprise service?Runbook, SLA/SLO, monitoring, incident categories, support model, change processService owner / operations
8. RevalidateHas any material change altered risk?Change record, retest results, risk reclassification, model/data/prompt reviewService owner / ARB
🔎

Risk tier decision model

Low risk

Read-only, internal productivity, no sensitive data, no material decision, no autonomous action. Fast-path review is acceptable when platform controls are already approved.

Medium risk

Uses internal business data, influences work decisions, or touches moderate-sensitivity content. Requires architecture, security, privacy, and operational evidence before pilot.

High risk

Processes regulated or sensitive data, affects people materially, writes to enterprise systems, or uses agentic automation. Requires full ARB approval, senior risk acceptance, and stronger testing.

Prohibited / not approved

Hidden surveillance, unlawful use, autonomous material decisions with no accountable human, unrestricted production write access, or uncontrolled sensitive data access.

Practical rule: keep the first production release read-only or draft-only unless the evidence pack proves identity, action limits, rollback, monitoring, and human approval are working.
Architecture principles

Principles that can be tested in practice

Each principle is written as a decision rule. It must influence design, review, deployment, or operations. A principle that cannot be tested becomes a slogan, not architecture governance.

🏛️

Principle set

AIP-01 to AIP-12

AIP-01 · Business value before technology

Statement: Every AI use case must start with a named business outcome, owner, and success measure.

Put into practice: ARB intake must include baseline process cost, target improvement, user group, expected benefit, and review date.

AIP-02 · Platform-first, not tool-first

Statement: AI capabilities should use approved shared platform services before bespoke stacks are introduced.

Put into practice: Reuse enterprise identity, model gateway, prompt management, retrieval service, logging, CI/CD, and support processes unless an exception is approved.

AIP-03 · Knowledge is governed before retrieval

Statement: AI must retrieve only from approved, owned, classified, and access-controlled sources.

Put into practice: Production RAG requires a source register, owner, classification, retention rule, access test, versioning, and citation/provenance design.

AIP-04 · Human accountability remains visible

Statement: AI may assist decisions, but an accountable human remains responsible for material decisions and actions.

Put into practice: Medium and high-risk workflows require HITL checkpoints, named approvers, approval logging, rejection path, and escalation model.

AIP-05 · Security, privacy and residency by design

Statement: Security, privacy, access control, and data residency must be designed before build, not added after deployment.

Put into practice: Threat model prompts, retrieval, tools, output handling, logging, identity, encryption, private connectivity, and vendor/data transfer boundaries.

AIP-06 · Risk-tiered governance

Statement: Governance must scale with data sensitivity, autonomy, external exposure, and decision impact.

Put into practice: Use fast-path review for low-risk internal read-only use cases; require full ARB and risk acceptance for high-impact or action-taking use cases.

AIP-07 · Transparency and contestability built in

Statement: Users must know when AI is used, what it can and cannot do, and how to challenge or correct harmful outcomes.

Put into practice: Publish user notices, source citations where grounding matters, limitations statements, support path, and correction/appeal workflow for material impact.

AIP-08 · Agents are controlled capability escalation

Statement: Action-taking agents must progress through explicit autonomy gates.

Put into practice: Start at read-only or draft-assist. Require allowlisted tools, least privilege, human approval, rate limits, rollback/compensating controls, kill switch, and action logs before production actions.

AIP-09 · Observability is a production requirement

Statement: No AI system enters production without quality, safety, cost, security, and operational telemetry.

Put into practice: Define dashboards, alert thresholds, owners, retention rules, sampling approach, and incident categories before go-live.

AIP-10 · Workflow integration with controlled entry points

Statement: AI should appear where work happens, but only through controlled and supportable interfaces.

Put into practice: Prefer embedded workflow entry points in M365, ITSM, CRM, ERP, knowledge portals, or approved apps. Avoid unmanaged chatbots and shadow interfaces.

AIP-11 · Interoperability and portability by design

Statement: AI architecture must avoid avoidable lock-in and preserve strategic flexibility.

Put into practice: Keep prompts, eval sets, retrieval configuration, model-routing policy, logs, and architecture decisions exportable where practical. Document exit constraints.

AIP-12 · Lifecycle, change and retirement are mandatory

Statement: AI use cases require ownership from intake through retirement.

Put into practice: Register every production AI use case, define review cadence, revalidate after material changes, and retire unsafe, unused, or unsupported AI services.

TOGAF alignment

How AI principles align to architecture governance

TOGAF provides the enterprise architecture method; these AI principles provide the AI-specific decision criteria, evidence expectations, and operational controls.

TOGAF ADM applied to AI
Preliminary · Principles
→
A · Vision
→
B · Business
→
C · Data & Apps
→
D · Technology
→
E/F · Roadmap
→
G · Implementation Governance
→
H · Change Management
🗺️

ADM phase mapping

ADM phaseAI architecture activityRequired artefactPrinciples in focus
PreliminaryEstablish AI architecture principles, governance roles, review process, and reusable platform standards.AI principles baseline, ARB decision model, platform standardsAIP-02, AIP-06, AIP-12
Phase A · Architecture VisionDefine business outcome, stakeholder impact, risk tier, and target capability.Use case intake, architecture vision, success metricsAIP-01, AIP-06, AIP-07
Phase B · Business ArchitectureMap business process, accountability, human control, operating roles, and support model.Workflow map, RACI, HITL matrix, service ownership modelAIP-01, AIP-04, AIP-10
Phase C · Information Systems ArchitecturesDesign data flows, knowledge sources, application interactions, APIs, RAG, prompts, and tool calls.Data flow diagram, source register, integration map, app component modelAIP-03, AIP-05, AIP-08
Phase D · Technology ArchitectureSelect platform, model gateway, identity, network, observability, runtime, and deployment pattern.Technology blueprint, security architecture, environment modelAIP-02, AIP-05, AIP-09, AIP-11
Phase E/F · Opportunities, Solutions and Migration PlanningSequence delivery, define MVP, migration plan, pilot scope, dependencies, and rollout path.Roadmap, backlog, release plan, migration plan, dependency registerAIP-06, AIP-10, AIP-12
Phase G · Implementation GovernanceReview delivery against principles, controls, architecture decisions, and risk acceptance.Compliance review, evidence pack, ADR, exception recordAll principles
Phase H · Architecture Change ManagementRevalidate after model, prompt, data, vendor, regulation, or workflow change.Change assessment, review record, updated risk tier, retirement decisionAIP-09, AIP-11, AIP-12
📦

Architecture repository structure

Policy layer
Principles and standards

AI architecture principles, platform standards, model access policy, approved patterns.

Design layer
Reference architectures

RAG pattern, agent action pattern, model gateway pattern, logging pattern, identity pattern.

Decision layer
Architecture decision records

Why a platform, model, data source, or autonomy level was chosen and what was rejected.

Evidence layer
ARB evidence packs

Threat model, source register, risk tier, test results, HITL, observability, operations readiness.

Assurance layer
Review and audit records

Gate outcomes, exceptions, expired reviews, incident records, revalidation results.

Lifecycle layer
Use-case register

Inventory of AI systems, owners, risk tier, business purpose, status, review cadence, retirement date.

Control model

Turn principles into reviewable evidence

ARB review should not approve intent. It should approve evidence that the design can be operated safely and changed responsibly.

✅

Minimum control and evidence matrix

PrincipleMinimum controlsEvidence requiredReview cadence
AIP-01Business owner, outcome metric, baseline, benefit reviewUse case intake, metric definition, cost estimate, benefit review datePilot + quarterly
AIP-02Shared identity, model gateway, logging, platform exception reviewArchitecture diagram, platform service list, exception recordEach use case
AIP-03Source register, classification, entitlement test, retention/retirement ruleSource inventory, access test, indexing rule, owner approvalQuarterly
AIP-04Human review gate, approval log, escalation path, accountable ownerRACI, HITL matrix, approval workflow, decision logEach release
AIP-05Threat model, privacy review, IAM design, data residency, encryption, audit retentionSecurity review, DFD, privacy assessment, OWASP LLM checklist, retention policyEach major change
AIP-06Risk tier, impact assessment, revalidation trigger, residual risk acceptanceRisk tier result, impact assessment, risk register, approval recordDesign + change
AIP-07AI disclosure, limitations statement, source display, contestability pathUser notice, sample outputs, support/escalation processEach release
AIP-08Tool allowlist, least privilege, approval gate, kill switch, rollback, rate limitAgent design record, permissions, action logs, rollback test, red-team resultPre-prod + quarterly
AIP-09Quality, safety, security, latency, cost and incident telemetryDashboard, alert rules, runbook, monthly review recordMonthly
AIP-10Workflow map, controlled entry point, support model, adoption planIntegration design, UAT results, support readinessPilot + release
AIP-11API abstraction, export requirements, exit plan, ADRPortability assessment, interface design, exit constraintsAnnual + change
AIP-12Use-case register, owner, change triggers, review cadence, retirement planLifecycle plan, review record, change assessment, retirement recordQuarterly / annual
🛡️

LLM and agent security checklist

Risk areaArchitecture controlEvidence
Prompt injectionSeparate system instructions from user/retrieved content, adversarial tests, retrieval filtering, tool isolation.Prompt injection test results, mitigation notes, failed test backlog.
Sensitive information disclosureRetrieval-time access checks, output filtering, redaction, data minimisation, no secrets in prompts.Access test, privacy review, output sampling, secret scan.
Improper output handlingTreat model output as untrusted; validate schema, escape content, block direct execution, require approval for system writes.Validation test, action approval log, downstream input control evidence.
Excessive agencyLeast-privilege tools, action limits, rate limits, tool allowlist, kill switch, rollback or compensating control.Tool permission matrix, rollback test, agent runbook, audit log.
Vector and embedding weaknessValidate content before indexing, enforce permissions at retrieval, monitor anomalous retrieval patterns.Index change log, source owner sign-off, retrieval access tests.
Unbounded consumptionToken budgets, cost alerts, rate limits, loop detection, usage quotas per user/service.Budget dashboard, alert rules, cost anomaly record.
Logging should be privacy-appropriate. Store metadata, references, decisions, safety events, and actions by default. Store full prompts or full responses only where there is a documented security, legal, or operational need with retention controls.
Reference architecture

Layered AI architecture for enterprise use cases

The reference architecture is logical. It can be implemented with Microsoft, AWS, Google, open-source, or hybrid platforms, provided the controls and evidence remain intact.

Request-to-response architecture flow
User / workflow
→
Identity & policy
→
AI gateway
→
Grounding / tools
→
Model inference
→
Response / action gate
→
Telemetry
🏗️

Logical architecture layers

LayerResponsibilitiesQuestions the architect must answer
Experience and workflowChat, portal, workflow embed, mobile, ITSM/CRM/ERP integration, user disclosure, feedback.Where will users access AI? What can they do from that surface? How are limitations shown?
Identity and policyAuthentication, authorization, user/service identity, role mapping, policy evaluation, access decisions.Is this user-context, service-context, or agent-context? Where is least privilege enforced?
AI gateway and orchestrationPrompt templates, model routing, content safety, tool allowlist, approval gates, redaction, policy enforcement.Which model is used? Which tools are callable? What actions are blocked or require approval?
Knowledge and dataSource registration, indexing, classification, provenance, data quality, retention, retrieval access.Which sources are approved? What data classification applies? Can retrieval be traced?
Model accessInference endpoint, model selection, evaluation, fallback, version management, cost control.Why this model? What is the fallback? How are quality and cost measured?
Tool and action layerAPI calls, workflow execution, write operations, transaction boundaries, rollback, compensating controls.What can the agent change? Can the change be reversed? Who approves high-impact action?
Observability and assuranceAudit events, metrics, logs, alerts, dashboards, incident correlation, review cadence.How will operators detect unsafe behavior, cost spikes, low quality, latency, or access violations?
🤖

Agent autonomy gates

GateCapabilityMinimum control
G0No AI. Human-only process.Document baseline process.
G1Read-only AI: retrieve, summarize, answer.Source register, retrieval access, citations, user notice.
G2Draft assist: AI prepares content, human sends/uses.Human review, output validation, audit metadata.
G3Approved action: AI prepares action, human approves execution.Approval log, least-privilege tool, action audit, rejection path.
G4Controlled automation: bounded action under monitoring.All G3 controls plus rate limit, kill switch, rollback/compensating control, alerting.
G5Exceptional autonomy: high-impact automated action.Senior risk acceptance, independent testing, lifecycle assurance, stricter review cadence.
Do not begin an enterprise AI program at G4 or G5. Start with G1 or G2, measure value and behavior, then increase autonomy only when controls are proven.
Operate and improve

Run AI as an enterprise service

AI operations must cover quality, safety, cost, security, support, model/data changes, and business value. Go-live is not the end of architecture governance.

📊

Operational dashboard model

Metric streamExample metricsOwnerAction trigger
Adoption and valueActive users, task completion, avoided effort, value metric, user satisfaction.Product ownerUsage low or value below business case.
Quality and groundingGrounded answer rate, source coverage, citation presence, unsupported-answer rate, retrieval failures.Platform owner / knowledge ownerQuality drops or source index becomes stale.
Safety and securityBlocked prompts, injection attempts, sensitive data events, denied tool calls, anomalous access.Security operationsAny spike, repeated event pattern, or data exposure signal.
Performance and costLatency p50/p95, token usage, model spend, cache hit rate, cost per interaction.Platform / FinOpsBudget threshold, latency breach, cost anomaly.
OperationsIncidents, known errors, user feedback, rollback events, support tickets.Service owner / operationsRecurring issues or failed release.
GovernanceOverdue reviews, expired exceptions, high-risk changes, unapproved sources, missing owners.ARB / riskException expiry, review breach, material change.
🔁

Material change triggers

Model change

New model version, new provider, changed model parameters, changed safety filter, fine-tune update, fallback change.

Data change

New source, changed classification, index rebuild, changed retention, major source content update, new data geography.

Action change

New tool, new write capability, new API scope, new approval bypass, expanded user group, higher autonomy gate.

Risk change

New regulation, new affected user group, new external exposure, incident, adverse outcome, significant cost or quality degradation.

Incident response workflow
Detect event
→
Contain or disable
→
Preserve evidence
→
Triage impact
→
Rollback / fix
→
Review and revalidate
Architecture teams should review recurring AI incidents as architecture feedback. Repeated prompt failures, unsafe tool calls, or access near-misses usually indicate a pattern or platform gap, not just a support issue.
Validation sources

Source-backed architecture basis

The guide is based on stable enterprise architecture, AI risk, AI management system, and LLM application security references. Organisations must still apply local legal, regulatory, and sector-specific requirements.

🔗

Source register

SourceValidated point used in this guideLink
The Open Group · TOGAF StandardTOGAF is the enterprise architecture method and governance context. ADM includes Phase G Implementation Governance and Phase H Architecture Change Management.Open source
NIST AI RMF 1.0AI risk management functions: Govern, Map, Measure, Manage. Used to structure ongoing governance, measurement, and management of AI risk.Open source
ISO/IEC 42001:2023AI management system requirements for establishing, implementing, maintaining, and continually improving AI governance and risk management.Open source
OWASP Top 10 for LLM Applications 2025LLM application risks including prompt injection, sensitive information disclosure, improper output handling, excessive agency, vector/embedding weaknesses, misinformation, and unbounded consumption.Open source
Internal architecture packPrinciple-to-control mapping, TOGAF alignment, AI risk tiering, evidence pack, agent autonomy, and ARB workflow content refined into this site.Uploaded source material
This website is architecture guidance, not legal advice. For regulated use cases, legal, privacy, security, and risk teams must confirm obligations before production approval.