Coding agents have become good at writing SQL, Python, PySpark, notebooks, and pipeline code.
The problem is that code generation is only one part of data engineering.
An agent can write:
SELECT *
FROM sales.orders
WHERE status = 'pending';But it may not know:
Which project contains the table.
Which dataset is trusted.
How the table is partitioned.
Which columns contain sensitive data.
Whether the query will scan terabytes.
Why yesterday's pipeline failed.
Which data source should be used instead.
Google Cloud Data Agent Kit is designed to give coding agents access to this missing context.
It provides MCP tools and agent skills that let supported coding agents work with Google Cloud data services directly from an IDE or CLI. The current Data Agent Kit supports services including BigQuery, Bigtable, Spanner, AlloyDB, Cloud SQL, Cloud Storage, Dataflow, Managed Service for Apache Spark, Managed Service for Apache Airflow, and Knowledge Catalog.
The interesting part is not simply that an AI can generate SQL.
It is that the agent can work with real cloud data and real data infrastructure instead of relying on schemas and examples manually pasted into a prompt.
What Is Google Cloud Data Agent Kit?
Data Agent Kit is a collection of MCP tools and agent skills for data engineering and data science workflows.
Google made the kit generally available in September 2026. It is available at no additional charge, although the Google Cloud services used by the agent continue to incur their normal charges.
A simplified architecture looks like this:
Developer
|
v
Coding Agent
|
v
Data Agent Kit
|
+-- MCP Tools
+-- Data Skills
|
v
Google Cloud
|
+-- BigQuery
+-- Cloud Storage
+-- Spanner
+-- Bigtable
+-- Cloud SQL
+-- Dataflow
+-- Spark
+-- AirflowInstead of manually copying information from Google Cloud into the agent's context, the agent can retrieve relevant information through its tools.
Why Does an Agent Need Access to Real Data?
Consider a developer asking:
Find the reason yesterday's sales pipeline failed.A generic coding agent does not automatically know:
Which pipeline?
Which project?
Which dataset?
Which execution?
Which logs?
Which source files?A data-aware agent can investigate the environment.
Conceptually:
User Request
|
v
Agent
|
+--> Discover Pipeline
|
+--> Inspect Recent Run
|
+--> Read Logs
|
+--> Inspect Code
|
+--> Query Data
|
v
Root Cause SummaryThis is the key difference between generating code and operating with context.
Data Agent Kit Uses MCP
Model Context Protocol provides the connection between the coding agent and Google Cloud data tools.
The architecture looks like:
Coding Agent
|
v
MCP Client
|
v
Data Agent Kit MCP Tools
|
v
Google Cloud APIs
|
v
Data ResourcesThe agent does not need a separate custom integration for every task.
Instead, tools expose structured operations that the agent can invoke.
For example:
list datasets
inspect table schema
run query
inspect job
read pipeline logs
create pipeline
deploy workloadThe available operations depend on the supported service and the user's permissions.
Which Coding Agents Can Use It?
Data Agent Kit is designed to work inside the developer environments teams already use.
Current Google documentation lists integrations including:
VS Code and VS Code-compatible IDEs
Antigravity
Cursor
Claude Code
Codex CLI
Gemini CLI
Google Cloud Shell
Google Cloud Workstations
The IDE extension provides a unified interface, while the plugin brings the tools and skills into supported coding agents.
This matters because developers do not have to move their entire workflow into a new data-specific application.
Installing Data Agent Kit
For VS Code-based environments, the extension can be installed from the Extensions panel.
Search for:
Google Cloud Data Agent KitFor Codex CLI, Google documents the following installation flow:
codex plugin marketplace add GoogleCloudPlatform/data-agent-kit-plugin
codex plugin add dak@dak-marketplaceFor Claude Code:
claude plugin marketplace add https://github.com/GoogleCloudPlatform/data-agent-kit-plugin
claude plugin install dak@dak-marketplaceGoogle Cloud Shell and Cloud Workstations come with Data Agent Kit preinstalled.
After installation, the agent needs Google Cloud credentials.
For the CLI plugin, Google documents using the Google Cloud CLI and Application Default Credentials:
gcloud init
gcloud auth login
gcloud auth application-default loginThe important point is that the agent operates using Google Cloud identity and permissions.
Querying BigQuery With an Agent
Suppose your organization has:
Project:
analytics-prod
Dataset:
sales
Table:
ordersYou could ask:
Find the top five products by revenue
for the last 30 days.The agent can discover the relevant data and construct a query.
Conceptually:
Natural Language
|
v
Agent
|
v
Discover Schema
|
v
Generate SQL
|
v
Run Query
|
v
Analyze Results
|
v
AnswerA generated query might look like:
SELECT
product_id,
SUM(revenue) AS total_revenue
FROM `analytics-prod.sales.orders`
WHERE order_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
GROUP BY product_id
ORDER BY total_revenue DESC
LIMIT 5;The important difference is that the agent can work with the actual environment rather than assuming a schema.
Why Schema Discovery Matters
Without schema access, an agent might guess:
customer_id
customerId
client_id
customer_keyOnly one may exist.
With Data Agent Kit, the agent can inspect the schema first.
Agent
|
v
Inspect Table
|
+-- Column names
+-- Data types
+-- Partitioning
+-- Metadata
|
v
Generate QueryThis reduces one of the most common problems with AI-generated SQL: making assumptions about the database.
Query Cost Matters
Writing correct SQL is not enough.
Consider a partitioned BigQuery table containing several terabytes.
An agent could generate:
SELECT *
FROM `analytics-prod.sales.events`;The query may be syntactically correct.
It may also scan far more data than necessary.
Google's Data Agent Kit skills are designed to guide agents toward cost-aware patterns, including checking partition information and using a dry run before executing BigQuery queries.
A better workflow is:
Question
|
v
Inspect Table
|
v
Check Partitioning
|
v
Build Filtered Query
|
v
Dry Run
|
v
Review Cost
|
v
ExecuteThis is much closer to how an experienced data engineer works.
A Safer BigQuery Workflow
Instead of allowing the agent to immediately execute every query, use:
1. Understand request
2. Discover schema
3. Check partitioning
4. Generate SQL
5. Validate SQL
6. Estimate cost
7. Execute
8. Analyze resultsFor example:
Developer:
Analyze monthly revenue by region.
Agent:
I found sales.orders partitioned by order_date.
I will restrict the query to the requested month
before executing it.That is better than blindly running a full-table scan.
Working With Real Results
The agent can use query results as context for the next step.
For example:
Developer:
Which region has the highest return rate?
Agent:
I will calculate returns divided by completed orders
for each region.The workflow becomes:
Question
|
v
SQL
|
v
Query Result
|
v
Agent Analysis
|
v
AnswerThe agent can then follow up:
Why is that region different?and generate another query.
This creates an iterative data-analysis workflow.
Querying More Than BigQuery
Data Agent Kit is not limited to BigQuery.
Google's documentation lists supported query sources including:
BigQuery
Bigtable
Spanner
AlloyDB for PostgreSQL
Cloud SQL for MySQL
Cloud SQL for PostgreSQL
The specific authentication and capabilities vary by service.
This makes the architecture useful for organizations that have a mixed Google Cloud data estate.
For example:
Coding Agent
|
v
Data Agent Kit
|
+---------------+---------------+
| | |
v v v
BigQuery Spanner Cloud SQL
| | |
+---------------+---------------+
|
v
AnalysisThe agent can work across data sources rather than treating every database as an isolated system.
Building Data Pipelines
Data Agent Kit also goes beyond querying.
Google documents workflows for creating and deploying data engineering pipelines, including pipelines using Managed Service for Apache Spark. It can also support orchestration workflows.
A developer might ask:
Create a pipeline that reads raw sales
files from Cloud Storage, transforms them,
and writes the cleaned data to BigQuery.The agent can work through a workflow such as:
Cloud Storage
|
v
Raw Data
|
v
Transformation
|
v
Quality Checks
|
v
BigQueryThe agent can generate pipeline code, inspect configuration, and help troubleshoot execution failures.
This is where Data Agent Kit becomes more than an SQL assistant.
Join the conversation! Your thoughts help the community grow.