Artifact-Oriented AI Architecture: Closing the Enterprise AI Architecture Gap

1. Purpose

Artifact-Oriented AI Architecture is an architectural pattern for high-consequence enterprise AI systems in which authority resides in governed artifacts rather than generated responses.

The pattern addresses a recurring failure mode in enterprise AI: architectural responsibilities are frequently assigned to the language model even though they belong to the surrounding software architecture.

Language models continue to improve in reasoning, synthesis, retrieval, planning, and generation. Enterprise systems, however, also require evidence authority, version control, lifecycle management, reproducibility, approval, publication governance, and institutional accountability. These capabilities cannot be achieved through model improvements alone.

This document defines the architecture, explains the Enterprise AI Architecture Gap, and describes an architectural pattern for closing it.

2. Problem Statement

Most generative AI applications implement a prompt-centric architecture.

This architecture is highly effective when the generated response is itself the product. It becomes increasingly difficult to apply in high-consequence enterprise environments where the output must be:

• evidence-supported;
• reproducible;
• reviewable;
• versioned;
• approved;
• traceable;
• governed;
• publication-ready; and
• accountable over time.

In these environments, the generated response cannot simply become the authoritative result because the system must also know:

• which evidence supports the conclusion;
• why that evidence was selected;
• whether the evidence was approved;
• which version is authoritative;
• what downstream artifacts depend upon it;
• whether the result can be reproduced;
• who approved it; and
• whether it is safe to publish.

These are architectural responsibilities rather than model-reasoning responsibilities. They require persistent system state, deterministic control, and institutional authority that exist independently of any individual model execution.

3. Core Concept

Artifact-Oriented AI Architecture separates probabilistic reasoning from deterministic governance.

The language model remains the probabilistic reasoning engine within the architecture. Its responsibilities include:

• interpretation;
• reasoning;
• comparison;
• synthesis;
• drafting; and
• explanation.

The surrounding architecture owns deterministic and governed responsibilities, including:

• evidence authority;
• architectural state;
• versioning;
• lineage;
• validation;
• review;
• approval;
• promotion;
• publication; and
• reproducibility.

The architecture therefore separates responsibilities rather than attempting to increase model responsibility.

The model contributes intelligence.

The architecture governs institutional knowledge.

4. Architectural Separation of Responsibilities

Artifact-Oriented AI Architecture explicitly separates architectural responsibilities between the language model, the governing framework, and human decision makers.

Each component performs work consistent with its strengths. The model performs probabilistic reasoning. The framework performs deterministic engineering. Humans exercise institutional judgment.

5. The Enterprise AI Architecture Gap

The Enterprise AI Architecture Gap is the difference between what increasingly capable language models can accomplish and what enterprise systems must govern.

Model improvements continue to enhance:

• reasoning quality;
• language quality;
• retrieval;
• planning;
• tool use;
• synthesis; and
• interaction.

They do not, by themselves, establish:

• authority;
• evidence governance;
• lifecycle state;
• reproducibility;
• approval boundaries;
• lineage;
• publication control; or
• institutional accountability.

As models become more capable, this gap becomes increasingly significant because the consequences of generated outputs also increase.

6. Architectural Evolution

The engineering reconstruction revealed a consistent progression in architectural responsibility.

Each engineering decision resolved an immediate architectural constraint while exposing the next. Viewed collectively, these decisions describe the transition from prompt-centric execution toward governed, artifact-oriented systems.

7. Architectural Responsibilities

7.1 Authority

The first architectural responsibility is separating authoritative evidence from generated interpretation.

A language model may summarize, compare, or reason over evidence, but it should not establish factual authority merely by generating text.

Authoritative evidence exists as a governed artifact with provenance.

Examples include:

• clinical observations distinct from diagnostic reasoning;
• legal evidence distinct from legal argument;
• engineering observations distinct from generated interpretation; and
• career evidence distinct from resume language.

7.2 Evidence Selection

Once evidence becomes authoritative, the architecture must determine which evidence applies to the current objective.

Evidence selection is an engineering decision rather than a narrative activity.

It should therefore be explicit, inspectable, reviewable, reproducible, and independently governable.

7.3 Capability Alignment

Enterprise mandates rarely map directly to keywords.

They describe capabilities, responsibilities, organizational context, operating conditions, outcomes, and risks.

The architecture therefore derives capability requirements before evidence selection.

Capability alignment establishes a traceable relationship between organizational requirements and the evidence selected to support them.

7.4 Optimization

Relevant evidence does not necessarily produce a complete evidence package.

Optimization evaluates the package as a whole by considering:

• coverage;
• balance;
• role distribution;
• evidence diversity;
• scale;
• completeness; and
• coherence.

This is deterministic package composition rather than probabilistic generation.

7.5 Curation

Optimization determines which evidence should appear together.

Curation determines how that evidence exists within the architecture.

A curated evidence package preserves:

• selected evidence;
• reserve evidence;
• rejected evidence;
• governing rationale;
• capability coverage;
• provenance;
• approval status; and
• downstream purpose.

The curated package becomes a governed artifact that provides bounded, authoritative context for downstream reasoning.

7.6 Architectural State

Conversation history is not architectural state. The architecture explicitly maintains:

• artifact identity;
• version;
• lifecycle state;
• validation status;
• lineage;
• promotion history; and
• dependency relationships.

Without explicit state, the system cannot reliably determine what is authoritative, current, superseded, approved, or publication-ready.

7.7 Governance

Architectural state requires explicit governance. The architecture separates:

• Review — quality evaluation.
• Approval — confirmation that requirements have been satisfied.
• Promotion — transition to authoritative status.
• Publication — release for downstream use.

The language model contributes recommendations. The architecture governs authority.

8. Artifact-Oriented Architecture Pattern

Artifact-Oriented AI Architecture treats major engineering concepts as governed artifacts. Representative artifact classes include:

• Mandate Artifact
• Capability Requirement Artifact
• Evidence Artifact
• Evidence Selection Artifact
• Curated Evidence Package
• Generated Draft Artifact
• Review Artifact
• Scorecard Artifact
• Approval Artifact
• Promotion Artifact
• Publication Artifact

Every governed artifact possesses:

• stable identity;
• version;
• source lineage;
• lifecycle state;
• validation status;
• governance state;
• dependency relationships; and
• promotion history.

9. Reference Architecture

The language model operates within the architecture. It does not define the architecture.

10. Responsibility Allocation

The language model performs probabilistic work:

• interpreting mandates;
• explaining relationships;
• synthesizing evidence;
• comparing alternatives;
• identifying risks;
• generating rationale; and
• producing candidate artifacts.

The governing framework performs deterministic work:

• artifact persistence;
• source binding;
• schema validation;
• lineage management;
• graph construction;
• evidence governance;
• approval gates;
• promotion;
• publication; and
• reproducibility.

Whenever a relationship can be deterministically derived from governed artifacts, the framework should construct it rather than delegating the responsibility to probabilistic reasoning.

The framework should not delegate deterministic engineering responsibilities to the language model.

11. Engineering Principles

Artifact-Oriented AI Architecture is founded on two engineering principles.

Principle 1 — Deterministic Governance

Probabilistic reasoning should operate within deterministic governance.

The model reasons over governed artifacts.

The architecture establishes what is authoritative, current, approved, and publishable.

Principle 2 — Responsibility Separation

Each component should perform work consistent with its engineering characteristics.

Probabilistic components perform probabilistic work.

Deterministic components perform deterministic work.

Governance components perform governance.

Human participants exercise institutional judgment.

No component should assume responsibilities belonging to another.

12. Why Better Models Are Not Enough

Improved language models reduce many classes of error, but they do not eliminate architectural responsibilities.

A stronger model does not automatically establish:

• evidence authority;
• artifact lineage;
• approval state;
• lifecycle control;
• reproducibility; or
• publication governance.

As model capability increases, these architectural responsibilities become more important rather than less.

13. Conclusion

Artifact-Oriented AI Architecture reframes enterprise AI from a prompt-output paradigm to a governed artifact paradigm.

The objective is not to reduce the role of the language model. The objective is to place probabilistic reasoning inside an architecture capable of governing authority, evidence, lifecycle, and publication.

The architectural principle is straightforward.

Use models for intelligence.

Use architecture for authority.