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.
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 item | Architecture outcome | Reason |
| Named business and service owner | Hold | AI cannot be operated or risk-accepted by an unnamed team. |
| Approved data source register | Hold | Ungoverned grounding creates misinformation, leakage, and audit risk. |
| Retrieval-time access enforcement | Reject for production | Application-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/actions | Reject for production | Accountability cannot be delegated to a model or autonomous agent. |
| Telemetry and incident path | Hold | Unobservable 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
| Stage | Decision to make | Minimum evidence | Owner |
| 1. Intake | Is this a business problem worth solving with AI? | Use case, affected users, business outcome, success metric, process owner | Business owner / product owner |
| 2. Risk tier | Is the use case low, medium, high, or prohibited? | Data sensitivity, decision impact, autonomy level, external exposure, legal/compliance triggers | Risk, privacy, security, ARB |
| 3. Pattern selection | Which architecture pattern is safe and supportable? | Platform decision, identity pattern, data flow, RAG design, model access, tool/action boundary | Enterprise architect / solution architect |
| 4. Evidence pack | Can the design prove control readiness? | Architecture diagram, threat model, source register, HITL matrix, observability design, ADR | Solution architect / product owner |
| 5. Gate review | Approve, approve with conditions, hold, or reject? | Evidence mapped to principles and risk tier; exception record if applicable | Architecture Review Board |
| 6. Pilot | Does the solution work safely with controlled users? | Pilot metrics, feedback, security events, grounding quality, cost profile, support tickets | Product owner / platform owner |
| 7. Production | Is it ready to operate as an enterprise service? | Runbook, SLA/SLO, monitoring, incident categories, support model, change process | Service owner / operations |
| 8. Revalidate | Has any material change altered risk? | Change record, retest results, risk reclassification, model/data/prompt review | Service 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 | AI architecture activity | Required artefact | Principles in focus |
| Preliminary | Establish AI architecture principles, governance roles, review process, and reusable platform standards. | AI principles baseline, ARB decision model, platform standards | AIP-02, AIP-06, AIP-12 |
| Phase A · Architecture Vision | Define business outcome, stakeholder impact, risk tier, and target capability. | Use case intake, architecture vision, success metrics | AIP-01, AIP-06, AIP-07 |
| Phase B · Business Architecture | Map business process, accountability, human control, operating roles, and support model. | Workflow map, RACI, HITL matrix, service ownership model | AIP-01, AIP-04, AIP-10 |
| Phase C · Information Systems Architectures | Design data flows, knowledge sources, application interactions, APIs, RAG, prompts, and tool calls. | Data flow diagram, source register, integration map, app component model | AIP-03, AIP-05, AIP-08 |
| Phase D · Technology Architecture | Select platform, model gateway, identity, network, observability, runtime, and deployment pattern. | Technology blueprint, security architecture, environment model | AIP-02, AIP-05, AIP-09, AIP-11 |
| Phase E/F · Opportunities, Solutions and Migration Planning | Sequence delivery, define MVP, migration plan, pilot scope, dependencies, and rollout path. | Roadmap, backlog, release plan, migration plan, dependency register | AIP-06, AIP-10, AIP-12 |
| Phase G · Implementation Governance | Review delivery against principles, controls, architecture decisions, and risk acceptance. | Compliance review, evidence pack, ADR, exception record | All principles |
| Phase H · Architecture Change Management | Revalidate after model, prompt, data, vendor, regulation, or workflow change. | Change assessment, review record, updated risk tier, retirement decision | AIP-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
| Principle | Minimum controls | Evidence required | Review cadence |
| AIP-01 | Business owner, outcome metric, baseline, benefit review | Use case intake, metric definition, cost estimate, benefit review date | Pilot + quarterly |
| AIP-02 | Shared identity, model gateway, logging, platform exception review | Architecture diagram, platform service list, exception record | Each use case |
| AIP-03 | Source register, classification, entitlement test, retention/retirement rule | Source inventory, access test, indexing rule, owner approval | Quarterly |
| AIP-04 | Human review gate, approval log, escalation path, accountable owner | RACI, HITL matrix, approval workflow, decision log | Each release |
| AIP-05 | Threat model, privacy review, IAM design, data residency, encryption, audit retention | Security review, DFD, privacy assessment, OWASP LLM checklist, retention policy | Each major change |
| AIP-06 | Risk tier, impact assessment, revalidation trigger, residual risk acceptance | Risk tier result, impact assessment, risk register, approval record | Design + change |
| AIP-07 | AI disclosure, limitations statement, source display, contestability path | User notice, sample outputs, support/escalation process | Each release |
| AIP-08 | Tool allowlist, least privilege, approval gate, kill switch, rollback, rate limit | Agent design record, permissions, action logs, rollback test, red-team result | Pre-prod + quarterly |
| AIP-09 | Quality, safety, security, latency, cost and incident telemetry | Dashboard, alert rules, runbook, monthly review record | Monthly |
| AIP-10 | Workflow map, controlled entry point, support model, adoption plan | Integration design, UAT results, support readiness | Pilot + release |
| AIP-11 | API abstraction, export requirements, exit plan, ADR | Portability assessment, interface design, exit constraints | Annual + change |
| AIP-12 | Use-case register, owner, change triggers, review cadence, retirement plan | Lifecycle plan, review record, change assessment, retirement record | Quarterly / annual |
🛡️
LLM and agent security checklist
| Risk area | Architecture control | Evidence |
| Prompt injection | Separate system instructions from user/retrieved content, adversarial tests, retrieval filtering, tool isolation. | Prompt injection test results, mitigation notes, failed test backlog. |
| Sensitive information disclosure | Retrieval-time access checks, output filtering, redaction, data minimisation, no secrets in prompts. | Access test, privacy review, output sampling, secret scan. |
| Improper output handling | Treat 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 agency | Least-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 weakness | Validate content before indexing, enforce permissions at retrieval, monitor anomalous retrieval patterns. | Index change log, source owner sign-off, retrieval access tests. |
| Unbounded consumption | Token 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
| Layer | Responsibilities | Questions the architect must answer |
| Experience and workflow | Chat, 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 policy | Authentication, 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 orchestration | Prompt 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 data | Source registration, indexing, classification, provenance, data quality, retention, retrieval access. | Which sources are approved? What data classification applies? Can retrieval be traced? |
| Model access | Inference 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 layer | API 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 assurance | Audit events, metrics, logs, alerts, dashboards, incident correlation, review cadence. | How will operators detect unsafe behavior, cost spikes, low quality, latency, or access violations? |
| Gate | Capability | Minimum control |
| G0 | No AI. Human-only process. | Document baseline process. |
| G1 | Read-only AI: retrieve, summarize, answer. | Source register, retrieval access, citations, user notice. |
| G2 | Draft assist: AI prepares content, human sends/uses. | Human review, output validation, audit metadata. |
| G3 | Approved action: AI prepares action, human approves execution. | Approval log, least-privilege tool, action audit, rejection path. |
| G4 | Controlled automation: bounded action under monitoring. | All G3 controls plus rate limit, kill switch, rollback/compensating control, alerting. |
| G5 | Exceptional 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 stream | Example metrics | Owner | Action trigger |
| Adoption and value | Active users, task completion, avoided effort, value metric, user satisfaction. | Product owner | Usage low or value below business case. |
| Quality and grounding | Grounded answer rate, source coverage, citation presence, unsupported-answer rate, retrieval failures. | Platform owner / knowledge owner | Quality drops or source index becomes stale. |
| Safety and security | Blocked prompts, injection attempts, sensitive data events, denied tool calls, anomalous access. | Security operations | Any spike, repeated event pattern, or data exposure signal. |
| Performance and cost | Latency p50/p95, token usage, model spend, cache hit rate, cost per interaction. | Platform / FinOps | Budget threshold, latency breach, cost anomaly. |
| Operations | Incidents, known errors, user feedback, rollback events, support tickets. | Service owner / operations | Recurring issues or failed release. |
| Governance | Overdue reviews, expired exceptions, high-risk changes, unapproved sources, missing owners. | ARB / risk | Exception 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 | Validated point used in this guide | Link |
| The Open Group · TOGAF Standard | TOGAF 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.0 | AI risk management functions: Govern, Map, Measure, Manage. Used to structure ongoing governance, measurement, and management of AI risk. | Open source |
| ISO/IEC 42001:2023 | AI management system requirements for establishing, implementing, maintaining, and continually improving AI governance and risk management. | Open source |
| OWASP Top 10 for LLM Applications 2025 | LLM application risks including prompt injection, sensitive information disclosure, improper output handling, excessive agency, vector/embedding weaknesses, misinformation, and unbounded consumption. | Open source |
| Internal architecture pack | Principle-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.