The Self-Discovering Data Mesh.
Every AI use case in an enterprise rebuilds the same wheel. The data isn't missing — it's unreachable in a usable shape. The bottleneck is not storage; it is the friction of getting an agent to the right slice of the right system, under the right policy, without a six-week integration.
The fragmentation tax
Production support, analytics, story-and-impact analysis, code-change reasoning — each builds its own pipeline, its own transformations, its own access wiring against the same underlying systems. Enormous duplicated engineering, and it is the single biggest blocker to useful enterprise AI.
The core design
- A "dumb" aggregation layer. It standardises and indexes; it holds no per-use-case business logic. Simple by design; avoids pre-defining every scenario.
- Intelligence lives in the calling agent and the policy gate. The agent brings its own role and context (developer, reporting, production support). The platform exposes the same underlying data differently depending on who is asking — a developer agent gets error logs with PII scrubbed; a reporting agent gets aggregated, anonymised metrics. Privacy and entitlement enforcement sit at the point of call, keyed to caller identity.
The differentiator — autonomy, near-zero provider effort
The hard, novel part: data providers should have to do almost nothing. Instead of every owner registering and shaping exposures, the agent does the legwork.
Bootstrap from what already exists
Identity, entitlements, and software-inventory platforms already encode who can reach what. Use these as the starting map.
Self-discover
Probe across heterogeneous sources — 50 applications whose logs live variously in AWS, on-prem, Splunk, elsewhere — and learn what you can actually read.
Build a living catalogue
"I can search these 25 sources directly; these 25 are gated; here is what each would need." Continuously updated.
Negotiate access
For blocked sources, fire the request through the organisation's existing entitlement workflow. Humans approve through standard governance — they don't expose data manually.
Caller-context — same data, different view
Developer agent
{
"ts": "2026-06-21T09:14:02Z",
"service": "checkout-api",
"level": "ERROR",
"user": "<pii-scrubbed>",
"card": "<pii-scrubbed>",
"trace": "NullPointer at line 142",
"stack": "..."
}
Reporting agent
{
"window": "2026-06-21 · last 1h",
"service": "checkout-api",
"error_rate": 0.018,
"error_count": 142,
"affected_users": 89,
"trend_vs_24h": "+34%"
}
Same source, same query path. The policy gate decides what each caller sees, keyed to who they are and what they're for.
Why this is more than data mesh / fabric
Existing data-mesh and data-fabric concepts still assume humans define and maintain exposures. The contribution here is agent-native autonomy: discovery, catalogue-building, and access negotiation performed by the agent — with humans reduced to governing guardrails rather than building pipelines.
Open research questions
- How does the agent discover sources with no central catalogue, using only entitlement systems as a seed?
- What is the minimal protocol a data system must expose so the agent can probe it without bespoke integration?
- How do you keep access negotiation secure and auditable — preventing privilege creep while enabling autonomy?
Why now
Every enterprise is mid-scramble to make internal data AI-ready, almost always with brittle, hand-built connectors. A self-discovering, access-negotiating layer is the missing infrastructure beneath every enterprise AI programme.