Enterprise Generative Search — Azure and Open Source

Who asks, what the platform reads, and what it deliberately never writes to.

The shape of a request in one picture: understand, plan, retrieve, rank, generate, assure.

The three rules the rest of the architecture is a consequence of.

Six classes of question, and what each is allowed to spend before anything is generated.

Who the platform is for, in their own words, and what each of them gets to do with it.

What happens in the first four seconds, and why the trough is not latency.

Where an averaged answer is worse than no answer at all.

The journey that decides whether content owners trust the platform or blame it.

Eight layers, dependencies pointing down, and the single upward call drawn rather than hidden.

The deployable units, their technology, and which of them hold GPUs or credentials.

How a sentence becomes a typed, authorised, replayable plan.

Four backends behind one contract, and what that contract obliges each of them to accept and return.

Four published interfaces, and every system the platform depends on.

How each of the six sources is read, authorised, refreshed and parsed.

Six model tasks, where each runs, what each costs, and what happens when it is unavailable.

From a change in a source system to a chunk that can be retrieved and cited.

Four zones, and the only one of them that has a recovery point objective.

Seven content types, seven strategies, and why one setting for all of them fails.

Fifteen entities, and the one join that makes an answer auditable.

How authorisation travels from a source system to a filter, a cache key and an audit record.

The loop that keeps the index honest about time, and publishes it when it is not.

One request, twenty-one messages, and the re-retrieval that is the normal case rather than the exception.

Where the model is allowed to decide, and the three things it never decides.

Three hundred candidates down to eight passages, and what each stage is allowed to remove.

Six slots, their trust levels, their budgets, and what is sacrificed when the window is short.

How a fluent draft becomes claims that either hold, get re-retrieved, or are withdrawn.

The model names an intent; the broker and the guard decide what actually runs.

Five modalities, how each is represented and matched, and the limit each one has.

Five rungs down from a full answer, and why the bottom rung is still a working product.

Two regions, four node pools, and a failover that does not depend on replicating a search index.

Code, prompts, index schemas and models through one path with the same gates.

Six layers of measurement, what each blocks, and how often each runs.

How one bad answer becomes a fixed system and a permanent test.

One trace id across seven stages, so a wrong answer has a cause rather than an argument.

What a query costs, what each line scales with, and which lever actually moves the total.

Five trust zones, and every flow that crosses one.

Sixteen messages from a login to a filtered query, with no application identity anywhere in them.

Six concrete attacks, the control for each, and the residual risk stated rather than implied.

Classified once at ingest, enforced everywhere afterwards by a filter.

From a written policy to evidence an auditor accepts, without a single interpretive step.

Fifteen named failures across four planes, each with a detector and an owner.