Time to complete: 8-16 weeks build; 2-6 weeks per phase with platform acceleration
Difficulty level: Advanced
Prerequisites: executive sponsorship for cross-functional scope decisions, admin access to source systems, a named owner for the semantics phase, basic familiarity with graph or catalog tooling
Tools needed: a graph substrate (OSS or platform), a semantic/ontology layer, an MCP-compatible delivery mechanism
The table below maps all seven phases before the step-by-step detail. Use it as a build checklist, or jump straight to the phase you’re on.
| Phase | Name | Decision point | Validation checkpoint |
|---|---|---|---|
| 1 | Scope the runtime-vs-layer split | What’s runtime-ephemeral vs. layer-durable | Written scope doc, two named owners |
| 2 | Connect and ingest source systems | Which sources are in scope, in what order | Source inventory, one lineage-capable source connected |
| 3 | Bootstrap the context graph | Graph representation: OSS or platform | Graph populated, entity-identity approach documented |
| 4 | Define semantics, ontology, identity | Who certifies the ontology | Ontology certified, one agent query tested |
| 5 | Attach trust signals | Policy enforcement: agent-side or layer-side | End-to-end lineage, named certification approver |
| 6 | Deliver through MCP and playbooks | MCP, API, or SQL as the delivery target | Delivery endpoint live, one playbook documented |
| 7 | Evaluate and maintain | Drift/freshness cadence | Cadence scheduled, quality baseline recorded |
Why does a context layer need a reference architecture, not just a definition?
Permalink to “Why does a context layer need a reference architecture, not just a definition?”Most search results for this query answer what a context layer is, not what order to build it in. That gap matters: according to Cloudera and Harvard Business Review Analytic Services (2026), only 7% of enterprises say their data is completely ready for AI. A definition doesn’t close that gap. A sequence with decision points and checkpoints does, which is what a context layer reference architecture is: a numbered, phase-ordered build methodology any team, buying a platform or building on open-source tools, can follow to stand up a governed context layer for AI agents.
There’s a second, more specific gap to name before going further. Search results for “context layer” split into two conversations that aren’t the same question. One is the agent-runtime conversation: Reddit, Hacker News, and LinkedIn practitioners like Anthony Alcaraz debating working context, session state, and memory inside a single agent’s execution loop. The other is the enterprise-infrastructure conversation: why AI agents need an enterprise context layer in the first place, the durable, governed substrate underneath every agent that Atlan, Snowflake, and Gartner describe. This page is about the second one. Looking to manage an agent’s context window instead? Start with memory layer vs. context layer or how to build an AI agent harness. Phase 1 below makes that split an explicit, written decision rather than an assumption.
Gartner’s Andrés García-Rodeja put a number on what happens when teams skip that distinction: 60% of agentic analytics projects relying solely on the Model Context Protocol will fail by 2028 due to the lack of a consistent semantic layer (Gartner Data & Analytics Summit 2026). This guide’s sequence is what avoids that outcome, not a replacement for understanding what a context layer is or how it differs from a semantic layer, but the order of operations for building one.
What do you need before building a context layer reference architecture?
Permalink to “What do you need before building a context layer reference architecture?”Self-qualify against these four categories before starting phase 1. Skipping this step is why builds stall mid-phase rather than failing to start.
Organizational prerequisites:
- Executive sponsorship empowered to make the build-vs-buy call and to name the two owners phase 1 requires, with authority to resolve disputes between them once named
- A named owner for phase 4 (semantics), distinct from whoever owns the agent-runtime harness
- Agreement on which teams’ data sources are in scope for phase 2, decided before ingestion starts, not during it
Technical prerequisites:
- Admin access to source systems: databases, warehouses, BI tools
- A graph substrate decision (OSS framework like Graphiti or Cognee, or a platform like Enterprise Data Graph) made before phase 3, not during it
- An MCP-compatible or API delivery target identified before phase 6
Team and resources:
- A semantics/ontology owner at 20-40% FTE through phases 3-4
- A platform or data engineering lead for phase 2
- An evaluation owner for phase 7’s ongoing drift and quality monitoring
Time commitment: Planning runs 1-2 weeks. Phases 1-5 build across 6-10 weeks. Phase 6 delivery adds 1-3 weeks. Phase 7 recurs indefinitely; it is not a one-time close.
The context layer build loop: seven phases from the initial scope decision through continuous evaluation, each with its own decision point and validation checkpoint. Source: Atlan
Step 1: How do you scope the runtime-vs-layer split?
Permalink to “Step 1: How do you scope the runtime-vs-layer split?”This step decides, in writing, what belongs in the agent’s in-session runtime harness versus what belongs in the durable, governed context layer underneath it. Every later phase inherits this boundary, which is why it comes before any tooling decision, not after.
What you’ll accomplish: a written scope statement naming what’s runtime-ephemeral (working context, session state, tool-call memory) versus layer-durable (semantics, lineage, policy).
Time required: 2-5 days.
Why this step matters: conflating the two is the most-cited practitioner failure mode in the research behind this guide. Reddit, Hacker News, LinkedIn, and Google’s ADK team all converge on the same confusion from different angles.
| Dimension | Agent-runtime harness | Durable context layer |
|---|---|---|
| What it holds | Working context, session state, tool-call memory | Semantics, ontology, lineage, policy |
| Update frequency | Every turn, every session | Versioned, certified on a review cadence |
| Typical owner | Agent/application engineering | Data or platform engineering |
| Failure mode if conflated | Context window treated as a database; bloated system prompts | Business logic hardcoded per-agent instead of shared |
According to Datadog’s State of AI Engineering 2026, 69% of input tokens in enterprise LLM traces are spent on system prompts, evidence teams stuff durable-layer content into the runtime harness because no durable layer exists yet. Anthony Alcaraz, GTM Agentic Engineering Lead at AWS and author of Agentic GraphRAG, frames the harness as what makes an agent reliable: “it is the harness that provides the memory, tools, and boundaries required for consistent forward progress.” True of the harness, not the durable layer this page builds. Academic work on layered agent state (arXiv 2604.14228) backs the same split: assembly, persistence, and memory as distinct subsystems.
Validation checklist: written scope doc exists; both an agent-runtime owner and a context-layer owner are named, boundary agreed in writing.
Common mistakes: treating the context window as a database, in Alcaraz’s own framing; letting phase 2 ingestion scope drift to “everything.”
Teams that have scoped the runtime harness and want the design decisions behind the layer itself should see agent context layer design, covering the five dimensions this phase assumes.
Where does your data estate stand today?
The CIO's Guide to Context Graphs walks through the same scope-and-substrate decisions this build sequence covers, framed for a leadership audience making the build-vs-buy call.
Get the CIO Context GuideStep 2: Connect and ingest source systems
Permalink to “Step 2: Connect and ingest source systems”Phase 2 connects the source systems in scope, databases, warehouses, BI tools, and lineage-producing pipelines, that phase 3’s graph will bootstrap from.
What you’ll accomplish: source systems connected with initial metadata and lineage extraction running.
Time required: 1-3 weeks, depending on source diversity.
How to do it: prioritize systems that already produce lineage or query logs. Sequence the highest-value, highest-usage sources first. Confirm read access before planning any write-back.
A secondary decision sits inside this phase, alongside the source-scope call in Table A: the storage format. An Iceberg-native, open-format store like Context Lakehouse keeps this phase portable across clouds, which matters for teams weighing a model-agnostic or multi-cloud architecture rather than locking into a single vendor’s format.
Validation checklist: source inventory documented; access confirmed for every in-scope system; at least one lineage-capable source connected.
Common mistakes: connecting sources before the phase 1 scope statement exists, which re-litigates scope mid-ingestion; treating this as a one-time load instead of a continuous connection that phase 7 revisits.
The scope this section teaches, connecting first and stopping deliberately at the boundary phase 1 named, is what makes the next phase possible without re-doing this one.
Step 3: Bootstrap the context graph
Permalink to “Step 3: Bootstrap the context graph”This step turns connected source metadata into a graph substrate that later phases attach semantics, trust signals, and delivery to.
What you’ll accomplish: an initial graph populated from phase 2 sources, ready for semantic enrichment.
Time required: 2-4 weeks.
How to do it: choose a graph representation before starting. On the OSS side, that’s typically a Graphiti- or Cognee-class framework; on the platform side, it’s a managed graph like Enterprise Data Graph. Either way, resolve entity-identity conflicts early, before semantics, not after. The context graph vs. knowledge graph and context graph vs. vector database distinctions both matter for this representation choice, since a vector index alone can’t hold the relationship structure phase 4 needs.
This is also where AI-assisted bootstrapping earns its place: Context Agents can propose semantics and ontology from existing SQL, BI, and lineage signals for human certification, an “AI proposes, humans certify” pattern that shortens this phase specifically rather than replacing the judgment call phase 4 requires.
Validation checklist: graph populated from at least the phase 2 priority sources; entity-identity resolution approach documented.
Common mistakes: choosing a graph representation before the phase 1 scope is settled; treating graph bootstrap as a finished state rather than an ongoing process phase 7 revisits.
The layered-subsystem research cited in phase 1 (arXiv 2604.14228) applies again here: the graph is the persistence layer in that decomposition, distinct from the assembly and memory layers the runtime harness handles. Keep that boundary and phase 4 has a clean substrate to attach meaning to.
Step 4: Define semantics, ontology, and identity
Permalink to “Step 4: Define semantics, ontology, and identity”Semantics, ontology, and identity attach to the graph in this phase, so agents can reason over it instead of just querying it. It typically runs the longest of the seven phases, and it’s the one the mistakes section below flags as most often skipped past.
What you’ll accomplish: a certified semantic and ontology layer over the phase 3 graph.
Time required: 3-6 weeks, the longest phase in most builds.
Why this step matters most: Atlan AI Labs tested 522 enterprise queries across 13 tables and 94 columns and found a 38% relative SQL accuracy improvement when agents were grounded in governance-enriched context rather than raw schema (p < 0.0001), a lift attributable to this phase, not retrieval tuning or a bigger model. Snowflake’s independent validation found that adding an organizational ontology to agents produced a 20% accuracy improvement and a 39% reduction in tool calls, evidence from a different vendor’s stack that the semantics phase, not the delivery mechanism, is where accuracy is actually won.
Active ontology is the 2026 default for this phase: a living semantic layer rather than a static glossary that drifts out of date. The boundary between this phase’s output and a context graph is worth being precise about too, since teams conflate the graph (structure) with the ontology (meaning) and end up certifying the wrong artifact. And because this phase sits right at the edge of what a semantic layer traditionally covers, it’s the natural point to note that a context layer supersets a semantic layer rather than duplicating it.
Joe DosSantos, VP of Enterprise Data and Analytics at Workday, describes this phase as a shared-language problem before it’s a technology problem: build the semantic layer before activating it for AI, not the other way around. Workday’s own build followed that order, then activated the resulting shared language for AI through Atlan’s MCP server, which is the phase 6 payoff for getting phase 4 right.
Validation checklist: ontology certified by a named owner; identity resolution thresholds documented; at least one agent query tested against the semantic layer.
Common mistakes: skipping straight from phase 3 (graph) to phase 6 (MCP delivery) without this phase, the single most-cited failure mode in this research and the exact scenario Gartner’s 60% stat describes, developed fully in phase 7 below.
Check your accuracy baseline before you certify
The Context Maturity Assessment scores how ready your current semantics and ontology work is for agent consumption, before you lock in phase 4 as done.
Get Your Maturity ScoreHow a business graph maps organizational concepts to the data assets and metrics behind them, the phase 4 output in practice.
Step 5: Attach trust signals, lineage, certification, and policy
Permalink to “Step 5: Attach trust signals, lineage, certification, and policy”Lineage, certification, and policy enforcement, the provenance and governance signals, attach here, so an agent, or a human, can trust what the context layer returns.
What you’ll accomplish: lineage traced end to end, a certification workflow established, and a policy enforcement point decided.
Time required: 2-4 weeks, often run in parallel with phase 4.
How to do it: decide the policy enforcement point explicitly. This is a live open question the research behind this guide surfaced repeatedly: should enforcement happen at the agent, or at the context layer? Wire lineage from the phase 2 sources through the phase 3 graph so provenance is traceable, not asserted.
Worth naming once too: Cloudflare has positioned an Enterprise MCP reference architecture around centralized governance and identity-aware access, the access-control side of the wire; MCP governance decides who can ask, this phase decides what gets served.
CME Group’s build illustrates this phase at scale: 18M+ assets cataloged and 1,300+ glossary terms in year one, with lineage spanning on-premises Oracle, BigQuery, and Looker.
Validation checklist: lineage traceable end-to-end for in-scope sources; certification workflow has a named approver; policy enforcement point documented.
Common mistakes: leaving policy enforcement undecided until an incident forces the question, the single most expensive way to make this decision.
Ownership is the recurring tension here: who owns the context layer, data teams or AI teams, surfaces because certification authority and policy authority aren’t always held by the same team.
Step 6: Deliver through MCP, APIs, and operational playbooks
Permalink to “Step 6: Deliver through MCP, APIs, and operational playbooks”This step packages the certified, trust-signaled context layer into operational playbooks and delivers it to agents through MCP, APIs, or SQL, the phase most teams are tempted to start with, and shouldn’t.
What you’ll accomplish: MCP-based or API delivery live, with operational playbooks documented for how domain experts maintain what ships.
Time required: 1-3 weeks once phases 1-5 are certified.
According to the Model Context Protocol’s official documentation, MCP standardizes how applications provide context to language models, a delivery specification, not a context-generation mechanism. Repeating that here matters because “just add MCP” is the shortcut this research surfaced repeatedly across practitioner sources: teams treat phase 6 as the whole project instead of its last mile. How Atlan’s MCP server builds context for AI tools is one concrete look at what this phase produces once phases 1-5 are certified.
Two Tier-1 architectures are useful comparisons, precisely because neither is what this page describes. Microsoft’s Baseline Foundry Chat Reference Architecture is the closest thing to a true step-by-step methodology a Tier-1 vendor publishes, but scoped to a Foundry and Azure OpenAI chat app. AWS’s Agentic AI architecture in the enterprise offers a three-layer conceptual framework, useful as a mental model, but platform-scoped rather than a numbered sequence.
Context Engineering Studio is this phase’s ongoing infrastructure: the workspace where domain experts certify, version, and ship context products as sources and agent needs change. DigiKey’s build followed this ordering exactly: governed substrate first, phases 1 through 4 complete, then MCP activation. Teams scoping how agents stay context-aware across a session need this delivery layer to avoid re-deriving context on every call.
Validation checklist: delivery endpoint live; at least one operational playbook documented; domain-expert certification workflow in place.
Common mistakes: starting here before phase 4 is certified, the delivery-first shortcut Gartner’s 60% stat warns against, and the single fastest way to ship an agent that answers confidently and wrong.
Step 7: How do you evaluate and maintain a context layer after launch?
Permalink to “Step 7: How do you evaluate and maintain a context layer after launch?”This step treats the context layer as an ongoing discipline, not a finished build: evaluating drift, freshness, and quality, and checkpointing the whole sequence against Gartner’s three-core-component model.
What you’ll accomplish: a recurring evaluation cadence for drift, freshness, and quality, plus a documented cross-walk from the seven phases to Gartner’s three components.
Time required: ongoing. This phase recurs; it is not a one-time close.
| Gartner component (G00848874) | Which phases produce it | What “done” looks like |
|---|---|---|
| Semantics | Phases 3-4 | Certified ontology, tested against real agent queries |
| Operational state | Phases 2, 6 | Live delivery endpoint, documented playbooks |
| Provenance | Phase 5 | End-to-end lineage, named certification approver |
The mapping runs one direction: each phase’s output feeds a specific component, not the reverse. Phases 3-4 build and certify the graph, which is what “semantics” requires; phase 2’s connections and phase 6’s endpoint make the layer operationally live; phase 5’s lineage and certification make it provenanced, not asserted. Andrés García-Rodeja, Sr Director Analyst at Gartner, named the stakes at the Gartner Data & Analytics Summit 2026: “By 2028, 60% of agentic analytics projects relying solely on the Model Context Protocol (MCP) will fail due to the lack of a consistent semantic layer.” Snowflake’s 20%/39% findings, cited in phase 4, make the positive case: teams that checkpoint against this model see the accuracy Gartner’s warning implies they’d otherwise miss.
Validation checklist: drift-detection cadence scheduled; freshness SLAs documented per source; quality-eval baseline recorded from phase 4.
Common mistakes: treating phase 6 delivery as the finish line, which is how a certified layer quietly drifts back into the raw-schema problem phase 4 solved.
Continuous context quality testing, drift detection, and a versioned context repository are what phase 7 consists of day to day, none optional. Skipping it is how a build that passed every checklist through phase 6 still fails eighteen months later, quietly.
What are the most common mistakes when building a context layer?
Permalink to “What are the most common mistakes when building a context layer?”These four mistakes account for most of the rebuilds and stalled projects this research surfaced.
Mistake 1: Skipping the runtime-vs-layer scope decision
Permalink to “Mistake 1: Skipping the runtime-vs-layer scope decision”Why it happens: teams start building before anyone asks whether they’re solving an agent-session problem or an enterprise-infrastructure one.
How to avoid it: treat phase 1’s scope statement as a hard gate; no phase 2 work starts without it in writing.
If you encounter it: write the statement retroactively and audit what’s built so far against it.
Mistake 2: Jumping from graph bootstrap straight to MCP delivery
Permalink to “Mistake 2: Jumping from graph bootstrap straight to MCP delivery”Why it happens: MCP delivery is the most demoable part of the build, so it’s tempting to ship it first and backfill semantics later.
How to avoid it: treat phase 4 as a hard dependency for phase 6. No delivery endpoint goes live on an uncertified ontology.
If you encounter it: pull the endpoint back to staging until phase 4 catches up.
Mistake 3: Leaving policy enforcement undecided until an incident forces it
Permalink to “Mistake 3: Leaving policy enforcement undecided until an incident forces it”Why it happens: the agent-vs-layer enforcement question doesn’t block a demo, so it gets deferred indefinitely.
How to avoid it: make the enforcement-point decision a named line item in the phase 5 validation checklist.
If you encounter it: treat the first near-miss as the forcing function you’d rather have than an actual incident.
Mistake 4: Treating delivery as the finish line instead of phase 7 as ongoing
Permalink to “Mistake 4: Treating delivery as the finish line instead of phase 7 as ongoing”Why it happens: phase 6 feels like completion, so budgets and attention move to the next project.
How to avoid it: staff phase 7 before phase 6 ships, with a named evaluation owner and a scheduled cadence.
If you encounter it: schedule the first drift and quality review now, using phase 4’s baseline as the comparison point.
For a broader inventory, six context problems data teams building AI agents always hit pairs with this section without repeating it.
Best practices for building a context layer reference architecture
Permalink to “Best practices for building a context layer reference architecture”These five practices separate builds that reach phase 7 cleanly from the ones that stall or get rebuilt from phase 3 onward.
Practice 1: Write the phase 1 scope statement before touching any tooling. Every mistake in the section above traces back to this one being skipped or written too late.
Practice 2: Resolve entity-identity conflicts during bootstrap, not after semantics. Fixing identity resolution after the ontology is certified means recertifying, not patching.
Practice 3: Certify semantics with a named owner before delivery, not after. Atlan AI Labs’ 38% SQL accuracy lift and Snowflake’s 20% accuracy, 39% tool-call-reduction findings both trace to this practice specifically, not to any delivery-layer optimization.
Practice 4: Decide the policy-enforcement point explicitly, agent versus layer. An undecided default is still a decision, just an unaccountable one made by whichever engineer shipped first.
Practice 5: Schedule the phase 7 evaluation cadence before phase 6 delivery ships, not after. A cadence set up post-launch is reactive by definition; one set up pre-launch is a checkpoint the team already agreed to.
Each of these compounds: a team that gets practice 1 and 3 right has already avoided the two most-cited failure modes in this whole guide, and the remaining three practices mostly protect gains those first two already banked.
How Atlan streamlines building a context layer reference architecture
Permalink to “How Atlan streamlines building a context layer reference architecture”The seven phases above are vendor-neutral: they apply whether a team builds on open-source tools or buys a platform. This section is about the second path specifically, where Atlan accelerates the phases rather than replacing any of them. Phases 2 through 4, connect, bootstrap, and define semantics, are the slowest, highest-effort phases when done fully manually. Entity resolution and semantic certification in particular consume the bulk of a team’s 6-10 week build window, and they’re also the phases where a rushed shortcut costs the most later.
Context Agents change the shape of that work rather than skipping it: they propose semantics and ontology from existing SQL, BI, and lineage signals, and a human certifies the result. That AI-proposes, human-certifies pattern is what shortens phases 3-4 specifically, not the whole build, because certification still requires the named owner phase 4’s prerequisites call for. Context Engineering Studio is the phase 7 maintain infrastructure, the same versioning, review, and evaluation loop a serious manual build would eventually need to construct itself, and Context Lakehouse keeps the phase 1 storage decision portable rather than locked to a single cloud.
The three case studies referenced through this build sequence, CME Group’s 18M+ cataloged assets, Workday’s semantic-layer-first activation through Atlan’s MCP server, and DigiKey’s governed-substrate-before-MCP pattern, aren’t three different methodologies. They’re the same seven phases, executed in the same order, at three different scales, producing the same core components a context layer needs. That’s the point of a reference architecture: the phases don’t change based on company size or industry. Only how much of each phase gets automated does.
Real stories from real customers: Building the context layer at scale
Permalink to “Real stories from real customers: Building the context layer at scale”"We're excited to build the future of AI governance with Atlan. All of the work that we did to get to a shared language at Workday can be leveraged by AI via Atlan's MCP server…as part of Atlan's AI Labs, we're co-building the semantic layer that AI needs with new constructs, like context products."
— Joe DosSantos, VP of Enterprise Data & Analytics, Workday
"Atlan is much more than a catalog of catalogs. It's more of a context operating system…Atlan enabled us to easily activate metadata for everything from discovery in the marketplace to AI governance to data quality to an MCP server delivering context to AI models."
— Sridher Arumugham, Chief Data & Analytics Officer, DigiKey
Ready to build the business case?
If your team has scoped the seven phases and needs to justify the build, this calculator turns the accuracy and efficiency gains cited throughout this guide into a number a budget owner can act on.
Calculate Your ROIWhat separates context layer builds that ship from ones that get rebuilt
Permalink to “What separates context layer builds that ship from ones that get rebuilt”The seven phases here are not a preference. They’re a dependency chain: phase 4 needs phase 3’s graph, phase 6 needs phase 4’s certified semantics, and phase 7 needs a baseline that only exists if phase 4 was done right the first time. Reordering them moves the cost downstream, usually into a rebuild starting back at phase 3 or 4 after an agent has already shipped wrong answers with full confidence.
The build-vs-buy question doesn’t change that chain. Whether a team builds phases 2-4 on open-source tools like Graphiti and Cognee or buys a platform to accelerate them, the same seven phases apply in the same order; only who executes each phase changes. Teams evaluating that trade-off should read context layer evaluation criteria for the buyer-side version of this sequence, and context layer ROI for the business case once it’s in place.
Once phase 7 is running, treat evaluation as continuous: drift-detection frequency, freshness SLA adherence, and query-accuracy trend against the phase 4 baseline, not a launch announcement. From there, the natural next steps are scaling an agent context layer past a single-domain pilot, managing context across multiple agents, and treating context engineering as the ongoing discipline this architecture ultimately serves.
That’s the distinction this guide has drawn since phase 1: a reference architecture isn’t a checklist completed once. It’s the order of operations for a system that keeps needing phase 7, for as long as the agents on top of it need accurate answers.
FAQs about building a context layer reference architecture
Permalink to “FAQs about building a context layer reference architecture”1. How long does it take to build an enterprise context layer reference architecture?
Permalink to “1. How long does it take to build an enterprise context layer reference architecture?”Most enterprise builds take 8 to 16 weeks end to end, with 2 to 6 weeks per phase using platform acceleration. Fully manual builds on open-source tooling run toward the long end of that range, and phase 7 never fully closes since evaluation is ongoing.
2. Should you choose an agent framework before or after building the context layer?
Permalink to “2. Should you choose an agent framework before or after building the context layer?”Build the context layer first, or at minimum finish the phase 1 scope decision first. The layer produces the certified semantics, lineage, and policy signals a framework consumes at runtime. Choosing a framework first forces it to hardcode logic it should be reading from the layer instead.
3. Do you need MCP to have a context layer?
Permalink to “3. Do you need MCP to have a context layer?”No. MCP is a delivery mechanism, the wire an agent uses to request context, not the context layer itself. A context layer without an MCP endpoint still has value for BI, search, and governance. An MCP endpoint without a context layer behind it has nothing certified to serve.
4. What’s the difference between the agent-runtime harness and the durable context layer?
Permalink to “4. What’s the difference between the agent-runtime harness and the durable context layer?”The agent-runtime harness holds ephemeral, in-session state: working context, memory, and tool-call history that resets or ages out. The durable context layer holds governed, persistent state: semantics, lineage, and policy that outlive any single session and serve every agent, not just one.
5. What is the difference between a context layer and a reference architecture?
Permalink to “5. What is the difference between a context layer and a reference architecture?”A context layer is the infrastructure itself: the graph, semantics, and delivery mechanism an agent queries. A reference architecture is the methodology for building that infrastructure: the ordered phases, decision points, and validation checkpoints a team follows regardless of which tools or vendor they choose.
6. Can you evaluate a context layer before it’s fully built out?
Permalink to “6. Can you evaluate a context layer before it’s fully built out?”Yes, and you should. Phase 4 is the earliest point with enough structure to test agent query accuracy against a baseline. Waiting until phase 6 to run the first evaluation means discovering semantic gaps only after agents are already in production.
7. What happens if you skip the semantics phase and deliver through MCP first?
Permalink to “7. What happens if you skip the semantics phase and deliver through MCP first?”Agents get access to raw schema without certified business meaning, the exact failure mode Gartner cites: 60% of agentic analytics projects relying solely on MCP will fail by 2028 without a consistent semantic layer. Delivery-first sequencing is the single most common reason context layer builds get rebuilt.
Sources
Permalink to “Sources”- Gartner Data & Analytics Summit 2026: How to Build the Context Layer for Reliable AI Agents, Andrés García-Rodeja. https://atlan.com/know/gartner/key-takeaways-from-gartner-da-summit-2026/
- Enhanced Metadata Improves Query Accuracy, Atlan AI Labs. https://atlan.com/know/enhanced-metadata-improves-query-accuracy/
- The Agent Context Layer for Trustworthy Data Agents, Snowflake. https://www.snowflake.com/en/blog/agent-context-layer-trustworthy-data-agents/
- Only 7% of Enterprises Say Their Data Is Completely Ready for AI, Cloudera and Harvard Business Review Analytic Services. https://www.cloudera.com/about/news-and-blogs/press-releases/2026-03-05-only-7-percent-of-enterprises-say-their-data-is-completely-ready-for-ai-according-to-new-report-from-cloudera-and-harvard-business-review-analytic-services-reveals.html
- State of AI Engineering 2026, Datadog. https://www.datadoghq.com/state-of-ai-engineering/
- Anthony Alcaraz on agent harness architecture, LinkedIn. https://www.linkedin.com/posts/anthony-alcaraz-b80763155_most-ai-agent-writing-is-stuck-on-two-layers-activity-7451210336805834753-abub
- Dive into Claude Code: The Design Space of Today’s and Future AI Agent Systems, arXiv 2604.14228. https://arxiv.org/abs/2604.14228
- Model Context Protocol, official documentation. https://modelcontextprotocol.io/
- Baseline Microsoft Foundry Chat Reference Architecture, Microsoft Learn. https://learn.microsoft.com/en-us/azure/architecture/ai-ml/architecture/baseline-microsoft-foundry-chat
- Agentic AI Architecture in the Enterprise, AWS Prescriptive Guidance. https://docs.aws.amazon.com/prescriptive-guidance/latest/govern-architect-agentic-ai/enterprise-architecture.html
