# How ADI Works

ADI builds explicit understanding of your data before anything acts on it. That understanding is structured into four layers, each adding a level of meaning on top of the one below, and expressed as a machine-readable semantics summary and an enforceable contract.

## The four-layer architecture

### 1. Data Asset Layer (DAL)

What data physically exists and how it is structured: schemas, tables, columns, keys, and relationships. This is the raw catalogue of everything in your data.

### 2. Business Model Layer (BML)

What the business cares about. Entities (like organisations, users, projects), events (like signups, purchases), and the relationships between them. This layer maps the physical data to business concepts.

### 3. Analytical Model Layer (AML)

How the business can be measured. Dimensions (like country, time period), metrics (like project count, total budget), and the rules for how they are calculated and aggregated. This is where measurement becomes standardised.

### 4. Consumption Contract Layer (CCL)

How users and agents are allowed to ask questions. Supported intents, default behaviours, and guardrails. This is the system-level enforcement of correctness: a request the contract cannot answer correctly is refused, not guessed at.

## The agentic loop

ADI operates in a continuous cycle:

1. **Sense**: detects changes in data and schema.
2. **Understand**: continuously updates its semantic model.
3. **Answer**: responds to questions within explicit semantic boundaries.
4. **Enforce**: holds agents and copilots to the contract, so queries use the data the way the semantics allow.
5. **Learn**: incorporates reviewed feedback and system behaviour.

This cycle means ADI adapts as your data and business evolve, rather than requiring manual updates every time something changes. Updates to the semantics and the contract are explicit, versioned, and reviewed, so they can be approved, tested, and rolled back.

## What ADI changes

Building trustworthy analytics has always depended on business meaning that no layer in the stack actually owns, so every downstream tool, agents included, works with incomplete context.

Traditionally, closing that gap meant chaining together separate stages, each owned by a different role. Someone profiles the warehouse. Someone designs the semantic layer: the metrics, the dimensions, the rules. Someone wires governance around it. Two or three people, days to weeks for a first pass, and ongoing effort every time a schema or business rule changes. The business semantics stay implied in models and documentation, maintained by hand, and every handoff is a place where meaning gets lost.

Copilots and agents made querying faster but riskier too: they generate answers quickly, nothing checks whether the answer is valid, and the same question can return different numbers.

ADI gives business meaning an explicit, machine-readable home and an enforceable contract above the stack you already run. Agents keep doing the querying. ADI holds them to what the metrics actually mean. Your team still governs and refines the model, but the heavy lift no longer depends on filling multiple specialist seats for weeks at a time.

## Five layers of value

ADI adds five capabilities that raw data access leaves to chance:

1. **Semantic abstraction.** Metrics are queried by name, not by schema knowledge. A team defines "total budget" once, and every agent works from the same definition.
2. **Governance in the contract, not the prompt.** PII and disallowed group-bys are refused before any data is touched, and generated SQL is restricted to read verbs. Because the rules live in the contract, an out-of-contract request is refused when the SQL is generated, whatever the agent is prompted to do.
3. **Multi-agent consistency.** Every agent working from the same contract receives the same SQL for the same request, so within a shared contract the same question yields the same answer.
4. **Provenance.** Every query returns a traceable chain: which metric was measured, which governance checks ran, how tables were joined, and what time window was applied.
5. **Signature-gated execution, at the execution tiers.** Where a tier runs execution (self-hosted or fully hosted), generated SQL carries a signature attesting it was compiled from the contract, and only signed SQL runs through the verified path. The current Beta runs at t1, which generates and validates SQL for you to run in your own environment.

## Minimal footprint

ADI works from schema and context, not the data itself, so your underlying data stays where it is and analysis runs in your own environment. ADI holds only the meaning and the rules.