CNTXT.store
Search entity graph
GUIDE

The Agentic Data Stack: Context Infrastructure as the Evolution of Analytics Engineering

By Chris Davis•Published 2026-09-01

Overview

As Ian Macomber notes in his foundational essay on The Post-AI Data Stack, the emergence of autonomous AI agents, coding assistants, and natural language interfaces is often framed as a departure from traditional data engineering. In practice, context infrastructure is the direct architectural continuation of analytics engineering, dimensional modeling, and enterprise data management.

Each successive era of data infrastructure removed a technical bottleneck and expanded the scope of what data teams could build. In the agentic era, generating code, writing SQL, and producing dashboards have become near-zero-cost commodities. As analytical output becomes abundant, organizational consensus becomes the scarce resource.

The role of context infrastructure is to encode domain judgment, business rules, metric definitions, and institutional knowledge into a machine-readable foundation, ensuring that any AI agent operating across an enterprise arrives at a verified, consistent representation of reality.

flowchart TD
    A["~2013: Pre-Modern Stack<br>On-prem relational databases. Isolated data moats.<br>Single-node compute bounds."] --> B
    B["~2016: Cloud Data Warehouse<br>Snowflake, BigQuery. Decoupled storage and compute.<br>Native JSON processing."] --> C
    C["~2020: Modern Data Stack + Reverse ETL<br>Fivetran, dbt, Looker. Managed ingestion.<br>Operational actors."] --> D
    D["~2026: Agentic Data Stack<br>Headless semantic layers, MCP servers.<br>Consensus engineered across models."]

Historical Context: Expanding the Blast Radius of Data

Understanding the agentic data stack requires examining how previous architectural transitions eliminated specific friction points:

1. The Pre-Modern Era (~2013)

Data systems ran on single-node on-premises servers (e.g. Microsoft SQL Server 2012, Oracle). Compute and storage were tightly coupled. Analytical queries over 10 million rows frequently degraded transactional systems. Datasets were siloed across physical machines, making cross-domain joins (e.g. linking order transactions with payment gateway logs) technically infeasible without fragile manual data migrations.

2. The Cloud Data Warehouse Era (~2016)

The rise of cloud-native data warehouses (Snowflake, Google BigQuery, Amazon Redshift) decoupled storage from compute. Organizations could store petabytes of historical clickstream in object storage while allocating dedicated compute clusters for analytical queries. Native support for semi-structured data formats (JSON, VARIANT) eliminated the barrier to analyzing web events and product telemetry.

3. The Modern Data Stack Era (~2020)

Managed extraction-load tools (Fivetran, Airbyte) and transformation frameworks (dbt) democratized data pipelines. Analytics engineers used SQL and version-controlled Git repositories to build standardized star schemas and data marts. The emergence of Reverse ETL (Hightouch, Census) shifted data teams from passive reporters delivering static slide decks to operational drivers synchronizing calculated customer attributes directly into CRM and marketing systems.

The Core Shift: Output Abundance vs. Consensus Scarcity

In the pre-AI data stack, consensus was enforced through scarcity and human gatekeeping:

  • Building an analytical dashboard required weeks of work across instrumentation, ETL pipeline authoring, dbt dimensional modeling, and BI configuration.
  • Dashboards were organized in hierarchical folder trees corresponding to the corporate organizational chart.
  • The high cost of dashboard creation limited the number of competing metrics circulating within an enterprise.

In the agentic era, anyone can prompt an AI assistant or deploy a coding agent to write SQL, query database endpoints, and generate charts in seconds. However, this creates a severe reproducibility crisis:

[ User A asks Coding Agent: "What was our Q3 churn rate?" ] ──> Agent writes SQL (excludes refunds <30d) ──> Output: 4.2%
[ User B asks Slackbot:     "What was our Q3 churn rate?" ] ──> Agent writes SQL (includes all cancellations) ──> Output: 5.8%
[ User C asks BI Tool:      "What was our Q3 churn rate?" ] ──> Agent queries raw Stripe API                  ──> Output: 3.9%

Every model and prompt combination can select different table joins, apply conflicting filters, and derive divergent numbers. Consensus is no longer a natural byproduct of centralized reporting; it must be explicitly engineered into the context infrastructure.

Architectural Pillars of the Agentic Data Stack

The agentic data stack introduces five architectural requirements to ensure AI agents operate on verified enterprise truth:

flowchart TD
    subgraph Consumers["CONSUMERS & INTERFACES"]
        direction LR
        C1["Employees"]
        C2["Coding Agents"]
        C3["Slackbots"]
        C4["Autonomous Executive Agents"]
    end
    
    subgraph Harness["AGENT HARNESS & EVALUATION GATEWAYS"]
        H1["Consensus Divergence Testing"]
        H2["Trace Normalization"]
        H3["Access Control & Permission"]
    end
    
    subgraph Semantic["HEADLESS CONTEXT & SEMANTIC LAYER"]
        S1["Canonical Metric Definitions"]
        S2["Domain Context & Data Contracts"]
        S3["Offline Tagged Unstructured Data"]
    end
    
    subgraph Storage["STORAGE & EXECUTION ENGINES"]
        E1["Cloud Warehouses"]
        E2["Vector DBs & Graph Databases"]
    end

    Consumers -- "Standard Transports (MCP / SSE)" --> Harness
    Harness --> Semantic
    Semantic --> Storage

1. Agent-Readable Artifacts

Dashboards and data models are no longer consumed solely by human eyes. In the agentic stack, data artifacts are authored to be decomposed, verified, and reassembled by autonomous sub-agents.

This requires exposing machine-readable metadata alongside every data product:

  • Markdown documentation describing query grain, metric lineage, and known edge cases (e.g. llms.txt).
  • Standardized data contracts defining primary keys, update frequencies, and deprecation schedules.
  • Direct programmatic access to underlying parameterized SQL and cached tabular results (.csv/Parquet) rather than locked UI charts.

2. Agent-Operable Headless Tools

Data tools must expose first-class APIs and Model Context Protocol (MCP) servers rather than requiring web UI navigation. Autonomous agents cannot efficiently click through complex web dashboards. Modern context stacks provide clean headless endpoints that allow any authorized agent to inspect schemas, execute verified semantic queries, and retrieve documentation.

3. Agent-Agnostic Context & Semantic Layers

Organizations must avoid locking their business definitions into proprietary agent silos. When an enterprise embeds its metric definitions inside a single vendor’s closed assistant, switching models or adopting new developer tools requires rewriting business context from scratch.

A headless semantic layer (such as Cube.dev or dbt Semantic Layer) maintains centralized, model-agnostic definitions of business metrics (e.g. Net Revenue Retention, Customer Acquisition Cost, Gross Margin). Whether a query originates from Claude, GPT-4, an IDE extension, or an internal analytics bot, the semantic layer compiles the query into verified, deterministic SQL.

4. Agent-Testable Consensus & Evaluation Suites

Consensus must be tested and measured continuously across all model and interface combinations used within an organization.

# Consensus Verification Harness
results = query_all_interfaces(
    interfaces=["coding_agent", "slack_assistant", "internal_bi", "executive_subagent"],
    question="What was net revenue retention in Q2 2026?",
)

assert all_metrics_match(results, tolerance=0.0001)
assert identical_semantic_view_used(results)
assert authorized_evidence_path_followed(results)

Organizations track the Consensus Divergence Rate—the percentage of core business questions that return differing numeric results or diverging evidence paths across interfaces. For board metrics and executive KPIs, the consensus divergence rate must be zero.

To achieve this, evaluation harnesses verify both the final numerical output and the evidence trace (e.g. verifying the agent executed READ_DOMAIN_DOC -> QUERY_SEMANTIC_VIEW -> EXECUTE_SQL rather than hallucinating ad-hoc join logic).

5. Pre-Structuring Unstructured Data

SQL excels at tabular aggregations over structured transaction logs, but fails on unstructured customer calls, support tickets, and legal documents.

Rather than running expensive, non-deterministic LLM parsing passes dynamically at query time, the agentic data stack runs offline extraction pipelines. An asynchronous tagging model processes raw text (e.g. Gong sales transcripts) once, writing structured attributes (loss_reason, objection_category, competitor_mentioned) back into relational warehouse tables where downstream agents can perform fast, reproducible GROUP BY aggregations.

flowchart TD
    A["Raw Gong Call Transcripts"] -->|Asynchronous Batch LLM Extraction| B["Versioned Taxonomies & Prompts"]
    B --> C["Structured Warehouse Columns<br>(loss_reason, objection_type, competitor)"]
    C -->|Fast SQL Aggregation| D["Downstream Agent Queries & Reports"]

Compounding Institutional Intelligence

In traditional organizations, metric nuances exist only as tribal knowledge in the minds of veteran analysts (“Card total volume excludes refunds processed after day 45” or “Enterprise tier definitions changed in Q2”).

When employees query commercial AI chatbots without an intermediary semantic layer, every user correction trains the third-party model vendor rather than improving internal enterprise systems.

In contrast, the agentic data stack captures this “intelligence exhaust.” Every metric correction, documented edge case, and domain guideline is committed to version-controlled semantic models and domain documentation. This institutional knowledge compounds within the enterprise infrastructure, ensuring that every future agent, automated workflow, and newly hired employee inherits the accumulated operational judgment of the organization.

The New Mandate for Data Teams

The historical progression of data engineering demonstrates a consistent trajectory:

Era Primary Bottleneck Primary Deliverable Data Team Role
Pre-Modern (~2013) Single-server storage & compute Fragmented operational reports Database Administrator / Report Builder
Cloud Warehouse (~2016) Storage scale & semi-structured data Centralized data lakehouse Data Engineer / Warehouse Architect
Modern Data Stack (~2020) Pipeline maintenance & Reverse ETL Dimensional dbt models & dashboards Analytics Engineer / Operational Partner
Agentic Stack (~2026) Non-deterministic AI output & metric divergence Machine-readable context, semantic layers & evals Architect of Institutional Consensus

The measure of an analytics engineer in the agentic era is no longer how many individual dashboards they handcraft. It is their ability to encode domain expertise and business truth into machine-readable context infrastructure, such that any autonomous agent operating on behalf of the company reaches the correct conclusion independently.