60% of New Databases Are Launched by AI: What It Means for Your Stack

This article was originally published on the Cosmic blog.

Supabase recently shared a number that stopped a lot of developers mid-scroll: 60% of new databases on their platform are now launched by AI tools, with year-over-year growth in AI-initiated provisioning running at roughly 600%.

That is a measurement of what is already happening in production.

The database layer is one of the most consequential parts of any application. When the majority of new databases are no longer created by humans typing commands, it signals something structural is changing about how software gets built. This piece is about what that shift means, and why the backend is only half the story.

What Supabase Is Actually Measuring

To be precise about what these numbers represent: Supabase is counting databases provisioned through their platform where the initiating action came from an AI tool rather than a human directly. That includes Claude artifacts, Cursor, Lovable, Bolt, and a growing set of agentic workflows where a coding agent spins up a Supabase project as part of building an app.

The 600% YoY growth figure reflects how quickly this category went from novelty to default. A year ago, an AI provisioning a database was a party trick. Today it is a standard step in a large share of new application builds.

This is directionally consistent with what we are seeing across the broader stack. AI coding agents are writing code, making architectural decisions, selecting services, and invoking APIs to stand up infrastructure on behalf of the developers they serve.

Backend Provisioning Was Just the Beginning

It makes sense that databases were first. Database provisioning is well-defined, the APIs are clean, and the cost of getting it slightly wrong is recoverable. An agent can call a Supabase API, get a connection string back, and move on.

But every application that has a database also has content. It has a CMS, a media store, a set of structured objects that define what the product shows its users. And that layer has historically been far more resistant to automation, because most CMS platforms were built for humans to click through.

The Supabase data signals that the entire application provisioning workflow is moving toward being agent-callable: database, auth, storage, CDN, and content management.

This is what we built Cosmic's Agent Signup for.

What Agent-Callable Actually Requires

When an AI agent provisions a Supabase database, it does so through a clean REST API with predictable responses. The agent does not need to navigate a UI, interpret a visual dashboard, or wait for a human to click "confirm."

Content infrastructure needs the same properties to participate in this world. That means:

• A REST API and SDK the agent can call directly. Cosmic exposes a full REST API and a TypeScript SDK (@cosmicjs/sdk) that agents can use to read and write content, create buckets, and manage objects programmatically.
• Predictable schema. An agent needs to know what fields exist and what they accept. Cosmic's structured Object Types give agents a reliable contract to work against.
• Provisioning that does not require a human in the loop for every step. With Agent Signup, an AI agent can initiate a Cosmic project via a single API call. The human still verifies ownership through a 6-digit OTP to claim the project, which is the right trust boundary: agents handle the mechanical steps, humans confirm the relationship.

We wrote in detail about the broader design principles behind this in How to Make Your Product Agent-Callable.

The Content Layer Cannot Stay Manual

Here is the version of the problem that does not get talked about enough.

A developer today can wire up a full application backend in minutes with an AI agent: database via Supabase, auth via Clerk, compute via a serverless function. But when they get to the content layer, they often hit a wall. The CMS requires a human to log in, define a schema through a GUI, and manually create content types before any of the structured content can flow.

That friction is a real gap in the agent-buildable surface of the web. As the Supabase numbers show, the pace of agent-initiated provisioning is compressing the timeline between "I want to build this" and "this is deployed." Any layer that cannot keep up gets worked around.

This connects directly to what we have been building toward at Cosmic, and what we described in AI Is Reshaping the JavaScript Toolchain: the tools and infrastructure that earn a place in agent-built applications are the ones with clean, predictable APIs and SDKs that agents can reason about without human intervention in the critical path.

The SDK Is How Agents Talk to Your Content

For developers building on top of Cosmic today, here is what an AI agent can already do with the TypeScript SDK:

import { createBucketClient } from '@cosmicjs/sdk';

const cosmic = createBucketClient({
  bucketSlug: 'your-bucket-slug',
  readKey: 'your-read-key',
  writeKey: 'your-write-key',
});

// An agent reads the content schema
const { objects } = await cosmic.objects
  .find({ type: 'blog-posts' })
  .props('id,title,slug,metadata')
  .limit(10);

// An agent creates a new content object
const { object } = await cosmic.objects.insertOne({
  title: 'AI-generated post title',
  type: 'blog-posts',
  metadata: {
    content: 'Body content written by the agent...',
    published_date: new Date().toISOString(),
  },
});

This is the same pattern agents use when interacting with databases, auth providers, and storage. A clean SDK, predictable types, deterministic outputs.

What the 60% Number Should Shift in Your Thinking

If you are building a product that developers use, the Supabase number is a prompt to ask: is my product agent-callable today? Today, in production, with applications being built right now.

For content infrastructure specifically, the questions are:

1. Can an AI agent read and write content through a documented REST API or SDK without a human navigating a dashboard?
2. Can the project itself be provisioned programmatically, with humans verifying ownership rather than doing mechanical setup?
3. Is the schema predictable enough that an agent can reason about it without hallucinating field names?

These are table stakes for the generation of applications being built right now.

The backend got there first, as it usually does. The content layer is catching up fast.

---

Want to see what an agent-callable content layer looks like? Start free on Cosmic or book a call with Tony to talk through how AI agents can manage your content stack.