An agent that answers well on a demo dataset often falls apart on real customer data. The model is rarely the reason. The context it was handed is: partial, stale, or stitched together from five API calls that each returned one system's view of the same customer.
There are two ways to get business context to an agent. You can assemble it at runtime, calling each app's API every time the agent has a question. Or you can pre-materialize it: replicate and index the data before anyone asks, so the agent reads from a prepared copy your data team already trusts.
ETL for AI is how you build the second option. This guide covers what changes when the consumer of your pipeline is an agent, why we think pre-materialized context wins for most agent work, and how the stack fits together, from the connectors to the MCP endpoint your agents call.
TL;DR Agents get business context in one of two ways: runtime assembly, where the agent calls each app's API per question, or pre-materialized context, where data is replicated and indexed before the agent asks. Runtime assembly works for a single live lookup. It breaks on questions that span systems or time, because every question pays for fresh API calls and paginated payloads, and the agent sees one app at a time. ETL for AI keeps the pipeline you already run, including the modeling in your warehouse, and adds two steps analytics never needed: indexing text for semantic search, and serving the result to agents through a governed interface like MCP. You don't need a stack of new specialized stores. The warehouse you already run holds your organizational context. Index the text next to the records it came from and put one read-only endpoint in front of it. Cover the freshness gap with real-time fetch for the records that have to be live, instead of streaming every source. What is ETL for AI? ETL for AI is the process of extracting data from business systems, loading it into storage, and preparing it so AI agents can query and search it. The letters are the same as analytics ETL. Two things about the consumer are different.
First, an agent decides at runtime what it needs. A dashboard runs the same SQL every morning. An agent gets a question it has never seen, like "which accounts raised data residency concerns on calls this quarter?", and has to find the right tables, records, and passages of text on its own.
Second, a lot of the context an agent needs lives in text: call transcripts, support tickets, issue threads, docs, and email. Analytics pipelines usually move that text and then ignore it, because dashboards don't read paragraphs. Agents do.
So ETL for AI needs a serving step on top of the pipeline: a search index over the text, and an interface the agent can call. This is context engineering at the data layer: deciding what the agent can see, how fresh it is, and who is allowed to see it.
Runtime assembly vs. pre-materialized context This is the architectural choice that decides how an agent behaves in production, and many teams make it without noticing.
Runtime assembly is what you get when you connect an AI client to a stack of vendor MCP servers or an MCP gateway. Each server calls its app's API at the moment the agent asks. It's easy to set up and it demos well. In production, every question pays for the same round trips, raw paginated payloads fill the context window, and tool definitions for every connected app use up tokens before the agent does anything. Nothing links the customer in your CRM to the same customer in your support tool, so the agent rebuilds context from zero on every run.
Pre-materialized context means the data is replicated, joined, and indexed before the agent asks. The agent queries one copy of the business, with its history, that your data team already models and trusts.
Runtime assembly Pre-materialized context Where data comes from New API calls to each app, for every question Data already replicated to your warehouse What the agent receives Raw, paginated API payloads Query results and ranked text passages Questions across systems One app at a time; the agent stitches the answer All sources in one place, joinable with SQL Text such as calls and tickets Whatever keyword filter each API exposes Indexed for semantic search History What the API returns today Everything you've synced Setup One MCP server per app One endpoint for every source
Runtime calls still have a job. Checking whether one deal is still open, or reading a record that changed five minutes ago, is a live lookup, and a live lookup should be live. The mistake is using runtime assembly for everything.
Why does traditional ETL fall short for AI agents? The pipeline itself isn't the problem. Replicating every source into a warehouse is the hardest part of giving agents context, and teams that have done it are ahead. What traditional ETL lacks is everything after the load.
Agents can't reach the warehouse. Data lands in Snowflake or BigQuery, and then the agent has no governed way in. Wiring a warehouse to an AI client means service accounts, credentials, and a separate MCP setup that every team ends up doing differently.
Text isn't searchable by meaning. A customer worried about cost says "this feels steep for what we're getting." A user reporting a performance bug writes "the dashboard takes forever after the update" and never types "latency." A SQL LIKE filter misses both. The answer is in the warehouse, and the agent can't find it.
The last sync sets the clock. If a source syncs hourly, a renewal that changed stage ten minutes ago looks unchanged. When an agent fills that gap by guessing, you get a confident wrong answer. Stale and missing context is one of the main ways hallucinations reach production .
Broken syncs cost more. A failed sync used to mean a late dashboard that someone noticed by lunch. When an agent reads from that table, it means a wrong answer nobody flags. Pipeline reliability stops being hygiene and becomes a requirement.
How does ETL work in an agentic data infrastructure? We think about agentic data infrastructure in five layers.
Layer What it does Who provides it 1. Ingestion Connectors, managed auth, incremental sync, CDC, real-time fetch Airbyte's 700+ connectors 2. Storage and indexing Holds the replicated data and makes text searchable Your warehouse (Snowflake or BigQuery), plus the Airbyte context layer for search 3. Intelligence Business definitions, joins, relationships between records Your warehouse models today. Deeper Airbyte support is on the roadmap 4. Inference The model Yours. Bring the model of your choice 5. Agent interface How agents connect, with permissions and audit logging The Airbyte MCP
Here's how the ETL phases map onto those layers.
Extract and load: replicate every source into the warehouse Pre-materialized context starts with plain, reliable replication. Connectors pull from SaaS apps, databases, and files, handle auth and rate limits, and load into the warehouse on a schedule. Databases replicate with change data capture (CDC), which reads the transaction log so each sync only carries what changed. API sources sync incrementally. Schema changes propagate instead of breaking the pipeline.
Sync frequency is a cost and freshness dial. On Airbyte Cloud, syncs run as often as every hour on Standard, every 15 minutes on Plus, and every 5 minutes on Pro and Enterprise Flex. Pick each schedule based on how fast that source changes in ways your agents care about.
Coverage matters as much as speed. An agent can't reason about a system that never made it into the warehouse. Airbyte's catalog has 700+ connectors, and the Connector Builder covers internal and niche systems the catalog doesn't.
Transform: model in the warehouse, then index text for search Transformation covers a lot of ground: cleaning and deduplicating records, modeling them into tables people can query, defining metrics, and linking the same customer across systems. Agents need all of it as much as dashboards do. Airbyte doesn't handle that work today. Most teams do it in the warehouse with the modeling tools they already run, and those models are what an agent reads when it queries with SQL.
One part of transformation is new for agents, and analytics pipelines usually skip it: making text searchable. Structured records already work with SQL. Text needs an index, and that's the part of the T the Airbyte context layer covers.
Indexing starts from data you've already replicated:
Split. Airbyte reads the text fields marked for search on each source, like Gong call transcripts or Jira issue descriptions, and breaks them into passages.Embed. Each passage becomes a vector that represents its meaning. Airbyte runs a multilingual embedding model on its own infrastructure, so your text isn't sent to a third-party embedding API.Rank. At query time, Airbyte embeds the agent's question the same way, retrieves the closest passages, and runs them through a re-ranker.Search runs in hybrid mode, combining semantic and keyword matching. A question about billing complaints finds "I got charged twice," and a search for an order number still finds the exact match. Each result comes back with the passage, its surrounding context, and the record it came from, so the agent can join it to the rest of the warehouse with SQL.
That last part is why we index text next to the warehouse instead of copying it into a standalone vector database. A passage that knows its source record can be filtered by account, grouped by plan, or counted by quarter. A passage in a separate store can't, until someone builds and maintains the joins.
Serve: one governed endpoint for agents The serving layer is where agents connect. In Airbyte, that's the Airbyte MCP server at https://mcp.airbyte.com/mcp, which works with Claude, ChatGPT, Cursor, VS Code, and any other MCP client. With the Airbyte context layer turned on, an agent can do three things through it:
Chat with your warehouse. The agent writes read-only SQL against Snowflake or BigQuery and draws on the definitions and joins your data team already built.Search by meaning. Semantic search covers text from a growing set of sources, including Gong, Salesforce, Google Drive, Jira, Confluence, Gmail, Outreach, Pylon, and Zendesk Chat.Fetch what's live. Real-time fetch reads records directly from 50+ connectors, for anything newer than the last sync or not in the warehouse at all.The agent decides which to use. A good answer often uses all three: SQL to scope the question, semantic search to find what people said, and a live read to confirm the current state.
Because Airbyte loaded the data, the MCP server also knows where each table came from. When a dashboard number looks wrong, the agent can check the warehouse, find the pipeline that loaded the table, and read its last sync. That makes the same endpoint useful to the data engineers who run the pipelines, not only to the people asking business questions.
Fill the freshness gap with real-time fetch Pre-materialized doesn't mean stale. The warehouse holds history and cross-system context. Real-time fetch covers the slice that has to be current, like a deal stage, a ticket status, or an invoice that just got paid. That split is cheaper and simpler than running streaming pipelines for every source just so a handful of records stay fresh.
Do AI agents need streaming pipelines and a vector database? Most don't. Streaming has real uses, like scoring transactions for fraud as they happen. But most agent questions are about the business over days and quarters, with a few records where the current value matters. Schedule syncs to match how fast each source changes, and fetch live for the rest.
The same logic applies to adding a vector database, a feature store, and a graph database next to your warehouse. Each new store is another copy of your data with its own access rules, its own sync jobs, and its own way to go stale. If your team already keeps a governed copy of the business in the warehouse, index the text there and serve it through one endpoint. Your agents then query the same data your analysts already trust.
How should you choose your ETL infrastructure for AI? Start from where your data already lives If your sources already sync to Snowflake or BigQuery, most of the work is done. You need indexing and a serving layer, not a new platform. If key sources never made it into the warehouse, fix ingestion first. An agent with great search over half your systems still gives half-right answers.
Let security and compliance shape the design Agents need tighter controls than dashboards, because they act on whatever they can read. Check for these before you connect anything:
Off by default. In Airbyte, the context layer stays off until an organization admin turns it on. Workspace editors then choose which sources and destinations agents can read, and turn on semantic search connection by connection.Read-only. SQL is limited to SELECT and SHOW TABLES, and real-time fetch can only list and get records. Agents can't change data through the context layer.The user's permissions, nothing more. Each person signs in with their own Airbyte account, and the agent can't grant itself more access. Access control for agents should work this way everywhere.Credentials stay out of the chat. Queries use the credentials saved on the connector, which the agent never sees. Give that connector a read-only warehouse role scoped to what agents should see.Everything is logged. Each action is recorded with the user, the tool, and the target.For regulated teams, also check where each piece runs. With the Airbyte context layer, warehouse chat runs as SQL inside your own Snowflake or BigQuery account. Semantic search and real-time fetch run on Airbyte's cloud infrastructure. If data has to stay inside your boundary end to end, run replication on Airbyte Flex (hybrid deployment) , where the data plane runs in your cloud, VPC, or on-prem environment, and keep real-time fetch and semantic search turned off.
Models will keep changing. The data, and the context built from it, should stay yours. Own your context, and you can swap the model on top without rebuilding what sits underneath.
Build vs. buy Connectors are the expensive part of this stack to build yourself, and the work never ends: every API changes its auth, rate limits, and schema on its own schedule. Building a custom index and MCP server on top of a warehouse is more achievable, but then you also own permissions, audit logging, and embedding infrastructure.
A middle path works for most teams. Use managed connectors for ingestion, keep business definitions in the warehouse where your team already maintains them, and use a governed serving layer instead of writing your own. Because Airbyte's engine and connectors are open source, you can inspect the code that touches your data and build a custom connector when a source isn't in the catalog.
What does AI agent ETL look like in practice? Each example follows the same pattern: replicate, index, serve.
Finding risk in sales calls RevOps wants every account that raised data residency concerns on calls this quarter, with each account's opportunity stage.
Replicated: Gong calls and Salesforce opportunities, synced to the warehouse.Indexed: Gong transcripts.Served: The agent runs semantic search over transcripts for residency concerns, which catches "can we keep this in the EU?" and "we'd need this in our own AWS account" alongside literal mentions. It joins the matching calls to Salesforce with SQL to add the stage, then makes a live read on any deal that may have moved since the last sync.Explaining a support spike Refunds spiked last week, and support leadership wants to know why.
Replicated: Zendesk Chat conversations and the accounts table.Indexed: Conversation text.Served: The agent confirms the spike and its date range with SQL, runs semantic search over that week's conversations for the reasons customers gave, and joins the matches to the accounts table to group them by plan. The analyst gets an answer grounded in what customers wrote, without building a text classifier or a separate vector store first.Tracing a bad number to its pipeline A revenue dashboard drops 40% overnight.
Replicated: Payment data, loaded by an Airbyte pipeline.Served: A data engineer asks the agent what happened. It checks the warehouse and sees the newest charge rows landed at 2:04 AM the previous day. It finds the pipeline that loads the table and reads its last sync: the 3:00 AM run failed because an API key expired. Revenue didn't fall. The sync did. The fix is to update the credentials and rerun the sync.The warehouse query in this example needs the context layer. The pipeline check works on every plan.
What's the fastest way to get ETL for AI into production? Start with one question your SQL couldn't answer, and the sources it touches.
Replicate. Sync those sources to Snowflake or BigQuery. If they already sync through Airbyte, skip this step.Turn on the context layer. An org admin enables it in Airbyte Cloud. Choose which sources and destinations agents can read, and turn on semantic search for the connections that carry text. Airbyte can backfill the search index from your warehouse, which may use warehouse compute.Connect the Airbyte MCP. Point your AI client at https://mcp.airbyte.com/mcp and sign in with your Airbyte account.Ask. Check the answer against what you know, then add the next source.The Airbyte MCP server is open source and free on every plan, including Airbyte Core. The context layer is included on Airbyte Cloud Standard, Plus, Pro, and Enterprise Flex, and the 14-day free trial on Standard and Plus includes it. Read the context layer docs , start a free trial , or talk to sales about rolling it out on Flex.
Frequently asked questions What is pre-materialized context? Pre-materialized context is business data that's been replicated, joined, and indexed before an agent asks for it. The agent reads from that prepared copy instead of calling each app's API per question, which means fewer API round trips and access to cross-system history that no single API call returns.
What's the difference between traditional ETL and ETL for AI agents? Traditional ETL moves data into a warehouse for dashboards and reports. ETL for AI keeps that pipeline and adds two layers on top: an index that makes text searchable by meaning, and a governed interface, usually MCP, that agents use to query, search, and fetch live records.
Do AI agents need real-time data pipelines? For most questions, no. Scheduled syncs keep the warehouse fresh enough for questions about trends, history, and accounts. Use real-time fetch for the records where the current value matters, like a deal stage or a ticket status. Streaming every source to cover those records usually adds more cost and complexity than the use case needs.
Do I need a separate vector database for AI agents? Not if you index text alongside the warehouse records it came from. A standalone vector store is another copy of your data with its own permissions and sync jobs, and its results can't be joined back to your structured data without extra work.
How does ETL for AI reduce hallucinations? Agents guess when context is missing, stale, or split across systems. Replicating every relevant source, keeping syncs healthy, indexing text so the agent can find what people actually said, and fetching live records when freshness matters all close those gaps. No pipeline eliminates hallucinations, but missing and stale context are the causes you can fix at the data layer.
Can an agent change data through the Airbyte context layer? No. The context layer is read-only. Warehouse queries are limited to SELECT and SHOW TABLES, and real-time fetch can only list and get records.
Which warehouses does the Airbyte context layer support? Snowflake and BigQuery. Airbyte replicates to many other destinations, but warehouse chat and semantic search in the context layer work on data synced to those two.