Which agent is best at managing your Supabase: Claude, Codex or Kimi?

What the stages actually mean (pulled from the eval scenarios in the repo):

• Build: create from scratch. Schema, auth, RLS policies, Edge Functions, a todos app where users only see their own rows.
• Deploy: ship it. Deploy a function with its secrets, self-host with Docker Compose, wire up Prometheus metrics.
• Investigate: something is wrong, find out why. A deleted user still has access, an error rate spike, realtime subscribed but no events arriving.
• Resolve: the problem is known, fix it. An RLS policy leaking data across users, a slow query spiking CPU, a migration history mismatch.

A few things stood out to me more than the ranking itself:

1. Agents build well. They investigate worse. Almost everyone aces Build and Deploy. The scores drop on Investigate, which is the "something is broken, figure out why" stage. That matches what I see in support every week: people get a working app fast, then get stuck the moment something breaks and the agent starts guessing.

2. Skills close the gap for smaller models. In the launch post, Sonnet 5 went from 78% to 100% on Build once Supabase's agent skills were loaded, and GPT-5.4 mini went from 78% to 89%. Top models barely needed them. If you're not using the agent skills repo yet, this is the argument for it.

3. Agents don't read the docs as much as you'd think. Claude Code checked the docs in under 40% of scenarios, about 2 pages per task, versus roughly 8 pages for Codex. Supabase also found their Postgres best practices skill was only activating in ~10% of sessions until they rewrote its description (now ~60%).

4. Agents build with yesterday's knowledge. Two habits Supabase called out: even in projects that already used declarative schemas, agents tried to hand-write migrations anyway; and they kept verifying auth by hand with supabase-js in Edge Functions instead of reaching for the newer @supabase/server. Root cause is the same: training data has a date, the ecosystem doesn't. If nothing forces the agent to consult current docs, it confidently ships you last year's best practices. Which is also the real argument for skills: they inject today's truth into a model trained yesterday.

So which one should you actually use?

The honest answer is: probably the one you already live in. Most people aren't choosing an agent from scratch, they have a subscription and a workflow. So here's the practical read:

• If you're on Codex: the data says GPT-5.6 sol is the strongest all-rounder right now, and notably the only one acing Investigate.
• If your main environment is Claude Code (mine is): the recommended setup from this data is loading the Supabase agent skills (npx skills add supabase/agent-skills) and preferring declarative schemas over hand-written migrations. With skills loaded, Sonnet 5 went from 78% to 100% on Build.
• The token-saving corollary: since Sonnet + skills matches the top models on Build, you don't need to burn your most expensive model scaffolding a schema. Save it for the parts that are actually hard.

And the workflow change I made after seeing this

The Investigate gap has a structural fix: don't let the builder grade its own homework. I set this up as a skill in my environment (open sourced it, work in progress: https://github.com/CarolMonroe22/supabase-db-supervisor): anything database-related the agent builds triggers a second pass from a fresh session playing the investigator, and nothing ships without its explicit OK.

So "ok, but what do I actually do with this benchmark" has a concrete answer. Every time an agent touches my database, the supervisor:

• Proves who can see which data with real queries, not by reading the policy and nodding.
• Runs the advisors on both lenses: security and performance, the unindexed foreign keys and slow traps you'd otherwise find at the worst possible moment.
• Checks migration history against reality, and flags hand-written migrations where a declarative schema was the right call.
• Catches yesterday's-knowledge shortcuts: outdated packages where a newer one exists for the job.
• Stays current on every run: it consults today's docs, and tells me when Supabase updates their agent skills upstream, so my agents are never working from stale instructions.
• Knows who to delegate to: it checks who currently leads the leaderboard on Investigate and routes the supervision to that agent. When the standings change, the routing changes with them, no update needed. That awareness is half the value: you always know who's actually best today, not who was best when you picked your favorite.
• Reports in a table with a verdict: OK or NEEDS ATTENTION, and every failure comes with the proof query, a suggested fix, and one sentence in plain language explaining what actually happened.

In my case, today, that investigator is Codex: the only agent scoring 100% on Investigate right now, so the supervision pass goes to Codex even though Claude does the building. And I never leave Claude Code to do it: the skill invokes the Codex CLI from inside the session, hands it the evidence, and the verdict comes back into the same conversation. Nothing to open, nothing to switch. Same would work for Kimi through OpenCode, or whatever agent you pay for. Route by stage, not by loyalty.

If you're not technical, this setup is the one I'd recommend most. You don't have to be the expert who judges the work: you make the agents judge each other, and your job becomes reading the verdict. Just make sure you ask for that verdict in plain language: a good supervision report should tell you what happened and why it matters, not dump SQL at you. Understanding what's going on is still your part of the deal. And still, I'll always recommend the extra step: understand your database, learn how Supabase works. It will make you design better things, 100%.

The whole benchmark runs against real containerized Supabase stacks, not mocks, and scoring mixes deterministic checks (can the right user access the right data) with an LLM judge. It's Apache-2.0, so you can run it yourself.

Resources (all official Supabase):

• Launch post: https://supabase.com/blog/introducing-supabase-evals
• Live leaderboard: https://supabase.com/evals
• The benchmark repo: https://github.com/supabase/evals
• Agent skills (the ones that closed the gap): https://github.com/supabase/agent-skills, install with npx skills add supabase/agent-skills
• Postgres best practices for AI agents, the 30 rules behind that skill: https://supabase.com/blog/postgres-best-practices-for-ai-agents

Curious what this sub has seen: does the Investigate gap match your experience? And if you're already splitting work between agents, how do you decide who gets what?