Google Embeds AI Models in AlloyDB to Run Agents Directly on Data

Power intelligent agents with AI-native databases — Google Cloud Tech

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)

Reading summary

Google Cloud's data leadership argues that enterprise autonomous agents require an "Agentic Data Cloud" that brings AI models directly to operational databases rather than extracting stale data to external models. Built across AI-native storage engines, context platforms, and standard protocols like Anthropic's Model Context Protocol (MCP), this architecture aims to deliver high-accuracy text-to-SQL translation, hybrid retrieval, and automated governance. Inverting the Legacy Data-to-AI Pipeline (1:43) Amit Ganesh contends that traditional enterprise architectures hobble autonomous agents because disconnected warehouses and operational databases act as walled gardens. Moving data out of operational systems to external AI models introduces latency, runs agents on stale snapshots, and strips essential domain context. Google's strategy inverts this paradigm by moving model inference directly into database engines, uniting operational storage, analytical scale, and Google Cloud TPUs into what Ganesh calls a real-time "system of action for agents, not just a system of insights." Embedding Hybrid Retrieval and Foundation Models in SQL (9:24) Yannis Papakonstantinou explains that AI-native engines eliminate the need to synchronize separate operational stores, vector databases, and analytics systems. In AlloyDB, Google embedded its ScaNN index—scaling to over 10 billion vectors—alongside accelerated HNSW and BM25 full-text ranking, uniting vector distance and keyword search into a single SQL user-defined function. Developers use natural language AI functions in SQL to invoke models like Gemini to rerank 1,000 to 2,000 retrieved candidate rows using real-world context, while TimesFM generates time-series forecasts in seconds without pipeline extraction. Papakonstantinou reports that Target.com migrated its entire production search traffic to AlloyDB, securing a 20% gain in search relevance over external vector databases. In Spanner, a virtual graph model layers directly onto existing relational tables, enabling GraphRAG traversals over live data without ETL pipelines. Bridging Natural Language and Deterministic Execution (21:23) Production agents require near-perfect text-to-SQL accuracy and rigorous security boundaries that probabilistic model prompts cannot guarantee alone. The Data Agent Platform addresses this via its Query Data tool, which achieved first place on the industry-standard BIRD benchmark by combining schema ontologies, query blueprints, and live value searches. To protect multi-tenant environments from prompt injection and data leaks, the platform routes generated queries through Parameterized Secure Views bound to session credentials, enforcing deterministic row-level access controls at the database engine level. Standardizing Agent-to-Data Connectivity via Open MCP (31:04) Connecting diverse enterprise systems to frontier models creates a costly N×M integration bottleneck. In a fireside discussion, Anthropic's David Soria Parra observes that the Model Context Protocol (MCP) acts as an open standard for tool and data integration, mirroring how SQL standardized database queries fifty years ago. Soria Parra notes that Anthropic itself runs on AlloyDB and supports deep database operators because models excel at analyzing broad candidate pools once the database handles heavy hybrid retrieval. Google supports this standard via managed zero-ops MCP servers guarded by Model Armor, as well as the open-source MCP Toolbox for Databases, which supports over 40 data sources and reached version 1.0 with 14,000 GitHub stars. Turnkey Agents for Builders, Operators, and Analysts (42:48) To operationalize these technologies, Google introduced pre-built agents categorized by enterprise role. Builders access the Data Agent Kit and direct database bindings in AI Studio, which currently supports Firestore and is adding Cloud SQL for PostgreSQL. Database operators receive Gemini-powered Observability Agents linked to Database Center and Testing Agents that measure performance differentials before schema or configuration changes deploy. Business users can query live operational data without writing SQL using the Conversational Analytics Agent, which protects data boundaries through parameterized views and is already in production at EchoStar's AMR team. Google Cloud and Anthropic present native database AI primitives and open MCP standards as a foundational shift from static data stores to active agent platforms. However, reaching enterprise-wide deployment depends on completing ongoing MCP governance roadmaps—including standardized skill distribution, support for long-running asynchronous tasks, and hardening identity and transport layers across multi-cloud environments.

Source quotes

[9:24] Yannis Papakonstantinou: An AI native database doesn't just store data, it natively processes and understands the data using built in AI primitives. [1:43] Amit Ganesh: For the first time in the 50 plus year history of databases, we are at a truly inflection point.

Original transcript

[0:12] Good afternoon and everyone. [0:15] To harness the incredible power of AI, [0:19] we all want to build high value agentic workflows [0:23] and experiences that work with our enterprise data. [0:27] But to do that, we need the best agentic data platform [0:32] to earn the trust of our users. [0:35] We need our agents to be highly accurate [0:38] and also comply with the stringent privacy, security, [0:43] and governance needs of our enterprise. [0:46] Today in this session, we'll give you exactly that. [0:50] I'm Amit Ganesh and I'm joined here with me today, [0:55] yannis papaconstantinou, my colleague at Oracle at Google [0:59] and from Anthropic David Soria, the creator of the model context [1:03] protocol. [1:05] In this session, we will start with our strategy with data [1:08] and AI in the agentic era. [1:10] Then yannis will join us to dive into how [1:14] AI native databases are key to giving agents their superpowers. [1:19] From there, we will jump into how [1:21] you can leverage our data agent platform [1:24] to build your own agents. [1:26] We'll then do a fireside chat with David. [1:30] And then finally, we'll wrap up by talking [1:32] about our pre-built data agents from Google that you can use out [1:37] of the box. [1:39] We have so much exciting content to cover. [1:41] Let's get going. [1:43] We are in a truly transformative era for data and AI. [1:48] For the first time in the 50 plus year history of databases, [1:54] we are at a truly inflection point. [1:58] The power of AI is transforming what databases can do. [2:03] And customers are racing to take advantage of AI. [2:07] They are integrating agents with enterprise data [2:12] to Create Autonomous agentic systems that [2:16] is going to transform every aspect of their business. [2:21] However, legacy data architectures of today [2:25] pose a big challenge in the adoption [2:27] of agents in the enterprise. [2:30] These systems are walled gardens of disconnected warehouses [2:35] and siloed operational databases. [2:38] This makes it hard for agents to be [2:40] able to seamlessly access data from all the different sources. [2:46] Even if agents have access to the data, agents need context. [2:52] They need the semantic knowledge that [2:55] helps give them the meaning of the data in the database, [2:59] enabling them to be accurate and effective. [3:03] Now, to use AI today, you have to move your data to AI. [3:09] This creates a lag. [3:11] Your agents are no longer working with the real time [3:14] state of your business. [3:16] Additionally, doing manual integration increases [3:20] cost and gives an additional time before you can actually [3:24] bring those agents to life. [3:27] What if instead you could move AI to data [3:32] and break down those walls. [3:36] At Google, we are doing exactly that. [3:39] Our strategy is to have our world class AI and data [3:44] teams working together in the same company that have uniquely [3:48] combined our State of the art AI stack with our industry leading [3:54] data stack to create the best agentic data platform, one that [4:01] integrates AI at every layer of the stack. [4:05] For example, compute is no longer [4:07] on just arm or Intel processors. [4:09] We bring in TPUs when you're doing inference as part [4:13] of your database workload. [4:15] We bring in models into SQL and we are bringing data agents [4:20] into the agentic layer. [4:23] We are introducing a whole new category for the next decade, [4:28] and we are calling it the agentic Data Cloud. [4:31] This is a system of action for agents, [4:34] not just a system of insights. [4:37] It is AI native with the vertically integrated data [4:41] and AI stack. [4:43] It is flexible. [4:45] It embraces open standards. [4:47] You can use open source products like Postgres. [4:50] You can run it anywhere. [4:52] You can bring your own data, or you could even [4:55] bring your own model and plug it into agentic Data Cloud. [5:00] Most importantly, however, it is trusted. [5:04] Being grounded in enterprise's semantic knowledge as context [5:09] gets you the highest quality. [5:12] And the agentic data platform comes [5:14] with strict guardrails that force your agents to operate [5:21] within the strict privacy, security, [5:24] and governance standards needed by your enterprise. [5:29] There are three key pillars of agentic Data Cloud [5:33] that are crucial for you to leverage [5:36] to help power your agents. [5:38] Let's go into those first. [5:41] Our AI native databases have state of the art AI models [5:45] and capabilities built into the database for agents to utilize. [5:50] These include multiple models of data, not just structured data. [5:54] You could have images. [5:55] You could have video converted into embeddings. [5:58] You could have numeric data coming through time series, [6:01] for example. [6:02] Or you could have data that is stored and represented [6:05] as graph models. [6:06] In addition to multiple modalities of data [6:09] and the AI models for them being built into the database, [6:14] we are also including multiple modalities of accessing [6:18] and operating on that data. [6:20] So, for example, if you're working [6:22] with time series in the database now, [6:25] you can do forecasting and anomaly detection [6:27] on that time series. [6:28] If you're working with vectors and embeddings, [6:32] you can do vector search. [6:34] And most importantly, all these different accesses [6:38] and modalities of working with multi-modal data [6:41] are available on a single unified platform in SQL. [6:45] To give you one example of it in close partnership [6:49] with Google research. [6:50] We have introduced the times FM foundational [6:55] model similar to the large language model. [6:58] This model has been pre-trained on time series, [7:01] and it's a state of the art model [7:03] that can make what used to take minutes or hours, days, [7:09] or even months to do things like forecasting. [7:13] Now you can literally do them in seconds using agents. [7:18] The second big pillar is that of the data agent platform. [7:23] Here we offer tools and frameworks [7:25] to create agents that have at their disposal [7:28] the trusted knowledge catalog. [7:31] Think of this as the nerve center, which [7:33] contains your enterprise's context that agents [7:36] use to operate with data. [7:39] And it also includes a comprehensive suite of MCP tools [7:44] and a state of the art natural language interface to data. [7:49] I'm really pleased to see our partnership with Anthropic wear. [7:54] Google, together with other companies such as Anthropic [7:57] and AWS, are helping set the standard of the model context [8:03] protocol and evolve the standard going forward. [8:06] Additionally, Google also offers MCP toolbox and open source [8:12] product, where we invite community contribution to build [8:16] and further use and adoption of MCP. [8:20] In addition to State of the art AI built into our AI native [8:24] databases and our data agent platform, [8:28] we also offer a suite of pre-built agents [8:31] for every aspect of the database for builders, [8:35] for operators of databases, as well as for business users [8:39] through conversational analytics. [8:42] Now, when it comes to conversational analytics [8:45] x agents need natural language as the language of interaction. [8:53] So I am really thrilled to share that Google holds the number one [8:57] spot in the industry standard bird benchmark leaderboard [9:01] for natural language to SQL through our conversational [9:05] analytics agent and platform. [9:08] We are enabling high quality conversational experiences [9:12] for users as well. [9:14] I'm excited to welcome yannis to join me [9:18] on stage to dive through those pillars, [9:21] starting with the AI native database. [9:24] Thank you Amit. [9:28] An AI native database doesn't just store data, [9:33] it natively processes and understands [9:36] the data using built in AI primitives. [9:40] Thus, your agents can issue SQL queries [9:45] that search over the combination of your structured data. [9:50] Text, data, images, and videos and get high quality results [9:57] by combining SQL with. [9:59] The power of foundation models. [10:02] And it's not only search. [10:03] As Amit told you, using AI functions such as forecast [10:09] and a few more that we will talk later. [10:11] You can predict time series and do and bring [10:15] the power of Gemini app to your data. [10:20] AlloyDB is an AI native database. [10:25] Purpose built for the agentic era. [10:28] We have taken 100% PostgresSQL compatibility and added to it [10:36] Google's advanced innovations. [10:38] The result is a true powerhouse, a single destination that [10:44] serves as your relational store, your high performance vector [10:49] store, and an analytics engine that's 100 times faster [10:55] than standard Postgres. [10:58] Another game changer of AlloyDB is the AlloyDB Omni. [11:03] It gives you the freedom to take the same Cloud grade power [11:10] and run it anywhere on premise, on any Cloud, [11:15] or even on your local laptop. [11:19] AlloyDB provides a powerful AI Search layer [11:25] that combines SQL, classic text search, graph search, [11:32] and the power of foundation models [11:36] through vector search and AI functions. [11:39] Why do you need this combination. [11:42] Because today, keyword search is not [11:47] enough to meet end user demands. [11:51] For example, when your customer looks for some research, [11:57] the top results you see on the screen [12:00] may not even have the keyword summer, [12:05] but they nevertheless capture the customer's intent, [12:10] such as clothing materials like linen and cotton. [12:16] Today, the search experience has to be holistic and understand [12:22] the user intent. [12:24] And how does AlloyDB achieve this. [12:28] Step one. [12:30] Industry leading vector search AlloyDB. [12:35] Differentiated since 2024. [12:38] For over open source Postgres by not just providing plain [12:46] PD vector support, but also bringing to AlloyDB Google's [12:51] proprietary scan index, the one that [12:55] is behind Google Search, YouTube, [12:59] and many other properties. [13:02] This provided all the wonderful performance gains [13:06] that you see on this slide, and we have more [13:10] coming at this next. [13:13] First, we have support for 10 billion plus vectors with scan. [13:20] Second, we are boosting PD vector w [13:25] with AlloyDB columnar engine technology [13:29] to provide up to four times faster vector [13:32] search over standard PD vector without you having [13:38] to make any changes over your Apigee vector [13:42] has w configuration. [13:45] At this point, you may ask, why do we [13:47] perfect not just one, but two types of indices scan and w. [13:55] Because AlloyDB is goal is to provide you [13:59] the best in class vector search experience for your use case. [14:05] And stay tuned. [14:06] We are on a path to making the index type just [14:10] an implementation detail. [14:14] Now you often need more than just vector search. [14:19] You need hybrid search. [14:21] AlloyDB acts as a unified backend, [14:25] giving you hybrid search, which means combination of vector [14:30] search with full text search Among the many features that [14:36] are coming up, I'd like to highlight the state of the art [14:41] BM25 ranking that gives you high quality text search results [14:48] and in turn, high quality hybrid search [14:53] results in the query example. [14:55] Here we see the new hybrid search [14:59] UF that combines results from AlloyDB vector [15:04] search and AlloyDB text search directly into SQL, SQL. [15:13] And AlloyDB did not stop on hybrid search. [15:16] It also brings you powerful AI functions [15:20] to complement your AI Search journey. [15:25] AI functions bring to your data and your searches [15:30] the nuanced understanding and world knowledge of Gemini. [15:36] Let me give a concrete example. [15:38] What if on your retail site, your customer [15:43] searches for comfortable shirts for a summer in Santorini. [15:49] Your database likely does not know where Santorini is [15:54] or what the weather will be like in Santorini, [15:57] but I functions have this knowledge through Gemini [16:03] and AlloyDB brings you this power directly into its SQL. [16:10] A common pattern that we see is hybrid search gives you [16:18] the first top 1,000 2000 result candidates [16:23] for your customer's question, and then you rerank these [16:28] candidates based on. [16:31] In our examples case, they're fit for a Santorini summer [16:36] using the I function. [16:39] The best part is about the ease of use [16:43] you can program I functions using natural language [16:48] as shown in the example. [16:50] AlloyDB also has a non-gm faster version [16:54] of the rank function powered by Google Cloud's leading [17:00] semantic ranker. [17:03] And this is just one example. [17:06] We have more generally available LLM based AI functions today [17:11] that can be used for search AI. [17:15] For filtering, I generate to create interesting annotations [17:21] and explanations that personalize [17:23] the results to your users. [17:26] And as I said, rank and I functions [17:35] are not only for cells. [17:37] I told you about the powerful forecast function, [17:42] which uses Google's times FM and can make predictions [17:47] about the future based on historic operational data [17:52] that you have in your database. [17:55] New this year analyze sentiment I function and summarize I [18:01] function. [18:03] We also have optimized AI functions [18:06] beginning with support for AI. [18:08] If this provides superior performance and about 1,000 [18:13] times cost reduction over the default baseline LLM calls, [18:20] this enables you to use AI at scale. [18:28] What is the business impact of these innovations. [18:31] I'm going to use target.com as an example. [18:34] Target.com was looking to enhance their online search [18:38] experience. [18:39] They used AlloyDB and the scan index to optimize searches, [18:44] including dynamic SQL filters on complex data types. [18:51] They reported enhancing the relevance of their customer [18:56] searches by 20% By bringing this workload to AlloyDB [19:02] and using the functionalities that we saw. [19:05] They also got top performance for the filtered search queries, [19:09] far exceeding anything that could be achieved by integrating [19:14] manually a relational database with a purpose built vector [19:18] search engine. [19:19] As a result, target.com moved their entire search traffic [19:24] to AlloyDB. [19:26] We believe that target.com is ahead of the curve. [19:31] Many organizations are still treating holistic search, [19:36] which includes structured data vectors, text [19:39] search as an application level problem for their search teams. [19:45] We think, however, that as people [19:47] see the results and business outcomes that [19:50] come by combining different modalities right [19:55] in the database, they will quickly [19:57] follow target.com example. [20:02] Second I native database Spanner. [20:06] It's building on its global scale and multi-modal abilities [20:11] for mission critical AI. [20:15] It is excelling on the fifth component of AI Search graphs. [20:21] Graphs capture the relationships among the entities [20:25] in your database and graph search. [20:29] You may have heard of it as GraphRAG [20:32] in the context of genetic programming, [20:35] the search pattern wear hybrid search [20:38] is coupled with graph search ability [20:40] to get results based on their relationships. [20:44] At this point, you may worry, but I have my data in SQL. [20:49] Do I need to create a graph copy. [20:51] No you don't. [20:52] The graph model is virtual and layered [20:55] layered over your SQL model. [20:58] So in conclusion, we saw how Google Cloud AI native databases [21:04] AlloyDB and Spanner enable a unified approach where [21:08] SQL queries understand logic, language, and relationships. [21:13] By combining these AI primitives, the. [21:17] Net effect. [21:18] These queries can feed your agents [21:20] the most accurate and relevant information. [21:23] So now let's switch to the second pillar, the data agent [21:27] platform. [21:30] The second pillar of how AI native databases [21:33] can give your agents the most accurate and secure and relevant [21:38] data. [21:39] So far, we have been talking about SQL queries [21:42] with powerful AI primitives, but nevertheless SQL queries. [21:47] And as Amit said, natural language [21:51] is the new protocol for human to agent and agent to agent [21:56] communication. [21:58] And here is the 10 Mile High problem. [22:00] Your database still speaks SQL and will continue speaking [22:05] SQL for many good reasons. [22:08] And here is the 10 Mile High solution. [22:11] The data agent platform combines data [22:15] Plus Gen AI to bridge the gap between natural language [22:21] and SQL. [22:22] This allows you to unlock accurate, real time, [22:27] authentic experiences with your data. [22:30] When we go, however, below the 10 [22:33] Mile High point the promise of generative AI classes [22:40] with the unforgiving nature of production ready database [22:47] applications. [22:48] This creates a massive gap between a simple demo [22:52] and a reliable, production ready application. [22:57] Bridging a natural language requests to SQL [23:01] faces multiple challenges. [23:03] The accuracy gap. [23:06] Many database applications need near 100% accuracy. [23:11] The security gap we see lack of in-database granular access [23:18] control role, forcing developers to either limit [23:23] the scope of their agents and/or to build custom security layers [23:32] from the ground up. [23:34] And that adds to the general manual scaffolding burden, [23:39] and we must help you to focus on valuable application features, [23:46] rather than creating scaffolding and guardrails and security [23:51] guardrails so that if you are to remember, [23:56] one thing about the data agent platform [23:59] is this it enables developers to build agents that get secure, [24:07] near 100% accurate text to SQL from the database [24:13] and its integration ready via MCP [24:16] that we will be talking more later. [24:22] The data agent platform consists of two layers. [24:25] First, a set of configurable tools [24:28] that provide to your agents secure and accurate text to SQL. [24:32] And second, an infrastructure layer [24:36] that helps you Hill climb to 100% accuracy [24:41] and ensures that attackers do not get access to other end [24:46] user's private data. [24:50] The oops wrong way. [24:55] Query data is the first tool that we released. [25:01] Here you see it in action. [25:04] The end user, or likely the agent [25:07] asks how much money did I spend yesterday. [25:10] And on the other end comes the SQL query [25:12] that does exactly this query. [25:15] Data uses Gemini and your unique database context [25:20] to help you reach 100. [25:22] To help you reach near 100% accuracy. [25:26] How does it enable you to reach that high level of accuracy. [25:31] Its unique ingredient is that it combines [25:34] three types of context schema ontologies [25:38] that describe the schema. [25:41] Query blueprints that allow you to inject [25:45] your own nuanced interpretation for particular questions [25:49] and particular question Fragments, [25:52] and finally, value searches that allow [25:56] you to disambiguate the question against the full data [26:01] of your database. [26:03] Look in our blog and stay tuned for our upcoming [26:07] white papers and code labs for more. [26:11] As Amit so earlier, I am thrilled [26:17] to announce that we have been occupying the top one [26:22] spot on text to SQL benchmark, and this is using only. [26:30] This benchmark is using only the schema ontologies. [26:35] As I told you, we can do all the way to 100% [26:39] by also using query blueprints and value searches. [26:45] Now, the data agent platform remember it is accurate, secure, [26:54] and the infrastructure helps you engineer and evaluate context [27:00] on your journey to a 100% accuracy. [27:05] And it is also integration ready as I will discuss cars later, [27:13] I would like to spend a little time [27:15] on the parameterized secure views. [27:18] The feature behind security. [27:21] This is a deterministic security guardrail. [27:26] Going back to my question, notice [27:29] that the question the SQL query did not refer to the table user [27:36] charges because a smart attacker could manipulate the query [27:42] to get to other users' data. [27:44] Rather, it used a parameterized secure view. [27:50] This is deterministic security guardrail [27:54] because the view provides to the agent only the current end [28:01] user's data. [28:03] It is a virtual view, so it is very efficient as well. [28:07] So please go ahead. [28:09] Use query data to power your authentic applications. [28:12] There are many details that I see the clock running out [28:16] and I'm not going to describe, but I have a recommendation. [28:21] Two hours from now, Hughes network systems [28:25] will be describing how they overhauled their customer [28:31] support operations by data agents that combine ADK, [28:38] MCP toolbox, and query data. [28:41] And I'm giving back to Amit for more on MCP. [28:46] Thank you very much. [28:51] The full tool of AI native databases and the data agents. [28:56] Maybe there's one quick thing I would [28:58] like to just remind us again. [29:00] That really tickles me when I see [29:02] this, which is you what he showed [29:04] you is you can write a single query, [29:06] or even better because natural language is [29:09] the language of agents. [29:10] Maybe you can ask a natural language question [29:13] to the conversational data platform and ask the questions [29:16] like, hey, show me a forecast of sales for all red shoes. [29:22] Now, this is a tricky question because red shoes [29:26] isn't something in the database because there [29:28] are many types of red shoes. [29:29] So what it does is it will do a vector search on red shoes [29:35] to find the appropriate rows that are similarity matched [29:39] with red, the phrase red shoes. [29:42] Once it gets those rows and identifies those keys, [29:46] then it will fetch the time series corresponding [29:49] to each of those products. [29:51] Feed those time series into the time CFM forecasting model [29:57] and actually give you a projection. [30:00] Notice that you're getting so many layers of AI integration [30:05] completely out of the box using our agentic Data Cloud you're [30:09] getting an agent at the agentic layer, [30:12] you have models, the forecasting model [30:14] and the natural language Gemini model integrated into the PL/SQL [30:19] layer. [30:20] And in fact, this query will run both on an arm chip [30:24] for most of the database work, as well as the inference work [30:28] for those AI agents will actually invoke TPUs. [30:31] So just imagine that your database application [30:33] is leveraging the full power of Google Cloud's integrated AI [30:38] platform. [30:39] With that probably heard me mention a couple of times [30:42] how we have taken the effort to ensure that virtually [30:47] every capability that you saw earlier in AI [30:50] native databases and our data agent platform [30:52] is activated using MCP. [30:54] So even if you get an agent from us, we go to extra lengths [30:58] to ensure that it's exposed and surfaced [31:00] via MCP so that when you build your own agents, [31:04] your agents have the full superpowers that we have created [31:08] at their fingertips. [31:12] Now, our strategy at Google has been multifold around MCP. [31:17] First, we have fully managed MCP servers [31:22] that activate all of Data Cloud resources from. [31:27] And I'll go into that in a little bit more detail in a bit. [31:30] The second is I mentioned this earlier. [31:33] We have a very popular open source [31:35] project called MCP toolbox. [31:38] And third, beyond tools, we are heavily [31:40] involved in the steering committees for MCP, [31:43] together with Anthropic, to help evolve and advance the MCP [31:48] protocol itself for the whole industry. [31:52] Our managed MCP servers are 0 ops ways [31:56] for agents to use GCP resources. [31:59] They simplify discovery. [32:02] They provide enhanced data protection through Model Armor. [32:06] They provide observability and most importantly, they [32:10] enable governance in your enterprise. [32:13] Because MCP opens agents to the entire surface of Google Cloud, [32:18] our strong built in governance capabilities [32:21] in Cloud around controls and visibility [32:24] of which MCP servers have been activated, [32:26] is invaluable in deploying agents into production. [32:31] Now, we have taken a very comprehensive approach [32:35] towards MCP. [32:36] Virtually every service in Data Cloud, [32:40] which includes every service in databases, virtually [32:43] every service in analytics and in storage. [32:46] All these services are now available through MCP [32:50] to your agents. [32:51] For example, the Postgres database in Cloud SQL [32:54] is available through MCP. [32:56] AlloyDB is available through MCP, [32:58] and when I say available you can provision the database is [33:03] you can execute SQL against the database, [33:05] you can execute vector search against the database [33:08] and you can do observability. [33:09] You can ask the database questions about hey, [33:12] what are my slowest queries and why are they slow. [33:14] You can do this all using your favorite agents, [33:17] be it Cloud core, Gemini CLI or Code or any of these variants. [33:23] And most importantly, all of this is 0 ops. [33:27] You simply take your agent, point it [33:29] to our central MCP server, and it goes on from there. [33:34] In exploring and accessing your Cloud resources, [33:39] the open source MCP toolbox for databases [33:41] is now available as a stable 1.0 version, reflecting [33:45] the broad adoption of MCP toolbox. [33:48] With 14,000 GitHub stars and more than 100 contributors from [33:54] around the world, the toolbox supports over 40 data sources, [33:59] both first party data sources from Google, [34:02] open source and third party products, [34:04] as well as popular databases such as Oracle and MongoDB. [34:09] What developers really love about our open source toolbox [34:13] is its ability to bridge AI agents and databases securely, [34:18] while providing the ability for users to customize and extend [34:23] MCP to include their own business logic and business data [34:26] models. [34:29] With that, it is my distinct honor [34:32] to host a fireside chat with David Soria from Anthropic, [34:37] the co-creator of MCP. [34:39] Please give him a hand. [34:47] David it is. [34:48] It is really great to have you here. [34:50] Now, before we get started, I want to first thank you [34:53] for your pioneering work in creating MCP, something [34:57] that is enabling blink. [34:58] Thousands of us Google as well as our enterprise customers, [35:03] making use of data and other tools [35:05] together with their agents. [35:09] So, David, let's get started with a few questions. [35:13] MCP has become really popular amongst developers [35:16] for building agentic applications. [35:18] What were the primary factors contributing [35:21] to its growing adoption. [35:24] Yeah, I think it's a good question in my mind. [35:27] At the time, the ecosystem and still now the ecosystem [35:30] is in a need for having a connective layer between the AI [35:36] applications or the frontier models and the data [35:39] and the systems that power the enterprises. [35:41] Because at the end of the day, people [35:43] do not want to rebuild the Gemini application [35:45] or Cloud over and over again, but instead take their data [35:49] and their workflows to these systems. [35:52] And they want to build these integrations, not 10 times. [35:54] They want them build them once. [35:55] That's what's it's a classic end times end problem. [35:59] And that's where a protocol like MCP comes in. [36:01] And so in many ways, as we're seeing more and more companies [36:05] going through AI transformation, you [36:07] see an increased need for this kind of connectivity. [36:10] And so that's why MCP is still growing. [36:12] Secondly, I think we have built MCP in a way [36:15] that it makes it fairly easy in my mind, to build MCP servers, [36:21] to integrate them. [36:22] And so it's a very easy thing for people [36:25] to go and take their company systems [36:28] and connect them to the frontier models using something like MCP. [36:32] That resonates with us really well because we [36:36] are in the data world. [36:37] And as in the data world, about 50 years ago, the SQL language [36:41] was invented. [36:42] And that really transformed the way people build applications. [36:45] And I do remember the time before MCP [36:49] when you had to do one off integration like n by m problem, [36:52] and it feels like MCP kind of created [36:55] a similar moment for connecting models with data and tools. [37:00] Now, David, we have spent a lot of time [37:02] today talking about Google Cloud databases, strategy around AI [37:06] native databases, and how building [37:08] vector search, hybrid search, these really cool AI [37:12] operators that invoke TPUs. [37:14] We have done a lot of that integration in here, [37:19] versus a strategy where simply AI is simply [37:22] like a wrapper around data. [37:24] We'd love to get your thoughts on how you see this as different [37:29] compared to other ways of doing the integration. [37:32] Yeah, I think when you think about what agents really want, [37:35] like agents, agents are really, really good [37:37] or models are really good at selecting data or from an input. [37:43] But getting to that first layer of input [37:45] is actually really difficult. And so having something [37:48] built into a database that supports [37:51] like the complicated things that are vector search [37:54] and keyword search, and combining these in hybrid ways. [37:58] And having these additional I operators really [38:01] helps people to give agents already [38:04] like the toolset for them to go and search what they need to do, [38:08] and then do the final selection. [38:10] That's, I think, different from how we have done traditionally [38:12] as humans, databases where we were carefully [38:15] crafting SQL over and over for that one perfect query. [38:20] But agents are really good at selecting vaster, [38:23] bigger amounts of data and then searching through them [38:26] by themselves and giving them the tools [38:27] and giving them these indexes that are again, [38:30] complicated to build at to their fingertips, [38:33] I think is a really good way to work through, [38:37] like sifting through company data [38:39] as people need in many ways. [38:41] When we started with geospatial data, [38:44] we added, gist indexes to the databases. [38:48] And later when we had a document, [38:50] we added document to specific data things to the databases. [38:54] And so in a way, I think this is similar in that having [38:58] these native tools directly in databases [39:00] will just enable a new set of capabilities in agents [39:04] to go and select the right things that they need [39:06] to do to get to work through the tasks that they've been given. [39:10] Since agents are there for the service of users, [39:14] if we can make agents have more superpowers, [39:17] I guess we all benefit more from them. [39:19] And they thrive from in data. [39:20] That's what they want. [39:21] They churn through data and they're very, very good [39:23] at that part. [39:24] But getting that connectivity part is the key part. [39:27] That's right. [39:27] OK great. [39:28] Fantastic how do you think the integration of Google Cloud [39:30] databases and MCP benefits our customers. [39:34] When you really think about, some of the Google [39:39] databases their power some of the biggest businesses [39:42] in the world. [39:42] And so, we are at Anthropic use AlloyDB for example, [39:47] and having this being available to us in an open protocol [39:53] that we can then use to connect it and ground [39:56] our workflows in the data that we [39:59] have at these database systems. [40:02] I think is really helping a great deal of us as a customers [40:05] and others, of course, as well, to then go ahead and build [40:09] interesting things with that. [40:10] In addition, if you really build these things in an open, [40:14] in an open way, you still get on the database side, [40:18] like deep integration into enterprise grade security items [40:23] and other parts that you like. [40:25] And that's why you use something like an AlloyDB [40:27] or a similar patterns. [40:29] And so I think it's just enables people [40:33] to mix and match with what the systems on the other side [40:36] that they require, but still don't lose the power. [40:39] Why they came to your platform in the first place. [40:41] Which is, having large scale databases that [40:44] are just going to run. [40:45] Then, of course, in addition, you [40:47] have some of the smartest engineers in the database [40:49] business working. [40:52] At Google and having them come up [40:54] with new innovative ideas like security aspects for the SQL [40:59] queries, I think helps a great deal [41:01] to move to help people build more secure agentic systems. [41:05] I really liked, I think, what you mentioned [41:07] about the security, it almost feels [41:09] like a balance of power between giving the most [41:12] tools to the agents while still having guardrails or security [41:17] guardrails so that they can thrive, [41:19] but only within the bounds of what they're allowed to. [41:22] Absolutely and these guardrails are [41:23] like getting increasingly important there, [41:26] because enterprises do deeply care about the data that's [41:29] flowing through the systems. [41:30] We do indeed. [41:31] Looking ahead to the rest of 26 and beyond, [41:34] what are some of the most exciting things in the future [41:37] of MCP and agentic AI for MCP. [41:39] I think there's a lot of really cool things [41:41] that are coming down the line, both on the roadmap. [41:43] And one of the big things that I think [41:44] will enable another layer of capabilities [41:47] is we're going to make it possible to serve skills [41:51] over MCP servers so that people that offer MCP servers [41:55] can also offer domain specific knowledge for MCP servers [41:59] in the form of skills. [42:01] In addition, we're going to work on Long running tasks, which [42:04] is super interesting to really enable more agentic behavior. [42:07] And then really lastly, we're working and really [42:11] making MCP a bit more ready for all aspects in enterprises. [42:15] But what I'm really most excited about, [42:17] and I think you alluded a little bit to that, [42:19] is I think MCP is one of these rare open source [42:21] communities where the industry comes together [42:26] across Google, across Anthropic, across other of our competitors, [42:32] and they work together on a common standard [42:35] in a very, hopefully good way to elevate [42:39] the overarching ecosystem for everyone. [42:42] Indeed that is incredible. [42:44] Thank you very much, David. [42:46] It was so great to have you here for the fireside chat. [42:48] And again, thank you for all your contributions in MCP. [42:56] Now you heard about how we have native databases [42:59] and how we have a data agent platform for you [43:02] to build these agents. [43:03] Now, you may be wondering if Google [43:05] has been utilizing these tools to build our own agents out [43:09] of the box for you, and let's go through that next. [43:12] We have talked about AI native databases, [43:16] but when you combine them with pre-built data agents and tools, [43:22] they become even more powerful. [43:23] So I'm thrilled to share that we have built a comprehensive suite [43:27] of agents for you to use, and that spans every single role [43:33] connected with data. [43:34] It's the builders who, for example, get a tool [43:37] like onboarding to decide which database to use, [43:40] how to architect your system. [43:41] It is operators of databases, you [43:44] may have to troubleshoot a slow running query, [43:46] for example, all the way to business users. [43:49] That includes folks' business analysts, [43:52] who would love to get access to real time data [43:55] all the way to maybe a factory shop floor worker who [43:59] wants to look through maintenance records [44:01] and do some analysis on the defects [44:03] that they're seeing with some machines. [44:06] So let's quickly dive into it. [44:08] First, we have recently launched this week [44:11] and announced the data Agent Kit. [44:13] It's an ecosystem led developer experience that [44:17] includes agent skills that David mentioned, [44:21] MCP servers like MCP toolbox, as well as [44:24] extensions created specifically for Data Cloud. [44:28] That's a great way for you to start with this package [44:31] and get started. [44:33] We are also taking our flagship AI Studio vibe coding platform [44:38] and building in its support for databases natively. [44:41] Today we have already launched Firestore [44:44] as an underlying database for you [44:46] to build apps using AI Studio. [44:48] And stay tuned for Cloud SQL for Postgres support coming soon. [44:54] We have a database observability agent [44:57] that automates heavy lifting of database management. [45:01] Powered by Gemini, it transforms millions of complex data points [45:05] into clear, actionable insights. [45:08] We have extended that to include database center as well, [45:12] so that you can get real time insights [45:15] on your entire database. [45:16] Estate on Cloud. [45:20] We know change management is really important to you. [45:23] To help with that, we are introducing a database testing [45:28] agent that automatically tests performance impact of changes [45:32] that you may make to your database. [45:34] They could be application changes. [45:36] They could be configuration changes. [45:38] And this testing agent summarize the differences [45:41] of performance between your pre-update configuration [45:46] and your post-update configuration. [45:49] Now, in addition to the agents for builders and agents [45:53] for operators, I'm thrilled to share that two weeks back we [45:57] launched our conversational analytics agent. [46:02] I personally find working with conversational analytics agent [46:06] a magical experience. [46:08] I simply go to the Cloud Console, go to the place [46:11] where you have the agents, have the agent, [46:14] point to one of my operational database [46:16] and start conversing with it. [46:19] You can have a lot of fun doing it, [46:21] but most importantly, this is unlocking [46:24] access to real time operational databases [46:28] to all your business analysts, to all your business users. [46:31] I said, even someone working on an assembly line [46:35] can now securely using parameterized secure views [46:40] that Janice spoke about. [46:42] Query using the conversational data agent [46:45] questions they have about maintenance records [46:47] or do other useful agentic workflows. [46:52] Here's a great example of AMR from EchoStar, [46:55] who has already taken the conversational analytics [46:58] agent deployed in production and seeing compelling advantages [47:03] from using it in production. [47:08] As we reach the conclusion of this session, [47:10] I want to recap how we are enabling [47:12] you to create these trusted, high value agents to transform [47:16] every aspect of your business. [47:18] With the three pillars we spoke about in agentic Data Cloud [47:22] the AI native databases where we have [47:25] brought state of the art AI seamlessly integrated [47:28] into your data. [47:30] Our data agent platform with the most comprehensive and highest [47:34] quality tools for agents, including natural language [47:39] interface to data, and our suite of powerful, pre-built agents [47:44] that you can deploy at all your users directly today. [47:50] I invite you to continue your journey with a few deep dive [47:52] sessions that are coming up. [47:54] Yannis mentioned the session that he has at 2:45, [47:57] which is a discussion group, and there are a number of additional [48:00] sessions. [48:01] You can take a picture and try to go [48:02] to a few of these, where you will be [48:04] able to continue your journey. [48:06] Learning more about Data Cloud. [48:11] These are two offers I wanted to quickly highlight [48:13] that I think are worth noting. [48:15] Worth noting. [48:16] There's the ramp program. [48:19] This offer enables you to migrate and modernize your data [48:22] estate with expert led support and the data strategy workshop, [48:27] where you can take what you learned today in this session, [48:30] to the next step of planning and acting on it in your enterprise. [48:34] Price I want to sincerely thank you for your time today. [48:39] The transition from day of databases, from being just a [48:43] place where you store data to AI native systems that [48:46] power the future of agentic era is a shift that we'll see once [48:51] in a generation. [48:52] And I can't wait to see how you are [48:55] going to take what we shared with you today, [48:58] and lead the charge in leveraging [49:00] AI in your own enterprise. [49:03] Your insights are invaluable to us, [49:05] so please take a moment to share your feedback [49:08] through the mobile app. [49:09] We're just getting started on our journey of turning data [49:13] into Autonomous intelligent systems, [49:16] and I look forward to our continued partnership [49:18] and having you as a customer leveraging AI [49:22] as you take a step to the next generation of agentic systems.