Context Acquisition vs Context Exposition: The Real AI-Readiness Gap

Sovereign context operating model

An AI agent is only as good as the context it can reach. For a regulated enterprise, that context — the architecture repository — is also one of its most sensitive assets.

The operating model that matters is not "expose the repository over MCP"; it is "govern what context leaves, to whom, and under which residency and audit constraints".

• Decide which object types are queryable, and which are never exposed
• Keep context fresh: reconcile the repository against live sources, not a yearly snapshot
• Make every answer traceable to a governed source the user is entitled to see

Execution focus for this topic

Exposing context is a commodity; acquiring and governing good context is the durable moat.

Use this page as a decision support asset: align stakeholders, validate trade-offs, and connect architecture choices to measurable business outcomes.

• Primary query focus: Context Acquisition vs Context Exposition: The Real AI-Readiness Gap
• Decision scope: strategy, governance, operating model, and execution constraints
• Expected output: clear next actions with ownership and measurable indicators

Everyone is solving the easy half of the problem

There is a gold rush around making context available to AI agents. Vendors announce MCP servers, connectors and "talk to your data" demos every week. It looks like progress, and in a narrow sense it is. But it is solving the easy half of the problem.

Two distinct jobs hide under the word "context". The first is exposition: making context reachable by an agent over a standard interface. The second is acquisition: building context worth reaching in the first place. The industry is racing on the first because it demos well. The durable value, and the defensibility, live in the second.

This piece draws that line clearly, argues why acquisition is the real AI-readiness gap, and is honest about who else plays here and how far our own thinking is shipped versus still a direction.

Exposition is a commodity

Exposition is the act of opening a source so an agent can query it — typically through an MCP server, the emerging "USB port" for AI. It is genuinely useful and increasingly standard. But standard is the point: a protocol that everyone implements the same way is, by definition, a commodity.

An MCP endpoint does not create knowledge. It carries whatever sits behind it. Point one at a stale spreadsheet and the agent reasons on a stale spreadsheet, fluently and confidently. The protocol adds reach, not truth. So "we support MCP" is never a moat — it is table stakes, and a thin one.

• A standard protocol everyone implements the same way cannot differentiate a product
• Exposition adds reach, not correctness — it surfaces whatever quality already exists
• An MCP server over a poor source produces fluent, confident, wrong answers

Acquisition is the hard, valuable problem

The truth an agent needs is scattered. It lives in ServiceNow and the CMDB, in Jira tickets, in Azure and other clouds, in the IAM directory, in M365 and a long tail of documents and spreadsheets. None of these agree on naming, granularity or freshness, and none of them, alone, describes how the estate actually fits together.

Acquisition is the work of turning that scatter into something an agent can reason on. It is five distinct steps, and each is genuine engineering: aggregate the sources, normalize them into a shared vocabulary, relate the pieces into a connected graph, qualify what is trustworthy and current, and govern who and what may use it. This is where AI-readiness is won or lost.

• Aggregate — pull from ServiceNow, Jira, Azure, CMDB, IAM, M365 and documents
• Normalize — reconcile naming, granularity and overlapping records into one vocabulary
• Relate — connect capabilities, applications, dependencies, data flows and risks
• Qualify — mark what is current, sourced and trustworthy, and what is stale
• Govern — control access in a permission- and data-residency-aware way

Why acquisition is defensible and exposition is not

A context graph that has been acquired well accumulates knowledge. Every reconciliation, every relationship qualified, every correction fed back makes the model a little more accurate and a little more specific to the organization. That accumulated, governed truth is hard to copy — a competitor cannot clone two years of careful normalization and relating overnight.

An exposition layer has the opposite economics. Anyone can stand up an MCP server in a sprint. There is nothing accumulated, nothing organization-specific, nothing that gets better with use. That is the textbook shape of a commodity versus an asset: the moat is the graph you built, not the port you opened.

Be honest: ServiceNow and SAP play here too

It would be dishonest to claim acquisition is unclaimed ground. ServiceNow has invested heavily in a CMDB and service graph; SAP holds deep process and master-data context. Within their domains they acquire context at a scale and breadth ArchiLU does not match, and we will not pretend otherwise.

Our edge is not raw breadth — it is the lens. We focus on the architecture context for regulated FR/Lux/EU institutions, under a sovereignty and governance constraint the broad operational suites are not built around: context that can be reasoned on without the sensitive blueprint leaving your control, fit for DORA, NIS2, GDPR and EU AI Act scrutiny. Narrower scope, sharper fit — not a bigger net.

• ServiceNow / SAP: strong, broad operational-context acquisition within their domains
• ArchiLU: architecture context under a regulated, sovereign, governance-first lens
• We compete on fit and data-residency control, not on breadth

Continuous acquisition is the direction — and our conviction

Mature acquisition is never finished, because the estate never stops changing. Systems are added, retired and reorganized; what was true last quarter drifts. So the goal is not a one-off import but continuous acquisition — a model that keeps reconciling and re-qualifying itself as reality moves.

We are honest about the gap between vision and shipped. A sovereign, data-residency-aware MCP server is a conviction and a roadmap, not a product you can buy today. What exists now is a connected EA model — capabilities, application portfolio and dependencies — hosted in an EU region or on-premise under your control, in native French and English, built around DORA and CSSF documentation needs. (A tool helps you document and prove governance; it does not by itself make you compliant.)

The strategic point stands regardless of timeline: build context first, govern it, and treat exposition as the last, easy step. If you only remember one thing, make it the order — acquire and qualify the truth before you wire any agent to it. The fastest way to see where your own organization sits on that curve is our free EA Maturity Assessment.

Regulated AI context KPIs

Measure whether your context is trustworthy and governed, not how many queries the agent runs.

• Context freshness: median age of architecture objects vs live reality
• Share of answers traceable to a governed, permission-scoped source
• Sensitive object types covered by redaction/residency policy
• Audit coverage: prompts and responses logged and reviewable

Common mistakes

Most MCP-for-EA initiatives fail on context quality and governance long before they fail on the protocol.

• Exposing the full architecture repository to external LLMs without data-residency controls
• Treating MCP as the differentiator instead of the governed context behind it
• Connecting an 18-month-old, hand-maintained repository an agent cannot trust
• No permission-awareness, logging, or redaction of sensitive object types

Practical checklist

Run this before connecting any AI agent to your architecture repository.

• Confirm where prompts and responses go, and whether data stays in your region
• Enforce permission-aware access so the agent only sees what the user may see
• Classify and redact sensitive object types (vulnerabilities, data flows, controls)
• Log prompts and answers for audit, and keep a human in the loop for any change