Cloud Blog

Cross-cloud conversational analytics made simple with open standards

Tue, 13 Oct 2026 16:00:00 +0000

The reality for most organizations is that data lives everywhere. As engineering teams expand and adopt specialized platforms for their workloads, enterprise data naturally disperses across multiple clouds and operational systems. When analytical and AI initiatives require context from across the entire organization,these teams traditionally face a difficult trade-off: build complex extraction pipelines to copy data into a central repository or accept fragmented reporting.

Traditional architectures address this fragmentation with scheduled extraction pipelines that copy remote datasets into a central staging warehouse. This approach creates synchronization lag, adds recurring storage costs, and triggers variable network egress fees. When schemas change upstream, pipelines break, and teams spend hours reconciling metrics across out-of-sync dashboards.

BigQuery and Google Cloud’s borderless Lakehouse offer a streamlined way to solve this challenge with a foundation based on the open Apache Iceberg REST catalog specification. Rather than moving data to the compute engine, you can bring Google Cloud compute and generative AI directly to your data, querying it in place across Databricks, Snowflake, and AWS Glue.

In this post, we walk through how to configure Databricks Unity Catalog for federation into BigQuery (AWS Glue and Snowflake set up in appendix), run a single query joining data across all three external catalogs, and use conversational analytics in BigQuery to explore the consolidated data with natural language.

Figure 1: BigQuery federates metadata across external Apache Iceberg REST catalogs through Lakehouse, enabling in-place conversational analytics without data migration.

The borderless lakehouse architecture

This solution uses Lakehouse runtime catalog to synchronize metadata from other cloud providers, allowing you to query data with BigQuery or external open source engines through the Apache Iceberg REST catalog endpoint, all without migrating the data. Because Databricks Unity Catalog, Snowflake Horizon Catalog, and AWS Glue Data Catalog support the open Apache Iceberg REST catalog specification, you can apply a consistent connection pattern across all three platforms.

When you run a federated query, Lakehouse runtime catalog separates metadata synchronization from storage access:

Metadata synchronization: Lakehouse runtime catalog periodically syncs schemas, snapshot pointers, and table definitions from the remote catalog based on a refresh schedule you define.
Direct storage access: During query runtime, a compatible engine reads Parquet data files directly from remote object storage, such as Amazon S3, using temporary credentials issued by the remote platform.

All query processing runs within Google cloud compute such as BigQuery or Managed Service for Apache Spark. Remote Databricks clusters, Snowflake virtual warehouses, and AWS compute instances are not invoked during execution.

Authentication follows an explicit three-step deployment pattern: create the federated catalog in Google Cloud, inspect its configuration to retrieve its automatically generated service account, and grant access permissions within the remote platform.

You can use AI to generate sample data. The schema details for tables are provided below.

Configure Databricks Unity Catalog

We begin in Databricks by preparing the catalog and table. In Unity Catalog, federated access requires that your target schema be associated with an external location registered in Databricks:

code_block: <ListValue: [StructValue([('code', "-- Run inside Databricks SQL workspace\r\nCREATE CATALOG IF NOT EXISTS dbx_retail_db;\r\n\r\n-- Declare the managed target location at the schema level\r\nCREATE SCHEMA IF NOT EXISTS dbx_retail_db.dbx_core \r\n MANAGED LOCATION 's3://my-databricks-bucket/retail/data/';\r\n\r\n-- Create the Iceberg dimension table\r\nCREATE TABLE IF NOT EXISTS dbx_retail_db.dbx_core.dim_products (\r\n product_key INT,\r\n product_id STRING,\r\n product_name STRING,\r\n category STRING,\r\n subcategory STRING,\r\n brand STRING,\r\n price DOUBLE,\r\n cost DOUBLE\r\n)\r\nUSING iceberg;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31d430d0>)])]>

You can use AI to generate sample data. The schema details for tables are provided in each section.

Before external engines can read this table, a Databricks metastore administrator must enable External data access on the metastore details tab.

Go to Databricks Admin account and under User Management, create a Databricks Service Principal and make a note of its UUID "6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx"

Connect Databricks to BigQuery

Next, create the federated catalog inside Google Cloud using the gcloud command-line tool. You will need your Databricks workspace URL and the application ID of your Databricks service principal:

code_block: <ListValue: [StructValue([('code', 'export GCP_PROJECT_ID="my-lakehouse-project"\r\nexport GCP_REGION="us-central1"\r\n\r\ngcloud alpha biglake iceberg catalogs create dbx_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --primary-location="$GCP_REGION" \\\r\n --catalog-type="federated" \\\r\n --federated-catalog-type="unity" \\\r\n --unity-instance-name="dbc-xxxxxxxx-xxxx.cloud.databricks.com" \\\r\n --unity-catalog-name="dbx_retail_db" \\\r\n --unity-service-principal-application-id="6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx" \\\r\n --refresh-interval="300s"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31406810>)])]>

Once created, describe the catalog to view its assigned service account:

code_block: <ListValue: [StructValue([('code', 'gcloud alpha biglake iceberg catalogs describe dbx_retail_db \\\r\n --project="$GCP_PROJECT_ID"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30fcf510>)])]>

Return to Databricks to assign permissions to your service principal:

code_block: <ListValue: [StructValue([('code', '-- Grant catalog traversal permission\r\nGRANT USE CATALOG ON CATALOG dbx_retail_db \r\n TO `6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx`;\r\n\r\n-- Grant schema and read permissions\r\nGRANT USE SCHEMA,EXTERNAL USE SCHEMA, SELECT ON SCHEMA dbx_retail_db.dbx_core \r\n TO `6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx`;'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33ffc3d0>)])]>

You must grant the EXTERNAL USE SCHEMA privilege to the Databricks Service Principal on the target schemas or catalog to enable credential vending for external data access.

Finally, to complete the connection, configure the federation policy on the Databricks service principal with the following details -

Issuer URL* - https://accounts.google.com
Subject* - numeric subject ID returned by the catalog describe command eg 1124251400450xxxxxxxx
Audiences - https://accounts.cloud.databricks.com

Run one query across three clouds

Federated Iceberg tables are addressed in BigQuery using four-part paths: project.catalog.namespace.table.

In our environment, sales transactions reside natively in BigQuery:

code_block: <ListValue: [StructValue([('code', 'CREATE SCHEMA IF NOT EXISTS local_retail_dataset\r\nOPTIONS(location="us-central1");\r\n\r\nCREATE OR REPLACE TABLE `my-lakehouse-project.local_retail_dataset.fact_sales` (\r\n sale_id STRING,\r\n sale_date DATE,\r\n customer_key INT64,\r\n product_key INT64,\r\n store_key INT64,\r\n quantity INT64,\r\n unit_price NUMERIC,\r\n discount NUMERIC,\r\n total_revenue NUMERIC,\r\n total_cost NUMERIC,\r\n margin NUMERIC\r\n)\r\nPARTITION BY sale_date\r\nCLUSTER BY store_key, product_key;'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33fffd10>)])]>

We can now run a single SQL query joining our native sales transactions with customer records in Snowflake, product lines in Databricks, and store locations in AWS Glue:

code_block: <ListValue: [StructValue([('code', "SELECT \r\n c.first_name || ' ' || c.last_name AS customer_name, -- From Snowflake Iceberg\r\n p.product_name, -- From Databricks Iceberg\r\n s.store_name, -- From AWS S3 Iceberg\r\n SUM(f.quantity) AS total_units_sold, -- From BigQuery native fact\r\n SUM(f.total_revenue) AS total_sales_revenue -- From BigQuery native fact\r\nFROM `my-lakehouse-project.local_retail_dataset.fact_sales` f\r\nINNER JOIN `my-lakehouse-project.sf_retail_db.CORE.DIM_CUSTOMERS` c \r\n ON f.customer_key = c.customer_key\r\nINNER JOIN `my-lakehouse-project.dbx_retail_db.dbx_core.dim_products` p \r\n ON f.product_key = p.product_key\r\nINNER JOIN `my-lakehouse-project.glue_retail_db.glue_retail_db.dim_stores` s \r\n ON f.store_key = s.store_key\r\nGROUP BY 1, 2, 3\r\nORDER BY total_sales_revenue DESC\r\nLIMIT 10;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c47010>)])]>

BigQuery processes the joins in place. Notice that Snowflake identifiers appear in uppercase (CORE.DIM_CUSTOMERS), while Databricks and AWS Glue maintain lowercase table paths.

Figure 2 - Query results combining data across Snowflake, Databricks, and AWS Glue.

Explore cross-cloud data with natural language

Because federated Iceberg tables behave like native tables within BigQuery, downstream analytical features inherit access directly. You can point conversational analytics in BigQuery at these federated schemas to let team members explore cross-cloud data using natural language prompts.

To give conversational analytics full operational context, we save our federated join as a logical view:

code_block: <ListValue: [StructValue([('code', "CREATE OR REPLACE VIEW `my-lakehouse-project.local_retail_dataset.v_omnichannel_sales_pulse` AS\r\nSELECT \r\n f.sale_id,\r\n f.sale_date,\r\n c.first_name || ' ' || c.last_name AS customer_name,\r\n c.country AS customer_country,\r\n p.product_name,\r\n p.category AS product_category,\r\n p.brand AS product_brand,\r\n s.store_name,\r\n s.city AS store_city,\r\n s.region AS store_region,\r\n f.quantity,\r\n f.total_revenue,\r\n f.margin\r\nFROM `my-lakehouse-project.local_retail_dataset.fact_sales` f\r\nINNER JOIN `my-lakehouse-project.sf_retail_db.CORE.DIM_CUSTOMERS` c \r\n ON f.customer_key = c.customer_key\r\nINNER JOIN `my-lakehouse-project.dbx_retail_db.dbx_core.dim_products` p \r\n ON f.product_key = p.product_key\r\nINNER JOIN `my-lakehouse-project.glue_retail_db.glue_retail_db.dim_stores` s \r\n ON f.store_key = s.store_key;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c46110>)])]>

Analyze sales performance in natural language

When you ask conversational analytics in BigQuery:

"Who are our top customers by total sales revenue, what products did they buy, and which stores did they shop at?"

Conversational analytics evaluates the schema across all three remote catalogs, generates the SQL statement, executes the query, and presents the response.

Figure 3: Conversational analytics in BigQuery translates plain-language prompts into federated queries across Snowflake, Databricks, and AWS Glue.

Plan for caching and data residency

Before deploying federated catalogs in production, consider these operational behaviors:

Background refresh timing: The --refresh-interval flag controls metadata synchronization. The minimum interval is 300 seconds. For larger catalogs containing hundreds of tables, metadata retrieval can take longer. If a sync cycle overruns, BigQuery skips the next scheduled run to avoid task queuing.
Automatic query caching: BigQuery caches retrieved cross-cloud data blocks in the region where your federated catalog resides (e.g. us-central1). This helps reduce network transfer on repeated queries. Because cached blocks reside within Google Cloud storage in that region, confirm that this aligns with your organization's data residency policies.
Encryption controls: Cross-cloud cache blocks use Google-managed encryption keys. If your organization enforces the constraints/gcp.restrictNonCmekServices policy constraint, BigQuery bypasses the cache and reads directly from remote storage for every query.
Monitoring access metrics: You can evaluate cache utilization in your query execution plans. Check the objectStorageStats section in BigQuery job statistics to compare cacheBytesRead against objectStorageBytesRead.

Next steps

In summary, Google Cloud’s borderless Lakehouse helps you activate your data regardless of where it lives without costly migrations or building additional data pipelines. Get started today by reviewing the borderless Lakehouse architecture documentation to learn more about supported regions and credential configurations. You can work through the borderless Lakehouse codelab to practice federating external catalogs step-by-step. Finally, connect with your Google Cloud account team or customer engineer to evaluate borderless lakehouse patterns for your specific data platforms or industries.

Appendix

Setting up Snowflake and AWS Glue cross cloud data access

Connect Snowflake and Big Query

Configure Snowflake Horizon Catalog

We begin in Snowflake by creating the database, schema, and Iceberg table. In Snowflake Horizon, managed Iceberg tables expose an open Apache Iceberg REST catalog interface automatically:

code_block: <ListValue: [StructValue([('code', "-- Run inside Snowflake SQL worksheet\r\nCREATE DATABASE IF NOT EXISTS sf_retail_db;\r\nCREATE SCHEMA IF NOT EXISTS sf_retail_db.core;\r\n\r\n-- Create the Iceberg dimension table\r\nCREATE OR REPLACE ICEBERG TABLE sf_retail_db.core.dim_customers (\r\n customer_key INTEGER,\r\n customer_id VARCHAR,\r\n first_name VARCHAR,\r\n last_name VARCHAR,\r\n email VARCHAR,\r\n gender VARCHAR,\r\n country VARCHAR,\r\n signup_date DATE\r\n\r\n)\r\nCATALOG = 'SNOWFLAKE'\r\nEXTERNAL_VOLUME = 'SNOWFLAKE_MANAGED';"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c477d0>)])]>

Before external engines can read this catalog, configure a dedicated reader role and grant traversal permissions across the database, schema, and table.

SQL

code_block: <ListValue: [StructValue([('code', '-- Create a dedicated reader role\r\nCREATE ROLE IF NOT EXISTS gcp_lakehouse_reader_role;\r\n\r\n-- Grant database and schema traversal permissions\r\nGRANT USAGE ON DATABASE sf_retail_db TO ROLE gcp_lakehouse_reader_role;\r\nGRANT USAGE ON SCHEMA sf_retail_db.core TO ROLE gcp_lakehouse_reader_role;\r\n\r\n-- Grant read access on the target table\r\nGRANT SELECT ON TABLE sf_retail_db.core.dim_customers TO ROLE gcp_lakehouse_reader_role;'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c44150>)])]>

Next, create the federated catalog inside Google Cloud using the gcloud command-line tool. You will need your Snowflake account identifier, the reader role, and the root Iceberg database name:

bash

code_block: <ListValue: [StructValue([('code', 'export GCP_PROJECT_ID="my-lakehouse-project"\r\nexport GCP_REGION="us-central1"\r\n\r\ngcloud alpha biglake iceberg catalogs create sf_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --primary-location="$GCP_REGION" \\\r\n --catalog-type="federated" \\\r\n --federated-catalog-type="snowflake" \\\r\n --snowflake-account-identifier="xy12345-ab67890" \\\r\n --snowflake-warehouse="SF_RETAIL_DB" \\\r\n --snowflake-role="gcp_lakehouse_reader_role" \\\r\n --refresh-interval="300s"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33fff010>)])]>

In the Apache Iceberg REST specification, --snowflake-warehouse references the catalog root database name (SF_RETAIL_DB), not a virtual compute warehouse.

Once created, describe the catalog to view its assigned numeric service account ID:

bash

code_block: <ListValue: [StructValue([('code', 'gcloud alpha biglake iceberg catalogs describe sf_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --format=\'value(biglake-service-account-id)\''), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c47e50>)])]>

Return to Snowflake to bind Google Cloud's numeric identity to a passwordless service user via Workload Identity Federation (WIF):

SQL

code_block: <ListValue: [StructValue([('code', "-- Run inside Snowflake SQL worksheet\r\nUSE ROLE ACCOUNTADMIN;\r\n\r\n-- Bind Google Cloud's numeric identity to a passwordless service user\r\nCREATE OR REPLACE USER snowflake_service_user\r\n TYPE = SERVICE\r\n WORKLOAD_IDENTITY = (\r\n TYPE = GCP\r\n SUBJECT = '102669xxxxxxxxxxxxxxxxx' -- Numeric subject ID returned by gcloud describe\r\n )\r\n DEFAULT_ROLE = gcp_lakehouse_reader_role\r\n COMMENT = 'Service user for Lakehouse catalog federation over WIF';\r\n\r\n-- Grant the reader role to this service user\r\nGRANT ROLE gcp_lakehouse_reader_role TO USER snowflake_service_user;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c46fd0>)])]>

This establishes passwordless authentication over OpenID Connect, allowing BigQuery to discover table metadata and vend temporary query-time credentials directly from Snowflake Horizon.

Configure AWS Glue Data Catalog

We begin in AWS by preparing the IAM identity, establishing access permissions across AWS Glue and Amazon S3, and registering the Iceberg table.

First, create a placeholder trust policy named trust_policy.json. This allows you to provision the AWS IAM role before Google Cloud assigns the unique catalog service agent:

code_block: <ListValue: [StructValue([('code', '{\r\n "Version": "2012-10-17",\r\n "Statement": [\r\n {\r\n "Effect": "Allow",\r\n "Principal": {\r\n "Federated": "accounts.google.com"\r\n },\r\n "Action": "sts:AssumeRoleWithWebIdentity",\r\n "Condition": {\r\n "StringEquals": {\r\n "accounts.google.com:aud": ["PLACEHOLDER_VALUE"],\r\n "accounts.google.com:sub": ["PLACEHOLDER_VALUE"]\r\n }\r\n }\r\n }\r\n ]\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c44a50>)])]>

Create the IAM role using the AWS CLI. Setting a 12-hour session duration (43200 seconds) prevents credential expiration during long-running analytical queries:

code_block: <ListValue: [StructValue([('code', 'export AWS_ROLE_NAME="lakehouse_glue_federation_role"\r\n\r\naws iam create-role \\\r\n --role-name "$AWS_ROLE_NAME" \\\r\n --assume-role-policy-document file://trust_policy.json \\\r\n --max-session-duration 43200'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c44190>)])]>

Next, define the permissions policy in a file named permissions_policy.json. This policy grants BigQuery permission to read the AWS Glue catalog metadata and access the underlying Parquet data files in Amazon S3:

code_block: <ListValue: [StructValue([('code', '{\r\n "Version": "2012-10-17",\r\n "Statement": [\r\n {\r\n "Sid": "GlueCatalogRead",\r\n "Effect": "Allow",\r\n "Action": [\r\n "glue:GetCatalog",\r\n "glue:GetDatabase",\r\n "glue:GetDatabases",\r\n "glue:GetTable",\r\n "glue:GetTables"\r\n ],\r\n "Resource": "arn:aws:glue:us-east-2:123456789012:*"\r\n },\r\n {\r\n "Sid": "S3BucketAndObjectRead",\r\n "Effect": "Allow",\r\n "Action": [\r\n "s3:ListBucket",\r\n "s3:GetObject"\r\n ],\r\n "Resource": [\r\n "arn:aws:s3:::my-glue-iceberg-bucket",\r\n "arn:aws:s3:::my-glue-iceberg-bucket/*"\r\n ]\r\n }\r\n ]\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c479d0>)])]>

Attach this permissions policy to your newly created role:

code_block: <ListValue: [StructValue([('code', 'aws iam put-role-policy \\\r\n --role-name "$AWS_ROLE_NAME" \\\r\n --policy-name "lakehouse_glue_federation_policy" \\\r\n --policy-document file://permissions_policy.json'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31c46a50>)])]>

Important (AWS Lake Formation): If your AWS environment uses AWS Lake Formation, verify that the IAMAllowedPrincipals group has access to the target database and table (or grant explicit Lake Formation permissions to lakehouse_glue_federation_role if the bucket is registered with AWS Lake Formation). Without this, Lake Formation security settings will block the IAM role from accessing catalog metadata.

With permissions in place, create the database and Iceberg table in AWS Glue using Amazon Athena:

code_block: <ListValue: [StructValue([('code', "-- Run inside Amazon Athena\r\nCREATE DATABASE IF NOT EXISTS glue_retail_db;\r\n\r\nCREATE TABLE IF NOT EXISTS glue_retail_db.dim_stores (\r\n store_key INT,\r\n store_id STRING,\r\n store_name STRING,\r\n city STRING,\r\n state STRING,\r\n region STRING,\r\n manager STRING,\r\n opened_date DATE\r\n\r\n)\r\nLOCATION 's3://my-glue-iceberg-bucket/retail/dim_stores/'\r\nTBLPROPERTIES (\r\n 'table_type'='ICEBERG', \r\n 'format'='parquet', \r\n 'write_compression'='zstd' \r\n\r\n);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33e20a10>)])]>

Connect AWS Glue to BigQuery

Next, register the federated catalog inside Google Cloud using the gcloud command-line tool. You will need your 12-digit AWS Account ID, AWS Region, and the role ARN created above:

code_block: <ListValue: [StructValue([('code', 'export GCP_PROJECT_ID="my-lakehouse-project"\r\nexport GCP_REGION="us-central1"\r\nexport AWS_REGION="us-east-2"\r\nexport AWS_ACCOUNT_ID="123456789012"\r\n\r\ngcloud alpha biglake iceberg catalogs create glue_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --primary-location="$GCP_REGION" \\\r\n --catalog-type="federated" \\\r\n --federated-catalog-type="glue" \\\r\n --glue-warehouse="$AWS_ACCOUNT_ID" \\\r\n --glue-aws-region="$AWS_REGION" \\\r\n --glue-aws-role-arn="arn:aws:iam::${AWS_ACCOUNT_ID}:role/lakehouse_glue_federation_role"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33e22a50>)])]>

To prevent premature background refresh failures while the AWS trust policy propagates, initialize the catalog without setting a refresh schedule.

Next, extract the unique numeric subject ID assigned to the catalog by Google Cloud:

code_block: <ListValue: [StructValue([('code', 'export LAKEHOUSE_SA_ID=$(gcloud alpha biglake iceberg catalogs describe glue_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --format="value(biglake-service-account-id)")\r\n\r\necho "Assigned Lakehouse Service Account ID: $LAKEHOUSE_SA_ID"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33e23090>)])]>

Return to the AWS CLI and update your IAM role's trust policy, replacing the placeholder with the verified Google Cloud identity:

code_block: <ListValue: [StructValue([('code', 'cat > trust_policy_final.json << EOF\r\n{\r\n "Version": "2012-10-17",\r\n "Statement": [\r\n {\r\n "Effect": "Allow",\r\n "Principal": {\r\n "Federated": "accounts.google.com"\r\n },\r\n "Action": "sts:AssumeRoleWithWebIdentity",\r\n "Condition": {\r\n "StringEquals": {\r\n "accounts.google.com:aud": [\r\n "$LAKEHOUSE_SA_ID"\r\n ],\r\n "accounts.google.com:sub": [\r\n "$LAKEHOUSE_SA_ID"\r\n ]\r\n }\r\n }\r\n }\r\n ]\r\n}\r\nEOF\r\n\r\naws iam update-assume-role-policy \\\r\n --role-name "$AWS_ROLE_NAME" \\\r\n --policy-document file://trust_policy_final.json'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33e206d0>)])]>

5. Enable metadata synchronization and verify

bash

code_block: <ListValue: [StructValue([('code', 'gcloud alpha biglake iceberg catalogs update glue_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --refresh-interval="300s"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33e20490>)])]>

Verify that the namespaces are discovered and synchronized:

bash

code_block: <ListValue: [StructValue([('code', '# Verify namespaces synchronized from AWS Glue\r\ngcloud alpha biglake iceberg namespaces list \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --catalog="glue_retail_db"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33e208d0>)])]>

Gemini 4 Argon available on Google Cloud, built to help solve your business’ hardest problems

Tue, 13 Oct 2026 16:00:00 +0000

Last week we announced that Gemini Enterprise has evolved to make it even simpler to get work done, and introduced the Gemini agent, your new universal agent for work. It's always on and ready to answer your questions. It will write code, complete longer and more complex tasks, or perform whatever you need to get the job done, all from a single prompt box. And model intelligence underpins it all.

To enable a new frontier of work, we are making our new frontier model, Gemini 4 Argon, available on Google Cloud.

We trained Argon to work with both depth and precision, which allows it to maintain context across long, multi-step tasks which are reinforced with strong domain expertise along the way. Whether your team is running complex software builds, handling detailed financial and legal work, or deploying cybersecurity tools like CodeMender, Argon helps your teams maintain focus from start to finish.

Customers and partners using Gemini 4 Argon

Four ways Argon changes how your business works

1. Hand off your hardest work

Your teams already use Gemini for business to answer questions and draft content. With Argon, they can hand off the deep, multi-step work that used to take hours or days, and get back finished work they can use.

Argon reads long documents that mix text, tables, charts and images, and turns them into one clear output grounded in those sources. It can pull findings from many sources into a single structured answer, analyze data over time, and write stronger legal, finance, and executive documents. On long tasks, it keeps going until the job is done. We trained Argon to respect system boundaries, report negative findings honestly, and pause for confirmation before taking irreversible steps, and it tells you when it couldn't find something or finish a task.

Customers who tested Argon tell us it excels at turning huge, unstructured inputs into cohesive outputs.

"As software development becomes more agentic, teams need models that can support long-running, multi-step work across all stages of the development lifecycle. Gemini 4 Argon is designed to help organizations bring AI into development, security, and operations while keeping it within established enterprise workflows and controls.” – Stuart Moncada, VP, GitLab.

2. Precise, verifiable results on the work that drives your business

In finance, legal, tax, and other regulated work, calculations and data extraction need to be precise, repeatable, and verifiable.

For financial quantitative work, Argon can help automate multi-step ledger reconciliations, spreadsheet formulas, and variance analyses. It delivers high calculation integrity, citation fidelity, and formula accuracy across quantitative models. The proof is in the numbers: Argon leads on the Vals Index, which measures economic impact across finance, coding, legal, and tax work.

In legal research, Argon can help legal teams review case law and regulatory filings to pull out verified citations and key precedents. It leads on domain-specific evaluations like Harvey's Legal Agent Benchmark for legal research and drafting, with strong citation fidelity and direct answers when helping teams evaluate complex legal precedents.

"Gemini 4 Argon shows how much progress Google has made on agentic legal reasoning. We saw substantial improvements over Gemini 3.1 Pro across our legal agent evaluations, particularly in corporate M&A, data privacy and cybersecurity, and EC/VC. Accuracy also held up on long-document analysis, an encouraging result for lawyers working through detailed transactional matters." – Niko Grupen, Head of Applied Research, Harvey.

“We collaborated with Google on NowAI-Bench to help shape Gemini 4 for key enterprise work. In early access, it delivered roughly 20% improved task success than Gemini 3.8 Flash, with standout gains in HR and customer service. On the ServiceNow AI Platform, our L1 Service Desk AI specialist brings Google’s most advanced intelligence, governed and secure, turning tasks into fully autonomous work.” - Nenshad Bardoliwalla, Senior Vice President, AI Products, ServiceNow.

3. Build and ship products faster

Argon is built to handle complex, multi-step projects from start to finish. Our customers consistently ask for intelligence that can break down goals, track progress, and update multiple files at the same time.

"Gemini 4 Argon handles complex tasks reliably, from 3D games to rich animations. In Figma Make, it helps teams turn their most ambitious, multi-step ideas into impressive prototypes.” – Loredana Crisan, Chief Design Officer, Figma.

To see how well Argon handles this, we put it to work on our own tools. The team behind our open-source Agent Development Kit (ADK) set out to reduce framework overhead and improve code performance while maintaining full compatibility with existing applications. Working autonomously overnight within automated testing guardrails, Argon surfaced optimizations, now live in google/adk-python, that cut in-memory session prep time by 40% in long sessions and speed up cold imports by 21%. To learn more, read the engineering deep dive here.

Across Google, engineering teams using Argon in Google Antigravity have increased agentic code submissions by more than 35% while cutting code rollbacks by nearly a third. The Chrome team used Argon to finish an architectural refactor across hundreds of files in Chromium's 40 million-line codebase, completing months of work in weeks. Argon's improvements in spatial reasoning, mathematical precision and visual coding also make it faster to go from idea to working prototype.

For more advanced algorithms, our code optimization and discovery agent AlphaEvolve uses Argon to deliver strong performance improvements across real-world enterprise workloads, including factory scheduling, logistics, game code speed-ups, and chip layout — as well as complex mathematical benchmarks, and more.

To learn how to best use Argon, check out the developer's guide.

4. Stronger defense for your code and business

While Argon has cyber mitigations that block offensive tasks such as pentesting and exploitation, you can still take full advantage of Argon’s defensive capabilities using CodeMender to find and fix vulnerabilities, or use Argon with your own security harness. It ties for first place on CWE-Bench v1 with a top score of 68% for remediating security vulnerabilities.

"We are integrating Gemini 4 Argon into MarketingX for automated codebase security audits. In our evaluations, the model successfully identified 100% of top-priority vulnerabilities with 0% fabricated vulnerabilities across verified claims. This precision unlocks proactive, code-level security for our customers before deployment.” - Yunus Emre, Chief AI Officer of AI Lab, HubX.

Security also means being able to trust Argon inside your own environment. Argon is our most resilient model yet against indirect prompt injections, where malicious instructions or context are used to hijack a model’s behavior. It leads the Gray Swan Indirect Prompt Injection benchmark, cutting attack success across 15 adaptive attempts to 0.7%. That matters when Argon reads email, documents and webpages that may contain hidden malicious instructions.

We are also releasing Argon without cyber guardrails to a select set of trusted defenders, which allows for testing a full breadth of cybersecurity capabilities. Trusted defenders are vetted through our Fairwind Program, a limited access initiative that provides government, critical infrastructure, and cybersecurity partners exclusive, unmitigated access to advanced models.

Enterprise customers and partners in our early access program are already seeing strong wins with Argon.

^{Leaders from Amplitude, Deloitte, and Rakuten share Gemini 4 Argon results}

Get started

Starting today, Gemini 4 Argon is available in Gemini for business on the web, desktop, and mobile. Enterprise developers and builders can access Argon via API in Gemini platform under model ID gemini-4-argon, in Google AI Studio, and in Google Antigravity.

Argon launches at an introductory rate of $2 per million input tokens and $10 per million output tokens through November 30, 2026, with cached input tokens priced at 95% off. After November 30, standard pricing of $4 per million input tokens and $20 per million output tokens will apply. Review the model card and developer guide for complete technical specifications, token limits, and migration instructions.

Cyber defenders can join us at Security Summit to learn how to use Gemini 4 Argon to defend against machine-speed threats and automate remediation.

One Agent Development Kit, five languages

Tue, 13 Oct 2026 12:22:00 +0000

When we talk about agents, that doesn't necessarily mean we're talking about Python. In today's modern ecosystem, an agent might run as a high-concurrency Go microservice on Cloud Run, or live inside a browser tab calling Chrome's on-device model. Yet many agent frameworks assume a Python-only stack. That assumption forces teams to either spin up a Python service just for their agent workloads, or to build agent orchestration logic from scratch in their own language.

Google's Agent Development Kit (ADK) removes that trade-off with coverage for Python, Go, TypeScript, Java, and Kotlin. Each version of the ADK is built from the ground up for its own runtime and type system, while sharing a unified architecture with interoperability through open protocols.

A shared foundation

Picking a language doesn't lock in your architecture: all five support the same open protocols. ADK includes a Model Context Protocol client in every language, so a custom tool exposed as an MCP server can be called from any of them immediately.

For multi-agent systems, ADK supports the Agent2Agent (A2A) protocol, allowing an agent to communicate with a remote agent over HTTP. Through A2A, agents written in different languages or frameworks are interoperable.

Starting agent-first

To get started, run the one-time setup command to check your Google Cloud authentication, install the CLI, and then set up first-party ADK skills in coding agents like Antigravity, Claude Code, or Codex:

code_block: <ListValue: [StructValue([('code', 'uvx google-agents-cli setup'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30d66b50>)])]>

Then, run the scaffold command to generate a working project with A2A endpoints and deployment config for Cloud Run, Gemini Enterprise Agent Runtime, or Google Kubernetes Engine (GKE):

code_block: <ListValue: [StructValue([('code', '# Scaffold an ADK project (use --agent adk for Python or --agent adk_go for Go)\r\nagents-cli scaffold create my-go-agent \\\r\n --agent adk_go \\\r\n --deployment-target cloud_run \\\r\n --region us-central1'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30d654d0>)])]>

Both the ADK for Python and ADK for Kotlin repositories also ship agent builder skills in their source trees, and the adk.dev/llms.txt resource gives any coding agent on-demand API documentation across all five languages.

Coding-agent skills scaffold your project while MCP and A2A connect all five language runtimes.

Hands-on view of each ADK

The clearest way to feel the difference between the five languages is to define the same weather tool in each one and see how its design fits the runtime.

Python

In ADK for Python, you don't need a decorator or a schema builder class. You pass a plain Python function into the tools parameter, and ADK inspects its signature, type hints, and docstring at startup to automatically construct the tool declaration and Pydantic parameter schema:

code_block: <ListValue: [StructValue([('code', 'from google.adk.agents.llm_agent import Agent\r\n\r\n\r\ndef get_weather(city: str) -> dict:\r\n """Retrieves the current weather report for a specified city.\r\n\r\n Args:\r\n city (str): The name of the city for which to retrieve the weather report.\r\n """\r\n return {"status": "success", "report": f"Sunny and 72F in {city}."}\r\n\r\n\r\nroot_agent = Agent(\r\n name="weather_agent",\r\n model="gemini-3.8-flash",\r\n instruction="Answer questions about the weather in a city.",\r\n tools=[get_weather],\r\n)'), ('language', 'lang-py'), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30d66d50>)])]>

Beyond fast prototyping, Python is ADK's reference implementation, shipping the broadest set of Google Cloud integrations (BigQuery, Spanner, Bigtable) and model adapters (Gemini, Anthropic, OpenAI, LiteLLM). Paired with the adk eval or agents-cli eval run commands, its evaluation tooling scores agent trajectories against golden datasets in continuous integration (CI) to test the whole system end to end, even when your production service runs in another language.

Go

While Python leads in experimentation and evaluation, ADK for Go hits the sweet spot for production backend engineering.

A Go tool function takes the agent.Context configuration and a strongly typed input struct. The functiontool.New function uses Go generics to infer both the input and output schemas from your struct tags:

code_block: <ListValue: [StructValue([('code', 'type GetWeatherArgs struct {\r\n\tCity string `json:"city" jsonschema:"The city to look up weather for."`\r\n}\r\n\r\ntype GetWeatherResult struct {\r\n\tReport string `json:"report"`\r\n}\r\n\r\nfunc getWeather(_ agent.Context, args GetWeatherArgs) (GetWeatherResult, error) {\r\n\treturn GetWeatherResult{Report: "Sunny and 72F in " + args.City}, nil\r\n}\r\n\r\nweatherTool, err := functiontool.New(functiontool.Config{\r\n\tName: "get_weather",\r\n\tDescription: "Retrieves the current weather report for a city.",\r\n}, getWeather)'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30d66510>)])]>

Because the functiontool.New function is generic over your handler's signature, the Go compiler verifies that your function matches the expected contract before your binary ever runs.

Go was also the first language after Python to ship the ADK 2.0 Graph Workflow runtime. When you need deterministic control flow alongside LLM reasoning, the workflow.New function wires agents and plain Go functions into a directed graph with conditional routing and parallel steps:

code_block: <ListValue: [StructValue([('code', 'ag, err := workflowagent.New("order_pipeline", []workflow.Edge{\r\n\t{From: workflow.Start, To: triageNode},\r\n\t{From: triageNode, To: fulfillNode, Route: workflow.StringRoute("fulfill")},\r\n\t{From: fulfillNode, To: notifyNode},\r\n})'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30d64c50>)])]>

Where Go really stands out is in production on Cloud Run and GKE. A compiled Go agent packages onto a roughly 2 MiB Google distroless static base image, with no language VM or heavy dependency tree. A static Go binary binds to its port as soon as the container starts, skipping the module imports of dynamic languages and the JAR unpacking and JIT warmup of JVM services.

After it's running, Go's concurrency model fits agent workloads naturally. Each goroutine starts with a 2 KB stack and minimal scheduling overhead, so a single instance can multiplex thousands of concurrent streaming requests and tool calls. ADK for Go also includes built-in A2A server handlers and OpenTelemetry tracing out of the box.

TypeScript

TypeScript erases type annotations when compiling to JavaScript, so runtime reflection isn't an option. Instead, ADK for TypeScript pairs with Zod. You pass a z.object(...) schema to the FunctionTool function, and TypeScript statically infers the parameter types of your execute callback from that single declaration:

code_block: <ListValue: [StructValue([('code', 'import { FunctionTool, LlmAgent } from "@google/adk";\r\nimport { z } from "zod";\r\n\r\nconst getWeatherTool = new FunctionTool({\r\n name: "get_weather",\r\n description: "Retrieves the current weather report for a city.",\r\n parameters: z.object({\r\n city: z.string().describe("The name of the city."),\r\n }),\r\n execute: async ({ city }) => {\r\n return { status: "success", report: `Sunny and 72F in ${city}.` };\r\n },\r\n});\r\n\r\nexport const rootAgent = new LlmAgent({\r\n name: "weather_agent",\r\n model: "gemini-3.8-flash",\r\n instruction: "Answer questions about the weather in a city.",\r\n tools: [getWeatherTool],\r\n});'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30d67150>)])]>

Your runtime input validation, the JSON Schema sent to the model, and your IDE autocomplete inside the execute callback all flow from one source of truth.

TypeScript also runs on the ADK 2.0 Graph Workflow engine and ships a standalone browser bundle. Beyond Node.js services, you can run an ADK agent directly in a browser tab using WebMCP for page-level tools and Chrome's on-device Prompt API.

Java

ADK for Java snaps right in for teams who have standardized on Maven, Gradle, and Spring Boot. You add @Schema annotations to method parameters and assemble agents by using a fluent LlmAgent.builder() API:

code_block: <ListValue: [StructValue([('code', 'public class WeatherTools {\r\n public static Map<String, String> getWeather(\r\n @Schema(name = "city", description = "The name of the city")\r\n String city) {\r\n return Map.of("status", "success", "report", "Sunny and 72F in " + city);\r\n }\r\n}\r\n\r\nLlmAgent agent = LlmAgent.builder()\r\n .name("weather_agent")\r\n .model("gemini-3.8-flash")\r\n .instruction("Answer questions about the weather in a city.")\r\n .tools(FunctionTool.create(WeatherTools.class, "getWeather"))\r\n .build();'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30ad82d0>)])]>

At runtime, the runner streams agent events reactively through RxJava. For local testing and existing JVM apps, ADK for Java ships a Maven Dev UI plugin alongside first-party bridges for Spring AI and LangChain4j.

Kotlin

ADK for Kotlin takes a strong stance on build-time safety. Its Kotlin Symbol Processing (KSP) compiler plugin reads @Tool and @Param annotations at build time and emits the tool schema directly into bytecode:

code_block: <ListValue: [StructValue([('code', 'class WeatherTools {\r\n @Tool(\r\n name = "get_weather",\r\n description = "Retrieves the current weather report for a city.",\r\n )\r\n suspend fun getWeather(\r\n @Param("The name of the city.") city: String\r\n ): Map<String, String> = mapOf("status" to "success", "report" to "Sunny and 72F in $city")\r\n}\r\n\r\nval agent = LlmAgent(\r\n model = Gemini("gemini-3.8-flash"),\r\n name = "weather_agent",\r\n instruction = Instruction("Answer questions about the weather in a city."),\r\n tools = WeatherTools().generatedTools(),\r\n)'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30ad8450>)])]>

If a tool signature uses an unsupported type or declares a default value on a non-nullable parameter, your Gradle build fails immediately instead of breaking in production. Because the .generatedTools() function uses zero runtime reflection, it survives Android R8 shrinking.

That zero-reflection design makes it possible to run the entire agent loop locally on Android. It offers JVM server support, including a Spring AI bridge and experimental ADK 2.0 graph workflows. On-device, ADK for Kotlin integrates with LiteRT-LM for tool calling and ML Kit (Gemini Nano) for text generation. It also works with Room and AppSearch for local state, and Android AppFunctions for OS-level actions, all without requiring a network connection.

Choice without compromise

Having five native languages in ADK means you don't have to pick a single runtime for your entire organization. Because every version of ADK speaks MCP and A2A, each component of your system can use the language that fits it best.

What languages have you used to build agents with Google's ADK? Let me know what stack you're running on X, LinkedIn, or Bluesky.

Introducing TimesFM 3.0 with multivariate time-series forecasting in BigQuery

Mon, 12 Oct 2026 16:00:00 +0000

Overview

Since introducing zero-shot time-series forecasting in BigQuery with AI.FORECAST — initially powered by TimesFM 2.0 and later upgraded to TimesFM 2.5 — you have been able to generate forecasts directly in SQL without training or managing custom models. However, up until TimesFM 2.5, these foundation models were limited to univariate forecasting, predicting future values from the history of a single time series alone. In practice, most real-world forecasting problems are multivariate, where related targets and external drivers like weather, promotions, and holidays jointly shape future outcomes.

Today, we are thrilled to announce the preview of TimesFM 3.0 in BigQuery. Developed by Google Research, TimesFM 3.0 is a 330-million parameter state-of-the-art foundation model designed to unlock native multivariate time-series forecasting directly inside BigQuery SQL. TimesFM 3.0 ranks #1 across all three major public time-series leaderboards — GIFT-Eval, FEV-Bench, and TIME — achieving top zero-shot accuracy on both covariate and multivariate forecasting tasks compared to existing foundation models.

Alongside its new multivariate capabilities, TimesFM 3.0 also serves as a drop-in upgrade for univariate forecasting via AI.FORECAST and anomaly detection via AI.DETECT_ANOMALIES. Existing workflows can immediately benefit from higher benchmark accuracy simply by specifying model => 'TimesFM 3.0'.

What’s new: Multivariate foundation modeling

With TimesFM 3.0, BigQuery brings enterprise-grade multivariate modeling into familiar SQL workflows via AI.FORECAST:

Capability	TimesFM 2.0 / 2.5	TimesFM 3.0
Forecasting scope	Univariate only	Univariate and multivariate
Target columns	Single target	Single or multiple targets
Covariate columns with past-only values	Not supported	Supported
Covariate columns with past and future values	Not supported	Supported

Multivariate forecasting with BigQuery SQL

To see how these capabilities work together, let’s forecast daily commuter (subscriber_trips) and leisure (casual_trips) bike rides over a seven-day horizon using the NYC Citi Bike public dataset (bigquery-public-data.new_york.citibike_trips).

BigQuery uses a single-table input format for multivariate forecasting that combines two sets of rows:

Historical observation rows: timestamps between start time (2016-01-01) and the forecast cutoff date (2016-06-01), fully populated with target metrics, past covariates, and known future covariates
Future horizon rows: timestamps across the seven-day forecast horizon (2016-06-01 to 2016-06-07) populated with known future covariates, while target columns and past-only covariates are set to NULL

code_block: <ListValue: [StructValue([('code', "WITH data AS (\r\n SELECT\r\n DATE(starttime) AS date,\r\n IF(MIN(starttime) < '2016-06-01', COUNTIF(usertype = 'Subscriber'), NULL) AS subscriber_trips,\r\n IF(MIN(starttime) < '2016-06-01', COUNTIF(usertype = 'Customer'), NULL) AS casual_trips,\r\n IF(MIN(starttime) < '2016-06-01', AVG(tripduration / 60.0), NULL) AS avg_duration_min,\r\n IF(EXTRACT(DAYOFWEEK FROM MIN(starttime)) IN (1, 7), 1.0, 0.0) AS is_weekend\r\n FROM `bigquery-public-data.new_york.citibike_trips`\r\n WHERE starttime >= '2016-01-01' AND starttime < '2016-06-08'\r\n GROUP BY date\r\n)\r\nSELECT\r\n *\r\nFROM\r\n AI.FORECAST(\r\n TABLE data,\r\n MODEL => 'TimesFM 3.0',\r\n TIMESTAMP_COL => 'date',\r\n TARGET_COLS => ['subscriber_trips', 'casual_trips'],\r\n PAST_COVARIATE_COLS => ['avg_duration_min'],\r\n FUTURE_COVARIATE_COLS => ['is_weekend']\r\n );"), ('language', 'lang-sql'), ('caption', <wagtail.rich_text.RichText object at 0x7f7e33e23dd0>)])]>

This query highlights the three multivariate dimensions supported in TimesFM 3.0:

Forecasting correlated targets (target_cols) Instead of running separate models for each rider segment, passing TARGET_COLS => ['subscriber_trips', 'casual_trips'] forecasts both metrics jointly in a single call. TimesFM 3.0 captures the cross-series dynamics between commuter and casual riders — such as shared weather sensitivity and diverging weekend ridership patterns.
Using past covariates (past_covariate_cols) Some signals can only be observed historically and are not known in advance, such as average ride duration (avg_duration_min), historical foot traffic, or unplanned service disruptions. Passing PAST_COVARIATE_COLS => ['avg_duration_min'] (with future horizon rows set to NULL) gives the model historical context to distinguish temporary shocks from underlying trends without requiring future values for that feature.
Using future covariates (future_covariate_cols) Other external drivers are known ahead of time across both the historical window and the forecast horizon — such as weekends (is_weekend), holidays, or scheduled promotions. Passing FUTURE_COVARIATE_COLS => ['is_weekend'] (populated across all rows through 2016-06-07) allows TimesFM 3.0 to condition its seven-day predictions directly on upcoming calendar events.

Understanding the output

The function returns structured predictions for each target column specified in target_cols. For each column in target_cols, AI.FORECAST returns a struct containing the point forecast (value) and the lower and upper prediction interval bounds:

date	subscriber_ trips.value	subscriber_trips.prediction_ interval_lower_bound	subscriber_trips.prediction_ interval_upper_bound	casual_trips.value	casual_trips.prediction_ interval_lower_bound	casual_trips.prediction_ interval_upper_bound	time_series_type	confidence_level	ai_forecast_status
2016-06-01 00:00:00 UTC	44699.64	32590.76	55723.44	4581.32	1727.91	9189.31	forecast	0.95
2016-06-02 00:00:00 UTC	44611.75	30413.05	57209.19	4647.17	1466.23	10273.55	forecast	0.95
2016-06-03 00:00:00 UTC	41379.15	26218.65	54940.09	5341.36	1568.23	11805.86	forecast	0.95
2016-06-04 00:00:00 UTC	30164.34	14266.43	45075.92	9097.74	2558.27	18452.52	forecast	0.95
2016-06-05 00:00:00 UTC	26727.27	10101.44	42239.33	8398.50	1692.15	17768.99	forecast	0.95
2016-06-06 00:00:00 UTC	36713.84	19493.00	52679.59	4723.08	400.08	11710.73	forecast	0.95
2016-06-07 00:00:00 UTC	39749.97	22157.42	56119.86	4180.97	95.70	10845.74	forecast	0.95

TimesFM 3.0 in BigQuery Conversational Analytics

You can also run multivariate forecasts using natural language in BigQuery Conversational Analytics. On the same bigquery-public-data.new_york.citibike_trips dataset, you can simply ask "Forecast both daily subscriber and casual trips for June 1–7, 2016 using two month historical data, with average trip duration as a past covariate and weekend indicator as a future covariate." Conversational Analytics automatically generates and executes the underlying AI.FORECAST query with TimesFM 3.0, returning a summary of the results, interactive forecast charts with prediction intervals for each target, and key forecast insights.

Multivariate forecasting with TimesFM 3.0 in BigQuery Conversational Analytics, generating 7-day predictions, interactive charts, and insights from a natural-language prompt.

Summary and next steps

With native multivariate support in TimesFM 3.0, BigQuery brings state-of-the-art foundation model forecasting to complex, interconnected enterprise datasets without requiring data movement, custom feature engineering pipelines, or dedicated model hosting infrastructure.

To start forecasting with TimesFM 3.0 in BigQuery:

Read the Google Research blog post to learn more about the TimesFM 3.0 model architecture and capabilities.
Explore the BigQuery TimesFM documentation.
Follow the step-by-step multivariate forecasting tutorial.
Try AI.FORECAST with `model => 'TimesFM 3.0'` directly in the BigQuery Studio SQL workspace.
Try AI.DETECT_ANOMALIES with `model => 'TimesFM 3.0'` for univariate time series anomaly detection in BigQuery.
Try AI.EVALUATE with `model => 'TimesFM 3.0'` for univariate time series evaluation in BigQuery.

Agentic data science with the Data Agent Kit

Mon, 12 Oct 2026 16:00:00 +0000

Imagine your compliance team notices that payments are taking longer than expected to clear. They suspect fraud, and you’re the data scientist helping figure out which transactions to investigate first. Assembling that shortlist requires ingesting and cleaning raw transaction logs, training a model on past fraud, scoring new records, and scheduling the pipeline to run daily. Here’s how you can build that workflow end to end with an agent, using the Data Agent Kit inside the Antigravity IDE.

Introducing the Data Agent Kit

Data Agent Kit helps you work with Google Cloud data through a plugin for coding agents or an extension for Visual Studio Code-based IDEs. It brings two significant additions to the workflow:

Help for your agent: MCP tools connect your agent to data services. Skills are Markdown files that give it instructions and best practices for working with your data stack
Tools in your IDE: work with Google’s Agentic Data Cloud, from querying databases to deploying an Airflow pipeline, without leaving your editor

Loading the data

Let’s start with the raw transaction logs in Google Cloud Storage. You can ask the agent to create a notebook that loads them into BigQuery using Spark:

code_block: <ListValue: [StructValue([('code', 'Create a PySpark notebook to ingest JSON transaction logs from gs://financials-clearing-raw/ into the BigQuery table transactions.raw_transactions.'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e312fe6d0>)])]>

The agent generates a Jupyter notebook that loads the JSON logs into a BigQuery table named raw_transactions. You can open the notebook, review the code, and run it using a preconfigured Spark Serverless runtime from the IDE.

Running a generated PySpark notebook

After the notebook runs, you can open the raw_transactions table with the Data Agent Kit. The extension allows you to browse the table and inspect its metadata right from the IDE.

Inspecting a BigQuery table in the IDE

The records are now in BigQuery, but they aren’t ready for model training yet. First, we’ll handle duplicate and incomplete records, then join the remaining records with info about who sent and received each payment.

Cleaning it up

Let’s put the cleanup logic into a dbt project so we can run it on each new batch of data. We’ll also test that each transaction appears only once. Prompt the agent:

code_block: <ListValue: [StructValue([('code', 'Create a dbt project in dbt_project/ for the BigQuery dataset transactions.\r\n\r\nDeduplicate raw_transactions by transaction_id in staging. Separate records with null IDs into invalid_transactions. Join valid records with dim_payers and dim_payees to create enriched_transactions, preserving the is_fraud label. Add a transaction uniqueness test.'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e312fc3d0>)])]>

The agent generates a dbt project with SQL models for cleaning and enriching the data. Take a look at the generated code to check how it handles duplicates and joins reference tables. Then run dbt build in the terminal. This builds the staging and enriched tables in BigQuery, along with a separate table for records with missing transaction IDs. dbt also runs the uniqueness test.

Validating dbt models in the integrated terminal

We also keep the is_fraud column, which indicates whether a past transaction was fraudulent. We’ll train the model on records with known labels and use it to score new transactions, where we’re unsure yet whether fraud occurred.

Building the review queue

With the data prepared, let’s ask the agent to create a training notebook using a Random Forest classifier running on Spark Serverless.

code_block: <ListValue: [StructValue([('code', 'Create a PySpark notebook to train a RandomForestClassifier\r\non table transactions.enriched_transactions.\r\n\r\nPredict is_fraud, training only on records where the label\r\nis not null. Encode categorical features, scale amounts,\r\nand evaluate the model using ROC AUC. Save the evaluated model to gs://models/fraud_model.'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e31d16550>)])]>

Review and run the notebook, then check its evaluation output to see how well the model separates fraudulent transactions from legitimate ones. You can also use the Data Agent Kit extension to verify that the trained model artifacts were saved to Google Cloud Storage.

Verifying the trained model artifacts in Google Cloud Storage

Now we can use the saved model to score transactions that don’t have an is_fraud value yet:

code_block: <ListValue: [StructValue([('code', 'Create a batch inference notebook that loads the saved model from gs://my_models/fraud_model and scores records in transactions.enriched_transactions where is_fraud is null.\r\n\r\nWrite transactions with a fraud probability score >= 0.50 to the Spanner table SparkEvalFraudReviewQueue, in the instance cymbal-fraud, database fraud-db.'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30a4e6d0>)])]>

In this example, the inference notebook scores the unlabeled transactions in BigQuery and sends those with an estimated fraud probability of 50% or higher to the Spanner review queue. The flagged records help the team decide where to investigate, but they still need to determine whether fraud occurred.

Look at how the inference notebook filters and writes flagged records, then run it. Once it finishes, query the Spanner table in the IDE to inspect the results.

Querying flagged transactions in the Spanner table

This table is the list we set out to build. The compliance team can now start reviewing transactions, and we have a workflow that gets records from raw logs into the queue.

So far, we have been kicking off each step ourselves. We can now connect them so the workflow runs automatically each day.

Running it again tomorrow

Each day we will load the latest logs, apply the dbt transformations, and score unlabeled transactions using the saved model. We’ll use the Managed Service for Apache Airflow to run these steps in order. Ask the agent:

code_block: <ListValue: [StructValue([('code', 'Create an orchestration pipeline named fraud_analysis_pipeline that runs ingestion, the dbt project, and batch inference in that order.\r\n\r\nSchedule it daily at midnight. Use Spark Serverless for the notebooks, including the Spanner connector for inference, and gs://YOUR_ARTIFACT_BUCKET for artifact storage.'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30a4cb10>)])]>

The agent generates a YAML pipeline definition and deployment configuration. The pipeline definition sets the schedule and dependencies between steps. Meanwhile, the deployment configuration specifies the Airflow environment where it will run.

Data Agent Kit then turns the definition into an Airflow DAG, which you can explore as an interactive graph in the IDE. Open the pipeline under “Orchestration Pipelines” and click a task to inspect it. For notebook tasks, you can follow the link straight back to the code.

Inspecting a data pipeline

With the Airflow environment configured, click “Run pipeline” in the canvas. Data Agent Kit packages the notebooks and dbt project, deploys the DAG, and triggers a run. Open the pipeline’s execution history to follow its progress. You can also select individual tasks to inspect their status, duration, and logs.

Kicking off an Airflow DAG and inspecting the logs

Airflow will run the pipeline every day, taking new batches of data from raw logs to the review queue. The compliance team can now focus on flagged transactions, and you’ve automated the work of getting those records to them!

Try it yourself

If you are ready to try this for yourself, we have designed a codelab that walks you through the full setup so you can build and run this workflow. You can also read our documentation or check out the skills and tools in the open-source repository on GitHub.

10 Years of the SRE book: Announcing the second edition of "Site Reliability Engineering”

Mon, 12 Oct 2026 16:00:00 +0000

A decade ago, Google released Site Reliability Engineering: How Google Runs Production Systems with O'Reilly Media. What began as a collection of our practices for managing large-scale infrastructure became a bestselling book, and inspired many organizations to adopt the reliability practices it outlined: applying software engineering to operations to build systems that are scalable, reliable, and sustainable.

Over the past ten years, computing landscapes have undergone profound shifts. AI, microservices, multi-cloud deployments, serverless paradigms, and platform engineering have all reshaped how we build and operate software. To mark the 10th anniversary of the book's release, we are excited to announce the completely rewritten second edition of the Google SRE book, reflecting a decade of lessons learned both inside Google and across the broader industry, to offer fresh guidance tailored for today's operational challenges.

Why update the book?

When we published the first edition, many organizations were focused on early cloud migrations and just starting to transition from monolithic architectures. Today, with organizations delivering software at a high velocity and at global scale, the challenge is no longer adopting cloud infrastructure, but maintaining high reliability in the face of the immense complexity.

Modern production environments operate under constant change. System boundaries are more complex, dependencies are deep, and failure modes are more complex and damaging than ever before. The explosion of resource-intensive workloads like generative AI has changed the economics and operational requirements of infrastructure management.

Writing this second edition required us to take a step back and evaluate what it takes to successfully implement SRE today.

A decade of evolution: How SRE practices have progressed

The second edition takes a deep dive into how foundational site reliability engineering practices have matured over the last ten years, shifting from manual, task-specific work toward automated, platform-wide capabilities. Consider, for example:

SLOs and error budgets: In 2016, teams relied on basic availability metrics and manual error budget policies. Today, practices have matured into user-centric, multi-tiered SLOs with dynamic burn-rate alerting and automated policy enforcement.

Monitoring and observability: Early setups centered on static dashboards, basic logs, and manual alert triage. Modern observability leverages OpenTelemetry, distributed tracing, and automated anomaly correlation to find root causes quickly.

Automation and platforms: Operations have shifted from writing custom scripts for isolated tasks to using declarative infrastructure as code, internal developer platforms, and resilient, self-healing systems.

Reliability testing: Rather than relying solely on scheduled game days and synthetic load tests, modern engineering embeds continuous resilience checks, automated pipeline testing, and live production canary verification.

Capacity and resource management: Manual provisioning and static forecasting have been replaced by dynamic auto-scaling, cloud FinOps alignment, and dedicated cost and cluster optimization for GPU and TPU workloads.

Organizational models: SRE has expanded beyond dedicated teams assigned to specific applications. Today's organizations use hybrid models, platform engineering integrations, and reliability champions embedded across product teams.

SRE in the age of AI

Then there’s the dual relationship between SRE and artificial Intelligence: how SRE supports AI infrastructure, and how SRE teams use AI to enhance operational reliability.

Running large language models (LLMs) and foundation models introduces novel reliability challenges. The book outlines methodologies for operating AI infrastructure at scale:

Managing massive GPU and TPU hardware cluster reliability and network topologies
Monitoring non-deterministic outputs and latency characteristics unique to AI
Ensuring pipeline reliability for continuous model training, fine-tuning, and data processing

AI is also rapidly becoming a force multiplier for reliability engineers. The second edition shares practical frameworks for enhancing human operational efficiency:

Using generative AI tools to assist in real-time incident triage and postmortem generation
Interrogating complex system telemetry using natural language queries
Using predictive machine learning models to identify resource bottlenecks before outages occur

What hasn’t changed? The importance of culture

While technologies and architectures continuously evolve, the core principles of SRE remain intact, and are key to establishing a reliability-focused culture. Accordingly, the second edition re-emphasizes and expands upon the human elements of system engineering, and how to get there.

Whether you’re new to the field, a practitioner, an engineering manager, or a technology executive, the rewritten second edition of Site Reliability Engineering serves as your definitive roadmap for the next era of production systems.

You can order your copy today in physical format (see Google Books) or digital format from O'Reilly.

Trusted Data Apps for the Agentic Data Cloud, powered by Looker

Mon, 12 Oct 2026 16:00:00 +0000

As a business intelligence user, this probably sounds familiar: Most dashboards only provide you with a standardized canvas and a fixed library of charts, and the “analysis” consists of a CSV export that takes you to another system. Or sometimes it's designing the dashboard that’s the challenge: You can picture the executive briefing, the customer-facing portal, or the interactive explainer that you want, but can’t assemble it out of the available grid tiles.

Either way, the solution has always been to build a custom application. The advent of AI has sped up the process — a working prototype now takes an afternoon — but the excitement of that first demo fades fast. Without access to governed data, row-level security, an infrastructure owner, or a clear path through security review, a tool written by an LLM is simply a prototype that can never go to production.

Today, to bridge this gap, we are announcing Looker Data Apps (in preview) — pairing the speed of agent-generated applications with the governance, security, and trust of your existing Looker governance framework. Describe what you need in plain language, and the agent builds it as a real, production-grade application hosted natively inside Looker!

What is a data app?

A data app is a bespoke, interactive web application generated by an AI agent and hosted natively within Looker. While dashboards provide top-down visibility, data apps serve as an active system of action designed around a specific operational workflow. A data app:

Goes beyond standard grid tiles with pixel-perfect, bespoke layouts configured for a specific operational role or job-to-be-done.
Enables business users to input parameters, test scenarios, run live simulations, and update underlying records.
Connects end-to-end business processes by connecting data analysis to business execution tasks like updating source records or dispatching events to tools like Salesforce and Jira.

Build pixel-perfect interfaces using AI developer tools like Claude Code or Antigravity CLI, grounded directly by Looker’s semantic layer.

Expanding your semantic layer into an application platform

Data apps do not replace dashboards; they expand the boundaries of what you can build on top of your existing dashboards and semantic layer.

Dashboards excel at aggregate visibility and passive reporting. Data apps handle active execution, letting users modify parameters and trigger downstream business tasks.
Dashboards provide consistency using standardized chart libraries. Data apps deliver broad flexibility, unlocking custom web components and specialized interactions.
Data apps are grounded in governed data to ensure accuracy. Whether users are reviewing a KPI dashboard or adjusting budgets in a data app, all logic is governed centrally with the LookML semantic layer to eliminate metric discrepancies and hallucinations.

Transform analysis into action with customizable, multi-page web app experiences and embedded operational workflows.

Built for enterprise scale

We designed Looker Data Apps for demanding, governed enterprises.

Every measure is grounded in the semantic layer. Every app you build directly inherits your existing semantic models, row-level security, and access controls. Calculations stay consistent across the enterprise, and built-in query inspection lets teams audit every line of generated SQL to eliminate metric hallucinations.
Zero-code by default. Deploy agent-generated React applications directly inside Looker with no code. Or users can use LLMs like Claude Code and Antigravity CLI to build interactive apps and deploy them as data apps in minutes.
No runtime token costs. LLM tokens are only consumed when you’re designing or generating the app. After that, every end-user interaction runs on native Looker APIs and models. Put a data app in front of 50 people or 5,000 and the marginal cost doesn't change.
As easy as embedding a dashboard. You can deploy your data apps into external portals using the same workflows you use to embed a dashboard. No new pipelines, no custom application code, no second permission models.

From prototype to production in minutes

The days of having to choose between basic dashboards and investing valuable engineering time to build bespoke systems are coming to an end. Instead of letting prototypes stall in sandboxes due to compliance and security barriers, Looker Data Apps allows teams to deploy governed, production-grade tools in minutes.

Looker Data Apps are now in preview. Get started today.

What’s new with Google Data Cloud

Fri, 09 Oct 2026 16:00:00 +0000

October 5 - October 9

Data Agent Kit is now generally available to bring Google Data Cloud to any coding agent
Data Agent Kit provides a free collection of Model Context Protocol (MCP) tools and Google-authored agent skills that connect more than 15 Google Data Cloud services directly to coding agents across VS Code, Antigravity, Cursor, Claude Code, and Codex. This release expands support for developers and data practitioners to inspect schemas, author queries, and build end-to-end data pipelines in natural language directly from their IDE or CLI. Read the announcement blog.
Spanner Omni is now generally available for deploy-anywhere, multi-model workloads
Spanner Omni brings Spanner's distributed SQL, graph, vector, and key-value capabilities to any environment, including on-premises data centers, other public clouds via Kubernetes or VMs, and local developer laptops. Organizations can build and run multi-model applications with consistent APIs and query engines across hybrid and multi-cloud footprints while seamlessly scaling to managed Spanner on Google Cloud. Read the launch blog and explore how Spanner also removed cumulative mutation limits for DML transactions.
AlloyDB delivers PostgreSQL for agents and native BM25 hybrid search
We announced PostgreSQL for agents in AlloyDB, introducing an agentic database architecture engineered for real-time data access at agent scale with workload isolation. In addition, native BM25 ranking is now in Preview for AlloyDB and Cloud SQL, allowing developers to combine keyword search and vector embeddings directly in PostgreSQL without maintaining an external search engine. For hybrid deployments, the AlloyDB Omni RPM Orchestrator is now generally available, and you can dive deeper in our new Build AI apps and agents with AlloyDB eBook.
Lakehouse runtime catalog adds regional endpoints across 22 regions and GA support for flexible column names
Lakehouse runtime catalog regional endpoints are now live across 22 Google Cloud regions across the Americas, Europe, Asia-Pacific, and the Middle East, supporting both the Apache Iceberg REST catalog endpoint and the Apache Hive catalog endpoint to help customers meet strict data residency and sovereignty requirements. In addition, flexible column names for Apache Iceberg tables are now generally available by default across Iceberg external tables and managed tables, enabling seamless querying of columns containing spaces, hyphens, and Unicode characters. We also announced the Preview of cross-cloud caching and connections for the borderless Lakehouse.
Unlock predictive and agent-ready insights with BigQuery augmented analytics TVFs, TabFM, and identity columns
BigQuery introduced augmented analytics table-valued functions (TVFs): six built-in functions that automate metric diagnostics, trend analysis, and pattern discovery directly where your data lives and integrate as skills for AI agents. We also introduced TabFM in BigQuery to bring tabular foundation model capabilities to predictive analytics, alongside BigQuery identity columns to automatically generate sequential surrogate keys and simplify data warehouse pipelines.
Dataflow adds Pause/Resume and NVIDIA RTX PRO 6000 Blackwell GPU support for large-scale AI workloads
New Dataflow capabilities make it easier to run high-throughput streaming and batch AI pipelines at scale, including Pause/Resume job controls and support for NVIDIA RTX PRO 6000 Blackwell GPUs. And for teams running Apache Spark workloads, learn how to mitigate compute stockouts and maximize availability using flexible VMs.
Unlock up to 3x higher QPS and microsecond latency with Memorystore for Valkey 9.1
Memorystore for Valkey 9.1 is now available, delivering up to 3x higher queries per second (QPS) and microsecond-level caching latencies to accelerate high-throughput applications and real-time AI agent state management. Read the blog.
Customer momentum across Google Data Cloud — Yahoo, PayPal, Surescripts, Airwallex, and Lucius AI
Organizations across industries are scaling their data and AI foundations on Google Data Cloud. Yahoo uses flexible VMs in Managed Service for Apache Spark to reduce provisioning failures by 85%, while PayPal migrated mission-critical analytics workloads to Managed Service for Apache Spark to scale and reduce operational overhead. On the database front, Surescripts migrated 30.5 billion annual healthcare transactions to AlloyDB with 99.998% uptime, Airwallex manages more than 5,000 databases with 99.99% availability on Cloud SQL with a team of four DBAs, and Lucius AI runs a 210,000-tender global platform on AlloyDB and MCP with 47x faster ScaNN vector search.

September 7 - September 10

Pub/Sub SMTs can now AI Inference your Gemini Enterprise Agent Platform models!
Pub/Sub AI Inference SMTs allow you to apply inference on an incoming stream of events using models hosted in Gemini Enterprise Agent Platform. The model’s prediction is appended to your event, making it available for downstream processing in your data warehouse (like BigQuery) or operational database (like BigTable). This feature, now generally available, can dramatically simplify or enhance anomaly detection systems you are operating.
PostgreSQL Source Connector is now generally available in Managed Service for Apache Kafka!
Managed Service for Apache Kafka’s PostgreSQL connector allows customers to capture changes from their PostgreSQL database and ingest them into their Kafka infrastructure with low latency. This source connector is compatible with Cloud SQL for Postgres, AlloyDB, and self-managed PostgreSQL databases. Try this along with our entire portfolio of managed connectors, including MirrorMaker 2.0, BigQuery, Cloud Storage, and Pub/Sub! E-mail kafka-hotline@google.com if you have questions or feedback!

Pause-on-failure for Dataflow batch jobs is GA
Dataflow pause-on-failure enables you to preserve the state of a batch Dataflow job before it fails. By pausing your Dataflow job, you can address issues that are external to the pipeline and resume processing without losing completed work. This helps you better manage resource costs and improve job reliability when you face temporary outages or capacity constraints.

The insertAll API is now the BigQuery Storage Write API (REST)
The legacy insertAll streaming API is now rebranded as the BigQuery Storage Write API (REST). By dropping the "legacy" label, developers can confidently build long-term HTTP-based streaming workflows. This stateless JSON-over-HTTPS endpoint offers a lightweight alternative to heavy gRPC libraries—ideal for serverless web apps, IoT telemetry, and AI logging. The transition is seamless for existing users, requiring zero code changes and offering 100% backward compatibility. However, the Storage Write API (gRPC) version remains the recommended standard for high-throughput, continuous pipelines.

August 31 - September 4

Stateful processing is available in BigQuery continuous queries in Preview
Stateful operations significantly expand what’s possible with BigQuery continuous queries. This feature allows users to leverage functions like JOINs, aggregations, and windowing functions directly in their streaming queries. Now you can calculate metrics over time (for example, a 30-minute average) to power your downstream applications and AI agents with much richer, real-time signals.

Try out our feature here and share your feedback with bq-continuous-queries-feedback@google.com!
Synthetic data generator tool is available for Managed Service for Kafka
You’ve launched your first Kafka cluster. Now what? The next thing to do is to produce some data to the cluster, but that involves modifying a client application somewhere or spinning up a virtual machine. The synthetic data generator tool, now generally available, can start sending mock data to your cluster in 3 clicks, and will get data streaming into your cluster in less than two minutes. The perfect utility for those moments you just want to test your cluster and new features. Try our quickstart today!

Dataflow pipeline updates are faster & more flexible
Dataflow pipeline updates can now stop-and-replace pipelines, a major addition to the existing in-place-update feature. The new parallel pipeline option accelerates the migration between the old & new pipeline, resulting in reduced disruption to your business. You can also set a timeout on drains that prevents runaway costs for your pipeliness in the event of stuck processing. This feature is generally available. Try it here!

July 6 - July 10

New Lakehouse managed tables now in preview
Lakehouse tables for Apache Iceberg are now in preview and available in the console. By using Google-managed Apache Iceberg tables in Lakehouse, you can eliminate the overhead of maintaining duplicate data pipelines and complex synchronization logic between BigQuery and open-source engines. This unified table format delivers native, multi-engine read and write interoperability, allowing you to run concurrent DML/DDL operations across diverse analytics tools on a single, shared storage layer. Built-in automated table management handles painful background optimization tasks like compaction and partition tuning, freeing up your team to focus on building rather than managing storage maintenance.

June 1 - June 5

Beyond the Query: Powering AI Agents with Bigtable, Firestore & Memorystore
Discover the latest advancements in Google Cloud's NoSQL Database portfolio, including Bigtable, Firestore, and Memorystore. This series is designed for a broad audience: whether you are exploring these databases for the first time or are an existing user looking to leverage the new capabilities announced at Next '26.

Register here to secure your spot!

Cloud Engineer's AI Toolkit Workshops: Solve data-driven challenges with BigQuery, AlloyDB, Gemini and more. Hosted by Google Cloud Labs, this highly technical event is built specifically for Platform Engineers, SREs, and cloud infrastructure teams ready to bridge the gap between AI prototypes and production-grade deployments. Look out for more locations coming soon

Toronto - June 25 (Data Cloud) | RSVP Here
Chicago - June 30 (Data Cloud) | RSVP Here
Start a 10-day Bigtable free trial with a 1 node SSD cluster and up to 500GB of storage capacity. With no credit card required to start, you can easily ingest workloads and manage workloads that require low-latency, high-throughput, and predictable access. Plus, new Google Cloud customers get $300 in free credits on signup.

May 11 - May 15

Managed Service for Apache Airflow has launched a wave of new features, including the general availability of Airflow 3.1, AI-powered agentic troubleshooting, a new managed Airflow MCP Server for custom agent integration, and declarative YAML-based orchestration pipelines—discover all the details in the full blog post.

April 20 - April 24

Google-built ODBC Driver for BigQuery is now available in Preview
We are excited to announce the launch of the new, Google-built ODBC driver for BigQuery. This new open-source driver provides a direct, high-performance connection for applications to BigQuery and is developed entirely in-house by Google. Download a new driver and connect your application to BigQuery.

April 13 - April 17

We announced we are reintroducing Data Studio to play a significant role in the AI era, expanding from data visualizations and reports to host BigQuery conversational agents and data apps built in Colab notebooks.
We announced BigQuery Graph is now available in preview, offering an easy-to-use, highly scalable graph analytics solution, empowering data professionals to model, analyze and visualize massive-scale relationships in an entirely new way.

April 6 - April 10

We introduced Conversational Analytics for Looker Embedded environments, enabling users to add natural language experiences to their own custom data-driven applications, powered by Gemini.
We expanded Looker’s capabilities for faster ad-hoc analysis, with the introduction of self-service Explores, enabling you to bring your own data to Looker’s semantic layer and gain instant access to insights in a governed data environment.

March 23 - March 27

We showed you how you can scale your reads with Cloud SQL autoscaling read pools. This feature allows you to provision multiple read replicas that are accessible via a single read endpoint and to dynamically adjust your read capability based on real-time application needs.
Our customers are leveraging the full power of Conversational Analytics and Looker to drive major business and technical breakthroughs in the AI era. Companies like Telenor, Pet Circle, Fluent Commerce, Lighthouse Intelligence, Wego, and ROLLER are turning data into insights and actions, grounded by Looker’s semantic layer.

March 16 - March 20

We introduced an enhanced Gemini assistant in BigQuery Studio, transforming the agent from a code assistant into a fully context-aware analytics partner.

February 23 - February 27

We introduced managed and remote MCP support for Google Cloud databases, including AlloyDB, Spanner, Cloud SQL, Bigtable and Firestore, to power the next generation of agents. This announcement extends the ability for AI models to plan, build, and solve complex problems, connecting to the database tools our customers leverage daily as the backbone of their work environment.
We outlined how you can build a conversational agent in BigQuery using the Conversational Analytics API to help you build context-aware agents that can understand natural language, query your BigQuery data, and deliver answers in text, tables, and visual charts.

February 16 - February 20

Our customers are leveraging the full power of Looker to drive major business and technical breakthroughs. Companies like Arrive, Audika, Carousell, Framebridge, GumGum, Intel, Overdose Digital, Ocean Network Express, Subskribe and Promevo are leveraging Looker’s newest AI-driven capabilities, including Conversational Analytics, to transform data to insights and actions, and empower their entire organization with a single source of truth, powered by Looker’s semantic layer.

February 2 - February 6

Join us on March 4 for our webinar, Win Your AI Strategy with Cloud SQL Enterprise Plus, to learn how to power your generative AI workloads with 3x higher performance and 99.99% availability. Register today to discover how to build a scalable, enterprise-grade foundation for your most demanding AI applications.

January 26 - January 30

We introduced Conversational Analytics in BigQuery, which allows users to analyze data using natural language. Conversational Analytics in BigQuery is an intelligent agent that generates, executes and visualizes answers grounded in your business context directly in BigQuery Studio, making data insights for data professionals more conversational.
We outlined how data products have become the foundation for AI agents, providing the context needed to make autonomous agents reliable and trusted for real business use, backed by organized business logic and semantic understanding.
We highlighted how you can supercharge data analytics workflows, and outlined Google Cloud’s AI agent offerings for data engineering, data science, and development tools, so you can integrate agentic workflows in your applications, empower your teams and speed discovery.

January 19 - January 23

We have fundamentally reimagined Firestore with pipeline operations for Enterprise edition. Experience a powerful new engine featuring over a hundred new query features, index-less queries, new index types, and observability tooling to improve query performance. Seamlessly migrate using built-in tools and leverage Firestore’s existing differentiated serverless foundation, virtually unlimited scale, and industry-leading SLA. Join a community of 600K developers to craft expressive applications that maximize the benefits of rich queryability, real-time listen queries, robust offline caching, and cutting-edge AI-assistive coding integrations.
Introducing Google Cloud SQL on MSSQLTips: We are highlighting a new technical guide published on MSSQLTips titled "Introducing Google Cloud SQL." This article serves as an essential resource for SQL Server administrators and developers exploring Google Cloud's fully managed database service. It provides a detailed overview of Cloud SQL capabilities, including high availability, security integration, and the seamless transition of on-premises SQL Server workloads to the cloud, making it an ideal resource for those planning their migration strategy.
We are excited to announce the Public Preview of Microsoft Entra ID (formerly Azure Active Directory) integration with Cloud SQL for SQL Server. Designed to tackle the challenge of identity sprawl in multi-cloud environments, this integration allows organizations to govern database access using their existing Microsoft identity infrastructure. Key benefits include centralized identity management, enhanced security features like Multi-Factor Authentication (MFA), and simplified user administration through direct group mapping. This feature is available for SQL Server 2022 and supports both public and private IP configurations.

January 12 - January 16

Google-built JDBC Driver for BigQuery is now available in Preview
We are excited to announce the launch of the new, Google-built JDBC driver for BigQuery. This new open-source driver provides a direct, high-performance connection for Java applications to BigQuery and is developed entirely in-house by Google. Download a new driver and connect your Java application to BigQuery.
Troubleshoot Airflow tasks instantly with Gemini Cloud Assist investigations: Cloud Composer just got smarter. We are excited to announce that Gemini Cloud Assist investigations are now available directly within Cloud Composer 3. Instead of manually sifting through raw logs, you can now simply click "Investigate" on a failed Airflow task. Gemini analyzes logs and task metadata to identify failure patterns—such as resource exhaustion or timeouts—and provides actionable recommendations driven by Gemini Cloud Assist to resolve the issue. This integration shifts the debugging experience from manual toil to automated root cause analysis, significantly reducing the time required to restore your pipelines. Learn more about AI-assisted troubleshooting.

Modernizing Unstructured Data Workflows: Alteryx Live Query meets Google Cloud BigQuery

Fri, 09 Oct 2026 16:00:00 +0000

Alteryx One Live Query and Google Cloud BigQuery redefine how enterprises handle complex, unstructured data at scale by reducing reliance on disconnected tools, minimizing data movement, and enabling warehouse-native execution.

Live Query provides an intuitive, browser-based environment that allows business users to build sophisticated data pipelines without writing a single line of code. When paired with the scale and performance of BigQuery, this duo enables secure SQL pushdown, meaning data transformation logic is executed directly within the warehouse rather than moving it across the network. This synergy is particularly potent for document-heavy workflows, where Live Query can orchestrate Google’s advanced AI and machine learning models — like Gemini — to extract intelligence from PDFs and images while maintaining the strict data governance and security of the BigQuery environment.

From invoice PDFs to govern exception reporting in BigQuery with Live Query

Finance and operations teams often find themselves buried under a mountain of vendor invoices. These documents come as PDFs with inconsistent data, varying invoice number formats, and a high risk of manual error. Traditionally, data teams have had to resort to manual data extraction or use a fragmented series of tools to move data into a warehouse — a process that is both time-consuming and prone to duplicates or amount mismatches.

With the integration of Live Query for BigQuery, you can now automate the entire lifecycle of an invoice. By processing PDFs, extracting key fields, and standardizing results directly within the BigQuery ecosystem, data teams can identify exceptions like anomalies or data issues within the documents faster while ensuring their governed enterprise data configured through the BigQuery fine grained access policies never has to leave the warehouse.

Solution overview: Extract, classify, validate, route, and post

Let’s dive deeper into how the Live Query solution works. Invoice PDFs arrive as unstructured documents in Google Cloud Storage. In the Live Query workflow, the Document Extract tool extracts structured fields using the model selected by the user, such as Gemini or Document AI. The results are then standardized for reliable matching and compared against historical invoice records already stored and governed in BigQuery.

This automated workflow is designed to move from document to decision with minimal manual intervention. At enterprise scale, that pattern is not just about processing a handful of PDFs — it is about enabling analytics and AI over millions of unstructured documents while keeping reconciliation logic aligned with BigQuery.

By combining AI-driven extraction with BigQuery-native execution, the solution provides:

Higher straight-through processing: Reducing manual handling and allowing more invoices to move through the process automatically.
Faster reconciliation and fewer manual exceptions: Comparing extracted invoices against BigQuery data earlier in the process so teams can identify duplicates and mismatches sooner, reducing the number of invoices that require manual review.
Stronger auditability: Maintaining a clear trail of data from source to operational output.
Reduced data movement: Keeping data resident in BigQuery and leverage its built-in capabilities for enhanced security, governance, and control.

Architecture: A Google Cloud-native pattern

At a high level, invoice PDFs are staged in Cloud Storage, processed through a Live Query workflow in the browser, reconciled against governed invoice history already resident in BigQuery, and written back as operational outputs for finance teams. The key architectural advantage of this pattern is that workflow authoring happens in the browser, while transformation and reconciliation logic are executed through platform services against the governed data environment.

The Live Query architecture is designed for warehouse-scale processing and governed execution. It uses secure SQL pushdown to execute transformation and reconciliation logic directly in BigQuery, and integrates with Gemini for advanced AI capabilities such as document extraction, classification, and summarization.

Live Query (Browser): Users author workflows visually in the browser, configuring document extraction, classification, cleansing, validation, and routing logic.
Alteryx One Platform Services: The Transformation Service coordinates request handling, execution planning, and result retrieval between the browser workflow and the customer data environment. The services also add traceability and observability across workflow execution, strengthening both operational monitoring and auditability.
Customer Google Cloud: Invoice PDFs are staged in Google Cloud Storage (GCS), historical invoice data remains governed in BigQuery, AI-backed extraction runs against that environment, and the workflow outputs are written back into BigQuery.

In this pattern, the browser is the authoring layer, Alteryx One Platform Services are the coordination layer, and Google Cloud is the governed data and execution layer. It allows workflow logic to be authored visually in Live Query while execution remains aligned with governed data and warehouse-scale processing in BigQuery.

Live query workflow walkthrough: From PDF to insight

Let’s take a closer look at how the Live Query workflow handles unstructured PDFs, using an invoice as the example.

Ingest invoice PDFs
The workflow begins by pointing to a directory input in Google Cloud Storage, where the raw PDF files are stored. In practice, this step does more than just identify a folder: it enumerates the PDF locations and returns file-level metadata — such as absolute file paths, size, and created / updated timestamps — so the workflow can reliably pass the right document set into downstream extraction steps.

Extract key fields
Using Alteryx’s Document Extract tool, the workflow processes PDF invoices stored in Google Cloud Storage and extracts structured or semi-structured results directly in BigQuery. The extraction step uses the user-selected model, either Document AI or Gemini AI, depending on the workflow configuration. Under the hood, the tool builds a temporary external object table from the input document URIs and executes the appropriate function — ML.PROCESS_DOCUMENT for Document AI model or AI.GENERATE for Gemini AI model. For this workflow, the Gemini path is used, with AI.GENERATE returning the requested invoice fields into the downstream Live Query workflow.

During interactive design, Live Query limits processing to a small subset of document URIs for preview, while runtime execution processes the full set of invoice PDFs.

code_block: <ListValue: [StructValue([('code', "-- illustrative pattern only\r\nSELECT *\r\nFROM AI.GENERATE(\r\n MODEL project.dataset.gemini_model,\r\n (\r\n SELECT\r\n uri,\r\n 'Extract invoice_number, invoice_amount, vendor_name, net_amount, tax_amount, and line_items.' AS prompt\r\n FROM project.dataset.temp_invoice_object_table\r\n )\r\n);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e312feb50>)])]>

Classify extracted content
After extraction, the workflow uses Alteryx’s Classify tool to apply zero-shot classification to the extracted invoice text. In this use case, line-item content is labeled into predefined business categories — such as industrial or office supplies — using AI.CLASSIFY in BigQuery, which returns a new predicted-label column into the downstream workflow. This business context makes the extracted data more useful for downstream reconciliation, exception handling, and reporting.

code_block: <ListValue: [StructValue([('code', "-- illustrative pattern only\r\nSELECT *,\r\n AI.CLASSIFY(line_item_text, categories => ['industrial', 'office']) AS line_item_classify\r\nFROM upstream"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30a4f1d0>)])]>

Normalize data
The extracted invoice numbers are cleansed and standardized so that minor formatting differences — such as whitespace or inconsistent formatting — do not hide potential duplicates during reconciliation.

Compare against history
The workflow joins the normalized current invoice records against historical invoice data already resident in BigQuery. This reconciliation step identifies records with matching invoice numbers already present in history and flags them as potential duplicates.

Flag exceptions
A formula step then applies business-rule logic to the remaining records. Those rules can vary by workflow and may include checks for amount mismatches, missing required fields, invalid totals, or other finance-specific exceptions. In this example, one rule checks whether invoice_amount matches net_amount + tax_amount and flags mismatches for review.

Produce operational outputs
The workflow produces two operational outputs: one for invoices matched to historical records and flagged as potential duplicates, and another for unmatched current invoices that have been validated, labeled for exceptions where needed, and prepared for unpaid-invoice processing.

The result is not just extracted data, but governed operational outputs that finance teams can review and act on immediately.

Summary: A governed document-to-decision workflow

Our joint customers are excited for these new capabilities that will help improve business processes.

“What stood out to me about Alteryx One: Google Edition was how naturally it fits into the Google Cloud experience. I'm excited about the opportunity to make analytics more accessible by enabling business users to work with BigQuery data through an intuitive, governed experience.” - Michael Wyant, Vice President, Enterprise Data & Corporate Solutions, Papa Johns

This use case is more than just a simple extraction tool; it represents a strong Google Cloud-native pattern for transforming unstructured documents into actionable operational outputs. Instead of moving warehouse data into disconnected preparation tools, the workflow keeps storage, extraction, reconciliation, and output generation aligned with governed enterprise data already resident in BigQuery. By combining the intuitive design of Alteryx One Live Query with the scale and AI capabilities of BigQuery, finance teams can reduce manual effort, accelerate exception handling, and focus on higher-value strategic initiatives.

Welcome to Gemini at Work 2026: Introducing the Gemini agent

Thu, 08 Oct 2026 12:00:00 +0000

Editor’s note: This article is adapted from Thomas Kurian’s keynote address at Gemini at Work 2026. It includes a number of announcements:

Gemini, a single, universal agent for work that answers your questions, handles your knowledge work, creates your images and media, and writes and runs code.
Inline in Workspace, Gemini works directly inside Gmail, Drive, Docs, Slides, Sheets, Chat, and Calendar, carrying the same memory, skills, and controls it has everywhere else.
New data and analytics skills that allow both technical teams and everyday business users to use plain-language questions to get to actionable operational insights in minutes.
Industry-specific specialization with tools, skills, connectors and knowledge specific for financial services and legal teams.
How we secure and govern agents through identity and policy management, authorization and permission controls, secure sandboxing, network gateways, and more.
Leading cost controls through multi-model orchestration, Smart Routing, real-time spend caps, and more.
Customer use cases that showcase the breadth and depth of our customers around the world.

Bringing the best technology to all of you is what drives us at Google Cloud. In the last year, nearly 500 Google Cloud customers each processed more than one trillion tokens. Today, nearly 80% of all Google Cloud customers are using our AI products, and nearly 90% of the Fortune 100 use Gemini Enterprise. At that kind of scale, organizations have moved past experimentation and are running their business on it.

Work now starts in the prompt window.

To meet this moment, today we are excited to announce the Gemini agent: your new single, universal agent for work. It has all of your business context and can be used for everything from knowledge work to answering questions, and from content creation to coding, all from a single prompt box. It plans the work, uses skills and tools, connects to your systems, and brings back something finished — inside the documents, the inbox, and the developer environments you already work in. It chooses the best model for the job, has built-in cost controls, and most importantly, has the security, administration, and governance required by your company.

The Gemini agent is your new single, universal agent for work.

Introducing the Gemini agent

Gemini answers your questions, handles your knowledge work, creates your images and media, and writes and runs code — all in a single agent and a single API. You give it objectives, not instructions. You delegate an outcome and come back to finished work. For an agent to do that, it has to be connected to your personal workflows, your systems of record, and your enterprise controls. Gemini can function as your personal assistant or as a team member, where it works on behalf of a group of people, like a project manager within a team, or on behalf of a specific role in an organization, like an analyst in your finance department.

The agentic capabilities in Gemini are built around core architectural principles:

Unified agent: Gemini is an agent that can answer your questions when you chat with it, work autonomously to complete objectives you assign it, and generate code — all from a single interface. You can assign it work, schedule tasks that need to be completed, or have it respond to events.
Omnipresent access: Gemini can be accessed from any device including web, iOS and Android mobile devices, Windows and Mac desktops, and any channel (command line, Google Workspace, Microsoft 365, or Slack). It can also be integrated into third-party applications and surfaces and operates as a headless agent, meaning it does not need a dedicated user interface.
Persistent execution: It runs in the cloud, meaning it maintains a single set of memories, context, and one personalization graph no matter what device or channel you access it on. You never have to re-brief it or wonder which machine you told it to do something on. Work that takes hours or days keeps running after you close your laptop, and it is still there when you come back.
Multi-agent orchestration: Gemini doesn’t work alone. It can dynamically create a roster of sub-agents — temporary, job-specific agents, each with their own identity — to tackle multi-step tasks. Gemini can communicate with these sub-agents to coordinate workflows, including parallel and sequential steps that can run for hours or days. In addition, Gemini can act as a coworker agent — which is more like a team member, with a persistent, defined role and operational presence across days, sessions, and multiple changing responsibilities — and delegate and coordinate tasks. Coworker agents have dedicated identities including their own @agents.company.com emails, their own persistent storage, and only have access to the context that you or your team members provide.
Deeply contextual: Gemini arrives already knowing your tools, data, and work history. Whether you ask it a question, assign it an objective, or have it generate code, Gemini learns from every interaction with you. The longer you collaborate with it, the better it understands you and how you work. Teams can create dedicated projects to further optimize the context, skills, and tools Gemini uses when it works with you.
Model choice flexibility: Gemini is the agent, and the model underneath it is a separate choice. It runs each job on the model that fits best — orchestrating across our Gemini family of models and Claude models from Anthropic today, and other leading private and open models in the future — to deliver optimal quality and lower your costs. The best model for the task is not always the largest one. Matching the model to the work raises accuracy on the difficult jobs and lowers cost on the simple ones. And the leading model changes every few months, so keeping that choice open means your context, your skills, and your data stay put when it does.

Top customers across industries were early testers and are already realizing its benefits: Premium sportswear brand On tested this new dynamic selection capability to accelerate its speed-to-market. This builds on the proven, large-scale multi-model strategies already used by leaders: Shopify blends frontier models for millions of merchants to unlock data and drive sales, and PayPal routes 10 million multi-model requests every week.

Powering Gemini: Skills, tools, and context

Gemini understands your business — everything from pricing to product portfolios to departmental norms — and all the institutional knowledge that makes your company unique. Three capabilities make that possible: tools that connect it to your systems, skills that teach it how your work gets done, and context that lets it remember.

Tools and tools registry: Gemini can securely connect to the software your company already runs, including collaboration tools like Confluence, Microsoft Office, Teams, Slack, and Workspace; development tools like Git and Jira; enterprise platforms like Salesforce and ServiceNow; databases like BigQuery, Databricks, Postgres, and Snowflake; and files on your own desktop. It can also connect and work securely with any Model Context Protocol (MCP) server inside or outside your company network. It also offers an enterprise tools registry, so teams can build and publish tools for the rest of the company.
Skills and skills registry: Skills are reusable sets of instructions, knowledge, or workflows stored as modular prompts that teach agents how to perform specific, multi-step tasks. Gemini ships with a robust global library of skills. Teams or departments can build and publish custom skills to a shared company registry, and you can build your own personal skills. Gemini chooses the right skills and tools to perform a task and continuously learns from each execution, improving its consistency, while saving token costs.
Context and memory: Gemini learns from each question you ask it, each objective you assign it, the people you work with, and uses your personal context and your organization's context to personalize and improve the quality of its responses. It keeps four kinds of memory: session memory for the task in front of it, even when it runs for days; semantic memory, a structured knowledge base it builds as it reads documents, talks to people, and works with other agents; procedural memory for how a job gets done, including skills it writes for itself; and episodic memory of everything it has done before. Gemini onboards itself the way a new hire would, learning you, your tools, and your team before it starts.

Customers seeing significant benefits from Gemini Enterprise include:

BNP Paribas, a European leader in banking and financial services, is transforming Corporate & Institutional Banking by deploying Gemini Enterprise into LLM@CIB, its internal generative AI assistant available to more than 65,000 employees, to streamline workflows like preparing credit memos and boosting the productivity of customer advisers while maintaining strict enterprise-grade security and data governance.
Bradesco, one of Brazil’s largest banking and financial services conglomerates, is streamlining heavy operational workflows by deploying Gemini Enterprise for automated fiscal, accounting, and contractual analysis. The finance team has accelerated proposal reviews, service classification, and budgetary workflows, cutting document review time from 1 hour to 5 minutes while reducing risk inconsistencies by 60% and achieving over 10% in financial efficiencies.
Merck is exploring new frontiers in molecular research with the potential to significantly compress discovery timelines while maintaining complete data privacy and security.

Orange Spain, a leading telecommunications operator in Spain, is speeding up its digital transformation by deploying more than 1,000 custom Gemini Enterprise agents. Employees across HR, IT, sales, and customer service have built custom agents to automate incident triage, analyze network issues, and retrieve corporate knowledge, boosting operational agility and response times while helping non-technical staff automate daily workflows with zero IT bottlenecks.
Santee Cooper, South Carolina’s state-owned electric and water utility, is modernizing its financial planning and grid reliability by deploying a specialized AI model built on Gemini Enterprise. Financial planning teams and utility operators are automating complex financial scenario modeling and query execution using simple natural language and expect to boost modeling speed by up to 75% while mitigating market risk across a $10 billion grid expansion budget.
SOMPO, a leading Japanese insurance provider, built over 10,000 custom AI agents across its 34,000 employees to automate tasks like document search and summarization for employee efficiency. Their engineering team used Gemini Enterprise to cut the development time for new models from one week to a single day, freeing up engineers for more important work.
Ulta Beauty is helping guests shop 30,000 products by deploying the Ulta AI shopping assistant built with Gemini Enterprise. Online shoppers have translated conversational questions into personalized beauty recommendations, boosting digital sales conversion rates three-fold while skipping traditional search filters to buy the products they love instantly.
Wesfarmers, the parent company of Australian retail giants Bunnings, Kmart, and Officeworks, is deploying agents across its portfolio. An internal agent at Bunnings saved staff half a million hours of administrative work, while shopping agents — that help customers discover products and build their carts — have increased conversion rates up to three times higher for Kmart and Officeworks.

Organizations worldwide are driving measurable impact.

Gemini in Google Workspace

Gemini not only answers your questions, handles your knowledge work, and writes your code — it works directly inside Gmail, Drive, Docs, Slides, Sheets, Chat, and Calendar, carrying the same memory, skills, and controls it has everywhere else. It works inline: in the email thread, in the document, and in the chat space.

Inside Workspace, Gemini works three ways:

Personal assistance: Gemini works as your personal agent and arrives already knowing your calendar, your team, your projects, and how your documents relate to one another. It is briefed before you start. For example, you can ask Gemini to set up a meeting with the usual team of regional event leads next week, without supplying a single name or email address. Gemini determines who those people are from the membership of your chat space and the thread from your last event, checks their calendars, and starts an email thread to coordinate a time that works, even with external participants. It handles work that spans applications the same way: researching market trends, building a financial model in Sheets, then creating a deck that presents both, without you re-explaining the project at each step.
Proactive delegation: Gemini uses this same intelligence to proactively suggest tasks you can delegate to it. For example, if your manager emails you asking for the latest project update as a slide deck, Workspace Intelligence recognizes that as a delegatable task and gives you a single-click option to pass it to Gemini. It applies the same reasoning to your inbox, surfacing the message that matters most rather than the one that arrived last, and explaining why.
A member of your team: You can also use Gemini to create a coworker agent that works with your entire team. You simply describe the role you need, and Gemini creates it. The agent receives its own Workspace account, including an email address, calendar, Drive, and presence in your company directory. Your colleagues work with it the way they work with anyone else, by adding it to a Chat space or @mentioning it. For example, a marketing manager can ask an events coordinator agent in a chat group to draft a launch readiness document, which it posts back to the group when complete. The marketing manager could also tag the agent in a document comment, where it can suggest an edit in the Doc and reply in the comment thread, appearing under its own name in version history. A coworker agent acts under its own identity rather than yours, and it sees only what you share with it. Access follows the sharing and membership your team already uses, and no outside connector holds your data.

Data analysis, data engineering and machine learning

We are also giving Gemini skills built for specific domains, starting with data.

Data and analytics represent a foundational domain where Gemini transforms business workflows, enabling organizations to move from plain-language questions to actionable operational insights in minutes. We are introducing purpose-built capabilities tailored to both technical teams and everyday business users:

For Data and ML engineers: We are extending Gemini with machine learning skills and tools that back every data scientist and data engineer with a team of agents. Engineers describe the outcome they want in plain language, and Gemini generates PySpark code, provides notebooks to edit and test it, trains models, and troubleshoots and fixes pipeline issues on its own.
For business users: Anyone in your organization can generate reliable, real-time operational reports simply by asking. Gemini uses operational reporting skills integrated with BigQuery and the Knowledge Catalog to construct and save the query. Once saved, teams can run reports on demand without incurring token costs, guaranteeing consistent, verified answers every time.

Three Google Cloud capabilities keep those answers grounded:

Knowledge Catalog: Gemini integrates directly with your Knowledge Catalog to map business definitions once so all agents use them. This deep understanding of your organization’s schemas and business rules for terms like “net margin” and “addressable market” dramatically improves accuracy. Whether your metrics live in Databricks, dbt, LookML, or SAP, Gemini reads them directly where they sit to ensure factual responses.
Smart Storage: Ninety percent of enterprise data is unstructured — PDFs, images, scans, and audio recordings — which often remain "dark" and unreadable. Smart Storage changes this by enriching unstructured objects in place and writing context back directly onto the object itself. The intelligence stays where the bytes reside and inherits your existing security posture.
Borderless Lakehouse: Organizations should not be forced to move or duplicate their data to use AI. Our borderless Lakehouse allows Gemini to query Amazon S3 and Azure Data Lake with no variable egress fees, read directly from Salesforce Data 360, SAP, and Workday without copying data, and federate open Apache Iceberg tables across Databricks Unity, Snowflake Horizon, and AWS Glue.

You can start by registering data sets that you discover in your lakehouse with the Knowledge Catalog, and then assign Gemini simple or complex analysis to perform. It identifies the necessary data sets from the Knowledge Catalog, generates the necessary SQL, Spark or Python code to calculate the results, and runs the code on our Managed Spark Service with Lightning Engine or in BigQuery. It can also generate charts and build dashboards in the tools your analysts already use.

By grounding its data agents in the Knowledge Catalog, Bloomberg Media lifted its SQL query accuracy by 63% during initial development. As William Anderson, Bloomberg Media’s CTO, noted: “...by grounding our AI in a trusted institutional context, we ensure confidence in the accuracy and quality of every insight generated.”

Additional customers are seeing tremendous value from our data solutions:

Deutsche Telekom used BigQuery, Cloud Storage, and Knowledge Catalog to build a unified data lakehouse to overcome a fragmented and slow data infrastructure spread across 40+ legacy on-premise systems, allowing their teams to now move ten times faster while addressing European data sovereignty and security requirements.
Etsy migrated three petabytes of data to a unified lakehouse. By using BigQuery and open-source Apache Iceberg, they can now perform critical data joins up to 60% faster, allowing them to train models on much larger datasets and better connect buyers with the perfect items.
Snap connected its Prism agent directly to its storage archives, cutting technical diagnostic troubleshooting times down from 30 minutes to just 30 seconds.

Industry-specific specializations

Every industry runs on knowledge a general model does not have. We are specializing Gemini for individual industries, with the skills, tools, and knowledge specific to each one. It is now in preview for Financial Services and Legal, and coming soon to Government, Healthcare, and Retail.

Financial Services: Gemini for Financial Services automates what is usually pieced together across many workstreams: investment research, credit analysis, and risk modeling. It draws on trusted financial data from FactSet, LSEG, S&P Global, SEC filings, and your own proprietary repositories. Built with more than 50 foundational skills and designed to satisfy rigorous compliance, it shows its reasoning through confidence scores, explicit methodologies, full data lineage for easy auditing, and source citations you can check. Gemini for Financial Services is already being used by global financial institutions like CME Group and Deutsche Bank.
Legal: Gemini inherits matter-level permissions and ethical walls directly from document management platforms like NetDocuments and iManage. Partners like Harvey automate complex legal work while meeting the firm's confidentiality standards, while Onit streamlines contract lifecycle management without exposing privilege. Cooley is building a confidential information redaction agent on Gemini Enterprise for Legal that automates redactions, including personally identifiable information and confidential material, before legal filings go public. In high-stakes litigation, this can cut days of document review while maintaining the firm's rigorous standards for client confidentiality.

In addition, we’ve seen our ecosystem and customers create new vertical applications as well. For example, Deloitte has created a multi-agentic solution to help organizations identify the highest-value opportunities for AI applications for their business. Their Agentic AI blueprint develops operational heat maps to pinpoint areas ready for agentic redesign, accelerating the deployment of custom agentic workflows and achieving up to a 3x faster path to measurable business impact.

Securing and governing agents

Two factors determine whether an enterprise agent program succeeds or stalls: whether you can govern it, and whether you can afford it.

When deploying autonomous agents across an organization, governance comes down to answering four fundamental questions:

Who is the agent, and what identity does it have?
What is it allowed to do or what permissions is it granted?
What did it do and where can I see what it did?
What should it never touch?

Identity, policy, and observability answer the first three. The fourth is Agent Gateway.

Identity: Every agent gets its own identity, cryptographically attested and governed like an employee, with least-privilege permissions. That identity is stamped into the logs that capture its work, and into any virtual machine spun up to run code on its behalf.
Authorization and permissions: You give each agent fine-grained, role-based access permissions, approved by your organization’s security administrators. When the Gemini agent connects to an external system, its identity is mapped and propagated through industry standards such as OAuth.
Auditing: In addition, every action Gemini takes is written to an audit trail and attributed to the agent rather than to a person. Since the identity travels into any virtual machine the agent spins up to run code, you can monitor those logs with our observability tools in real time and catch anomalous behavior before it matters.
Policy management and control: Gemini gives you identity, discovery, governance, and security by default. All Gemini agents execute tasks safely inside an Agent Sandbox with its own network boundary. All traffic — in, out, and between agents — passes through Agent Gateway, an AI network firewall enforcing your organization’s policies in real time. You write the policy once, such as: “agents may not open documents classified Need to Know.” Gemini applies it to every agent in your company instead of checking one agent at a time.

Leading cost controls and spending options

While per-token prices have dropped 98% since 2024, enterprise AI volume has exploded. Running every simple loop through a premium model quickly breaks corporate budgets. We announced new flexible spending options recently and are adding to those today:

Multi-model orchestration: As mentioned earlier, Gemini allows you to choose the right model for the job, and even combine different models for specific tasks in larger projects to deliver optimal quality and lower your cost.
Smart routing: Our routing tool automatically triages enterprise workloads so each one runs on the model that delivers maximum performance at the lowest possible cost.
Real-time spend caps: You can set a hard limit on a project's AI spend in the Cloud Billing Console, and Gemini enforces it. Gemini monitors token usage and sandbox costs, and if a spend cap is triggered, that project's agent pauses, and you can choose to resume work with a single click in the console. Because the tracking is per project, companies can charge AI costs back to specific departments.

Infrastructure: 80% better price-performance

All of this innovation — the agent, the data, the identity, and everything else — runs on our AI Infrastructure and our models. They are the reason the economics work.

First, our AI infrastructure. We co-design the chips, the network, the data center, and the software that connects it all as one highly-optimized system — our AI Hypercomputer. This vertical integration delivers significantly better price-performance than the generic setups, and we are continuing to push the state of the art here. For example, our latest TPU 8i system delivers 80% better price-performance than the prior generation, making complex, high-value agent tasks both fast and highly affordable.

On top of this silicon sit our models: Argon for frontier reasoning, Flash for speed and volume, Omni for generative media, and Gemma for lightweight, open-weights edge workloads.

The edge capabilities are already real. NASA’s Jet Propulsion Laboratory is running Gemma directly on a satellite in orbit, a first for a vision-language model. JPL’s NAVI software analyzes Earth imagery on board the satellite and sends a summary with key information to ground operators.

Supercharged by our ecosystem

We remain committed to choice at every layer of the stack, ensuring you have the freedom to choose the best tech stack for your unique needs.

Inside Gemini, you have a broad choice of third-party agents from leading SaaS providers as well as connectors that are ready to use. They are even easier to discover as collections in the new AI Solution Finder.

Around Gemini, our services ecosystem continues to rapidly scale to meet enterprise demand. Together, in the last month alone, our global consulting partners have put more than a hundred thousand of their developers and consultants through Gemini hackathons.

In addition, Accenture has made a significant investment by establishing a dedicated Gemini Enterprise Business Group to accelerate customer adoption and innovation. Several other partners have also expanded their commitments to support the growing demand for Gemini, including establishing specialized centers of excellence and training Gemini credentialed practitioners to help customers build and deploy production-grade agents faster.

Gemini Enterprise in action: Global momentum

Organizations worldwide are driving measurable impact across every major region:

Europe and Middle East

Arden University, a UK provider of flexible online and blended learning, is preparing students for the global job market by rolling out Gemini Enterprise. Over 30,000 students and staff will now have access to advanced Al tools to personalize their studies and gain essential skills for the workplace.
Commerzbank, one of Germany’s largest private banks, is using Gemini Enterprise to automate document quality assurance, reducing manual work on document reviews from 20 hours to just one. They are expanding this with a multi-agent system for AI-driven QA.
Lloyds Banking Group is scaling agentic AI across the bank. Envoy, a secure, Gemini-powered pipeline, has already onboarded nearly a thousand engineers building production-ready AI use cases. From fraud detection to commercial client onboarding, Envoy gives teams a reusable agent marketplace, a "golden path" for building agents, and a CI/CD pipeline — all wrapped in the guardrails and security a highly regulated bank demands.

Nokia is tackling the complexity of modern telecom networks with an ecosystem of specialized agents built on Gemini Enterprise. This allows operators to fix issues before subscribers are impacted by automating troubleshooting and cutting issue resolution time by up to 80%.
On, a premium sportswear brand, is scaling workforce productivity and efficiencies by deploying Gemini Enterprise to every employee to drive personal productivity and foster an AI-ready culture. Team members have launched no code agents that help with efficient knowledge extraction, executive reporting, market research, scheduling, onboarding and more.
Ooredoo Qatar, the leading telecommunications provider in Qatar, is integrating Gemini Enterprise into their AI transformation strategy to drive advanced automation and intelligence. Its customer support, marketing, security, and field operations teams have deployed AI agents to optimize internal operations management, while accelerating rapid issue resolution and marketing campaigns to deliver around the clock, highly personalized, proactive customer experiences.
Qatar University, the nation's premier institution of higher education, is transforming higher education operations and academic research by deploying Gemini Enterprise campus-wide. Thousands of faculty and staff are deploying more than 2,000 custom AI agents to modernize institutional workflows, automate complex administrative operations, and enhance academic productivity.
Ryanair, Europe’s largest airline, is modernizing its collaborative operations and infrastructure by deploying Gemini Enterprise and Google Workspace to 35,000 employees. Flight crews, operations planners, and corporate staff will benefit from automated decision-making, optimized crew logistics, and enhanced corporate productivity, while a resilient dual-cloud strategy strengthens infrastructure resilience and supports the airline's target growth to 300 million passengers by 2034.
Starling, one of the UK's top-rated digital banks, built its Scam Intelligence tool on Gemini Enterprise. It analyzes online marketplace ads for suspicious content and has quadrupled the rate at which customers cancel potentially fraudulent payments.
Other major European customers include Berenberg in banking, Bouygues Telecom, the application building platform Lovable, and Siemens in automation.

Asia Pacific

Airwallex, the global financial platform processing over $200 billion annually, has deployed Gemini Enterprise across its infrastructure to resolve customer issues 10x faster, automate dispute handling to cut case time by 40%, and accelerate software time-to-market by over 95% while building specialized agentic finance workflows for automated treasury, payables, and payments.
DBS Bank, Southeast Asia’s largest bank, is moving past pilots into enterprise production by deploying deterministic chains of 70 to 80 specialized agents on Google Cloud to synthesize complex financial, regulatory, and market intelligence for corporate credit memos, shifting relationship managers from manual research to high-value client advisory while keeping humans firmly in the loop.
Hitachi is transforming global power and utilities by deploying agents directly to frontline workers via HMAX, Hitachi’s portfolio of AI-powered solutions. Field technicians have built agents for over 200 use cases — such as using image-recognition agents to verify photos of every tool and wire before and after a job — boosting productivity by up to 30% while keeping workers safer.
NTT DOCOMO, Japan’s leading mobile operator, built data agents that reduced time-to-insight from two weeks to instant, which gave four hundred fifty thousand hours a year back to the business. Building on this success, they are now deploying Gemini Enterprise to drive their next wave of productivity.
Tata Steel, a global steel manufacturing leader, successfully deployed more than 300 specialized AI agents in nine months to enhance manufacturing safety, optimize predictive supply chains, and cut customer complaint turnaround times by 50%.
Zip, an Australia-based digital financial services company, is transforming its product-development lifecycle in the U.S. by deploying Gemini Enterprise to build an AI-Native Product Factory. Cross-functional teams will use this unified agentic environment to connect customer research, design, engineering, and compliance, boosting product development velocity and parallel experimentation while lowering the cost and complexity of bringing new financial products and experiences to market.
Other APAC leaders include LG in electronics, Marubeni in trading, and TCS in technology services.

Latin America

Banco BV, a leader in the Brazilian financial sector, is using Gemini Enterprise to create personalized scripts for its customer relationship managers, accelerating client communications by 80%. The new AI platform allows the bank to quickly engage customers with tailored financing and investment opportunities.
CNA/SENAR, Brazil’s national agriculture and livestock federation, is expanding access to critical agricultural information by deploying JoIA, a conversational AI assistant on WhatsApp built on Gemini Enterprise. 40,000 active users, with the potential to support 5 millions producers across the country, have accessed localized input pricing, weather forecasts, and financial health evaluations to facilitate in-field decision-making.
Farmacias del Ahorro, one of Mexico’s leading drugstore and pharmacy retail chains, is accelerating corporate operational efficiency by deploying PotencIA, an internal program built on Gemini Enterprise. 1,000 corporate employees across IT, e-commerce, and marketing have adopted the tools for daily business workflows, boosting active user adoption to 95% while generating an estimated 140,000 hours in annual productivity gains.
Globo, Latin America’s largest media company, is optimizing early-stage software planning by deploying PlanejaAI, an AI agent solution built on Gemini Enterprise. Product Owners, managers, and analysts have accelerated epic refinement and quarterly planning, boosting pre-development plan accuracy by 33% and slashing validation time from 20 minutes to 6 seconds while saving 127 hours in a single quarter.
Grupo Bafar, a prominent Mexican food producer and consumer retail group, is accelerating national retail expansion by deploying Gemini Enterprise for automated contract management. Legal and retail operations teams have streamlined the preparation of operational annexes for store openings, boosting processing capacity tenfold while slashing contract preparation time from 140 to 17 minutes per branch.
Laureate Education, a major higher education network serving nearly 500,000 students across Mexico and Peru, is transforming academic and administrative operations by deploying Gemini Enterprise and Gemini for Education. Faculty and staff have personalized learning paths, enhanced teacher support resources, and modernised campus administration, boosting student engagement and operational readiness while driving long-term career employability for graduates.
Other LATAM leaders include iFood delivery services, Livelo in customer loyalty, SEBRAE in public services, and Yduqs in education.

North America

Albertsons, a leading U.S. food and drug retailer, is ensuring customers get the freshest produce with its patent-pending Intelligent Quality Control tool built with Gemini Enterprise. Distribution center inspectors are using computer vision and Gemini models to instantly evaluate fresh fruit and vegetable quality against company standards, boosting rating consistency across shifts and locations while speeding up inspections to get perishable food onto grocery shelves faster.
Avid, a leading provider of media technology for film and television, is streamlining video post-production through browser-based editorial experiences and agentic creative workflows built with Gemini Enterprise. Editors and directors can use conversational content discovery, AI-assisted transcription, and intelligent media organization within their creative workflows — including within a Google Chrome browser — helping teams spend less time on manual administrative tasks and more time focused on storytelling.
Constellation Energy Company, a leading energy supplier, will build Gemini Enterprise agentic workflows directly into its core operations. Power generation teams will have access to advanced AI capabilities to accelerate capacity delivery, optimize asset dispatch, and protect critical infrastructure.
Honeywell Technologies Forge platform includes predictive maintenance capabilities built on Gemini Enterprise, such as contextualizing operational data at scale and providing proactive maintenance recommendations. This helps customers minimize costly, unplanned outages, protecting and extending the lifespan of their mission-critical equipment.

PayPal built its AI platform on the Gemini Enterprise to create new commerce tools, cutting the time it takes to deploy new models from weeks to just minutes.
The Home Depot, the world’s largest home improvement retailer, is speeding up customer support and product discovery by deploying AI voice and digital assistants built on Gemini Enterprise. DIY shoppers and contractors calling stores or using Magic Apron have skipped rigid phone menus, searched local inventory with natural speech, and resolved inquiries in real time, boosting phone resolution speeds by four-fold (understanding customer needs in under 10 seconds) while allowing in-store associates more time to focus on face-to-face shoppers.
The RealReal, the leading online marketplace for authenticated luxury resale, is transforming luxury consignment by deploying Ask TRR, a conversational shopping concierge built with Gemini Enterprise. Resale shoppers have navigated and searched a massive, shifting catalog using natural language instead of rigid filters, which will boost user engagement across all 45 million members while making it effortless to discover and secure rare, "one-of-one" luxury pieces before they sell out.
Verizon is modernizing its customer and enterprise operations with Gemini Enterprise and agentic Data Cloud. The technology has helped resolve inbound customer calls and chats automatically, helped predict and resolve network anomalies, and automated marketing campaign orchestration, boosting customer satisfaction and automated resolution rates while unifying legacy data lakes into a single source of truth.
Whenere, an immersive storytelling platform, is revolutionizing interactive 3D worldbuilding, starting with bringing Pride and Prejudice to Fortnite. To build the Netherfield estate, the team used Dreamlands, an agentic 3D worldbuilding platform built on Gemini Enterprise. With Gemini generating each new texture in about seven seconds for under ten cents, one artist created nearly 250 custom assets in a single day and completed a historically accurate estate in under a week, all while keeping full creative control.
Leading hospital systems and healthcare services companies like Highmark Health and Seattle Children's rely on Gemini Enterprise to run secure administrative and clinical support workflows.
In public sector, Gemini Enterprise is being used across the states of Arizona and Missouri, the State University of New York (SUNY), and the Chief Digital and Artificial Intelligence Office, which has put Gemini Enterprise in the hands of 3 million uniformed and non-uniformed members of the US armed services. They have built more than a hundred thousand custom agents to streamline everyday tasks.
Small and midsize businesses including Aerotech, EDSpan Global,, Pinch Creative, Quadrant Health Group, Salt Productions, Strategem, and more are using Gemini Enterprise to empower their teams with AI agents that can streamline their operations, automate administrative workloads, help find information, and even support customer engagement. In fact, usage of Google Cloud’s AI tools by these customers has grown more than 5x year over year.
Other North American startups and innovators like Every Cure, Harvey, OpenEvidence, Recursion, and Replit are using Gemini Enterprise.

Our commitments to you

As you build the future on Gemini, we make three firm commitments:

We take the friction out: A future-proof platform that runs anywhere, executes any task, supports your choice of models, and applies enterprise controls.
We eliminate complexity: Google builds and integrates the entire stack: silicon, models, skills, tools, and security.
What you build stays yours: Your people and your data do not need to move, and your proprietary inputs and outputs remain entirely your own.

The technology is ready, our global partner ecosystem is scaling, and Gemini is ready to work for you.

Empowering SMBs to do more with Gemini

Thu, 08 Oct 2026 12:00:00 +0000

Today, we announced the new Gemini agent, your single, universal agent for work. For small and midsize businesses, with lean teams and margins, Gemini will be a critical tool for you to operate efficiently, deliver excellent customer experiences, and grow.

Millions of small and midsize businesses, or SMBs, already trust Google AI across multiple services, like Gemini Enterprise, Google Ads, and Google Workspace. And they are scaling fast: Their usage of Google Cloud’s AI tools increased more than fivefold year over year.

Now, SMBs can benefit from all of the agentic capabilities of Gemini.

The agentic era for SMBs has arrived

Gemini functions as a personal assistant and team member, connects to the systems and data you already use, operates across the interfaces you’re already familiar with, and offers the model choice, security, and cost controls you expect from Google Cloud.

It answers your questions, handles your knowledge work, creates your images and media, and even writes and runs code, all from a single prompt box. You delegate an outcome and come back to finished work. Gemini can act as a flexible team member, playing a specific role such as a project manager, bookkeeper, inventory manager, or marketing consultant.

And, Gemini is architected to be helpful out of the box, with benefits including:

Connects to popular SMB tools: Gemini connects to the systems you regularly use, like Asana, Box, Clay, Docusign, Dropbox, GitHub, LegalZoom, Notion, Salesforce, Shopify, Slack, Wix, and more. It utilizes context from these tools, your business data, and work history, and gets smarter and more helpful the more you use it.
Provides model choice: Gemini is the agent, and the model underneath it is a separate choice. It runs each job on the model that fits best—orchestrating across our Gemini family of models and Claude models today, and other leading private and open models in the future. Matching the model to the work raises accuracy on the difficult jobs and lowers cost on the simple ones. And the leading model changes every few months, so keeping that choice open means that even if you switch models, your context, your skills, and your data stay put.
Accessible everywhere you work: Gemini works across the surfaces that you use every day, including on the web, Android and iOS mobile devices, Mac and Windows desktops, and applications like Google Workspace, Microsoft 365, and Slack. Because it runs in the cloud, it keeps working even when you step away from your devices.
Keeps costs under control: We’ve also implemented leading cost controls into Gemini, to ensure you and your employees can confidently put Gemini to work. This includes multi-model orchestration to choose the right model for the job, smart routing that automatically triages workloads so each one runs on the model that delivers maximum performance at the lowest possible cost, and real-time project-level spend caps in the Cloud Billing Console.

Gemini is in early access with SMB customers today and will be available to all customers soon.

How SMBs are driving results with Google Cloud AI today

Globally, SMBs are already using Gemini Enterprise to drive their businesses forward, here are a few examples:

Aerotech, a U.S. industrial automation company, leverages Gemini Enterprise to scale its internal AI problem-solving platform across its workforce, reducing troubleshooting times to increase production capacity.
Angelus, a Brazilian dental and healthcare manufacturing company, uses Gemini Enterprise to streamline project management across its research and development department. This enables its teams to automatically pull technical project data into pre-approved templates aligned with the company’s brand identity and regulatory requirements.
EdSpan Global, an international education platform, uses Gemini Enterprise to automate the standardization of thousands of digital learning objects, reducing time spent on repetitive editing to accelerate course launches.
Eficode, a software development and DevOps firm in Finland, is using Gemini Enterprise to create a multi-platform support engine that quickly indexes complex internal wikis, so employees can provide customers with faster technical support.
KLog.co, a Chilean logistics technology company digitizing freight forwarding across Latin America, uses Gemini Enterprise to automate cargo tracking and shipping paperwork, cutting manual data entry errors by more than 90% and increasing document processing capacity tenfold.
Koufu, one of Singapore's largest food and beverage companies, is using Gemini Enterprise to automate sales reporting and data analysis. This reduces spreadsheet bottlenecks so shop managers can focus on front-of-house service quality.
La Maison du Whisky (whisky.fr), a specialized spirits and beverages retailer in France and internationally, chose Gemini Enterprise to create a 'Digital Sommelier' that transforms technical product data into high-end storytelling and marketing copy in seconds.
NEEOH, a leading Brazilian out-of-home advertising communication platform, uses Gemini Enterprise to standardize secure AI usage across its organization, enabling teams to generate campaign copy and build pitch proposals faster while keeping corporate client data secure.
Quadrant Health Group, a U.S.-based healthcare and clinical operations provider, uses Gemini Enterprise to unify its fragmented technology systems, automate repetitive back-office tasks, and empower clinicians with secure AI tools that safeguard patient data.
Salt Productions and Pinch Creative, U.S.-based event production and creative partner agencies, are using Gemini Enterprise to turn fragmented files into a searchable, single source of truth, reducing administrative work and presentation bottlenecks so staff can focus on event production and design.
Sep 2, a digital security provider, uses Gemini Enterprise to deploy autonomous AI agents for 24/7 threat monitoring. It can accelerate incident detection and neutralize security threats.
Stratagem, a technology consulting company based in the U.S., uses Gemini Enterprise to automate administrative workflows and develop retail customer service agents, freeing consultants to spend more time with clients and accelerate service delivery.
Sunhouse, a strategic brand design agency, uses Gemini Enterprise to easily find archived design work stored on Google Drive, enabling its teams to spend less time hunting for files and more time growing its business with global brands.

Get trained on Google Cloud AI

To help SMB teams get the most out of AI, we’ve created easy, no-cost learning programs that you can use through our Google Skills platform. To get started today, there are two ways to engage on the platform for free:

Claim 35 no-cost credits to access hands-on labs and earn skill badges across all levels
Sign your team up for Google Skills for Organizations

Today, Google Skills offers more than 3,000 courses, labs, and credentials to help you build practical skills with Google AI and products like Google Workspace and Gemini Enterprise, earn skill badges, and achieve valuable certifications on Google Cloud. Courses on the new Gemini agent will be available soon; in the meantime, you can get started with recommended courses such as:

Exploring Data Transformation with Google Cloud: For SMBs looking to move past simple tools and actually start scaling their broader operations on Google Cloud, this course provides a great entry point for business leaders looking to modernize their infrastructure and security posturing.
Google Workspace with Gemini: For SMBs looking to quickly boost everyday efficiency, this course serves as an essential, highly practical guide to seamlessly integrating AI into daily business operations, from drafting emails to automating simple workflows directly inside Gmail, Docs, and Drive.
SMB Learning Path: For SMBs looking for practical ways to scale their business operations, this catalog of courses focuses on combining introductory gen AI technical foundations with Gemini-led automation and the GEAR framework for custom agent development.

Work with a partner

Our partner ecosystem plays an important role in helping businesses implement Google Cloud AI, including Gemini.

Today, many partners offer certified experts on Google Cloud AI to SMBs, and can help with everything from identifying use cases for AI, prototyping, building custom agents, and more.

Visit our Google Cloud Partner Network today to get started with a partner.

Innovation in Ireland: How Irish brands scale with Gemini Enterprise

Thu, 08 Oct 2026 12:00:00 +0000

In recent decades, Ireland has grown into a vibrant hub for global technology. As modernization accelerates, Irish organizations — spanning government agencies, established enterprise brands, and growing startups in AI and other areas — are all advancing their technical foundations. Today, leaders across the country are injecting agentic AI into every layer of their business and operational workflows.

We are seeing organizations move from early prototypes to production-ready deployments using Gemini Enterprise. This progress supports Ireland's competitive position within the European market. According to a recent Implement Consulting Group report assessing Google’s local contribution, public and private leaders estimate between 40 billion to 45 billion euros of economic potential in global AI markets.

This ambition aligns with broader government initiatives. Since assuming the presidency of the Council of the European Union for the second half of 2026, Ireland has steered higher-level technology and policy discussions, outlining a National Digital and AI Strategy to improve productivity and innovation across sectors.

To support this strategy, we are focused on making these capabilities more accessible. Our local teams are collaborating with industry leaders to implement Gemini Enterprise which offers capabilities that range from conversational AI agents and natural language data analysis, to optimizing operations with agentic ecosystems.

The economic impact is already taking shape. In 2025 alone, Google operations — including our AI and cloud services — added an estimated 10 billion euros to the Irish gross domestic product. And this momentum is shared: Organizations across Ireland are using Google Cloud to modernize infrastructure and put AI to work.

Here are several ways Irish organizations are modernizing with Google Cloud and Gemini Enterprise:

Ryanair supports millions of passengers through AI-backed operations

Ryanair, Europe’s largest airline, is modernizing its collaborative operations and infrastructure by deploying Gemini Enterprise and Google Workspace for some 35,000 employees. Flight crews, operations planners, and corporate staff will benefit from streamlined decision-making, optimized crew logistics, and enhanced corporate productivity. At the same time, a dual-cloud strategy strengthens infrastructure resilience as the airline targets growth to 300 million passengers by 2034.

Smyths Toys rethinks the customer experience with agentic support

As one the world’s largest specialty toy retailers, Smyths Toys is reshaping its customer support with Google Cloud and Gemini Enterprise. By introducing an AI agent named Codie, the retailer has resolved more than 60% of its web inquiries and reduced holiday email backlogs. Customer care teams that previously handled up to 1,000 peak-season emails a day can now focus on the roughly 50 cases that need more complex judgment.

The Irish Revenue Commissioners: Advancing public sector data

Public sector agencies are also making strides in Ireland. The Irish Revenue Commissioners — responsible for taxes, customs, and keeping Ireland’s economy running smoothly — is working with Google Cloud to migrate from legacy on-premise systems to a unified AI-lakehouse architecture designed to break down data silos and establish a single source of truth. Strict data sovereignty controls safeguard taxpayer information while Gemini Enterprise powers agentic data analysis, helping Revenue deliver secure, responsive public services.

Virgin Media Ireland: Accelerating workflows

Supported by Liberty Global's partnership with Google Cloud, Virgin Media Ireland is moving AI from exploration to production. Through modern infrastructure and automation, the team now deploys workloads three times faster, is in the process of rolling out multiple AI agents, and is launching new customer services designed to drive business growth.

Irish startups scaling with enterprise tools

While established enterprises are modernizing legacy systems, Irish startups are building on modern technology from day one. Backed by a strong local tech ecosystem, these agile teams are creating services that compete on an international stage.

Hexis: Scaling personalized sports nutrition

Hexis builds technology solutions that help athletes refine their performance and recovery. By storing and processing that real-time biometric and behavioral data in Google Cloud, Hexis uses Gemini Enterprise to power natural language conversations that explain fueling adjustments to users throughout the day. Today, the platform supports 40% of the Tour de France peloton and half of Premier League clubs during the 2026–2027 season.

Kitman Labs: Unifying performance analytics

Founded in Dublin in 2012, Kitman Labs provides sports science and performance intelligence to more than 4,000 sporting organizations across 26 countries. By combining its intelligence platform with advanced analytics and Gemini Enterprise, Kitman Labs helps teams make data-informed decisions that support athlete health, lower injury risk, and extend player career longevity.

Spryt: Automating healthcare coordination

Spryt streamlines healthcare coordination across the U.K. and U.S., using AI built on Google Cloud and Gemini Enterprise to optimize patients’ experiences, reduce missed appointments, and cut administrative burden. The company collaborates with the NHS, operates in more than 70 US clinics, and has analyzed 224 million appointment records as part of a multiyear initiative with Mayo Clinic.

IMPT: Automating carbon offsetting

By connecting AI, blockchain, and Google Cloud, IMPT embeds verified carbon offsetting into everyday hotel bookings and online purchases. Following a 15-week migration to Google Cloud, IMPT supports 8 million listings across 195 countries. With Gemini Enterprise, the company’s lean team handles about 400 daily customer chats with a six-second median response time, allowing staff to focus on growing its business rather than managing systems.

Transform ideas from planning to production

As Ireland continues to expand as a global technology hub, local organizations are demonstrating how to translate AI potential into practical results. Explore our customer stories to see how other organizations are building with Google Cloud, or reach out to our team in Ireland to accelerate your journey.

Google Public Sector and SUNY launch AI-enabled platform to accelerate university research

Thu, 08 Oct 2026 12:00:00 +0000

Public research universities solve some of society’s most urgent challenges, but turning ideas into breakthroughs requires fast, secure access to cutting edge technology. In the agentic AI era institutions have an unprecedented opportunity to harness intelligent systems that can process massive datasets, run complex workflows, and dramatically accelerate the pace of scientific discovery.

Today at Gemini at Work, we’re announcing our collaboration with the State University of New York (SUNY) to launch the SUNY AI Platform, a secure AI and high-performance computing environment built on Google Cloud with Gemini Enterprise.

Initially available across nine of SUNY’s most research-intensive campuses, the platform is designed to help researchers move from hypothesis to discovery faster—and to help prepare New York’s students and workforce for an AI-driven economy.

Research with real-world impact

SUNY researchers are tackling challenges with direct impact for communities across New York and beyond. Their work includes improving weather prediction, detecting water quality issues, sequencing DNA for cancer treatments, and processing high-resolution brain scans to aid diagnosis.

To support that work, the SUNY AI Platform empowers researchers of all technical backgrounds to easily access and benefit from Google Cloud's advanced capabilities—bringing storage, high-powered computing, Gemini Enterprise, and more than 200 trusted AI models together into a seamless, centralized ecosystem. Rather than requiring individual teams and campuses to assemble these capabilities independently, researchers can work within a common foundation that helps simplify data analysis, enable collaboration across institutions, and apply consistent governance and responsible AI practices.

Equipping the SUNY community with AI-ready skills

Technology alone does not create impact; people do.

As part of this collaboration, SUNY is offering system-wide access to Google’s self-paced, industry-recognized AI credentials, available at no cost to students and faculty. Each course can be completed in 5-10 hours and requires no prior experience, helping learners build practical skills to write effective prompts, solve complex problems, and use AI tools responsibly. SUNY is also working to embed Google Career Certificates into academic programs so students can graduate with job-ready technical capabilities alongside their degrees.

Together, the SUNY AI Platform and these learning opportunities reflect a broader approach to AI adoption: pairing access to advanced technology with the skills and institutional capacity needed to put it to work responsibly.

To explore SUNY’s free AI learning tools and resources, visit suny.edu/google. Then read our case study here and watch our featured partnership video with Catherine Stollar Peters, SUNY’s Director of Research Data Strategy, to hear how academic leaders are using AI to transform education and the public sector.

You can also join us at the Google Public Sector Summit on October 20 to hear firsthand how leaders are using AI to transform organizations across the public sector.

Introducing Google Cloud’s U4 compute: Enabling ultra-low latency trading

Wed, 07 Oct 2026 16:00:00 +0000

In capital markets, operational success is built on predictable performance and low latency, where even tiny variations in packet timing alter queue priority and trade execution. At the same time, both exchange venues and their participants face mounting constraints in traditional on-premises data centers — from power and physical rack space limits to lengthy hardware procurement cycles. Increasingly, global capital markets seek the speed and determinism of physical co-location combined with the dynamic scalability and automation of the cloud.

At Google Cloud Next ‘26, we announced the Ultra Low Latency (ULL) Solution, now generally available, providing high-frequency trading workflows that run in the cloud with an ultra-low latency network and agility. The ULL Solution includes the new U4 machine family, also generally available today.

The ULL Solution is based on three infrastructure pillars:

Hardware-level networking: Scaleable, hardware-based multicast data distribution for reliable market-data feeds
Advanced networking observability: Dynamic network traffic capture with hardware-level timing accuracy, facilitating consistent auditing, market replays, and absolute trade validation without impacting primary traffic performance
Deterministic high-performance compute: Processing of latency-critical execution tiers in a highly predictable, consistent amount of time, every single time

Taken together, the ULL Solution’s compute, storage, networking, and observability provide financial exchanges and market participants with a number of technical capabilities:

Bare metal performance: Dedicated bare metal compute provides direct access to physical host resources, minimizing jitter and delivering predictable, low-latency execution for market-data feeds and order routing.
High-performance storage options: Local Titanium SSDs handle real-time transaction and tick logging on the host, complemented by scalable Google Cloud Hyperdisk for persistent market data archives and analytics.
Physical traffic isolation: The ULL trading fabric’s redundant A/B multicast market feeds are accessed through two independent and dedicated Titanium adapters, while an independent third Titanium adapter offloads telemetry, management, and provides access to Google Cloud services.
Hardware-accelerated multicast distribution: The ULL network architecture supports hardware-level multicast feed ingestion. This allows participants to stream high-throughput market data directly to low-latency trading applications, bypassing traditional hypervisor-level virtual switches.
Accelerated packet processing: Support for OpenOnload and DPDK enables Linux user-space networking to deliver predictable unicast and multicast packet handling while minimizing application code changes.
Precision timing and UTC synchronization: Integration with Google Cloud’s Firefly clock synchronization system allows the solution to consistently achieve sub-10 nanosecond network-level timestamping and better synchronization to UTC than the sub-100 microsecond regulatory requirement for financial exchanges.
Built-in telemetry: 24/7 low-latency packet capture and seamless out-of-band packet brokering for regulatory compliance and real-time analytics helps ensure deep visibility without impacting primary traffic performance.
24-7 market ready: The solution is designed for continuous, round-the-clock trading readiness by isolating production workloads in a dedicated primary zone for live trading, while routine cloud maintenance and qualification testing occur in a secondary zone for updates and testing.

Compute in the ULL Solution is delivered by the new U4 machine family, which brings predictable performance and ultra-low latency compute in three specialized machine series: dual-socket bare metal instances with three physical NICs — U4P for exchange operators and U4C for market participants — alongside U4S high-performance VMs for operators, participants, and service providers.

Machine Series	CPU Platform	CPU Cores	Memory	NICs	Storage Options
U4P (Bare Metal)	Intel 5th Gen Xeon (Emerald Rapids)	120 Physical Cores	512 GB or 768 GB	3 Physical (1 Standard + 2 ULL)	Local Titanium SSD (12 TiB), Hyperdisk
U4C (Bare Metal)	Intel 5th Gen Xeon (Emerald Rapids)	120 Physical Cores	512 GB or 768 GB	3 Physical (1 Standard + 2 ULL)	Local Titanium SSD (12 TiB), Hyperdisk
U4S (VM)	Intel 6th Gen Xeon (Granite Rapids)	2 to 288 vCPUs	Up to 2,232 GB	Multi-vNIC (Up to 200 Gbps)	Local Titanium SSD (18 TiB), Hyperdisk

Machine Series

CPU Platform

CPU Cores

Memory

NICs

Storage Options

U4P

(Bare Metal)

Intel 5th Gen Xeon (Emerald Rapids)

120 Physical Cores

512 GB or 768 GB

3 Physical (1 Standard + 2 ULL)

Local Titanium SSD (12 TiB), Hyperdisk

U4C

(Bare Metal)

Intel 5th Gen Xeon (Emerald Rapids)

120 Physical Cores

512 GB or

768 GB

3 Physical (1 Standard + 2 ULL)

Local Titanium SSD (12 TiB), Hyperdisk

U4S

(VM)

Intel 6th Gen Xeon (Granite Rapids)

2 to 288 vCPUs

Up to 2,232 GB

Multi-vNIC (Up to 200 Gbps)

Local Titanium SSD (18 TiB), Hyperdisk

We developed the U4 machine family to enable the world’s most technically demanding markets to run within Google Cloud and benefit from cloud services and scale. An example of this is our ongoing collaboration with CME Group, through which we are migrating listed derivatives markets to Google Cloud. Here, the U4C and U4P bare metal instances deliver direct physical co-location latency parity, providing predictable low-latency clock precision, and native hardware-multicast feed ingestion. This architecture demonstrates that core exchange systems and trading strategies can run in the cloud with the speed, consistency, and control that financial markets require.

"Migrating the world’s leading derivatives marketplace to the cloud requires uncompromising performance, latency, and reliability. Google Cloud’s Ultra Low Latency Solution and the U4 instance families represent a breakthrough for financial market infrastructure. By combining deterministic, ultra-low latency networking and dedicated bare metal compute with the benefits of the cloud, market participants can execute and ingest market data and execute with the speed of traditional co-location and the agility of the cloud." - Pearce Peck-Walden, Managing Director Markets Engineering, CME Group

Powered by Google Cloud-native infrastructure

The ULL Solution is available in select private Google Cloud regions, where trading teams can leverage core cloud infrastructure benefits such as rapid automated resource provisioning, on-demand capacity scaling, and dynamic fleet management. Trading teams can execute ultra-low latency trades on a dedicated, isolated ULL network, and offload data streams over an independent network interface to Google Cloud services such as BigQuery and Gemini Enterprise.

For exchange participants managing tick-to-trade workflows or processing real-time market data, microsecond variations are critical. As bare metal instances, U4P and U4C machine series don’t add any virtualization overhead for latency-sensitive execution tiers. Leveraging Google Cloud's Titanium offload system architecture, these bare metal instances provide direct access to the host resources. Compute Engine instances enable users to provision dedicated hardware through standard Google Cloud APIs, orchestrate deployments with infrastructure as code, apply Cloud Next Generation Firewall (NGFW) policies, and collect rich telemetry.

The U4S VM series complements these bare metal offerings for applications such as pre-trade risk validation and real-time analytics. Deployed alongside U4P and U4C instances, these VMs shorten transit hops across the trading architecture while offering elastic scaling from 2 to 288 vCPUs and networking up to 100 Gbps.

“Our testing of the U4 instances validated that Google Cloud delivers the low latency and determinism required for our demanding exchange trading workloads. Having both bare metal and VM options allows us to evaluate the value of that performance relative to its cost, helping us align the right infrastructure to each of our trading strategies.” - Corbin Kidd, EVP/CTO, Prime Trading

"In our tick-to-trade performance testing, the U4C bare metal instance demonstrated exceptional speed, showing that cloud compute and ultra-low latency networking can comfortably satisfy microsecond trading demands. But, what sets the U4 series apart isn't just raw processing speed, it’s structural determinism. When we stress-tested Google Cloud's U4 bare metal family, the performance curve remained virtually flat, which confirms that these cloud compute layouts can now offer the strict determinism institutional market participants require." - Christopher Wilson, Global Head of Experience Modernization, 28Stone

Looking to the future, this low-latency architecture serves as the foundation for algorithmic trading, allowing firms to feed real-time markets directly into AI-driven trading models.

Storage and placement for trading workloads

The U4 family supports Google Cloud storage options and placement policies, helping trading teams record trades at speed and minimize network latency between machines:

Local Titanium SSD for fast logging: For real-time trade logging and data caching without slowing down execution, U4P and U4C provide up to 12 TiB of direct-attached NVMe SSDs, and U4S VMs scale up to 18 TiB.
Hyperdisk for data archives: For historical market data, backtesting models, and regulatory archives, you can attach Hyperdisk Balanced and Hyperdisk Extreme volumes across all U4 series, scaling up to 32 volumes and 512 TiB per instance.
Placement policies: To reduce physical network hops, compact placement policies keep related machines close together in the data center. Alternatively, spread placement policies place machines on separate racks to improve resiliency.

Getting started with the ULL Solution

With the ULL Solution, financial exchange operators, exchange participants, and trading service providers can execute trades with the speed and reliability they need today while positioning their businesses to leverage continuously evolving AI and infrastructure capabilities for the trading of tomorrow. The ULL Solution is available in select Google Cloud regions. To learn more, check out the public documentation, and reach out to our team to request access.

Announcing MCP Toolbox Java SDK v1.0: Agentic data access for the enterprise

Tue, 06 Oct 2026 19:00:00 +0000

Co-authors:
Stenal Jolly, Strategic Cloud Engineer, Google
Anubhav Dhawan, Software Engineer, Google

Following the landmark announcement of MCP Toolbox v1.0, we're thrilled to announce that the MCP Toolbox Java SDK has officially reached version 1.0.

This release brings first-class, type-safe agent orchestration to one of the world's most widely adopted enterprise ecosystems. Java's mature architecture is purpose-built for rigorous demands, providing the high concurrency, strict transactional integrity, and robust state management required to safely scale mission-critical AI agents in production.

In this post, we'll tell you about what's new in Java SDK v1.0, show you a real-world example, and help you get started with your own implementation.

MCP: The universal interface

Today, developers face a compounding integration bottleneck: if you have N different AI models and M enterprise data sources, you must build, secure, and maintain N × M bespoke, custom connections. This lack of a unified integration layer forces engineering teams to rely on a fragmented web of ad-hoc pipelines. As a result, scaling an agentic architecture quickly becomes unsustainable, exposing sensitive enterprise databases to severe security vulnerabilities, fragmented access controls, and massive maintenance overhead.

Eliminating the fragmented web of custom integrations is the core problem solved by the Model Context Protocol (MCP). Acting as a universal interface—the "USB Type-C" for AI orchestration—MCP decouples models from data sources. Instead of writing custom or managed API integration code for every new model or database, developers write to a single, standardized protocol. This approach allows any MCP-compliant agent to securely and immediately interact with any MCP-enabled system. The MCP connection lets developers connect agents to real-world systems without building bespoke integrations for every new model.

What's new in Java SDK v1.0: Built for production workloads

When we announced the public Beta for the MCP Toolbox Java SDK, our goal was to bring first-class, type-safe agent orchestration to enterprise Java environments. Since then, we've collaborated with developers and open-source contributors to harden our APIs.

The v1.0 release marks a stable, backwards-compatible foundation suitable for enterprise workloads. Here's what's new and hardened since our v0.2 release:

Transport layer abstraction & HttpMcpTransport: We introduced a clean transport layer abstraction alongside HttpMcpTransport. This feature decouples the core protocol logic from underlying HTTP clients, making it easy to swap network implementations or customize connection pooling.
Decoupled client authentication: To simplify enterprise security compliance, client authentication is now decoupled using CredentialsProvider and AuthMethods classes. Credentials are resolved asynchronously on every request, so teams can refresh tokens dynamically or plug in their own token source (Google OIDC via ADC ships in the box, anything else is a one-method interface).
Default parameter support: Native support for default values in tool parameters, reducing prompt payload sizes and enhancing agent reliability.
Pruning bound parameters: Sensitive parameters that are bound server-side (like tenant_id) are now automatically stripped from exposed tool definitions so the LLM can't manipulate them.
Version selection & session tracking: Standardized MCP version selection and robust session tracking ensure consistent protocol negotiation and conversation-state lifecycles.
HTTP credential exposure warnings: Added built-in detection that warns you at runtime when credentials are about to travel over a plaintext HTTP connection.
Generic client headers map: Easily attach custom corporate proxy headers, transaction tracing IDs, or correlation metadata to all outgoing requests.

Get started with the Java SDK v1.0

We designed the MCP Toolbox Java SDK to be frictionless for enterprise teams. Just add the following dependency to your pom.xml:

code_block: <ListValue: [StructValue([('code', '<dependency>\r\n <groupId>com.google.cloud.mcp</groupId>\r\n <artifactId>mcp-toolbox-sdk-java</artifactId>\r\n <version>1.0.0</version>\r\n</dependency>'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cba8d0>)])]>

Real-world example: The autonomous transit concierge

To demonstrate the power of the Java SDK combined with AlloyDB, let's look at an enterprise use case.

Meet Cymbal Transit, a fictitious intercity bus network. Customers don't want to click through nested dropdown menus to plan a trip. They want to ask:

"I need to get from New York to Boston tomorrow morning. Can I bring my Golden Retriever? If so, book me the fastest trip."

To answer this question, an AI agent must cross-reference unstructured data (pet policies) with structured data (schedules and seat availability) and execute a transaction (booking)—all while maintaining the context of the conversation.

The foundation: AlloyDB schema with native embeddings

We used AlloyDB for this implementation because it handles relational data and high-dimensional vectors natively. Set up your database tables with these statements:

code_block: <ListValue: [StructValue([('code', "-- Enable necessary extensions for semantic search and embeddings\r\nCREATE EXTENSION IF NOT EXISTS vector;\r\nCREATE EXTENSION IF NOT EXISTS google_ml_integration;\r\n\r\n-- Table 1: Transit Policies (Unstructured Data for RAG)\r\nCREATE TABLE transit_policies (\r\n policy_id SERIAL PRIMARY KEY,\r\n category VARCHAR(50),\r\n policy_text TEXT,\r\n policy_embedding vector(768)\r\n);\r\n\r\n-- Table 2: Intercity Bus Schedules (Structured Data)\r\nCREATE TABLE bus_schedules (\r\n trip_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\r\n origin_city VARCHAR(100),\r\n destination_city VARCHAR(100),\r\n departure_time TIMESTAMP,\r\n arrival_time TIMESTAMP,\r\n available_seats INT DEFAULT 50,\r\n ticket_price DECIMAL(6,2)\r\n);\r\n\r\n-- Table 3: Booking Ledger (Transactional Action Data)\r\nCREATE TABLE bookings (\r\n booking_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\r\n trip_id UUID REFERENCES bus_schedules(trip_id),\r\n passenger_id VARCHAR(100),\r\n status VARCHAR(20) DEFAULT 'CONFIRMED',\r\n booking_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP\r\n);"), ('language', 'lang-sql'), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cbbd90>)])]>

Mapping intents to SQL: The `tools.yaml`

The MCP Toolbox lets you define custom tools securely. Rather than granting the LLM direct database access, a tools.yaml configuration maps natural language intents directly to parameterized, safe queries:

code_block: <ListValue: [StructValue([('code', 'kind: source\r\nname: alloydb\r\ntype: alloydb-postgres\r\nproject: my-project\r\nregion: us-central1\r\ncluster: my-cluster\r\ninstance: my-instance\r\ndatabase: postgres\r\n---\r\nkind: tool\r\nname: query-schedules\r\ntype: postgres-sql\r\nsource: alloydb\r\ndescription: Find available bus schedules between cities.\r\nparameters:\r\n - name: origin\r\n type: string\r\n description: The departure city name.\r\n - name: destination\r\n type: string\r\n description: The arrival city name.\r\n - name: limit\r\n type: integer\r\n description: Maximum number of schedules to return.\r\n default: 5\r\nstatement: |\r\n SELECT CAST(trip_id AS TEXT) AS trip_id, departure_time, ticket_price\r\n FROM bus_schedules\r\n WHERE lower(origin_city) = lower($1) AND lower(destination_city) = lower($2)\r\n ORDER BY departure_time ASC\r\n LIMIT $3'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cba650>)])]>

For the complete YAML file, see the tools.yaml file in the mcp-toolbox-sdk-java repository.

Stateful agent architecture in Spring Boot

The hardest part of building conversational AI in enterprise applications is managing state: when a user asks, "What times are available?" and follows up with, "Book the 8 AM one," the agent must remember prior context across turns.

Using the Java MCP Toolbox SDK with Spring Boot and LangChain4j, we can cleanly maintain conversational memory in the HTTP Session and we can cleanly separate the agent into two declarative components:

A declarative agent interface that manages the prompt, tools, and conversational memory via an HTTP session.
A tool execution service that routes agent requests directly to the MCP Toolbox server.

code_block: <ListValue: [StructValue([('code', 'interface TransitAgent {\r\n @SystemMessage({\r\n "You are the Cymbal Transit Concierge.",\r\n "Use the \'querySchedules\' tool for finding schedules.",\r\n "Use \'bookTicket\' to execute transactions.",\r\n "Use \'searchPolicies\' to look up luggage and pet rules."\r\n })\r\n String chat(@MemoryId String sessionId, @UserMessage String userMessage);\r\n}\r\n\r\n@Service\r\nclass TransitAgentTools {\r\n // These methods automatically invoke our MCP Toolbox server!\r\n @Tool("Query specific schedules between an origin and destination city.")\r\n public String querySchedules(String origin, String destination) { ... }\r\n\r\n @Tool("Book a ticket for a passenger.")\r\n public String bookTicket(String tripId, String passengerName) { ... }\r\n\r\n @Tool("Search transit policies for luggage and pet rules.")\r\n public String searchPolicies(String query) { ... }\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cbb490>)])]>

Notice how the @MemoryId annotation abstracts session tracking: Spring Boot automatically correlates conversational context to the user's HTTP session. Meanwhile, LangChain4j and the MCP Toolbox handle schema translation and tool routing behind the scenes—no handwritten if/else intent parsing required.

By pairing the MCP Toolbox Java SDK with LangChain4j, we achieve clean separation of concerns and effortless state management:

Zero-boilerplate session management: The @MemoryId String sessionId parameter binds conversation history directly to the user's HTTP session.
Declarative agent contract: The TransitAgent interface defines the model's persona and system instructions without complex prompt templating.
Type-safe tool execution: The TransitAgentTools Spring service wraps remote MCP database tools as native Java methods.

This architecture ensures your agent remains modular: you can refine prompt guidance in the interface, manage user sessions automatically, and execute secure database queries through MCP Toolbox without tight coupling.

Connecting the dots: Listing, invoking, and executing tools in Java v1.0

Now let's look under the hood of the TransitAgentTools interface. Inside those LangChain4j @Tool methods on our Spring @Service, the MCP Toolbox Java SDK handles the heavy lifting—bridging your Java service methods to the MCP tools defined in the tools.yaml file. In just a few lines of type-safe code, we can initialize our client using the new v1.0 decoupled authentication and headers abstractions:

code_block: <ListValue: [StructValue([('code', '// 1. Initialize the Client with Decoupled Auth and Custom Headers (v1.0)\r\nString serviceUrl = "https://toolbox-my-project-uc.a.run.app/mcp";\r\nMcpToolboxClient mcpClient = McpToolboxClient.builder()\r\n .baseUrl(serviceUrl)\r\n .credentialsProvider(new GoogleCredentialsProvider(serviceUrl)) // Decoupled OIDC credentials\r\n .headers(Map.of( // Generic client headers\r\n "X-Correlation-ID", "enterprise-session-abc123",\r\n "X-Client-Platform", "Spring-Boot"\r\n ))\r\n .build();\r\n\r\n// 2. Listing Discoverable Tools\r\nmcpClient.listTools().thenAccept(tools -> {\r\n System.out.println("Successfully discovered " + tools.size() + " tools.");\r\n});\r\n\r\n// 3. Invoking a Tool (Read-Only Data with Default Parameter Support)\r\n// "limit" is omitted: the SDK fills it from the default in the tool definition\r\nString schedules = mcpClient.loadTool("query-schedules")\r\n .thenCompose(tool -> tool.execute(Map.of(\r\n "origin", "New York",\r\n "destination", "Boston")))\r\n .join().text();\r\n\r\n// 4. Executing a Transactional Tool (Using Bound Parameters)\r\nAuthTokenGetter toolAuthGetter = () -> CompletableFuture.completedFuture(myIdToken);\r\n\r\nString bookingConfirmation = mcpClient.loadTool("book-ticket", Map.of("google_auth", toolAuthGetter))\r\n // Bind the authenticated user context securely. bindParam returns a new immutable\r\n // Tool, and the bound parameter is pruned from the definition exposed to the LLM!\r\n .thenCompose(tool -> tool.bindParam("passenger_name", "Jane Doe")\r\n // Execute the mutable transaction\r\n .execute(Map.of("trip_id", "123e4567-e89b-12d3-a456-426614174000")))\r\n .join().text();'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cba7d0>)])]>

Secure by default: authentication and deployment

Moving an AI agent to production requires rock-solid credential handling and an infrastructure that scales with demand. Let's look at how you can enforce credential safety across environments and deploy independently on Cloud Run.

Application Default Credentials (ADC) & safety

By using the GoogleCredentialsProvider service, your Java app inherits its secure identity from its execution environment (whether local or in Google Cloud) through Application Default Credentials (ADC)—no hard-coded keys, with OIDC tokens minted and cached per audience under the hood. Furthermore, v1.0 offers HTTP Credential Exposure Warnings that automatically detect when credentials are about to travel over a plaintext HTTP connection and emit a runtime warning telling you to switch to HTTPS.

Deploying the fleet to Cloud Run

Because MCP Toolbox and the Spring Boot Agent are fully decoupled, they scale independently on Google Cloud Run to meet high concurrency and stateful conversation requirements.

To set up and configure Toolbox on Cloud Run, download the open-source MCP Toolbox for Databases and then follow the deployment guide.

Get started today

With MCP Toolbox Java SDK v1.0, enterprise Java teams can wire Spring Boot and LangChain4j agents to the Toolbox server, and through it, to AlloyDB and every other supported data source. When you use the toolbox, arguments are validated against the tool definition before they leave the JVM, authentication is decoupled, and custom headers are attached to every outgoing request. The following implementation steps will help you get started.

Step 1: Add the Dependency

To start building with the SDK, add the following dependency to your Maven project's pom.xml file:

code_block: <ListValue: [StructValue([('code', '<dependency>\r\n <groupId>com.google.cloud.mcp</groupId>\r\n <artifactId>mcp-toolbox-sdk-java</artifactId>\r\n <version>1.0.0</version>\r\n \r\n </dependency>'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cbab10>)])]>

Step 2: Explore Resources & Demos

GitHub Repository: Java SDK for interacting with the MCP Toolbox for Databases
Official Documentation: MCP Toolbox for Databases

Demo Application: To experience the Java SDK V1.0 for MCP Toolbox latest, try the sample application Cymbal transit project.

Gradle implementation

If your team uses Gradle instead of Maven, remember they will need to translate this dependency:

code_block: <ListValue: [StructValue([('code', "implementation 'com.google.cloud.mcp:mcp-toolbox-sdk-java:1.0.0'"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cb8750>)])]>

Automatic version tracking

If you copy this setup into automated internal repositories, keep the XML comment  intact. It's required by the release manager's deployment scripts to automatically bump versions.

Now that you can integrate your modern agentic tools and servers to your enterprise Java applications with a stale MCP Toolbox Java SDK, get started today!

Managed Apache Iceberg at scale: How Spanner powers Lakehouse runtime catalog

Tue, 06 Oct 2026 16:00:00 +0000

As customers modernize to lakehouse architectures, they are standardizing on open formats such as Apache Iceberg to create a shared data estate across compatible engines. This enables you to build AI-native lakehouses that turn data to semantic knowledge, enable proactive action, and operate at an agentic scale.

One of the key components of a lakehouse is the catalog, and in the Apache Iceberg environment, that usually means the Iceberg REST Catalog. An Apache Iceberg catalog is responsible for maintaining table pointers, handling atomic commits, and serving as the single source of truth for table locations. But as large enterprise organizations modernize to lakehouses, they have begun to realize that they need a highly scalable and available managed catalog as a part of their lakehouse architecture. This becomes even more important as querying scales with agents. To support a large amount of repeated small queries from agents, you will need to build on top of a managed catalog that provides atomicity, consistency, availability and concurrency at massive scale.

In this blog, we explore the challenges a managed catalog faces in modern cloud environments at agent scale, and show you how Google Cloud’s serverless Lakehouse runtime catalog can help address them. Powered by Spanner, Google Cloud’s always-on database with virtually unlimited scale, and built to meet the open Apache Iceberg REST catalog specification, the Lakehouse runtime catalog is the highly scalable and available foundation you need for the agentic era.

Challenges a managed catalog needs to solve in the Lakehouse

When speaking with data engineers and infrastructure leads running production analytics at scale in a Lakehouse, the following core pain points consistently emerge and need to be solved by a managed catalog:

Atomic commits and concurrency control: Iceberg guarantees ACID transactions via optimistic concurrency control (OCC). A managed catalog must implement a bulletproof atomic compare-and-swap (CAS) operation to swap the current metadata pointer.

High availability and operational maintenance: Because queries fail immediately if the catalog is down, a managed catalog becomes a critical Tier-1 service.

Scaling the database backing the catalog: Catalog architects typically face a difficult trade-off when choosing a backing database for table metadata and state. Traditional scale-up relational databases provide SQL and ACID transactions, but hit vertical CPU, memory, storage and connection limits under heavy concurrent read/write loads unless manually sharded which incurs a huge operational overhead; while scale-out database systems are either eventually consistent, hard to manage, not enterprise-ready, or all of the above.

Table maintenance coordination: A catalog alone does not optimize data; you must build and operate ancillary pipelines for compaction, snapshot expiration, manifest rewriting, and orphan file cleanup.

Governance and security: A catalog acts as the security gatekeeper. The catalog must implement and maintain:

Authentication protocols (e.g., OAuth2 token exchange, IAM federation)
Access control down to namespace and table levels
Vended storage credentials (e.g., generating short-lived tokens so query engines don't need broad, direct storage credentials)

Lakehouse runtime catalog

To solve these challenges, we built the Lakehouse runtime catalog (GA) with support for Iceberg Rest Catalog. The Lakehouse runtime catalog is a fully serverless, highly available, and unified metadata registry designed from the ground up to support modern open table formats like Apache Iceberg. By natively implementing the Apache Iceberg REST Catalog specification, the Lakehouse runtime catalog decouples metadata discovery from compute engines, helping ensure multiple Iceberg-compatible engines can access a shared data estate and enabling you to take your workloads to production sooner. We’ve helped many customers streamline the migration of their managed catalogs. For example, Etsy migrated its catalog to Lakehouse runtime catalog, joining data in place to accelerate pipeline queries by 60%.

This approach offers a number of architectural benefits:

Open APIs: Support for Iceberg Rest Catalog enables different teams to use their preferred analytics tools on a single, unified dataset.
Multi-engine interoperability: Once registered, tables are immediately discoverable and queryable across Google Cloud Managed Service for Apache Spark, BigQuery, and open-source engines via standard REST interfaces.
Read/write interoperability for Iceberg tables: Leverage Iceberg-compatible engines such as BigQuery, Managed Spark to write to Iceberg tables registered in the Lakehouse runtime catalog. Customers can also use Managed Spark to write to Iceberg tables in external catalogs.
Fully managed Iceberg storage with enterprise-grade features: Use Google's differentiated infrastructure to run analytics with performance on Iceberg tables. This gives you the benefits of open-source flexibility plus performance, scale, governance, and multimodal processing.
Zero data copy: Table definitions point directly to your existing data in the underlying object store. You do not move, rewrite, or duplicate your underlying data.
Bi-directional catalog federation across clouds: Access data from Databricks Unity, Snowflake Horizon and AWS Glue with support for vended credentials and OIDC token exchange. This lets you bring Google AI directly to your AWS and Azure data.
Secure access using credential vending: The catalog supports multiple authorization mechanisms, letting you choose between credential vending and end-user credentials. This means that you can access tables with modern mechanisms such as credential vending without needing direct access to the files in the underlying object store (Cloud Storage, AWS S3, Azure Blob Storage).
AI-powered context and governance: The Lakehouse runtime catalog integrates directly with Knowledge Catalog and Cloud IAM, allowing you to define trusted context for your agents, and apply table-level security consistently across all compute engines. Get out-of-the-box search, lineage, and insights for Iceberg tables in the catalog.
Atomic commits and concurrency control, high availability and scalability: Backed by Google’s planet-scale infrastructure and Spanner, you get the high availability, concurrency and scale you need for your metadata to scale with your data. Support for Cloud Storage dual-region and multi-region buckets enables failover use cases. It also provides reduced TCO due to serverless and no-ops environments, and scalability for any workload size.

What powers the Lakehouse runtime catalog?

The Lakehouse runtime catalog is a highly available, concurrent and scalable catalog with strong consistency guarantees because it is built on top of Spanner. Unlike traditional scale-up relational databases that hit vertical single-node ceilings, Spanner combines full relational SQL semantics and multi-table ACID transactions with the horizontal scale-out elasticity for both reads and writes of a NoSQL system.

Spanner makes the Lakehouse runtime catalog highly available through Spanner’s regional configurations with up to 99.99% availability. Spanner also delivers out-of-the-box scalability for Lakehouse runtime catalog: As a horizontally scalable database, Spanner does not require manual sharding and scales compute and storage independently and transparently. Spanner dynamically monitors data volume and query load, splitting and redistributing data ranges across nodes. Compute nodes scale dynamically based on CPU utilization and storage thresholds. Spanner automatically detects split-level overload and moves heavy splits away from overloaded nodes. Spanner also lets Lakehouse runtime catalog users eliminate the traditional trade-offs between relational consistency and distributed scalability, delivering Lakehouse runtime catalog’s industry-leading consistency guarantees. Lakehouse transactions are serializable — the order of transactions within the database is the same as the order in which clients observe the transactions to have been committed. This foundation allows Lakehouse users to operate at agent-scale.

Then, to further power agentic use cases, the Lakehouse runtime catalog integrates directly with Knowledge Catalog to easily discover lakehouse Iceberg tables and provide trusted context to agents. Knowledge Catalog leverages an efficient combination of full-text search and native vector search provided by Spanner; this approach enables better recall for search retrieval, pairing lexical keyword searches with semantic embeddings in a single query. Because both index types are built on the identical base dataset, they update with strict, transactional ACID consistency alongside base table DML operations. This removes operational overhead such as managing sync pipelines, and external-vector and full-text search systems. In short, the Lakehouse runtime catalog provides faster time-to-market for your agentic use cases.

Combine analytical and operational workloads

With Google Cloud’s borderless Lakehouse based on Apache Iceberg, you can combine your analytical data with your operational workloads. Use cases span combining data assets from your Lakehouse with OLTP data (from Spanner) for analytics, to low-latency serving applications where your Lakehouse assets are accessible in an operational database such as Spanner, to conversational analytics in first-party and third-party agents.

Below, in an example, you can see the Lakehouse runtime catalog with Spanner in action. Here, we combine analytical data for taxi trips in Manhattan (backed by Apache Iceberg) with operational data for taxi zones in Spanner to find the most congested traffic routes. The example also shows that you can also use a Conversational Analytics Agent to access the same data and get second-order insights.

Find out most congested traffic routes in Manhattan

Modernize to the borderless Lakehouse

Modernizing to Google Cloud’s Lakehouse minimizes data silos across analytics engines and agents, unifies multi-engine governance, provides trusted context to your agents and slashes operational TCO. Leveraging the Spanner-based Lakehouse runtime catalog helps prepare your modern cloud environments to operate at agent-scale. To learn more and get started with a free trial, visit the

Lakehouse web page and learn more about Spanner here.

Networking for AI inference model serving - GKE only and for all other backends

Tue, 06 Oct 2026 12:00:00 +0000

Enterprises and individual developers frequently run multiple AI inference models. The right architecture can simplify how the models are called while also providing centralized governance. In this post, we'll look at two reference architectures focused on networking AI inference model serving: one for Google Kubernetes Engine (GKE) and one all other backend types. First, we'll explore the commonalities between the reference architectures that you'll see later. Then we'll explore unique components of the architecture for GKE backends and finally, we'll go over the elements of the architecture for all backend types.

The entry point

You can expose your model deployment behind a stable, secure, and reliable entry point that acts as the front end for inference calls. This entry point also acts as a control zone where policy, security, and logic can be enforced. Both the Cloud Load balancer and the Inference Gateway provide entry point capability. These types of endpoints can terminate secure connections with TLS, integrate with API management components, extend functionally with service extensions, and capitalize on capabilities of Model Armor for added security.

Common services in the designs

Both reference designs use these services:

Private Service Connect inference endpoint: Anchors the entry point inside your consumer Virtual Private Cloud (VPC) network. Traffic hits a private internal IP address, keeping inference calls in your private network.
Apigee API Management (Optional): Integrates via an Apigee Extension Processor callout to handle client identity verification, rate limits, and quota enforcement before requests ever reach compute resources.
Model Armor: Serves as an inline AI safety checkpoint, screening prompts and output completions against prompt injection and sensitive data leakage.

Design pattern serving on GKE only

This section focuses on a GKE-only backend design. To understand the full end-to-end concept, please read the entire architecture document Networking for AI inference model serving on GKE. The design pattern is based on this diagram:

In addition to the common services identified in the previous section, the design for GKE uses these components:

GKE Inference Gateway: Deployed as an internal Application Load Balancer (gke-l7-rilb). It acts as a specialized ingress engine that parses incoming request payloads, evaluates HTTPRoute rules, and steers queries to appropriate model-serving targets.
Inference pools: A logical group containing replicas of the same model. When the Gateway receives a prompt, it evaluates HTTPRoute rules to select the appropriate inference pool based on the model identifier. Pools have an initial size and can be configured to autoscale dynamically.
Model replica sets: Individual model replicas (inference server instances) deployed across single-node or multi-node GPU or TPU node pools. A replica set represents a uniform group of these model replicas.

The traffic flow GKE example

A client application that uses this GKE-based architecture to call a backend model would go through a flow like this:

Ingress: A client application in the consumer VPC issues an OpenAI-compatible API call to the local Private Service Connect endpoint, routing directly to the GKE Inference gateway using a regional internal Application Load Balancer.
Payload inspection: The Gateway reads the target model parameter specified in the request body and adds it to the HTTP headers.
Control plane validation: If Apigee is used, it checks client credentials and quotas. Model Armor screens the prompt for policy violations or data leakage.
Backend selection: The Gateway evaluates HTTPRoute mappings to identify the target pool, matches shared prefix cache context, and routes to the lowest-load GPU or TPU replica based on real-time Prometheus data.
Egress: The replica runs the inference workload. Output tokens pass through Model Armor for final response verification before streaming back over the private connection.

Design pattern serving on all backends

This section focuses on multiple backend types which can be used for inference, and it provides an overview of the architecture in the following diagram. To understand the full end-to-end concept, please read the entire architecture document Networking for AI inference model serving on all backends.

For architectures spanning mixed environments such as GKE, Cloud Run, Agent Platform, on-premises data centers, or external clouds, these additional components are used:

Regional internal Application Load Balancer: Serves as the central Layer 7 routing proxy that manages routing logic, SSL termination, and Service Extensions callouts.
Inference Payload Processor (Service Extensions): This is similar to body-based routing as used in the GKE Inference Gateway, but to enable the functionality on an Application Load Balancer a service extension is needed. A lightweight Cloud Run callout inspects the JSON body of incoming OpenAI API requests, extracts the target model identifier, and writes an X-Gateway-Model-Name header to drive URL map routing.
Network Endpoint Group (NEG): Delivers flexible routing to heterogeneous backends based on the injected model header.

All-backends traffic flow example

A client application that uses this architecture to call a backend model would go through a flow like this:

Private ingress: The client application targets the Private Service Connect endpoint over private IP address space. The regional internal Application Load Balancer receives the request.
Model name extraction: The load balancer sends the payload to the Cloud Run body-based router callout, which inspects the JSON payload and injects the X-Gateway-Model-Name header.
Policy and safety enforcement: The request passes to Apigee for identity and quota validation, then to Model Armor to scrub sensitive data and block malicious prompts.
NEG routing: The load balancer URL map inspects the model header and forwards the request to the matching backend NEG (Agent Platform, GKE, Cloud Run, Hybrid, or Internet).
Private delivery: The target backend executes the model prompt, Model Armor screens the completion, and the result returns privately along the ingress path.

What's next

Take a deeper dive into building AI workloads on Google Cloud:

Document set: Agentic AI architecture guides
Architecture Center: Multi-agent private networking patterns in Google Cloud
Document: Gemini Enterprise Agent Platform networking access overview

Want to ask a question, find out more, or share a thought? Please connect with me on Linkedin.

Where mission meets moonshot: Join us at the Google Public Sector Summit 2026

Tue, 06 Oct 2026 07:00:00 +0000

Across the public sector, the question has shifted from “what’s possible?” to “how can we drive mission impact?” We’ll be answering this question at the Google Public Sector Summit on October 20th at the Ronald Reagan Building in Washington, D.C.

This year’s summit brings together public sector leaders, creators, and builders to architect what’s next and bridge the gap between ambitious innovation and secure, scaled execution. Together, we’ll explore how public sector organizations are harnessing Google’s secure, integrated AI stack—encompassing everything from planet-scale infrastructure to leading models and agentic platforms—to turn ambitious moonshot aspirations into real-world outcomes that drive mission impact.

The Google Public Sector Summit is a celebration of what’s possible when human ambition and powerful technology come together in support of mission. Keep reading for a preview of the event, and how to make the most of your onsite experience.

Opening Keynote: Where Mission Meets Moonshot

Get inspired during our opening keynote which will feature Karen Dahut, CEO of Google Public Sector, Thomas Kurian, CEO of Google Cloud, and Chris Hein, Field CTO of Google Public Sector. They will share real-world customer examples and live product demonstrations that showcase Google’s technology in action across the public sector. Attendees will also get the opportunity to hear from public sector leaders who are collaborating with Google and applying technology to transform missions and power moonshots.

General Session: Cloud Talks

Join Elizabeth Moon, Managing Director of Customer Engineering for Google Public Sector, as she hosts a series of talks that dive deeper into the critical pillars of public sector transformation including infrastructure, AI, and security. Hear from Rich Sanzi, VP of Engineering for Google Cloud, Michael Gerstenhaber, VP of Product Management for Gemini, and Sandra Joyce, VP of Google Threat Intelligence, as they share strategies for establishing an infrastructure foundation for the agentic era, building safely with Google’s platforms, and implementing proactive defense at planet scale.

Breakouts: Panel Discussions and Birds of a Feather

Hear from Google Public Sector executives, industry partners, and leaders across defense, federal civilian, higher education, and state and local government through a series of panels and birds of a feather discussions.

From fragmented to fluid: Connecting data to build the agentic future. Moderated by Tony Orlando, Managing Director of Partner and Specialty Sales, this session will explore how agencies can break down legacy data silos and build a unified, AI-ready data foundation. Speakers include Andrew Mapes, CDAO Principal Deputy Chief Digital and AI Officer, Dr. Neil Jacobs, NOAA Administrator and Undersecretary of Commerce for Oceans and Atmosphere, and Scott Alfieri, Accenture Global Lead for the Google Business Group. An additional speaker, Adarryl Roberts, DLA CIO, has been invited.
Automating defense: Securing the agentic era against complex threats. Moderated by Ron Bushar, Managing Director and Chief Security Officer, panelists will discuss how they’re applying autonomous AI and threat intelligence to protect dynamic environments at machine speed. Speakers include Justin Fanelli, U.S. Navy CTO, Jamie Wolff, DOE-NNSA CIO, Vice Admiral (Ret.) TJ White, Texas Cyber Command Chief, and Thomas Browning, Rhombus Power Senior Vice President of Strategic Capabilities.
The agentic era: Advancing missions and transforming the way we work. Moderated by Elizabeth Moon, this session will highlight how secure, cost-efficient agentic capabilities can scale impact and advance missions. Featured speakers include Barry J. Schindler, USPTO Acting Commissioner for Patents, Miro Humer, Case Western Reserve University CIO, and Todd Johnston, Deloitte Managing Director, AI & Engineering and Defense, Security & Justice AI/Analytics Leader.
Interactive Birds of a Feather discussions. Connect directly with a small group of peers and Google experts to address critical mission blockers, share best practices, and accelerate your agency's journey beyond the pilot stage. Join discussions across a range of topics including tokenomics, migration, and compliance.

Demos, Lightning Talks and Labs

Experience Google’s innovations through hands-on labs, Lightning Talks, and demos taking place in the Mission Exchange on the showfloor. Topics will include agentic threat defense, multimodal AI citizen services, and legacy database modernization with AI.

Attendees can also join two expert-led labs:

Getting Started with Gemini: This introductory lab will guide participants through the fundamentals of Gemini and Gemini Notebook to summarize documents, search data and streamline daily tasks. No technical background required.
Build Gemini Agents: From Prompt to Prototype: This lab will help you bring your real-world agency use cases to life by building an AI agent with Gemini, with support from Google Cloud specialists.

Throughout the day, we will host Lightning Talks, which are dynamic 20-minute presentations featuring live demos and interactive Q&A that take place on the showfloor. These talks feature partner and customer speakers and showcase the "art of the practical" through live, real-world solutions.

Closing Session: What’s Your Moonshot?

Join us for an inspirational closing session that I’ll moderate with a special guest: NASA Administrator Jared Isaacman. Together, we’ll define what a moonshot means for the public sector in the agentic era and share strategies for fostering a culture of courageous problem-solving and applying technology to supercharge human ambition and ingenuity.

Register for the Google Public Sector Summit

Beyond the personalized programming and practical hands-on experiences, attendees will leave the event with a customized action plan for driving impact in their organization. Register today for the Google Public Sector Summit to gain the strategies, skills, and inspiration to turn your moonshot aspirations into a reality. Join us as we build what’s next for the public sector, together.

AlloyDB: A unified database engine for hybrid search

Tue, 06 Oct 2026 07:00:00 +0000

For modern AI and RAG applications, achieving high search relevance requires that you combine at least two techniques: vector search for semantic context, and full-text search (FTS) for keyword precision. While AlloyDB for PostgreSQL supports both of these capabilities, managing them has traditionally required a more hands-on operational approach to ensure peak performance.

The challenge is not executing the searches, but the subsequent fusion of result sets. Merging results from the vector query (distance scores) and the FTS query (relevance scores) requires complex SQL queries or custom code in the application layer. This often means maintaining a separate system for fusion, score normalization, and re-ranking.

This article details how AlloyDB AI's hybrid search eliminates this complexity. We will explore how recent updates allow you to:

Simplify hybrid search: Consolidate complex SQL queries, or multi-step application workflows into a single, high-performance SQL function powered by Reciprocal Rank Fusion (RRF).
Optimize FTS performance: Use the new RUM extension to achieve low-latency relevance ranking and efficient phrase matching by storing word positions directly in the index.
Leverage industry-standard ranking: Utilize the new natively supported BM25 index for superior keyword-based scoring directly out of the box.
Expand search versatility: Execute queries against specialized external clusters, including Elasticsearch, OpenSearch, and Solr, using the new external search Foreign Data Wrapper (FDW) without leaving the AlloyDB environment.

The problem of the multi-step workflow

Before AlloyDB AI's native solution, achieving robust hybrid search was very demanding, especially for developers trying to keep this logic within the database using standard SQL. This approach required multi-step orchestration that was not only difficult to manage and maintain for two sources, but became virtually impossible to scale as additional sources were added. These steps included:

Executing vector search: Run a query using a vector column or vector index (for AlloyDB this can be a ScaNN index) to find top k results, generating vector scores.
Executing the FTS query: Run FTS query e.g. by using a generalized inverted index, or GIN, to find top k results.
Normalizing scores (the brittle step): Write complex SQL logic or custom application code to map both result sets onto a common scale. This logic is prone to breaking when data distributions change.
Performing cross-service joins and re-rankings: Use application memory to perform a complex FULL OUTER JOIN on document IDs, apply a weighted summation of the normalized scores, and finally sort the combined results in cases where the FTS search was done in a separate system than the one used for vector search.

This decentralized approach led to fragile score logic, increased latency, high operational load, and a dependency on application expertise for maintaining search quality.

Simplifying hybrid search architectures with AlloyDB

The key to simplifying this is to adopt RRF, which, because it is inherently rank-based, cleverly bypasses the brittle step of score normalization entirely. RRF consists of two parts:

1. The single source of truth

Instead of a multi-step fetch and join process, you simply call one SQL function, providing your search components as a declarative JSON array:

SQL

code_block: <ListValue: [StructValue([('code', 'SELECT id, score \r\nFROM ai.hybrid_search(\r\n search_inputs => ARRAY[\r\n -- Vector Component (Semantic) with dynamic embedding generation from natural language\r\n $json${\r\n "data_type": "vector",\r\n "limit": 10,\r\n "table_name": "documents",\r\n "key_column": "doc_id",\r\n "vec_column": "embedding",\r\n "distance_operator": "<=>",\r\n "query_vector": "ai.embedding(\'text-embedding-005\', \'alloydb search\')::vector"\r\n }$json$::jsonb,\r\n \r\n -- Text Component (Keyword)\r\n $json${\r\n "data_type": "text",\r\n "limit": 10,\r\n "table_name": "documents",\r\n "key_column": "doc_id",\r\n "text_column": "content",\r\n "query_text_input": "alloydb search"\r\n }$json$::jsonb\r\n ]\r\n);'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e30cf2350>)])]>

(Note: The unified ai.hybrid_search API isn't limited to just two components. It also natively supports external search sources via the new FDW).

2. Database-native orchestration

The hybrid_search() function executes the entire workflow in a single query plan, minimizing overhead and helping ensure transaction consistency. It uses:

Dynamic CTE generation: The function constructs dynamic SQL, creating Common Table Expressions (CTEs) for each component. Each CTE is responsible for calculating the positional rank (ROW_NUMBER()) of its results.
Kernel-level fusion: All ranked component results are immediately combined using a FULL OUTER JOIN based on the document ID.
Final RRF score: The combined ranks are used to calculate the final, unified score using the RRF formula:

By taking this approach, brittle score calculations and application-side joins become unnecessary. While Reciprocal Rank Fusion (RRF) is our current ranking algorithm, we intend to introduce additional merging and ranking options down the road.

The result: Performance and operational simplicity

Moving from complex external workflows to native SQL functions provides immediate, measurable benefits:

Metric	Multi-step application workflow (simulated by manual SQL)	AlloyDB AI-native hybrid_search() UDF
Code complexity	Complex score normalization functions, service calls, and application joins.	Zero external logic; a single, declarative SQL call.
Maintenance	Constant tuning of normalization formulas.	No tuning required; RRF is rank-based and distribution-agnostic.

Enhancing FTS performance: The RUM extension

AlloyDB AI's hybrid_search() function is designed to deliver comprehensive search relevance by combining high-performance vector search with FTS. While AlloyDB's native FTS capabilities are powerful, reliance on the standard PostgreSQL GIN index for the text component can present a bottleneck for advanced operations.

The challenge with GIN indexes is that they do not store the positional information of words. This limitation forces costly table scans to re-analyze content for:

Relevance ranking: Calculating search result scores based on word proximity and frequency
Phrase searching: Finding exact word order, which requires positional information.

Introducing the RUM extension for low-latency FTS

The RUM extension is a powerful index access method based on GIN that directly resolves these performance issues.

RUM's core advantage: Unlike the GIN index (which maps word -> [docID]), the RUM index stores the positional information of each word directly within the index (e.g., word -> [(docID1, [pos])], ...).
Performance benefits: This allows RUM to perform complex operations like ranking and phrase matching predominantly within the index itself, avoiding expensive heap scans. RUM provides significantly faster relevance ranking and efficient phrase and proximity searches.
Great for hybrid search: RUM is a critical complement to vector search (like ScaNN) within a hybrid search framework, as GIN’s potential latency makes it less suitable for a real-time hybrid approach.

The RUM extension is an excellent choice for ranking-heavy or high-concurrency search applications. By storing word positions directly in the index, RUM cuts out the need to re-scan table pages during ranking, giving you fast and sorted results. However, it comes with some trade-offs: slower index builds and a larger disk footprint. If your workload prioritizes quick queries and precise ranking over write speeds and storage density, RUM is an investment that's well worth it.

Measurable gains and integration

Adopting RUM directly bolsters the performance of FTS in AlloyDB, showing considerable gains for raw FTS queries, as well as gains on hybrid search that includes FTS queries. Below are performance statistics showing the speedup between using RUM compared to GIN on various BEIR datasets.

(Performance based on tests using the BEIR Natural Questions benchmark.)

RUM integrates with the specialized <=> distance operator for search and ranking, which is supported for use in hybrid search SQL calls, delivering the best of both worlds. The following codelab shows how to configure and use the RUM index with the Hybrid Search UDF.

Introducing BM25 Index: The modern ranking standard

We recently introduced the BM25 index to CloudSQL and AlloyDB in preview, bringing the industry-standard relevance ranking via the pg_textsearch extension. BM25 uses TF-IDF, which accounts for term frequency saturation and document length normalization, delivering significantly higher precision and quality for keyword-based search queries. By leveraging native BM25 indexes within AlloyDB AI, you can achieve superior ranking accuracy out of the box, so that exact-term matches and critical keywords score well without having to implement external search engines or complex custom scoring logic.

code_block: <ListValue: [StructValue([('code', "-- Install pg_textsearch extension\r\nCREATE EXTENSION pg_textsearch;\r\n\r\n-- Create the native BM25 index on the content column\r\nCREATE INDEX idx_docs_bm25 \r\nON cymbal_products \r\nUSING bm25 (product_description) \r\nWITH (text_config='english');\r\n\r\n-- Full text search query\r\nSELECT product_name, product_description <@> 'cherry tree' AS bm25_score \r\nFROM cymbal_products\r\nORDER BY bm25_score \r\nLIMIT 5;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7e32c29790>)])]>

External search: Extending versatility with foreign data wrappers

To further extend search capabilities, we also introduced the external search Foreign Data Wrapper (FDW) in AlloyDB AI. This lets you execute full-text searches against specialized external clusters, starting with Elasticsearch, OpenSearch, and Solr, and provides several key architectural advantages:

Optimized retrieval: Leverage ranking algorithms and a richer feature set from dedicated search backends without leaving the AlloyDB environment.
Unified SQL interface: Interact with external data, perform joins, and meld results using standard PostgreSQL SQL without losing the expressiveness of advanced FTS queries.
Strong portability: Maintain existing search infrastructure while benefiting from the simplified hybrid architecture offered by AlloyDB AI.

The following codelabs are end-to-end code guides walking through hybrid search with Elasticsearch and Solr integrations.

A unified architecture for AI-powered search

The true challenge of modern search is not technical in nature, but in achieving architectural simplicity and sustained operational stability. AlloyDB AI addresses this with a unified platform built on three core innovations:

Simplifying hybrid search: AlloyDB AI’s hybrid search function, powered by RRF, transforms a fragile, multi-step application workflow into a single, high-performance SQL call. This native implementation eliminates the need for complex score normalization and application-side joins, drastically lowering the operational and engineering cost while delivering consistently accurate and fast hybrid relevant results.
Optimizing FTS performance: To ensure the FTS component of Hybrid Search meets diverse application demands, AlloyDB AI offers distinct full-text search options. The RUM extension optimizes for low-latency performance by storing positional data directly in the index to enable faster relevance ranking and efficient phrase searches — important when you need fast query speeds. Alternatively, the BM25 index provides industry-standard relevance ranking, and is the preferred choice when prioritizing keyword scoring precision. You can select between these options depending on whether your focus is search latency or ranking precision.
Enhancing versatility through external search: The addition of the external search through FDW extends AlloyDB’s reach to specialized search backends like Elasticsearch. This lets you leverage the superior scale and advanced retrieval features of dedicated search clusters while maintaining a familiar PostgreSQL interface. By integrating these external results directly into the hybrid search framework, AlloyDB AI ensures that you can combine even the most massive text repositories with vector-based semantic insights.

By consolidating the complexity of scoring, joining, and re-ranking within the database kernel, and offering a dual-path approach to FTS — leveraging RUM for optimized, low-latency, internal FTS or external search for specialized, scalable backends — AlloyDB AI delivers a robust and self-contained search foundation. This coexistence is essential to the overall hybrid search story, providing the flexibility to choose the optimal path based on workload, data volume, and existing infrastructure. Now, you can focus on building intelligent application features, confident that your search architecture is both highly performant and easy to maintain.

Watch it in action

Watch how AlloyDB is the ultimate hybrid search engine.

Learn about BM25 support in AlloyDB.

Getting started

Ready to bring more speed and cost-efficiency to your AI workloads?

New to AlloyDB? Discover AlloyDB with a 30-day free trial.
Getting started with hybrid search: Set up a text-search index and select a vector search index. Once these are created, you can find some examples to perform various hybrid search queries.
External search: Create a foreign data wrapper and foreign table in AlloyDB to query external data from Elasticsearch, Solr, or OpenSearch.

Introducing Google Cloud Modernize, transforming for (and with) AI

Mon, 05 Oct 2026 16:00:00 +0000

Today, we’re announcing Google Cloud Modernize, an end-to-end transformation portfolio to help enterprises collapse multi-year roadmaps with the power of AI.

Google Cloud Modernize brings together Google Cloud’s proven migration and modernization tools, including Migration Center, Google Cloud VMware Engine, Google Cloud Mainframe Modernization and our new EKS-to-GKE Migration Agent, into a single portfolio. With it, enterprise teams now have purpose-built agentic capabilities across infrastructure assessment, platform modernization, and application modernization.

Central to this portfolio is Modernization Hub, a newly launched in-console experience where developers and architects can analyze source code, map dependencies, and accelerate modernization for Java, .NET, and mainframe applications.

Agentic infrastructure assessment

Every transformation begins with an accurate assessment. With new Gemini capabilities in Migration Center, the Agentic Quick Estimator (GA) converts VMware inventory exports (such as RVTools) and infrastructure inputs into total cost of ownership (TCO) projections for your Compute Engine environment.

Using an interactive chat interface, teams can test real-time modeling assumptions, such as evaluating multi-region footprints or comparing BYOL licensing against pay-as-you-go, to discover contextual cost optimizations. This condenses weeks of spreadsheet modeling into a defensible business case in minutes.

Migration Center’s Quick TCO Estimator and agentic chat interface

For specialized support, we also provide a comprehensive modernization assessment at no cost through our Rapid Migration & Modernization Program (RaMP).

Platform modernization

With the rise of real-time AI agents querying backend systems, workloads increasingly require high-throughput infrastructure that removes I/O bottlenecks. Once you’ve defined your target environment using our assessments, there are several new purpose-built compute options for mission-critical workloads:

SAP S/4HANA at scale (X5 Series, GA): Delivers single-node 43 TiB memory configurations that remove the previous 29 TiB ceiling, allowing enterprise ERP estates to run without distributed partitioning overhead.
Core-optimized database performance (M4N Series, GA): Delivers 26.57 GiB RAM per vCPU paired with Hyperdisk Extreme. This prevents organizations from overprovisioning compute cores to meet memory requirements, reducing software licensing costs by more than 20% for Oracle and other core-licensed databases.
Ultra-low latency data engines (Z4D, GA and Z4M, Preview): Deliver up to 84,000 GiB and 168,000 GiB of high-speed local NVMe SSD respectively, 400 Gbps networking for both Z4D and Z4M, and RDMA support for Z4M. This throughput reduces I/O wait times and prevents query timeouts when real-time AI agents query vector stores, operational databases, and large-scale data pipelines.

Cloud elasticity for VMware environments

For organizations operating VMware estates that need the elasticity of the cloud but aren’t ready to re-architect their environment, the Google Cloud self-managed VMware solution provides administrative control on Bare Metal Z3 shapes with VMware Cloud Foundation (VCF) 9.1. Native global VPC links connect VMware estates directly to Compute Engine, Google Kubernetes Engine (GKE), BigQuery, and Gemini Enterprise, allowing teams to ground autonomous agents in operational data without code changes.

Automated container transitions to GKE

The new EKS-to-GKE Agentic Migration (Public Preview) automates transitions from AWS Elastic Kubernetes Service to GKE thanks to:

An automated pipeline: Manages discovery, Kubernetes manifest translations, storage and network mappings across clouds.
Enterprise-grade security: Built-in Human-in-the-Loop (HITL) approval gates and in-memory credential security maintain strict GitOps compliance.
A fast-track to modern runtimes: Quickly moves workloads to GKE to take advantage of low-latency model serving, autoscaling, and multi-agent orchestration.

NetEase Games demonstrated the value of this platform approach by containerizing services on GKE, reducing infrastructure scaling times from hours to five minutes during peak launches while cutting server costs by 40%:

"By integrating diverse computing instances and powerful orchestration, we have transformed our infrastructure into a competitive advantage, ensuring NetEase remains a leader in the global gaming market." - Deng Ding, Director of Site Reliability Engineering, NetEase Games

Application modernization with Modernization Hub

Landing on modern infrastructure enables teams to unlock legacy business logic and modernize their core applications. Modernization Hub centralizes several modernization tools directly inside the Google Cloud console.

.NET and Java modernization

Modernization Hub integrates the Google Cloud App Modernization CLI (CodMod), which uses Gemini to analyze large source code repositories, understand legacy application architectures,maps hidden dependencies, identifies modernization challenges and generates modernization recommendations. This enables customers to migrate legacy .NET Framework applications to modern .NET Core running on Linux containers, reducing OS licensing overhead, while also making these applications and data accessible to modern AI agent workflows.

Modernization Hub’s in-console interface

Mainframe modernization

For customers running mainframes, we provide specialized solutions to help accelerate and de-risk end-to-end application transformation to Google Cloud:

Mainframe Assessment Tool: Parses legacy mainframe codebases, extracts business rules, maps application and data dependencies to generate cloud-ready target application specifications and power agentic modernization workflows.
Dual Run: Substantially reduces cutover risk by replaying live production transaction streams simultaneously across the mainframe and the new cloud applications, verifying functional equivalence before going live.
Mainframe Connector: Copies mainframe data directly into Google Cloud services (BigQuery, AlloyDB, GCS and others), , unlocking legacy data and supports hybrid architectures.

Intesa Sanpaolo used Google Cloud mainframe modernization solutions to accelerate their core banking transformation off the mainframe and onto Google Cloud:

“To confidently move forward with Mainframe Modernization, we will need to provide confidence and assure the bank's leadership and internal control units as well as get approval from the regulators. One of the enablers for this is Google Cloud Dual Run, which is gradually providing the evidences to build such confidence to all three groups.” - Claudio Balbo, Head of IT Architecture, Intesa Sanpaolo

A proven track record and partner ecosystem

Deutsche Börse Group transitioned its mission-critical SAP S/4HANA environment and DAX® index calculations to Google Cloud, cutting disaster recovery times from hours to minutes, reducing aggregation latency by over 50%, and shortening development cycles from months to days.

To deliver these capabilities at enterprise scale, we are also collaborating with our global partner ecosystem to integrate Google Cloud Modernize with enterprise delivery frameworks, including Cognizant:

“Google’s modernization offering heralds the next frontier of AI-native modernization — enabling enterprises to autonomously decode legacy complexity and accelerate into cloud-first, intelligent architectures. Coupled with Cognizant's AI-led, governed delivery engine, we amplify this shift through agentic business processing, unlocking faster, outcome-driven value at scale.” - Nishant Upadhyaya, Global Practice Head – Digital Engineering, Cognizant

Accelerate your transformation now

Modernizing your infrastructure and applications is the baseline requirement for enterprise AI agility. Google Cloud Modernize equips teams to navigate each phase safely and efficiently as they pursue AI readiness and adoption.

Get started:

Join the webinar: Register for our upcoming session on November 17 to see live demos of Modernization Hub and our agentic migration tools.
Explore the console: Log into the Google Cloud Modernize console to access Modernization Hub.
Start planning: Visit the Google Cloud Modernize webpage, or request a modernization assessment at no cost today.

Cloud Blog

Cross-cloud conversational analytics made simple with open standards

The borderless lakehouse architecture

Configure Databricks Unity Catalog

Connect Databricks to BigQuery

Run one query across three clouds

Explore cross-cloud data with natural language

Analyze sales performance in natural language

Plan for caching and data residency

Next steps

Appendix

Connect Snowflake and Big Query

Configure Snowflake Horizon Catalog

Configure AWS Glue Data Catalog

Connect AWS Glue to BigQuery

5. Enable metadata synchronization and verify

Gemini 4 Argon available on Google Cloud, built to help solve your business’ hardest problems

Four ways Argon changes how your business works

1. Hand off your hardest work

2. Precise, verifiable results on the work that drives your business

3. Build and ship products faster

4. Stronger defense for your code and business

Enterprise customers and partners in our early access program are already seeing strong wins with Argon.

Get started

One Agent Development Kit, five languages

A shared foundation

Starting agent-first

Hands-on view of each ADK

Python

Go

TypeScript

Java

Kotlin

Choice without compromise

Introducing TimesFM 3.0 with multivariate time-series forecasting in BigQuery

Overview

What’s new: Multivariate foundation modeling

Multivariate forecasting with BigQuery SQL

Understanding the output

TimesFM 3.0 in BigQuery Conversational Analytics

Summary and next steps

Agentic data science with the Data Agent Kit

Introducing the Data Agent Kit

Loading the data

Cleaning it up

Building the review queue

Running it again tomorrow

Try it yourself

Agentic analytics with the Data Agent Kit

10 Years of the SRE book: Announcing the second edition of "Site Reliability Engineering”

Why update the book?

A decade of evolution: How SRE practices have progressed

SRE in the age of AI

What hasn’t changed? The importance of culture

Trusted Data Apps for the Agentic Data Cloud, powered by Looker

What is a data app?

Expanding your semantic layer into an application platform

Built for enterprise scale

From prototype to production in minutes

What’s new with Google Data Cloud

October 5 - October 9

September 7 - September 10

August 31 - September 4

July 6 - July 10

June 1 - June 5

May 11 - May 15

April 20 - April 24

April 13 - April 17

April 6 - April 10

March 23 - March 27

March 16 - March 20

February 23 - February 27

February 16 - February 20

February 2 - February 6

January 26 - January 30

January 19 - January 23

January 12 - January 16

What’s new with Google Data Cloud - 2025

Modernizing Unstructured Data Workflows: Alteryx Live Query meets Google Cloud BigQuery

From invoice PDFs to govern exception reporting in BigQuery with Live Query

Mapping intents to SQL: The `tools.yaml`