Build a data foundation for agentic AI on AWS: From lakehouse to MCP

Building a data foundation ready for agentic AI is becoming a priority for organizations deploying AWS. This foundation relies on a unified lakehouse and interoperability protocols like Model Context Protocol (MCP). You can move from prototype to production. Yet many teams struggle to know where to start.

According to Gartner, more than 40 percent of agentic AI projects will be canceled by 2027 for failing to deliver the expected value. While Gartner points to several contributing factors, we believe the root cause comes down to two things: a lack of governance and inconsistent data.

If you’re building a data platform for AI agents, you probably recognize four barriers. Your data is fragmented across silos. Your unstructured data is available but hard to use. Your agents and your systems lack a common way to communicate. Gaps in quality and governance weaken trust and create hallucinations.

Each barrier holds back agentic AI. Closing them requires rethinking your data foundation as a whole, rather than fixing pipelines one at a time.

In this post, we walk you through four pillars for building a data foundation on AWS that is ready for agentic AI.

Pillar 1: Building a unified lakehouse with zero-ETL

The foundation starts with where your data lives and how you query it.

Beyond the data lake and the data warehouse: The lakehouse as your foundation

Every data platform sits between two approaches. Data lakes offer flexible storage, open formats, and raw data preserved on Amazon Simple Storage Service (Amazon S3) at low cost, which suits data science and AI workloads. However, this flexibility often comes with weak governance. Data warehouses provide native ACID transactions, high-performance SQL, and strong governance, but they become rigid when handling growing volumes or unstructured data.

Amazon SageMaker Lakehouse combines both approaches without requiring a full migration. Your operational, analytical, and AI data live in one place. Amazon S3 Tables, a capability of Amazon S3, provides native, open-source Apache Iceberg support. You can read and write from Spark, Amazon Athena, Amazon EMR, or Amazon Redshift.

Three essential lakehouse capabilities for agentic AI

A lakehouse built for agents needs three capabilities. Zero-ETL ingestion removes the need to manage pipelines. A federated catalog gives you a unified view of tables across S3, Amazon Redshift, Snowflake, or Databricks. With query federation, you can interrogate multiple sources without duplicating data.

SELECT customer_id, sentiment_score FROM s3tables.sales_db.orders WHERE order_date > '2024-01-01';

Native zero-ETL integrations to feed the lakehouse

AWS Glue connectors bring in operational sources like Amazon Aurora, Amazon DynamoDB, and Amazon Relational Database Service (Amazon RDS). They also support SaaS sources including Salesforce, ServiceNow, and SAP. Streaming sources include Amazon Managed Streaming for Apache Kafka (Amazon MSK) and Amazon Kinesis. Raw data and vector embeddings land in the same governed foundation, ready for the next pillar: context engineering.

Figure 1: Amazon SageMaker Lakehouse unifying data through zero-ETL ingestion and a federated catalog

Pillar 2: Context engineering for high-performing AI agents

A lakehouse makes data accessible, but agents also need curated, relevant context to act on it effectively. Large language models (LLMs) remain stateless, with a finite context window. Feeding an agent excessive data often backfires. Research on long-context models identifies a lost in the middle effect, where information placed away from the prompt’s start or end gets effectively ignored (Liu et al., 2023). Context engineering addresses this challenge through a context manager built on three components: knowledge bases, session state and history, and data tools.

Figure 2: The context manager built on knowledge bases, session state and history, and data tools

For knowledge bases, AWS offers several vector store options, including Amazon OpenSearch, Amazon Aurora PostgreSQL, and Amazon Neptune. Amazon S3 Vectors, a capability of Amazon S3, stands out because raw data and indexed embeddings reside in the same governed lakehouse foundation. This means agents and business intelligence tools consume the same source of truth without duplicating data or managing a separate system.

The following snippet is illustrative pseudocode that shows the flow. Check the Amazon Bedrock Knowledge Bases API reference for the exact parameter names and model identifiers.

# Illustrative pseudocode: parameter names are simplified
bedrock_agent.create_knowledge_base(
    name="customer-context-kb",
    vector_store_configuration={
        "s3VectorsConfiguration": {
            "vectorBucketArn": "arn:aws:s3vectors:::my-vector-bucket"
        }
    },
    embedding_model_arn="arn:aws:bedrock:::foundation-model/amazon.titan-embed-text-v2"
)

Static knowledge covers only half the problem. Agentic memory preserves dynamic context across sessions through two tiers. Short-term memory holds raw session history. Long-term memory stores vectorized records.

Amazon Bedrock AgentCore memory, a capability of Amazon Bedrock AgentCore, automates this process with an extraction module. This module identifies key terms, such as a client name or project, in raw events. It writes them into long-term storage for reuse. The result includes personalization, conversation continuity, and fewer hallucinations.

Data tools complete the context manager. Rather than receiving everything in the prompt, an agent calls a tool to fetch only the curated data it needs, such as the result of a SQL query. These capabilities prepare agents before they start communicating with each other and with your systems. MCP, the topic of our next pillar, standardizes that tool access.

Figure 3: Amazon Bedrock AgentCore memory extracting key terms from raw events into short-term and long-term memory

Pillar 3: Multi-agent interoperability with MCP and open protocols

After agents can retrieve the right context, the next challenge is collaboration, both between agents and with existing systems. Multi-agent debate techniques, where models review and correct each other’s outputs, can help improve reliability compared to a single model (Du et al., 2023). Two open protocols address this need. Agent2Agent (A2A) handles agent-to-agent communication. Model Context Protocol (MCP) connects agents to your systems.

Agent-to-agent communication with open protocols

With A2A, agents collaborate over standard HTTP and JSON, without sharing memory or a direct connection. It supports long-running tasks. An agent handling a lengthy video processing job can report progress while an orchestrator decides whether to wait or reassign the task. Each agent publishes an agent card describing its capabilities, inputs, and outputs. Popular open-source agent orchestration frameworks can query this card before delegating work.

Connecting the agentic world to your systems with MCP

MCP standardizes how agents access your data and tools through three components. Resources expose read-only data. Tools run actions like SQL queries. Prompts provide reusable instructions.

Amazon Bedrock AgentCore Gateway, a capability of Amazon Bedrock AgentCore, centralizes this access. It connects to an AWS Lambda function, an API, or a SaaS integration like Salesforce. It also enforces authentication and audit logging in one place.

Semantic search and tool discovery

As your gateway grows, agents risk being overwhelmed by available tools. AgentCore Gateway addresses this with semantic search: agents query in natural language, and the gateway returns only the relevant, permission-scoped tools based on AWS Identity and Access Management (IAM) policies.

Pillar 4: Data and AI governance for trust and compliance

Agents now communicate and act through MCP, so the data they rely on must be trustworthy. Governance has become your true differentiator. Foundation models (FMs) are widely accessible, so your data and how you manage it are what set your agents apart. Amazon SageMaker Data Catalog addresses this need through three capabilities: discovery, governance, and collaboration.

Most enterprise data remains unstructured, with incomplete metadata. The catalog automatically generates summaries, glossaries, data lineage, and quality indicators for each dataset. This gives users confidence in the data before they connect an agent to it.

Governance follows a publish-and-subscribe model. Producers publish datasets, and consumers subscribe with access scoped to their needs, through full access, row-level filtering, or column-level filtering.

These workflows run through IAM and expose APIs, so teams can automate approval flows instead of managing access requests manually.

Amazon SageMaker Unified Studio brings producers, analysts, and data scientists into a shared environment. A built-in generative AI assistant translates natural language requests into SQL, Python, or visualization cells that teammates can run immediately. This turns data exploration into a shared, auditable notebook instead of disconnected scripts.

Together, these four pillars (lakehouse, context engineering, interoperability, and governance) form a foundation you can build at enterprise scale. You can find a full technical walkthrough in the recorded session video from AWS Summit Paris.

Figure 4: Lakehouse, context engineering, interoperability, and governance as the four pillars of an agentic AI data foundation

Conclusion

In this post, we outlined a four-pillar framework for an AI-ready data foundation on AWS, designed around connected capabilities rather than patched individual pipelines. Amazon SageMaker Lakehouse addresses the fragmentation and silo barrier. It brings operational, analytical, and AI data into one governed foundation with S3 Tables and native Apache Iceberg support. Context engineering with Amazon S3 Vectors and Amazon Bedrock AgentCore memory tackles the second barrier: unstructured data that is technically accessible but not usable. It turns your unified data into knowledge and persistent memory that agents can act on, instead of overloading a context window.

After your agents have the right context, MCP and Amazon Bedrock AgentCore Gateway address the interoperability barrier. They give agents a secure, centralized way to reach your tools and systems. Semantic search keeps tool discovery manageable as your gateway grows. Finally, Amazon SageMaker Data Catalog closes the governance gap that erodes trust and can introduce hallucinations. Its discovery, publish-and-subscribe access, and lineage capabilities give you the traceability that agentic AI needs to run in production.

If you’re starting this journey, sequence matters. Get your lakehouse and zero-ETL ingestion right first, because every downstream pillar depends on having a single, governed source of truth. Then invest in context engineering before you scale to multi-agent orchestration. Agents that hallucinate or lose session context will only compound errors after they start communicating with each other through A2A or MCP.

Treat governance as a parallel track from day one, not a final checkpoint. Column- and row-level access controls are far easier to build in early than to retrofit later.

These pillars also apply to workloads such as media personalization, customer service automation, and fraud detection pipelines. In each, multiple agents need to share a consistent, trustworthy view of enterprise data.

To go deeper, watch the recorded session video from AWS Summit Paris for the full technical walkthrough. You can also explore the Amazon SageMaker Lakehouse documentation and the Amazon Bedrock AgentCore documentation for implementation details.

About the authors