AI Infrastructure

Supabase Acquires Turso: What Compute and Select 2026 Mean

A plain-English guide to Supabase acquiring Turso and launching Compute: what shipped at Select 2026, what is production-ready, and what AI agent builders should adopt now or wait on.

Toolbit AI - Team
9 min read
Supabase Acquires Turso: What Compute and Select 2026 Mean

On October 2, 2026, at its Select conference, Supabase put three announcements on the table at once: a $150 million round led by GIC (announced by Supabase itself), an agreement to acquire Turso, and Supabase Compute, a new layer for running long-lived services right beside your database. The thread tying them together is a single bet: AI agents, not human developers, are becoming the database's dominant customer. Supabase says it already launches more than one million databases every week, with agents behind most of the new ones (both company-reported figures). That volume breaks the old economics of databases, and nearly everything announced this week is a response to it. Here is what each piece is, why they fit together, and what to do about it.

In short:

  • Supabase has agreed to acquire Turso, an open-source, SQLite-compatible database engine rewritten in Rust. Supabase has not disclosed the price, and press coverage calls it an undisclosed sum.
  • Supabase Compute, announced the same day, runs long-lived services and agents next to Postgres. It is in private alpha behind a waitlist.
  • Select 2026 also shipped Declarative Schemas 2.0 with pg-delta, config-in-code, agent-ready local development without Docker, and a per-app MCP server.
  • The thesis behind all of it: agents should be able to create a database as easily as code creates a file.

What exactly did Supabase announce on October 2?

Three things landed together, and they read best as one package.

The funding. Supabase announced the $150 million round itself, led by GIC with CapitalG, IronArc, and SquarePeg also participating, landing four months after the company's $500 million Series F at a $10 billion pre-money valuation. Per that release, the round includes employee liquidity, with proceeds earmarked for new AI agent features. Press coverage from SiliconANGLE adds independent technical color on the deal.

The acquisition. Turso is joining Supabase. The price is undisclosed, and the sources we read do not say when the deal is expected to close. Glauber Costa and Pekka Enberg plus the rest of the Turso team come aboard, with Glauber leading a new agentic infrastructure effort at Supabase. For existing users the message is continuity: Supabase continues around Postgres, Turso continues on SQLite, and the combined team builds something new that brings the Supabase experience to every agent.

The products. All announced the same day at Select, per Supabase's Select 2026 post: Supabase Compute (private alpha), Declarative Schemas 2.0 with the pg-delta migration engine, config-in-code for project settings, an agent-ready local development stack that runs without Docker, and a per-app MCP server you can add with a single shadcn command.

Why does Supabase think agents are the database customer now?

Because the shape of demand has changed, not just its size. A human developer provisions a database rarely; it is a commitment you own for years. An agent behaves differently: it spins up a database for a prototype, one for an exploration, one for a throwaway dashboard, one as a scratch store for a single task, and then it abandons them. Supabase's acquisition post puts it plainly: agents are spinning up millions of databases for the prototypes, explorations, dashboards, and apps they build.

The numbers trail that shift, and the attribution matters. In Supabase's own words, database launches grew 600 percent in the year to June 2026, and more than 60 percent of new databases were launched by some sort of AI tool as of that June - both company-reported from the Series F post. By October, Supabase's press release put the share at 70 percent of new databases created by agents or AI-driven tools, and its acquisition post says the company is "already launching over one million databases per week." Supabase also says growth accelerated since January as Claude Code and Codex expand who can build software at all.

The old cost model does not survive this. Today every small workload implicitly assumes a dedicated, long-running machine, and agents do not care about machines and they want a database now. Supabase's position, verbatim: "Agents should be able to create a database as easily as creating a file, with just as little concern about cost." The company argues this new pattern at this scale requires an evolution in database infrastructure, not an incremental bump.

There is a second, quieter demand pattern: agents as authenticated app users, not just builders. The per-app MCP server means an agent working inside your app generates database workload under the signed-in user's permissions. If you are designing for this world, the way agents hold and use context across steps - our AI agent memory guide covers it, starts to matter as much as schema design.

What is Turso, and why do agents want millions of tiny databases?

Turso is an open-source database engine compatible with SQLite, rewritten in Rust. The key idea is simple: a database is a lightweight file, not a long-running server process demanding its own machine. That design choice is what makes "a database per agent" economically sane.

The architecture, as Supabase's own post describes it, is a load/suspend model: Turso "rebuilt SQLite in Rust and created a cloud platform where a single server can manage millions of databases, loading them when needed and suspending them when they're not." No database hogs memory while nobody uses it. Press coverage of the deal adds technical color: near-instant spin-up, support for embeddings, encryption that differs slightly per database page, and a footprint small enough for smartphones and wearables. That is SiliconANGLE's reporting, not Supabase's own claim. The embeddings support is the piece agent builders will notice first, since a tiny file-based database that can also store vectors fits neatly into the vector database patterns most retrieval workflows already use.

Why did Supabase want it? Because it is the missing cheap-to-create tier. SQLite suits small, on-demand workloads; Postgres is what you want as an application scales. Today an agent that prototypes on SQLite faces a cliff when the workload grows up and needs Postgres. The bet is one developer experience across both tiers, from throwaway scratch database to production system. And this is not theoretical: Supabase names Superhuman, Sauna.ai, CTO.new, and Mastra as customers already provisioning a database per agent on demand, whether on Turso Cloud or in their own clouds. Turso founder Glauber Costa says in Supabase's press release that his goal has been to serve upwards of a billion databases.

Turso architecture: one server loading and suspending millions of small file databases instead of one machine per database

What is Supabase Compute, and how is it different from Edge Functions?

Status first: Supabase Compute is in private alpha, and you join a waitlist to get access.

What it is: long-lived services and agents in any language, in the same project as your database. Compute hosts things that should never exit, such as agents, embeddings jobs over large file sets, always-on services and sandboxed code, with no limit on how long a service runs. You choose memory and CPU, and you get a full Linux environment, which Edge Functions do not offer. Edge Functions remain the other way to run code next to your database, and they have no full Linux environment.

Supabase Compute (private alpha)Edge Functions
Run timeNo limit on how long a service runsNot stated in the Select post
EnvironmentFull Linux, you pick memory and CPUNo full Linux
AccessPublic HTTP URL, or private with no HTTP at allPublic HTTP URL

Compute deploys from the Supabase CLI or the Management API, with the service definition in config.toml. Each service gets a public HTTP URL by default, or you can mark it private with no HTTP at all, the right shape for background jobs or an agent sandbox nothing public can reach. You set an instance count and Supabase balances requests across them, and network restrictions can lock database access down to Compute instances only.

The agent angle is the most interesting part: agent skills for Compute let a coding agent write, deploy, monitor, and debug services itself. The same agent that owns your schema and config can own this layer too.

What else shipped for agent workflows at Select?

Beyond Compute, Select 2026 shipped four features that let a coding agent own schema, config, local development, and app-level agent access straight from the repo.

Declarative Schemas 2.0 with pg-delta. The reasoning is disarmingly practical: "coding agents are good at editing schema files and bad at writing migrations." So now the SQL schema files in your repo are the source of truth, and pg-delta, a diff engine, generates the migrations. It is the default for new projects created with supabase init; existing projects opt in through a config.toml flag, and you should review generated migrations before trusting them.

Config in code. Auth providers, API limits, and storage buckets move into config.toml. Two commands keep repo and dashboard honest with each other: supabase config pull brings dashboard changes back into your repo, and supabase pull fetches config, schema, and Edge Functions together.

Agent-ready local development. The new local stack runs as native processes with no Docker daemon required, which means it works inside Claude Code sandboxes, Codex, and CI runners. Each directory or worktree gets its own isolated stack, so an agent can test two changes side by side without collisions. It is alpha and off by default. You enable it with a config.toml flag or an environment variable.

The per-app MCP server. One shadcn command (npx shadcn@latest add @supabase/mcp-server) adds an authenticated MCP endpoint to your app. Users sign in exactly as usual, and row level security still decides which rows the agent can reach: the agent sees what the signed-in user may see. It requires asymmetric signing keys and the Supabase Auth OAuth server, and there is a headless template for apps where the agent is the main interface. If MCP itself is new territory for you, our MCP protocol explainer covers how these endpoints work.

Add it up: schema, config, long-lived services, and app-level agent access are all repo-reviewable artifacts now, and a coding agent can own the whole chain end to end.

What should you adopt now? And what should you wait on?

Adopt the schema-as-code, config-in-code, and per-app MCP pieces now; wait on everything still in alpha.

Adopt now:

  • Treat SQL schema files, not hand-written migrations, as the source of truth on new projects. pg-delta is the default there already.
  • Move project config into config.toml and use supabase config pull to keep the dashboard from drifting.
  • Add the per-app MCP server if users want agent access inside your app, and scope it hard with RLS, plus the signing keys and Auth OAuth server it requires.
  • Design agent workloads around many small databases - per user, per agent, per session, instead of one shared database. That is the pattern Supabase is building toward.

Wait on:

  • Supabase Compute: private alpha, waitlist only. Watch it, and do not build production work on it yet.
  • The no-Docker local dev stack: alpha and off by default. Opt in per project only where reproducibility risk is acceptable.
  • pg-delta on existing projects: fine to try, but review the generated migrations before you trust them.
  • Multigres for scale: Supabase's June 2026 Series F post calls v0.1 alpha "not yet production-ready."

The takeaway from the announcement day: the interesting question is no longer which database agents will use, but how many databases each agent gets.

Share this article

Related articles

Continue exploring similar guides and insights