RED. The First Agentic Starter Kit

I built the boring part that matters

May 04, 2026

TL;DR — RED is live. Play with the public demo: the database resets every 4 hours and you can log in as global admin to break things freely → red-demo.dev3o.com
Get the starter kit → red.dev3o.com
Read the docs → red.dev3o.com/getting-started/introduction

Why I Built RED

I’ve encountered different boilerplates over the years, and to be honest, I always found them bloated. Full of useless things, tons of abstraction layers because they need to be adaptable to whatever stack the user picks — Next.js, Hono, React, Angular, Supabase, Drizzle... You end up with code that doesn’t really fit any of them well.

I’m a builder. Always been. I was developing different kinds of software with a lot of technologies for the past 20 years. So way before linear regression could even code a Hello World.

I’ve been building AI agents with various libs — LangChain, fast-agent, the OpenAI Agent SDK — then switched to AI SDK in TypeScript because it’s just more convenient to have the full app in the same language, and the level of quality of AI SDK v6 is incomparable.

So in February I started to build my own starter kit for my own projects. I’m shipping a lot of ideas and I wanted to gather the best-of-breed of all web technology in 2026 to create agentic software.

The Stack

React 19, Vite, Tailwind 4, shadcn
Convex
BetterAuth
Autumn + Stripe
AI AI SDK v6
Email Resend + React Email
Bun / Turborepo / Biome

These are the best.

Historically I would rely on Auth0 or Clerk for authentication and permissions because it’s a lot of work to implement a good and secure auth layer. But one of the criteria for RED was to stay fully open-source on the auth side.

You don’t want a third party owning your identity layer the day they raise prices or get acquired. BetterAuth has grown a lot in OSS adoption over the last year and earned its place. With the help of AI and a serious security hardening pass, it’s now production-grade.

The other component that’s a game changer for SaaS is Autumn. I was used to implement Stripe API with native payment intents and doing my own thing. Autumn makes it so easy to do feature flags for premium options with a clever metered system that it was a no-brainer. Kudos to the team.

Resend is well known now. Email is routed through SES — the best infrastructure with the best developer experience. No-brainer too.

Bun? Who uses npm anymore, seriously.

Biome because even an AI code agent deserves beautifully indented code.

Convex. OK, here we need a real talk. I’ve been using Convex for a year now, initially with a Svelte app. Convex has built something truly unique. They merged the concept of Serverless, backend-as-a-service, and GraphQL-style query/mutation/subscription — without the horrible DSL. Isomorphic typing. Reactive database. But you keep owning your own backend.

Not like Supabase (which I tried and dislike a lot — nobody should bring back Oracle-vibe stored procedures in 2026). Convex built their own JS runtime on top of V8 with Rust. It’s reliable, modular, performant, WebSocket by design. All you need in 2026.

I Followed the Rabbit Longer Than Expected

I swallowed the red pill and I’m not sure RED still qualifies as a “starter kit.” I’ve created the first Agentic Boilerplate.

What I mean by that: init and update are unconventional. Usually when you upgrade a project you bump the semver in package.json, then go through the migration checklist and update a bunch of files manually. AI has made that easier — but I’ve gone a step further.

When I release a new version of RED, I create a migration manifest showing which files were touched and what changed. The red-update skill then computes a diff between your project (which has drifted from the initial version) and the upstream changes. The result is a precise migration plan executed interactively. It uses an askQuestion tool to discuss with you what you want to keep, how to handle multi-version upgrades, and where to merge instead of replace.

Here’s a snippet of what a release manifest looks like:

{
  "version": "1.1.0",
  "tag": "v1.1.0",
  "migrationManifest": {
    "from": "1.0.1",
    "to": "1.1.0",
    "breaking": true,
    "files": {
      "addIfMissing": [...],
      "removeIfUnmodified": [...],
      "replaceIfUnmodified": [...],
      "manualMerge": [...]
    },
    "commands": ["bun install", "bun run lint", "bun run typecheck", "bun run test"]
  }
}

Files are categorized by safety: addIfMissing, removeIfUnmodified, replaceIfUnmodified, manualMerge. Anything you’ve touched goes through human-in-the-loop merging. Anything you haven’t gets updated automatically. Your customizations survive upgrades.

That alone is worth shipping.

The Heart of RED — The Agentic Engine

If you’ve already built agents with tools, you know there’s complexity around:

Streaming tokens (Server-Sent Events)
Reloading mid-request, or server interruptions
Backend timeouts on long SSE requests
Multi-step tool processing with error recovery inside the agent loop
Multi-client editing the same AI conversation
Queueing prompts
Executing long-running tools (more than 15 minutes)
Executing async tool calls
Having the agent loop receive events from external sources (almost nobody does this in SaaS apps — it’s similar to what Claude Code does with dispatch)

RED solves all of that for you. Even more — thanks to Convex, I’ve been able to drastically reduce resilience issues in the tool loop execution.

Read the Core Mental Model for deeper explanation of the AI Module.

Architecture

The whole system lives inside Convex. The browser opens a reactive WebSocket subscription. The Agentic Engine drives one turn of the tool loop, suspends when it hits an async tool, and the poller wakes it up when results land. The Task Engine handles both work that runs inside Convex and work that runs on a remote worker — the remote one talks back over a signed HTTP callback.

Because every state transition is a database write, your run survives anything: closed tab, refresh, server restart, deploy mid-stream. Reopen the page, the reactive query loads the latest state, the loop keeps going.

Every concurrency edge case is mapped and guarded:

Two agent runs scheduled at the same time? Compare-and-swap at run start. Only one wins, the second no-ops.
The user sends a new message while the agent is mid-turn? It’s queued, claimed at the start of the next turn, never lost.
A task gets deleted mid-poll? The poller notices, marks the tool call as errored, and the run ends cleanly.
A late background result and the live drive race each other? Guarded. The drive that’s already running owns the state transition. The settler just persists bookkeeping in the background.
A remote worker tries to spoof a callback? Each task hands out a 32-byte one-time capability handle. Cleared on completion. Replays hit a 404.
A remote worker returns garbage output? Validated against the task’s output schema before it’s accepted. Invalid payloads bounce with a 400 — the worker can retry.
A model goes into a tool-call loop? Hard caps: 8 steps per turn, 24 steps per run.
A run gets wedged forever? A cron sweeps anything stuck for more than 15 minutes.

This is the boring infrastructure that I keep saying matters. The kind of stuff you don’t think about until you ship and your users start closing tabs mid-export.

What You Can Build With RED

Here we are. The best starter kit is RED, and there is no second best.

You can build the next generation of company — I call them the Agentic Startup.

A few examples:

Build the backend for a mobile-first app. Build your back-office and agentic features with RED, then bolt on a mobile client using the Convex client SDK.
Build an MCP server as an advanced assistant for a specific vertical, then sell API key access so users can plug it into ChatGPT or Claude.
Build a multi-model wrapper agent like OpenClaw.
Build a vertical startup like my friends at Upsellr, who chose RED to build their new platform — embracing agentic at 200% by creating the Cowork experience for the retail industry.

People who know me know the level of quality I put into my craft. I’m pretty proud of this one. It’s still young, and I’ll keep adding improvements — but it’s already 10x better than what’s out there.

Try It

The demo resets every 4 hours, so log in as global admin and break whatever you want.

→ red-demo.dev3o.com — live demo
→ red.dev3o.com — get the starter kit
→ red.dev3o.com/getting-started/introduction — full docs

If you landed on this post and haven’t subscribed yet, do it. The newsletter is free and this is exactly the kind of thing I’ll keep shipping.

— Pierre

Dev3o

Discussion about this post

Ready for more?