Google Cloud Tech
Moving foundation models and open protocol tools directly into database engines eliminates extraction pipelines, turning passive corporate storage into real-time systems of action for autonomous agents.
AI-assisted summary of Power intelligent agents with AI-native databases — original source. Check the original for full context.
Source published:
Key ideas
- Google Cloud introduced the Agentic Data Cloud strategy, co-locating AI inference on Cloud TPUs directly inside enterprise databases to eliminate data transfer latency and staleness. (1:43)
- AlloyDB expanded its vector search capabilities to scale beyond 10 billion vectors with Google ScaNN, while accelerating pgvector HNSW by up to 4x and introducing a unified SQL function for BM25 hybrid search. (11:19)
- Google's Data Agent Platform achieved the number-one spot on the industry-standard BIRD benchmark for text-to-SQL translation, utilizing schema ontologies, query blueprints, and value searches. (21:23)
- The open-source Model Context Protocol (MCP) Toolbox for Databases reached its 1.0 milestone with over 14,000 GitHub stars, supporting more than 40 data sources across Google Cloud, open-source, and third-party engines. (31:04)
Detailed notes
## Background Published on YouTube by Google Cloud Tech on June 25, 2026, as part of Google Cloud Next, this session features Google's Amit Ganesh and Yannis Papakonstantinou alongside Anthropic's David Soria Parra. The presentation details how AI-native databases power enterprise autonomous agents through multimodal SQL queries, in-database AI primitives, graph RAG, and open standards like the Model Context Protocol (MCP).
## TL;DR Google Cloud outlines its Agentic Data Cloud vision, reversing traditional data movement by embedding model inference, vector search, and forecasting directly into database engines like AlloyDB and Spanner. The speakers showcase in-database hybrid search combining ScaNN and BM25, Gemini-powered AI functions, GraphRAG, and the Data Agent Platform's secure text-to-SQL capabilities. Anthropic's David Soria Parra joins for a fireside chat explaining how MCP solves the $N \times M$ integration dilemma, leading into Google's suite of pre-built agents for builders, database operators, and conversational analytics.
## Atmosphere & style The session carries the polished, high-energy cadence of a premier cloud keynote, blending corporate strategic vision with concrete database engineering deep dives. Amit Ganesh frames the transition with executive gravitas, depicting an industry at a historic 50-year inflection point, while Yannis Papakonstantinou provides methodical, code-level clarity on in-database inference and security guardrails. The fireside conversation with David Soria Parra adds an engaging, collegial dimension that demystifies cross-industry collaboration and gives viewers a tangible sense of how open standards are actively reshaping enterprise software.
## Bulletin - [01:43](https://www.youtube.com/watch?v=7awKinJhGPo&t=103s) Google Cloud introduced the Agentic Data Cloud strategy, co-locating AI inference on Cloud TPUs directly inside enterprise databases to eliminate data transfer latency and staleness. - [11:19](https://www.youtube.com/watch?v=7awKinJhGPo&t=679s) AlloyDB expanded its vector search capabilities to scale beyond 10 billion vectors with Google ScaNN, while accelerating pgvector HNSW by up to 4x and introducing a unified SQL function for BM25 hybrid search. - [21:23](https://www.youtube.com/watch?v=7awKinJhGPo&t=1283s) Google's Data Agent Platform achieved the number-one spot on the industry-standard BIRD benchmark for text-to-SQL translation, utilizing schema ontologies, query blueprints, and value searches. - [31:04](https://www.youtube.com/watch?v=7awKinJhGPo&t=1864s) The open-source Model Context Protocol (MCP) Toolbox for Databases reached its 1.0 milestone with over 14,000 GitHub stars, supporting more than 40 data sources across Google Cloud, open-source, and third-party engines.
## Key takeaways - [01:43](https://www.youtube.com/watch?v=7awKinJhGPo&t=103s) Legacy enterprise architectures suffer from disconnected operational silos and data transfer lag, requiring a shift toward moving AI directly to where data lives. - [05:29](https://www.youtube.com/watch?v=7awKinJhGPo&t=329s) The Agentic Data Cloud is organized across three foundational pillars: AI-native databases, a data agent platform, and pre-built data agents. - [09:24](https://www.youtube.com/watch?v=7awKinJhGPo&t=564s) AlloyDB delivers 100% PostgreSQL compatibility while consolidating relational storage, high-scale vector indexing, and analytical acceleration up to 100 times faster than vanilla PostgreSQL. - [11:19](https://www.youtube.com/watch?v=7awKinJhGPo&t=679s) Hybrid search in AlloyDB merges semantic vector retrieval with BM25 full-text ranking inside standard SQL, avoiding brittle application-layer search coordination. - [15:16](https://www.youtube.com/watch?v=7awKinJhGPo&t=916s) In-database AI functions integrate Gemini's world knowledge and TimesFM forecasting directly into SQL queries, with specialized primitives like AI.IF reducing inference costs by up to 1,000x. - [18:28](https://www.youtube.com/watch?v=7awKinJhGPo&t=1108s) Spanner supports GraphRAG by overlaying virtual graph models onto existing relational tables, eliminating the need for ETL replication to dedicated graph databases. - [21:23](https://www.youtube.com/watch?v=7awKinJhGPo&t=1283s) Query Data relies on schema ontologies, query blueprints, and live value searches to drive text-to-SQL translation toward production-grade accuracy. - [21:23](https://www.youtube.com/watch?v=7awKinJhGPo&t=1283s) Parameterized Secure Views enforce deterministic, engine-level tenant isolation and security boundaries rather than relying on probabilistic LLM guardrails. - [28:46](https://www.youtube.com/watch?v=7awKinJhGPo&t=1726s) Complex multi-step workflows—such as combining semantic vector search with time-series forecasting—execute completely inside the database engine using paired CPUs and Cloud TPUs. - [31:04](https://www.youtube.com/watch?v=7awKinJhGPo&t=1864s) Google Cloud provides zero-ops managed MCP servers secured with Model Armor governance to expose all GCP databases, analytics, and storage services to autonomous agents. - [34:29](https://www.youtube.com/watch?v=7awKinJhGPo&t=2069s) The Model Context Protocol solves the classic N x M integration bottleneck between diverse enterprise backends and frontier foundation models. - [37:00](https://www.youtube.com/watch?v=7awKinJhGPo&t=2220s) Native in-database AI operators and indexes mirror historic additions like GiST geospatial indexing, giving agents broad candidate retrieval primitives to reason over. - [39:28](https://www.youtube.com/watch?v=7awKinJhGPo&t=2368s) Anthropic runs production workloads on AlloyDB, highlighting how open protocols enable organizations to combine frontier AI models with enterprise-grade database stability. - [42:48](https://www.youtube.com/watch?v=7awKinJhGPo&t=2568s) Turnkey pre-built agents address three primary organizational tiers: developers via the Data Agent Kit, administrators via Observability and Testing agents, and business users via Conversational Analytics. - [45:49](https://www.youtube.com/watch?v=7awKinJhGPo&t=2749s) The Conversational Analytics Agent enables non-technical personnel to safely query live operational systems using natural language backed by secure views.
## Detailed walkthrough ### [00:12](https://www.youtube.com/watch?v=7awKinJhGPo&t=12s) Welcome and the Agentic Era
Amit Ganesh opens the session by addressing the core challenge enterprises face today: organizations want to harness artificial intelligence to build high-value agentic workflows and user experiences grounded in enterprise data, but doing so requires an underlying data platform capable of earning user trust. Enterprises cannot deploy autonomous agents without ensuring high accuracy alongside strict adherence to enterprise privacy, security, and governance requirements.
To explore this frontier, Amit introduces his co-speakers: his colleague Yannis Papakonstantinou from Google, and David Soria Parra from Anthropic, the creator of the Model Context Protocol (MCP). The session roadmap covers Google's overarching data and AI strategy for the agentic era, followed by a technical deep dive from Yannis on how AI-native databases grant agents their core capabilities, an overview of the data agent platform, a fireside chat with David on MCP, and a walkthrough of Google's out-of-the-box pre-built data agents.
[01:43](https://www.youtube.com/watch?v=7awKinJhGPo&t=103s) Legacy Silos and Moving AI to Data
Databases have entered an unprecedented turning point after more than fifty years of history. As Amit observes: “For the first time in the 50 plus year history of databases, we are at a truly inflection point.” Customers are aggressively racing to integrate autonomous agents with enterprise data across every facet of their businesses. However, legacy enterprise architectures stand in the way. Today's environments resemble walled gardens composed of disconnected data warehouses and siloed operational databases, making it extremely difficult for an agent to access cross-functional data smoothly.
Even when agents gain data access, they lack semantic context—the crucial domain knowledge that explains what the raw data actually means. Moreover, traditional workflows force organizations to move their data out of operational systems over to AI models. This data movement introduces severe latency, leaving agents operating on stale data rather than the live, real-time state of the enterprise, while also inflating manual integration overhead and delaying time to market. Google's strategy flips this equation entirely by moving AI directly to the data. By joining its world-class AI and data engineering teams, Google is unifying its state-of-the-art AI stack with its data stack into an integrated offering termed the **Agentic Data Cloud**. Amit stresses that this paradigm shift redefines enterprise databases: “This is a system of action for agents, not just a system of insights.”
```mermaid flowchart TD accTitle: Legacy Data Architecture versus Agentic Data Cloud accDescr: Comparison showing legacy workflows moving data to AI with lag versus Agentic Data Cloud moving AI to data in place.
subgraph Legacy["Legacy Approach: Move Data to AI"] direction TB A["Siloed Operational DBs & Warehouses"] -->|"Extract, Transform, Move (Lag & Cost)"| B["Disconnected AI Models"] B --> C["Stale, Low-Context Agent Actions"] end
subgraph AgenticCloud["Google Agentic Data Cloud: Move AI to Data"] direction TB D["Unified Enterprise Data Store"] -->|"Native In-Database Inference (TPUs, Models in SQL)"| E["Trusted Semantic Context & Guardrails"] E --> F["Real-Time Autonomous Agent System of Action"] end ```
- **System of Action:** Moves beyond passive analytical dashboards to power live, autonomous agent execution. - **Deep Hardware & Software Integration:** Integrates AI at every layer, pairing standard CPUs with Google Cloud TPUs for in-database model inference. - **Open and Flexible:** Embraces open standards and engines such as PostgreSQL, allowing users to run anywhere, bring their own data, or plug in external custom models. - **Enterprise Guardrails:** Enforces privacy, governance, and strict access controls so agents operate strictly within enterprise compliance boundaries.
[05:29](https://www.youtube.com/watch?v=7awKinJhGPo&t=329s) The Three Pillars of the Agentic Data Cloud
Amit outlines the three foundational pillars that define the Agentic Data Cloud architecture:
```mermaid flowchart LR accTitle: Three Pillars of the Agentic Data Cloud accDescr: Three pillars showing AI-native databases, data agent platform, and pre-built agents.
P1["1. AI-Native Databases<br/>• Multimodal storage & SQL<br/>• TimesFM forecasting<br/>• In-database embeddings"] P2["2. Data Agent Platform<br/>• Trusted Knowledge Catalog<br/>• MCP tool suite & toolbox<br/>• Anthropic & AWS standards"] P3["3. Pre-built Data Agents<br/>• Builder & operator tools<br/>• Conversational analytics<br/>• #1 on BIRD benchmark"]
P1 --- P2 --- P3 ```
1. **AI-Native Databases:** Databases must natively handle multimodal data, ranging from traditional relational tables to image and video embeddings, graph models, and numeric time series. Crucially, operations on these disparate modalities—such as time series forecasting, anomaly detection, and vector search—are unified directly within SQL. For example, through partnership with Google Research, Google integrated **TimesFM**, a foundation model pre-trained on time-series data that accelerates forecasting workflows that previously took hours, days, or months down to literal seconds. 2. **Data Agent Platform:** This layer equips developers with tools, agent frameworks, and the **Trusted Knowledge Catalog**—which Amit describes as the "nerve center" providing the enterprise context agents need to reason accurately over data. It incorporates an extensive suite of Model Context Protocol (MCP) tools and natural language interfaces. Highlighting collaborative governance, Amit notes that Google is working alongside Anthropic and AWS to standardize and evolve MCP, while also providing the open-source **MCP Toolbox** to spur community contributions. 3. **Pre-Built Data Agents:** Out-of-the-box agents tailored for database builders, day-to-day database administrators/operators, and business users conducting conversational analytics. Highlighting the quality of their natural language interface, Amit announces: “So I am really thrilled to share that Google holds the number one spot in the industry standard BIRD benchmark leaderboard for natural language to SQL through our conversational analytics agent and platform.”
[09:24](https://www.youtube.com/watch?v=7awKinJhGPo&t=564s) AlloyDB: An AI-Native Database Built for Agents
Yannis Papakonstantinou takes the stage to unpack how AI-native databases grant agents their core capabilities. As Yannis explains, the fundamental shift lies in native intelligence: “An AI native database doesn't just store data, it natively processes and understands the data using built in AI primitives.” Instead of shuttling data back and forth to external microservices, an autonomous agent can formulate SQL queries that inspect structured records, text, images, and videos in a single pass, combining SQL semantics with foundation models and specialized AI functions like predictive forecasting.
Yannis highlights **AlloyDB** as Google’s flagship AI-native database purpose-built for this era. AlloyDB maintains 100% PostgreSQL compatibility while infusing proprietary Google innovations, creating a unified engine that acts as a relational database, an ultra-high-performance vector store, and an analytical processing engine running up to 100 times faster than standard PostgreSQL. For deployments spanning hybrid architectures, **AlloyDB Omni** allows developers to download and run the exact same cloud-grade database software anywhere—whether on-premises, on competing public clouds, or locally on a developer’s laptop.
- **Unified Workloads:** Eliminates the architectural friction of synchronizing separate relational databases, vector databases, and analytical warehouses. - **In-Database AI Execution:** Brings generative models like Gemini directly to enterprise data via SQL function calls. - **Run Anywhere Flexibility:** AlloyDB Omni decouples the engine from specific cloud infrastructure for consistent cross-environment testing and deployment.
[11:19](https://www.youtube.com/watch?v=7awKinJhGPo&t=679s) Vector Search Innovations and Hybrid Search in AlloyDB
Yannis explains why search in the agentic era must transcend legacy keyword matching. Modern users and AI agents demand holistic intent understanding. For instance, when an online retail shopper queries for "summer shirts," the most relevant items might be linen or cotton apparel that do not explicitly contain the word "summer." Fulfilling this intent requires semantic vector search alongside traditional exact-match filtering.
```mermaid flowchart TD accTitle: AlloyDB Hybrid Search Architecture accDescr: Hybrid search in AlloyDB combining ScaNN and HNSW vector search with BM25 full-text search inside a unified SQL UDF.
subgraph SearchQuery["User / Agent Query"] Q["'Summer Shirts' (Captures intent: linen, cotton)"] end
subgraph AlloyDBSearch["AlloyDB Search Layer"] direction TB V["Vector Search<br/>• Google ScaNN (10B+ vectors)<br/>• pgvector HNSW + Columnar Engine (4x faster)"] T["Text Search<br/>• State-of-the-art BM25 Ranking"] UDF["Unified Hybrid Search UDF in SQL"] V --> UDF T --> UDF end
SearchQuery --> AlloyDBSearch UDF --> Results["High-Precision, Context-Aware Search Results"] ```
To deliver this, AlloyDB has continually differentiated its vector capabilities since 2024. Rather than offering basic `pgvector` support alone, Google embedded its proprietary **ScaNN** (Scalable Nearest Neighbors) index—the same foundational indexing algorithm backing Google Search and YouTube. At Google Cloud Next, Yannis reveals major enhancements:
- **10 Billion+ Vector Scale:** ScaNN in AlloyDB now scales to support massive datasets exceeding 10 billion vectors. - **4x Accelerated HNSW:** For teams already running standard `pgvector` with HNSW indices, AlloyDB uses its Columnar Engine technology to accelerate vector search performance by up to 4x over vanilla PostgreSQL without requiring any schema or configuration adjustments. - **Index Abstraction:** Google intends to make the choice between ScaNN and HNSW an underlying implementation detail managed automatically by the database engine. - **Hybrid Search with BM25:** Acknowledging that vector search alone is insufficient, AlloyDB merges vector retrieval with advanced full-text search powered by state-of-the-art BM25 ranking algorithms. A dedicated hybrid search User-Defined Function (UDF) allows developers to seamlessly blend semantic vector scores and lexical BM25 scores directly inside standard SQL queries.
[15:16](https://www.youtube.com/watch?v=7awKinJhGPo&t=916s) AI Functions and In-Database World Knowledge
AI functions bring the nuanced reasoning and real-world knowledge of Gemini directly into database queries, bridging the gap between raw data storage and general-purpose intelligence. Yannis Papakonstantinou illustrates this with a retail scenario where a customer searches for "comfortable shirts for a summer in Santorini." A traditional database knows inventory, sizes, and colors, but has no comprehension of where Santorini is, what its Mediterranean climate feels like, or what fabrics are breathable enough for that heat. Gemini supplies that contextual knowledge. Through AlloyDB, developers can execute this reasoning straight out of SQL without orchestrating external model pipelines.
A standard architectural pattern is to use hybrid search to narrow down the catalog to an initial pool of 1,000 to 2,000 candidate items, and then rerank those candidates against the query's qualitative criteria—such as suitability for a Greek island summer—using an in-database AI function. Developers write and configure these AI functions using plain natural language. For workloads requiring lower latency, AlloyDB also offers a faster semantic ranking function that runs outside generative LLM calls, powered by Google Cloud's semantic ranker.
```mermaid flowchart TD accTitle: Hybrid Search and In-Database AI Functions Flow accDescr: Customer query is retrieved via hybrid search in AlloyDB and reranked using Gemini AI functions.
subgraph Retrieval ["Candidate Retrieval"] Q["Customer Query<br/>'Comfortable shirts for summer in Santorini'"] HS["AlloyDB Hybrid Search<br/>(Vectors + Structured Filters)"] Pool["Top 1,000–2,000 Candidates"] Q --> HS HS --> Pool end
subgraph InDatabaseAI ["In-Database AI Reasoning"] Pool --> RF["Rerank AI Function"] Gemini["Gemini Model Knowledge<br/>(Understands Santorini Climate)"] Gemini -.-> RF SR["Optional: Google Semantic Ranker<br/>(Non-LLM Fast Path)"] Pool -.-> SR end
subgraph Output ["Agent & User Results"] RF --> Out["Context-Aware, Ranked Results"] SR --> Out end ```
Beyond reranking search results, Google Cloud provides a suite of generally available LLM-based SQL functions. These include generative functions for dynamic annotations, personalized explanations, sentiment analysis, and text summarization. For numerical predictions, the database includes a forecast function powered by Google's TimesFM foundation model, which generates future projections based on historical operational records. Yannis Papakonstantinou highlights specialized optimized functions such as AI.IF: “This provides superior performance and about 1,000 times cost reduction over the default baseline LLM calls, this enables you to use AI at scale.”
- **Hybrid search candidate pool**: Typically pulls the top 1,000 to 2,000 candidate rows before applying secondary AI transformations. - **Natural language programming**: In-database AI functions accept natural language prompts directly within SQL statements. - **Specialized models**: TimesFM runs time-series forecasting against historical database rows without data movement. - **Cost reduction**: Optimized primitives such as AI.IF reduce inference costs up to 1,000× compared to default LLM calls.
---
[18:28](https://www.youtube.com/watch?v=7awKinJhGPo&t=1108s) Target.com Case Study and GraphRAG on Spanner
Yannis Papakonstantinou highlights Target.com to demonstrate the practical enterprise value of embedding AI search primitives inside the database engine. Target wanted to transform their online search experience by applying dynamic SQL filters to complex data types alongside vector search. By adopting AlloyDB and using the ScaNN index directly within the database engine, Target achieved query performance that far exceeded what was possible when manually gluing an operational relational database to an external, purpose-built vector search engine. Target reported a 20% increase in search relevance and subsequently migrated their entire production search traffic to AlloyDB.
Organizations often treat hybrid search—spanning structured relational data, embeddings, and full-text indexes—as an application-level problem managed by distributed application code. Yannis Papakonstantinou argues this architecture is outdated: “We think, however, that as people see the results and business outcomes that come by combining different modalities right in the database, they will quickly follow target.com example.”
Turning to Spanner, Papakonstantinou details how it addresses the fifth pillar of search: graph structures. Spanner extends its global scale and multi-modal engine into GraphRAG, pairing hybrid retrieval with relationship traversal among database entities. Rather than forcing teams to export operational records into a separate graph database, Spanner implements a virtual graph model layered directly on top of the existing relational SQL tables. This design allows complex GraphRAG traversals to run against live data with zero pipeline replication or ETL overhead, ensuring agents receive up-to-date, relationship-aware operational context.
---
[21:23](https://www.youtube.com/watch?v=7awKinJhGPo&t=1283s) The Data Agent Platform and Query Data
While natural language has become the default interface for interactions between humans and agents, operational enterprise databases continue to run on SQL. Bridging these two modalities exposes a severe gap between rapid prototype demos and the strict reliability demanded by production software. In production, applications require near 100% text-to-SQL translation accuracy. Concurrently, databases often lack the in-engine granular access controls necessary for autonomous agents, leaving developers to write burdensome manual scaffolding, ad-hoc guardrails, and bespoke security software.
To resolve these tensions, Google Cloud developed the Data Agent Platform. As Yannis Papakonstantinou explains, “if you are to remember, one thing about the data agent platform is this it enables developers to build agents that get secure, near 100% accurate text to SQL from the database and its integration ready via MCP that we will be talking more later.” The platform is organized into two primary layers:
1. **Configurable Agent Tools**: High-level modules, such as Query Data, that translate agent requests into valid, safe SQL. 2. **Context Infrastructure Layer**: An evaluation and engineering harness designed to hill-climb translation accuracy to 100% while stopping prompt injection and tenant-data leakage.
```mermaid flowchart LR accTitle: Data Agent Platform Architecture accDescr: High-level overview of Query Data combining schema ontologies, query blueprints, and value searches.
subgraph Inputs ["Natural Language Input"] Agent["Agent / End-User Request<br/>'How much did I spend yesterday?'"] end
subgraph DataAgentPlatform ["Data Agent Platform Layer"] QD["Query Data Tool<br/>(Gemini Engine)"] SO["Schema Ontologies<br/>(Structural Context)"] QB["Query Blueprints<br/>(Nuanced Interpretations)"] VS["Value Searches<br/>(Disambiguation)"] SO --> QD QB --> QD VS --> QD end
subgraph Execution ["Secure Execution"] PSV["Parameterized Secure Views<br/>(Row-Level Isolation)"] SQL["Deterministic Executable SQL"] QD --> PSV PSV --> SQL end
Agent --> QD ```
Query Data is the platform's initial production tool. When an agent receives an end-user inquiry like "how much money did I spend yesterday?", Query Data draws upon three contextual pillars:
- **Schema ontologies**: Semantic definitions describing tables, relationships, and business logic. - **Query blueprints**: Curated SQL patterns that map nuanced question fragments to domain-specific query designs. - **Value searches**: Live lookups that disambiguate names, entities, and values against actual database contents.
Using solely schema ontologies, Google Cloud took the number-one spot on global text-to-SQL benchmarks, with blueprints and value searches designed to push edge-case accuracy toward 100%.
For data isolation, the platform relies on Parameterized Secure Views. Instead of allowing generated SQL to hit tables like `user_charges` directly—where a malicious prompt could manipulate filters to inspect other users' balances—the generated query targets a virtual, parameterized view bound to the session's active credentials. This forms a deterministic security barrier at the engine level rather than relying on probabilistic LLM guardrails. Papakonstantinou noted that Hughes Network Systems successfully overhauled their customer service operations by combining this architecture with the Agent Development Kit (ADK), MCP Toolbox, and Query Data.
---
[28:46](https://www.youtube.com/watch?v=7awKinJhGPo&t=1726s) Unified Multimodal Execution and Open MCP Standards
Amit Ganesh returns to synthesize the unified AI-native database architecture, pointing out how multi-step agent requests execute without leaving the database layer. Consider a user asking: "Hey, show me a forecast of sales for all red shoes." Because "red shoes" is a qualitative category rather than a single database key, the platform executes a semantic vector search across catalog embeddings to identify every matching product. It extracts the associated primary keys, retrieves the respective historical time-series data for each product, and feeds those data points into the TimesFM forecasting model to project future demand.
This complex pipeline runs seamlessly within the platform. Database query processing operates efficiently on ARM processors, while model inference for vector transformations, Gemini language understanding, and TimesFM forecasts offloads dynamically to Cloud TPUs. The entire operational and analytical loop takes place across the PL/SQL and engine layers without manual data orchestration.
To prevent vendor lock-in and simplify integration, every feature across Google Cloud's AI-native databases and the Data Agent Platform is exposed through the Model Context Protocol (MCP). Amit Ganesh emphasizes that any pre-built agent tool Google ships is intentionally surfaced via open MCP endpoints, enabling developers to incorporate these database-backed agents directly into custom agent workflows, standard IDEs, and broader multi-agent ecosystems.
[31:04](https://www.youtube.com/watch?v=7awKinJhGPo&t=1864s) Google's Multifold MCP Strategy and Managed Infrastructure
Google Cloud's approach to the Model Context Protocol (MCP) centers on putting comprehensive system capabilities directly into the hands of AI agents. Amit Ganesh explains that Google’s strategy is three-pronged. First, Google provides fully managed MCP servers that activate resources across all of Google Cloud's Data Cloud. Second, Google champions the widely used open-source MCP Toolbox for Databases. Third, moving beyond individual tooling, Google collaborates directly with Anthropic on MCP steering committees to help evolve, govern, and advance the open protocol across the wider software industry.
```mermaid flowchart TD accTitle: Google Cloud MCP Architecture accDescr: Agents access Data Cloud services through managed MCP servers with Model Armor and governance controls.
subgraph Agents["Agent Ecosystem"] A["AI Agents<br>(Claude, Gemini CLI, Code)"] end
subgraph Managed["Managed MCP Control Plane"] M["Central Managed MCP Server<br>(Zero-Ops Discovery)"] MA["Model Armor<br>(Data Protection)"] GOV["Governance & Observability<br>(Visibility & Audit Controls)"] end
subgraph DataCloud["Google Cloud Data Cloud"] D1["Cloud SQL (PostgreSQL)"] D2["AlloyDB"] D3["Analytics & Storage Services"] end
A -->|"Connects to"| M M --- MA M --- GOV M -->|"Provisions / Queries / Vectors"| D1 M -->|"Provisions / Queries / Vectors"| D2 M -->|"Explores resources"| D3 ```
Google's managed MCP servers function as a "zero-ops" gateway for agents interacting with Google Cloud Platform (GCP). They simplify resource discovery, enforce strong data protection through Google's Model Armor, provide detailed observability, and furnish enterprise-grade governance. Because MCP exposes the entire operational surface of Google Cloud to autonomous agents, built-in governance controls—specifically visibility into which servers are activated and which actions are authorized—are essential for safely moving agentic projects into production. Virtually every service across Google Data Cloud—encompassing all database systems, analytics engines, and storage layers—is now accessible to agents via MCP. For systems like Cloud SQL for PostgreSQL or AlloyDB, agents can provision new instances, run SQL queries, perform vector similarity searches, and diagnose database performance by inspecting the slowest queries and uncovering underlying bottlenecks.
- Managed MCP servers require zero infrastructure operations: developers simply point an agent (such as Claude, Gemini CLI, or Code variants) to Google's central MCP server. - The open-source MCP Toolbox for Databases has officially reached its stable 1.0 milestone, reflecting massive global adoption. - The open-source project boasts over 14,000 GitHub stars and more than 100 contributors worldwide. - Over 40 distinct data sources are supported out of the box, including Google first-party cloud services, popular open-source platforms, and external systems such as Oracle and MongoDB. - Developers rely on the toolbox to bridge agents to databases securely while retaining the flexibility to inject their own custom business logic and domain data models.
---
[34:29](https://www.youtube.com/watch?v=7awKinJhGPo&t=2069s) Fireside Chat with David Soria Parra: Solving the $N \times M$ Problem
Amit welcomes David Soria Parra, co-creator of MCP from Anthropic, for an on-stage fireside chat. Amit opens by thanking him for creating an open protocol that is empowering thousands of engineers at Google and across enterprise customer deployments to bind data sources to agentic systems. When Amit asks what primary dynamics have fueled MCP's explosive developer adoption, David highlights the industry's desperate need for an open connective tissue between enterprise backend infrastructure and frontier models.
David explains that enterprises do not want to constantly rebuild baseline applications like Claude or Gemini from scratch; rather, they want to connect their existing business workflows and data to these models without writing custom, one-off connectors for every system pair. David points out: “That's what's it's a classic $N \times M$ problem, and that's where a protocol like MCP comes in.” Because building and integrating MCP servers was deliberately designed to be lightweight, developers can rapidly link proprietary internal systems to top-tier models. Amit notes that this transition mirrors the data revolution fifty years ago when the invention of SQL standardized application development: “I do remember the time before MCP when you had to do one-off integration like $N \times M$ problem, and it feels like MCP kind of created a similar moment for connecting models with data and tools.”
---
[37:00](https://www.youtube.com/watch?v=7awKinJhGPo&t=2220s) Deep Database AI Operators vs. Surface-Level AI Wrappers
Amit steers the conversation toward architecture, contrasting Google Cloud's strategy of building native AI engines—embedding vector search, hybrid search, and hardware-accelerated TPU operators directly into the database engine—against platforms that treat AI as a superficial API wrapper layered on top of legacy data stores. David strongly endorses deep engine integration, explaining that while foundation models excel at evaluating and filtering data once it is retrieved, generating that initial, high-quality slice of context from massive datasets is the true bottleneck.
Human engineers historically interacted with databases by painstakingly tuning and crafting SQL to return a single, precise result set. In contrast, autonomous agents operate far more effectively when retrieving broader candidate pools across hybrid search mechanisms (blending semantic vector distance with classic keyword matching) and then reasoning through those results themselves. David points out that relational databases adapted to new paradigms in the past by introducing specialized internal indexes:
> “When we started with geospatial data, we added GiST indexes to the databases. And later when we had a document, we added document-to-specific data things to the databases. And so in a way, I think this is similar in that having these native tools directly in databases will just enable a new set of capabilities in agents to go and select the right things that they need to do to get to work through the tasks that they've been given.”
David reinforces that agents inherently thrive on data: “They churn through data and they're very, very good at that part, but getting that connectivity part is the key part.” Equipping databases with first-class vector search and TPU operators gives agents the precise retrieval primitives they need to run complex workflows without human intervention.
---
[39:28](https://www.youtube.com/watch?v=7awKinJhGPo&t=2368s) Enterprise Security, AlloyDB at Anthropic, and the MCP Roadmap
Amit asks how the integration of Google Cloud databases and open MCP specifications directly serves production enterprise customers. David shares that Anthropic is not just a standards collaborator but an active customer: Anthropic itself runs on Google Cloud's AlloyDB. By exposing enterprise databases through an open protocol, developers can ground agent workflows in scalable data stores while preserving critical operational protections:
> “In addition, if you really build these things in an open way, you still get on the database side like deep integration into enterprise-grade security items and other parts that you like.”
Using an open protocol allows organizations to mix and match LLM frameworks without losing the stability, horizontal scale, and security optimizations designed by Google's database engineers. Amit observes that deploying agents requires a delicate equilibrium: “It almost feels like a balance of power between giving the most tools to the agents while still having guardrails or security guardrails so that they can thrive, but only within the bounds of what they're allowed to.” David agrees, emphasizing that guardrails are paramount because enterprise organizations care deeply about the integrity of the data moving through automated pipelines.
Looking ahead through 2026 and beyond, David highlights major protocol initiatives on the MCP roadmap: - **Skills Distribution:** Enabling MCP servers to expose domain-specific knowledge and procedural logic as reusable "skills" directly to visiting agents. - **Long-Running Tasks:** Protocol enhancements that manage asynchronous, long-duration tasks to unlock deeper, more reliable autonomous agent workflows. - **Enterprise Hardening:** Refining enterprise readiness across compliance, auditing, identity, and transport layers.
David concludes by celebrating the open collaboration driving MCP forward: “What I'm really most excited about... is I think MCP is one of these rare open source communities where the industry comes together across Google, across Anthropic, across other of our competitors, and they work together on a common standard in a very, hopefully good way to elevate the overarching ecosystem for everyone.” Amit thanks David for his pioneering contributions and closes the fireside session to warm audience applause.
[42:48](https://www.youtube.com/watch?v=7awKinJhGPo&t=2568s) Pre-Built Data Agents Across the Enterprise
Following David Soria Parra's walkthrough of the Model Context Protocol, Amit Ganesh returns to the stage to explore how Google Cloud applies these foundational technologies internally to deliver ready-to-use, out-of-the-box agents. While AI-native databases and custom agent-building platforms give developers unprecedented flexibility, combining them with turnkey agent solutions unlocks an even broader spectrum of organizational value. Amit emphasizes that Google has assembled a comprehensive agent suite tailored for every persona interacting with enterprise data, bridging technical and non-technical disciplines alike.
This suite is organized around three primary user tiers: builders, operators, and business consumers. Builders receive onboarding and architecture agents to help determine optimal database selection and schema design. Database administrators and reliability operators benefit from agents capable of diagnosing operational bottlenecks, such as isolating the root causes of slow-running queries. At the business layer, the agents democratize access for non-technical users, ranging from corporate financial analysts seeking real-time transactional metrics to frontline factory shop-floor workers investigating equipment maintenance logs and defect patterns.
As Amit Ganesh explains when setting up the vision for these turnkey capabilities: > “We have talked about AI native databases, but when you combine them with pre-built data agents and tools, they become even more powerful.”
```mermaid flowchart TD accTitle: Google Cloud Pre-Built Data Agent Suite accDescr: Three-tier architecture of Google Cloud data agents spanning builders, operators, and business users.
subgraph Builders["Builders & Developers"] B1["Data Agent Kit & MCP Toolbox"] B2["AI Studio Vibe Coding (Firestore & Cloud SQL)"] end
subgraph Operators["Database Operators"] O1["Observability Agent (Gemini & Database Center)"] O2["Database Testing Agent (Pre/Post Change Impact)"] end
subgraph Business["Business Users & Frontline"] U1["Conversational Analytics Agent"] U2["Parameterized Secure Views"] end
Builders --> Operators --> Business ```
---
[44:08](https://www.youtube.com/watch?v=7awKinJhGPo&t=2648s) Developer Kits, AI Studio Integration, and Operator Agents
Amit details the specific agent offerings launched across developer tooling and database administration. Leading the developer-facing announcements is the Data Agent Kit, an ecosystem-centric developer package that bundles curated agent skills, Model Context Protocol servers such as MCP Toolbox, and specialized extensions built specifically for Data Cloud. In parallel, Google has integrated native database connectivity directly into its flagship AI Studio "vibe coding" environment. Developers can already link apps directly to Firestore as the underlying persistent datastore within AI Studio, with native support for Cloud SQL for PostgreSQL arriving shortly.
For database administrators and platform reliability teams, Google introduced dedicated operational agents designed to eliminate manual toil. The Database Observability Agent automates monitoring by continuously ingesting telemetry across massive cloud database estates and distilling the data into targeted remediations. To support enterprise change management workflows, Google also introduced the Database Testing Agent, which evaluates the exact performance impact of schema, application, or configuration changes before they hit production.
Key concrete capabilities in this release include: - **Data Agent Kit:** Bundles pre-built skills, extensions, and MCP servers (including MCP Toolbox) tailored for Data Cloud workflows. - **AI Studio Database Native Support:** Live support for Firestore with forthcoming integration for Cloud SQL for PostgreSQL. - **Database Observability Agent:** Powered by Gemini, this tool integrates with Database Center to monitor entire multi-database cloud estates in real time. As Amit Ganesh notes: “Powered by Gemini, it transforms millions of complex data points into clear, actionable insights.” - **Database Testing Agent:** Automatically benches pre-update versus post-update environments, generating performance differential summaries for proposed database and application configuration updates.
---
[45:49](https://www.youtube.com/watch?v=7awKinJhGPo&t=2749s) Conversational Analytics for Operational Databases
Shifting focus from backend operators to end users, Amit highlights the Conversational Analytics Agent, launched two weeks prior to the event. Designed to eliminate the lag inherent in traditional data warehousing and dashboard creation, the agent establishes a direct conversational interface on top of live operational databases. A user simply navigates to the Google Cloud Console, points the agent at an operational data store, and begins conversing in natural language.
Crucially, this access is governed by the parameterized secure views previously detailed by Yannis Papakonstantinou, ensuring that data guardrails, tenant isolation, and enterprise security policies remain uncompromised regardless of who issues the prompt. This architecture allows workers without SQL proficiency—such as assembly line technicians troubleshooting machine reliability against historical repair records—to conduct sophisticated queries safely. Amit points to EchoStar, where their AMR team has deployed the Conversational Analytics Agent into production environments to extract immediate operational insights from live enterprise data.
Describing the user experience of querying live operational data through natural language, Amit Ganesh observes: > “I personally find working with conversational analytics agent a magical experience.”
---
[47:08](https://www.youtube.com/watch?v=7awKinJhGPo&t=2828s) The Agentic Data Cloud Vision and Next Steps
Amit concludes the presentation by tying together the three core pillars that define Google's Agentic Data Cloud strategy: 1. **AI-Native Databases:** Storage engines natively engineered with integrated, state-of-the-art AI primitives. 2. **Data Agent Platform:** Comprehensive, standardized toolsets and protocols—such as natural language data interfaces and MCP integration—allowing developers to construct robust custom agents. 3. **Pre-Built Agent Suite:** Turnkey, role-tailored agents ready for deployment across developer, operator, and business workflows.
To assist organizations in operationalizing these technologies, Amit directs attendees to follow-up deep-dive sessions, including an interactive discussion group hosted by Yannis Papakonstantinou later that afternoon at 2:45 PM. He also highlights two enterprise transition offerings: the Database Migration and Modernization (RAMP) program, which provides expert-guided architectural support for upgrading legacy data estates, and specialized Data Strategy Workshops focused on turning session concepts into executable enterprise plans.
Reflecting on the historical significance of the pivot toward agent-driven data architectures, Amit Ganesh delivers a final assessment of the industry's trajectory: > “The transition from day of databases, from being just a place where you store data to AI native systems that power the future of agentic era is a shift that we'll see once in a generation.”
Before stepping off, Amit encourages attendees to submit their session feedback via the Google Cloud Next mobile app and expresses his excitement for continuing partnerships as enterprises advance from basic data storage into autonomous, intelligent agentic systems.
## Notable quotes > [09:24](https://www.youtube.com/watch?v=7awKinJhGPo&t=564s) An AI native database doesn't just store data, it natively processes and understands the data using built in AI primitives. — Yannis Papakonstantinou
> [01:43](https://www.youtube.com/watch?v=7awKinJhGPo&t=103s) For the first time in the 50 plus year history of databases, we are at a truly inflection point. — Amit Ganesh
## Mentioned Amit Ganesh, Yannis Papakonstantinou, David Soria Parra, Google, Google Cloud, Anthropic, AWS, Target.com, Hughes Network Systems, EchoStar, AlloyDB, AlloyDB Omni, Spanner, Cloud SQL, Firestore, PostgreSQL, Oracle, MongoDB, Gemini, TimesFM, Model Context Protocol (MCP), MCP Toolbox, ScaNN, HNSW, BM25, Agent Development Kit (ADK), Data Agent Kit, Google Cloud TPUs, BIRD benchmark, Google Cloud Next 2026
## Video description AI-native databases are essential for powering agents with enterprise data. Learn how they enable highly relevant context, automate operations, and manage risk. In this session, we’ll examine AI-powered search, natural language interfaces, multimodal queries, and graph retrieval-augmented generation (RAG). These move beyond simple retrieval, providing agents with high-fidelity, interconnected context. Discover how open standards like Model Context Protocol (MCP) and agentic IDEs streamline workflows for rapid, reliable deployment of agents.
Watch more Google Cloud Next 2026 Sessions → https://goo.gle/gcloud-next-2026 Subscribe to Google Cloud Tech → https://goo.gle/GoogleCloudTech
Speakers: Amit Ganesh, Yannis Papakonstantinou, David Soria Parra
BRK2-021 #GoogleCloudNext
[Source](https://www.youtube.com/watch?v=7awKinJhGPo)