InsightsAI · Engineering · 12 min read
Agent-ready data: why unified graphs and deterministic pipelines beat better models
This piece lays out how to build an agent-ready data layer with unified graphs, MCP stitching, and deterministic pipelines so agents can finally be trusted in production.
Andrew XiaDirector of Engineering, Lazer

Most enterprise AI failures trace back to bad data foundations, not bad models.

A senior engineering leader at a large apparel company watched a demo of an internal “AI knowledge base” built on top of their inventory platform. The system had a single graph of entities across code, documentation, and meetings.
It could answer questions like:
- “Who owns the Europe tax integration, and what changed in the last release?”
- “Which services will break if we modify this warehouse schema?”
- “Where is the latest decision about the pricing rules for this brand?”
Halfway through the demo, they stopped the engineer and asked a different question:
Can we roll this out for the whole company?
Nothing about the model had changed in that moment. What changed was that, for the first time, they saw a system that actually knew where the truth lived.
That is the real constraint on most enterprise AI work. Agents do not fail because the model is not smart enough. They fail because the data layer underneath is not agent-ready.
Agents Fail From Data, Not Models
Across large enterprises, the failure modes repeat:
- Documentation from 2022 sits next to new docs with no signal about which one is current.
- Key workflow knowledge is held by a small number of people. Onboarding a new engineer takes a quarter because nobody knows who to ask about what.
- Different teams ship conflicting changes in parallel because nothing propagates between systems.
These are not “AI problems.” They are data and organizational problems. If you drop a state-of-the-art agent into that environment, it will simply be wrong with more confidence.
An agent-ready system starts from a different question:
If an agent were another engineer on the team, what stable, up-to-date structures would it need to rely on?
The answer is almost never “a bigger context window” or “a different model.” It is a data layer that is unified, normalized, graph-shaped where relationships matter, and exposed through deterministic interfaces that the model can call.
What “Agent-Ready Data” Actually Means
Agent-ready data is not a slogan. It has properties you can inspect:
- One clear source of truth per concept: customer, case, merchant, contract, product, claim.
- A stable identifier system across sources.
- A normalization layer that reconciles schema drift and code systems.
- A retrieval layer that can answer precise structural questions, not just keyword search.
- Deterministic APIs and tools that agents can call with predictable behavior.
Only after this exists does “drop an agent on top” start to mean something concrete.
The rest of this piece walks through patterns that have worked in practice:
- Company-wide knowledge graphs.
- Graph-native data products as AI substrates.
- Runtime data stitching with MCP.
- Normalization and schema-mapping as the real moat.
- Agent-ready artifacts and memory.
- Determinism as the design principle.
Pattern 1: The Company Knowledge Graph
At the apparel retailer, the engineering team’s graph looked roughly like this:
- A centralized graph database instance acting as the knowledge spine.
- Git hooks and CI jobs on every repository that:
- Parse the codebase’s abstract syntax tree to track dependencies between services, modules, and data structures.
- Use a model to extract technical decisions from pull request descriptions and review threads.
- A button in their internal doc system that pushes the current page into the graph as a typed node.
- Meeting transcripts ingested as another connected node type.
The result is not “more documentation.” It is a live, queryable structure:
- Code entities and their relationships.
- Decisions, linked to the parts of the system they affect.
- People, teams, systems, and domains tied together as first-class nodes.
When an engineer or agent starts work, the first tool call does not read the entire repo. It queries the graph for:
- “All services that call this API.”
- “Decisions that touched this feature flag in the last six months.”
- “Design docs linked to this bounded context.”
Two important things happen:
- Retrieval cost stays low, because you fetch exactly the slice you need instead of streaming a 100-page document.
- The model reasons over structure, not an undifferentiated blob of text. It can follow edges and constraints, which improves both speed and accuracy.
You can build this yourself with Neo4j or similar, which gives maximum flexibility over the schema and ingestion.
Or you can buy an off-the-shelf platform that already:
- Crawls and indexes Slack, docs, tickets, code, and drive systems.
- Enforces permissions.
- Presents a unified search and light graph over company knowledge.
Tools like Glean sit in this second bucket: act as the knowledge substrate and permission brain, while your engineering team focuses on the schemas, custom graph structures, and agents that sit on top.
The trade-off is simple:
- Build when you need deep customization inside a particular domain (for example, code intelligence in a very specific mono-repo).
- Buy when your primary job is “let everyone across the company ask questions and build agents over the existing systems,” and you do not want to own crawling, sync, and ACL correctness.
In both cases, the agent is powered by the same idea: there is a single place to ask, “What is true here?”
Pattern 2: Graph-Native Data Products as AI Substrates

Knowledge graphs are not just for internal documentation and code. They are a natural shape for many core business domains.
Take consumer spend.
One data platform we worked with models its world as a spend graph:
- Nodes: consumers, financial institutions, accounts, merchants, locations, transactions.
- Edges: spend, income, transfers, peer-to-peer flows, refunds.
- Attributes: merchant categories, brand taxonomy, demographics, geography, time.
Upstream, multiple providers deliver raw transaction feeds with different schemas and quality levels.
A graph-oriented pipeline:
- Normalizes and cleans merchant names with a multi-stage process.
- Uses a hierarchy of matching strategies (ID match, name match, alias tables, fuzzy similarity, rules, then AI) to map each raw record to a canonical merchant node.
- Enriches merchants with categories, locations, and other attributes.
The output is not “a table of transactions.” It is a graph that can answer questions like:
- “Show share of wallet between two brands by region over the last quarter.”
- “Find all merchants that behave like this new brand we just onboarded.”
- “Trace flows from a cohort’s income sources into specific merchant categories.”
On top of that, the platform exposes:
- Materialized views for specific verticals such as healthcare, retail, or financial services.
- A query service that handles filters, aggregation, caching, and access control.
- A standard API layer for products and partners.
When they added agents, they did not bolt a model directly onto raw transactions.
They added:
- An MCP server that exposes tools such as
query_spend,search_merchants,compare_brands, andverify_transaction. - A shared query engine underneath, so REST calls and MCP tools use the same logic and permissions.
Now any agent that speaks MCP can:
- Ask structured questions about spend patterns.
- Retrieve profiles of merchants.
- Compare brands over time.
- Verify that a transaction is part of a cryptographic proof set.
The important part is that the “AI integration” did not introduce a new data model. It reused the existing one. The graph was already the product. MCP just made it conversational.
Pattern 3: Runtime Data Stitching With MCP
Not every organization is ready for a multi-year push toward a unified graph or warehouse. Sometimes you need agents to work across a messy production stack right now.
In those cases, Model Context Protocol (MCP) gives you a different pattern:
- Wrap each system in an MCP server: tickets, logs, error tracking, databases, version control, monitoring.
- Define tools with clear schemas: list incidents, fetch logs, query metrics, read rows, open pull requests.
- Let the agent orchestrate calls across those tools within a single session.
One internal example looked like this:
- A support MCP that could pull the active ticket and affected customer.
- A logging MCP that could fetch logs for that customer and time window.
- An error-tracking MCP that could return the relevant stack trace.
- A database MCP that could inspect the rows involved.
- A Git MCP that could open the repository, branch, and eventually a pull request.
The human prompt was simple: “Find the root cause and open a PR with the fix.” The agent did the glue work that used to be the job: copying IDs between systems, filtering logs, pivoting between tools.
This is data unification at runtime instead of at rest.
The trade-offs are the mirror image of the graph pattern:
- You get speed to value, because there is no multi-month ingestion project.
- You depend more on tool schemas and runtime orchestration quality.
- You still need a clear control plane for which tools can be called with which arguments, and for logging what happened.
At scale, this is where “Enterprise MCP” architectures are trending: a shared layer that connects many MCP servers, manages governance and observability, and sits alongside existing integration platforms, rather than dozens of one-off connections buried inside agents.
In practice, most mature environments will end up with both:
- Graphs and warehouses as the long-lived memory and analytics layer.
- MCP stitching to walk across operational systems in real time.
Pattern 4: Normalization and Schema-Mapping as the Real Moat
Every one of these patterns hides a boring, expensive thing: normalization.
In healthcare, that means:
- Mapping every source system’s idea of a patient, provider, claim, or contract into a single schema.
- Standardizing codes: clinical codes, procedure codes, provider identifiers, plan identifiers, internal provider IDs.
- Resolving when “Dr. Jane Smith” in one system is the same provider as “J. Smith, MD” in another.
- Turning unstructured policy PDFs into structured rules with references back to the original text.
In financial data, it looks like merchant and institution matching:
- Multi-stage pipelines that clean and normalize merchant names.
- Matching strategies that favor deterministic IDs, then aliases, then high-threshold fuzzy matches, then AI only when needed.
- Guardrails to keep AI-assisted matches from degrading data quality.
In commerce, it shows up as global product catalogs for agentic checkout:
- Category structures and attributes that match what agent platforms expect.
- Metafields and specs that reflect how people actually ask about products in natural language.
- Consistent inventory and pricing representations across markets.
Everyone wants to talk about the model. In production systems, the model is often a paragraph of prompt and a model ID.
The actual work is:
- Designing schemas that survive contact with real data.
- Writing mappers that handle dirty inputs, version changes, and vendor quirks.
- Instrumenting quality so you know when matches or mappings are drifting.
Competitors who skip this layer can show a faster demo. Then they stall when someone asks for an audit trail, or tries to use the system in a regulated context, or simply runs it against a different slice of the business.
For teams that do not have the appetite to build this from scratch, some vendors are starting to position directly on this layer:
- Unified search and knowledge graph products that align identity and permissions across enterprise systems.
- Embedding and reranking stacks that treat complex documents as multi-facet objects instead of a single vector.
- Data transformation and catalog tools that sit under agents instead of under BI.
Your differentiation will not be “we chose vendor X.” It will be “we invested in the normalization layer until it became boring.”
Pattern 5: Agent-Ready Artifacts and Memory
Most discovery work inside enterprises still ends in a slide deck or a scattered set of docs. From an agent’s point of view, that is a cold start every time.
A better pattern is to treat every serious piece of discovery or architecture as if an AI system will need to consume it later:
- Deliver discovery outputs as a Git repository.
- Store system overviews, decision logs, and architecture sketches as markdown with clear headings, IDs, and links.
- Maintain a dedicated
context/directory of files optimized for retrieval (short, structured, high signal) rather than narrative prose. - Maintain a
skills/directory that encodes how to do specific tasks in the system, with examples.
When a build begins, engineers and agents both clone the same repo, and the first step is to mount it as context, not trawl through shared drives and chat logs.
On the agent memory side, simple “dump everything into a big vector store and hope” approaches do not hold up.
Internal experiments and external research both point in the same direction:
- Keep a small, always-present identity and configuration file that defines who the agent is working for and what environment it is in.
- Use dynamic summaries that refresh on a fixed cadence to keep medium-term context current at low cost.
- Maintain a longer-term graph or database of interactions that can be searched or traversed when needed.
The central idea is consistent: precision over volume. You want the agent to work from a small, correct, well-structured slice of context, not from everything it has ever seen.
Principle: Make Everything Deterministic You Reasonably Can
All of these patterns share a design principle:
- Use deterministic engineering wherever you can.
- Reserve probabilistic models for the parts that truly require judgment, language, or fuzzy matching.
- Put humans on the final, high-stakes decisions.
In concrete terms:
- Graph schemas, normalization pipelines, and entity-resolution rules are deterministic. They are configured, versioned code.
- MCP tool schemas and access policies are deterministic. They say which arguments are allowed and which systems can be touched.
- Cryptographic proof layers over data are deterministic. They either verify or they do not.
- Agents call into that world with probabilistic tools for classification, summarization, and planning, but their environment is not guesswork.
This is what makes evaluation possible. When an agent makes a bad decision, you can:
- Check whether it retrieved the wrong data (normalization or retrieval bug).
- Check whether it called a tool in the wrong way (schema or prompt issue).
- Check whether the model produced a poor judgment given good inputs (model choice or fine-tuning problem).
Without that separation, every bug is a mystery.
A Short Implementation Checklist
For a CTO or head of engineering looking at agents for the next year, a practical path looks something like this:
1. Map your truths.
List the real sources of truth for customers, accounts, products, contracts, cases, and transactions. Decide which system wins when they conflict.
2. Design the entity model and IDs.
Define how those concepts relate and how they will be identified across systems. Graphs are often a better mental model than tables, even if the implementation is relational.
3. Pick your storage pattern.
Decide where you need a centralized graph or warehouse and where MCP stitching is enough. In practice, use graphs and warehouses for long-lived knowledge and analytics, MCP for live operational flows.
4. Invest in normalization early.
Build or adopt a normalization layer that reconciles schemas and codes. Treat this as a versioned component with its own tests, not a set of scattered ETL scripts.
5. Expose data through tools, not raw text.
Define MCP tools, internal APIs, and query services that reflect your entity model. Make agents call those instead of reading semi-structured dumps.
6. Make discovery agent-ready.
Deliver major discovery and architecture efforts as structured repos with context and skills directories. Assume agents will need to reload this state in six months.
7. Draw the deterministic boundary.
Be explicit about which checks are rules, which are AI judgments, and where humans must sign off. Instrument logs and proofs accordingly.
A practitioner’s guide to building an agent-ready data layer
If you do this well, the choice of model becomes a tactical decision. You can swap models, add a second one, or move to a different vendor without rewriting the world. The durable asset is the agent-ready, deterministic data layer underneath.
That is where the real work is. And it is where the real moat will be.