Architecture

The platform underneath the workflow

Deterministic model routing, context assembled fresh before every analysis, and the infrastructure underneath — all of it ours to run. Your agency staffs none of it: no AI engineers, no routing layer to maintain, no infrastructure to operate.

Control plane

One gateway. Deterministic routing.

Every model call passes through a single gateway we operate. Which model handles a given task is decided by policy — not by the model, and not by anyone on your team.

One gateway, not many pipelines

Every model call goes through a single gateway that owns retries, streaming, tool calling, and token accounting.

Routing is configuration, not a guess

Which tier and model handles a task is decided by deterministic policy. The model never chooses its own governance.

Cost and usage are measured

Per-model pricing and token usage are recorded per call and surfaced in a cost dashboard.
Which tier and model handles a task is decided by deterministic policy. The model never chooses its own governance. The model is never asked which tier to run on, which tools it may call, or how many times to retry — that is fixed configuration we maintain and evaluate before the model sees the request. Nobody at your agency writes or tunes a routing table.

Entity context

Entity-complete, not prompt-complete

Before any analysis runs, the platform assembles everything it can reach about the entity in question. Nobody on your team configures this step or decides which sources to include.

Email

Full message corpus, threaded.

Active thread

The conversation in front of the user.

Canopy records

Carrier-pulled policy data.

Canopy analysis

Prior AI output over carrier data.

Policy ingest

Data you sent through the API.

Findings

Gaps and risks already identified.

Timeline

What happened to this entity, in order.

Knowledge base

Your SOPs, appetite guides, and procedures.

Calendar

Meetings and scheduling context.

Entity metadata

Customer, account, policy, and carrier records.

Database records

Direct structured lookups.

Unavailable sources

Explicitly reported when a source cannot be reached, rather than silently omitted.

That is 12 source types, assembled the same way every time — whether the request came from Morning Brief, a chat question, or a scheduled analysis — before your team ever sees a result. A source that cannot be reached is reported as unreachable rather than silently dropped from the dossier.

Trust

What it read, what was stale, what it could not reach

Every result the platform hands back tells you the basis it was built on. That is the difference between an answer you have to trust and one you can audit.

Context is assembled, not improvised

Analysis runs against a deliberately assembled entity dossier rather than whatever happened to be in the prompt.

Coverage is reported

Output states which sources were read, so a reviewer can see the basis of a recommendation.

Staleness and gaps are visible

Missing or out-of-date sources are surfaced rather than quietly excluded — the difference between an answer you can audit and one you have to trust.

Deterministic truth, stochastic synthesis

Code owns source inclusion, entity linking, freshness, routing, and output schema. The model writes the analysis.

Coverage and freshness: what the analysis read, and what it could not.

Capture pending

Must show the source list with a stale or missing source called out.

Vendor neutrality

You are never exposed to a model vendor decision

The gateway speaks to one internal model interface and one internal tool schema. A provider's API shape never reaches your integration, your contract, or your bill.

Providers sit behind adapters

An internal model interface and tool schema keep provider specifics at the edge. Anthropic runs in production today; the contract is provider-agnostic by design.

No separate AI vendor relationship

There is no model provider account to open, no inference contract to negotiate, and no per-token bill arriving at your agency.
Production today
Anthropic runs in production today. The internal contract is provider-agnostic by design, so when the frontier model shifts, that is an adapter we write, not a migration you run — a statement about the architecture, not a claim that a second provider is live.

Infrastructure

Where it runs

Production infrastructure, operated end to end by us. Your agency does not provision it, patch it, or watch it scale.

Azure Container Apps

Application and scheduled jobs.

Cosmos DB for MongoDB vCore

Per-tenant databases.

Azure Blob Storage

Documents and generated artefacts.

Azure Cache for Redis

Queues, idempotency, and hot state.

Azure AI Search

Hybrid keyword and vector retrieval over agency knowledge.

Azure Key Vault

Every secret, loaded at startup through managed identity.