AI Agent Skills for CockroachDB: Database Lifecycle Automation with AI

This post is part of the CRDB is Agent Ready launch series. See also: CockroachDB MCP Server | ccloud CLI

AI is changing how we build software applications. The more important shift, however, is happening underneath it: how infrastructure is managed and operated.

AI agents are quickly moving from experiments into real production workflows as they write code, run pipelines, diagnose incidents, and drive more application traffic. As that evolution unfolds, expectations for databases are changing too. It’s no longer enough for a database to be fast or scalable. It also has to: 

• support AI-driven applications 

• expose machine-readable signals  

• enable safe, reliable automation across the database lifecycle 

• give agents a clear path to reason about what’s happening inside the system

CockroachDB was built to meet those requirements. It’s a strong foundation for agent-driven applications, but just as importantly, it’s a database whose entire engineering lifecycle of onboarding, building, operating, and scaling can be managed with the help of AI agents. It’s not just the transactional backbone for AI-powered applications, but a system that works naturally with AI-assisted development and operations.

Today, we’re announcing CockroachDB Agent Skills: structured, reusable capabilities that let AI systems interact with CockroachDB in a secure, consistent, and auditable way, streamlining the full CockroachDB lifecycle.

CockroachDB for AI-driven applications 

Agentic-driven systems and applications behave differently from traditional services. They fan out work, retry aggressively, and generate bursts of concurrent writes across regions. Those patterns put real pressure on infrastructure.

CockroachDB efficiently handles that expanded load. It distributes data automatically, scales horizontally without manual partitioning, and maintains serializable isolation by default even under heavy concurrency and retries. Multi-region deployments, regional-by-row placement, and follower reads make it possible to run global, latency-sensitive workloads without sacrificing consistency.

These properties make CockroachDB an ideal backend for AI-driven applications. Running those scaled workloads is only one part of the story, however.

CockroachDB for AI-powered database operations

The bigger shift is how AI agents streamline database lifecycle automation in CockroachDB over time. Teams are starting to rely on AI agents across each phase of database management: 

• helping new users spin up clusters and follow best practices 

• reviewing schemas and migrations during development 

• investigating incidents in production 

• guiding scaling decisions as workloads grow

For instance, agents are accelerating operational workflows. They investigate incidents quickly, analyze performance regressions, review schema design, and validate upgrades. That only works if the database exposes its internal state in a structured, queryable way. 

This is a broader model of database lifecycle automation, where AI agents assist across onboarding, schema design, performance tuning, and scaling decisions. Instead of separate workflows, teams can use agents to continuously analyze system state, recommend changes, and streamline operations end-to-end.

CockroachDB does exactly that. Operational state is available through primitives such as observability information and stable APIs (e.g., SQL) including statement statistics, execution plans, contention events, range distribution, replication status, and system catalogs. Instead of scraping offloaded logs or guessing from partial signals, agents can query real metadata and build accurate explanations.

Still, raw access isn’t enough. Agents need well-defined ways to use that information –  that’s where skills come in.

What are Agent Skills for database automation?

CockroachDB Agent Skills are structured capabilities that define how an AI system interacts with CockroachDB. Each skill has clear inputs, outputs, and behavior. Instead of relying on open-ended prompting, an agent invokes a skill such as retrieving statement statistics, detecting background jobs, or analyzing execution plans. It then receives structured data in return.

Skills follow open standard interfaces, which makes them portable across models and tools. Whether you’re using Claude, an internal LLM, or another coding agent, the same CockroachDB skills work without rewriting integrations. The contract between the agent and the database stays consistent even as the tooling evolves.

We’re publishing CockroachDB skills openly so teams can build agent-assisted workflows across onboarding, development, operations, and scaling without starting from scratch.

How CockroachDB Agent Skills support database lifecycle automation

CockroachDB skills are organized around several practical domains that reflect how engineers already work with the database, including:

• Onboarding and migrations skills guide teams through data movement into CockroachDB using MOLT such as bulk-fetching from PostgreSQL, MySQL, Oracle, or MSSQL, running continuous CDC replication to keep data in sync during the transition window, and verifying row-level integrity before cutover.

• Query and schema design skills translate natural language into SQL, enforce distributed database best practices, surface anti-patterns like sequential ID hotspots and missing primary keys, and validate every generated query with EXPLAIN before returning results.

• Operations and lifecycle skills cover day-to-day cluster management such as routine maintenance, version upgrades, node decommissioning, and keeping clusters healthy across the full operational lifecycle.

• Performance and scaling skills identify slow queries, evaluate index effectiveness, surface write hotspots, and guide workload distribution to help clusters scale without degrading latency as data and traffic grow.

• Security and governance skills harden CockroachDB deployments across network isolation, authentication, encryption, and access control. They audit cluster security posture, configure private connectivity and IP allowlists, set up SSO and SCIM across all authentication layers, enforce least-privilege RBAC, manage TLS certificates and CMEK encryption, and enable audit logging ensuring clusters meet enterprise security standards. 

• Observability and diagnostics skills profile statement and transaction fingerprints, triage live SQL activity, audit table statistics, monitor background jobs, and analyze range distribution and leaseholder placement all directly from SQL.

By breaking workflows into discrete skills, agents can move step-by-step retrieving content, identifying high-value signals, narrowing scope, and forming grounded explanations. The result isn’t guesswork; it’s structured analysis built on real cluster metadata.

What AI-powered database operations look like in practice

CockroachDB is operable from anywhere, especially from the agentic tools engineers already use every day – this is where the benefits of Agent Skills shine through. Skills are what make CockroachDB understandable to any agent in a structured, repeatable way. They spell out how an agent retrieves cluster state, analyzes behavior, and proposes changes. Instead of relying on open-ended prompting, the agent calls well-defined capabilities with clear inputs and outputs.

CockroachDB Skills follow open, standard interfaces which means the same skill definitions can be used by different LLM agents without rewriting logic or rebuilding integrations. In practice, this makes them portable. If you switch models, adopt a new coding agent, or run an internal enterprise LLM, the skills move with you. The database remains operable in a consistent way because the contract between agent and system doesn’t change.

That portability is key to keeping CockroachDB agent-ready without locking you into a specific toolchain. It also ensures that as the agent ecosystem evolves, your operational workflows can stay consistent. 

Let’s explore some real-world scenarios where Agent Skills make a difference.

1. CPU spike detected: responding to a database alert

It’s 9:00 AM. 

You start your typical day by invoking a simple “morning routine” Skill. It scans your email inbox, prioritizes emails, and drafts suggested next steps. Today, it flags something important:

A High CPU utilization email alert fired overnight on your staging cluster.

Instead of digging through email threads or dashboards, you stay in your terminal:

Within seconds, the agent:

• Finds the alert emails

• Deduplicates repeated notifications

• Summarizes affected clusters

• Identifies alert type, threshold, and time window

Now you have a clear, structured summary. Not a wall of alert emails.

The agent then determines the next steps by establishing a connection to the test cluster via CockroachDB’s managed MCP server to identify next steps:

2. Using Agent Skills for database diagnostics

Instead of manually running queries and correlating metrics, the agent automatically selects correct troubleshooting workflows through skills:

• Background jobs consuming cluster resources

• SQL statements driving CPU usage

Because CockroachDB exposes operational state through SQL, these skills enable the agent to run these diagnostics directly against the cluster using the secure MCP connection.

Monitoring background jobs 

First, the agent verifies whether internal activity is contributing to the spike. It queries CockroachDB’s job tables and runtime metadata to check for:

• Schema changes or index backfills

• Backups or restores

• Migrations or data imports

• Any long-running internal processes

Profiling SQL statement performance

Next, the agent analyzes statement statistics to determine which queries are consuming CPU. Because CockroachDB surfaces detailed workload insights through system tables, the agent can:

• Rank statements by CPU usage

• Compare workload patterns before and after the alert window

• Detect new query fingerprints introduced by recent deployments

3.  Root cause analysis of database performance issues 

At this point, you’re not just looking at a CPU spike; you’re looking at a structured explanation of why it happened. The agent stitches together signals from statement statistics, job metadata, execution plans, and range-level insights. Within seconds, you see a clear diagnosis:

• Two slow queries dominating CPU time

• A backup job overlapping with peak workload

• A suboptimal primary key pattern on the user_events table

• Hot ranges forming due to uneven write distribution

• Full table scans driving unnecessary work

This is a layered diagnosis grounded in real cluster state.

What happened

The agent summarizes the incident in plain language:

Your staging cluster experienced sustained CPU above 80% due to two expensive queries on the user_events table. These queries ran during a backup job, compounding CPU usage and increasing latency across the cluster. Instead of manually correlating dashboards, you now have a timeline, root cause, and contributing factors all explained in context.

Why it happened

The deeper issue isn’t just slow queries. It’s a schema design pattern that behaves poorly in distributed systems. The agent highlights a critical anti-pattern:

A random UUID primary key on user_events.

In CockroachDB, this causes:

• Write hotspots as inserts scatter unpredictably across ranges

• Increased range splits and rebalancing

• Higher CPU usage during bulk inserts

• Full table scans for aggregate queries without supporting indexes

The agent also notes that the COUNT(*) query scanned hundreds of thousands of rows because no suitable index existed, further amplifying CPU pressure.

Finally, the backup job overlapped with peak write traffic, adding additional load at exactly the wrong time.

You now understand not just what happened, but why the distributed system behaved this way.

4. Recommended fixes for database performance optimization

The agent proposes several optimization approaches.

1. Improve the Primary Key Pattern

To reduce write hotspots and improve distribution, the agent recommends either:

• a hash-sharded UUID primary key, or

• a time-based composite key for time-series workloads

It generates example migration options and explains the tradeoffs of each.

2. Add Supporting Indexes

The agent recommends adding a secondary index to support common query patterns, reducing the need for full table scans.

3. Reschedule Backups

It also identifies that backups ran during peak workload hours, and suggests moving them to off-peak windows or coordinating them with bulk operations.

Each recommendation is tied directly to observed cluster behavior versus generic best practices.

The agent does not apply these changes automatically. Instead, it:

• generates migration scripts

• explains expected performance impact

• suggests validating changes in staging

• can also open a pull request in your schema repository

You review the proposal, approve testing, and run the migration in your staging environment. Because CockroachDB performs schema changes online, the agent can:

• monitor backfill progress

• track resource impact during index creation

• verify that CPU and latency improve

• confirm no regressions in related workloads

Only after validation do you promote the change to production using your normal deployment workflow.

AI-assisted database operations: Human + agent workflows

Database management isn’t fully autonomous yet, but it’s quickly becoming agent-assisted. Engineers are already prompting agents:  

• “Explain this spike.”  

• “What changed in this release?”  

• “Why is there a hotspot?”  

• “Simulate this index and estimate the impact.”  

• “Generate a migration plan.”  

• “Validate in staging.”  

• “Roll out safely.”

These interactions aren’t limited to incident response – they span the entire CockroachDB lifecycle, from onboarding and schema design to day-to-day operations and scaling decisions.

Agent Skills make that possible: They turn CockroachDB into a system that agents can understand, query, and act on with clear guardrails. The result is workflows that are conversational, structured, auditable, and still human-approved.

In this new model of database lifecycle automation, AI agents help teams continuously operate, optimize, and scale systems with less team toil. For teams and businesses, that means faster issue resolution, more predictable performance, and reduced operational overhead, without sacrificing control or reliability.

CockroachDB is ready for AI-powered applications. Now with Agent Skills supporting onboarding, building, operating, and scaling, it’s ready for AI-assisted database engineering. In the age of agents, infrastructure must be resilient and intelligible. CockroachDB is both.

Talk to a CockroachDB expert to see how AI-driven database lifecycle automation can work in your environment.

Kevin Ngo is a Staff Product Manager for Observability at Cockroach Labs, where he focuses on observability, diagnostics, and supportability for distributed SQL databases. With a decade+ in the data and database space, he works at the intersection of database operations, troubleshooting, and system understanding for both humans and automated systems.