dev0 | Devpost

landing-page
dashboard
diff-review
app-preview
file-tree

Dev0 Landing

Dev0 Task Board

Inspiration

Dev0 is inspired by the “Ralph Loop” — the idea of letting a code agent run until the task is actually done, not just drafted. I wanted to push this further into a full platform where engineers move up the abstraction ladder: from writing every line to acting as technical leads who assign work, review changes, and keep quality high.

Software development is changing fast, and long-running agents will become standard. Dev0 is built around that future: a system that gives agents structure, clean environments, and accountability. Instead of “prompt → code dump,” the platform treats agents like team members: they get a spec, a clean sandbox, clear tasks, and a review gate at the end.

What it does

Dev0 turns a product idea into an execution pipeline:

Gemini 3 Flash generates a project preview (name, summary, stack).
Gemini 3 Pro creates a task graph with dependencies.
Tasks run inside isolated E2B sandboxes via Gemini CLI.
Each task produces a GitHub pull request with diffs and logs.
You review, merge, or request changes from a central mission control UI.

The result is a PR-first workflow where agent execution is visible, contained, and reviewable.

Architecture Overview

How we built it

Dev0 is built with TanStack Start + React 19 on the frontend and Drizzle ORM + PostgreSQL on the backend. Gemini 3 models handle planning and execution. The platform provisions E2B sandboxes, runs Gemini CLI in YOLO mode, streams execution logs in real time through Upstash Realtime, and creates PRs using the GitHub API.

The pipeline is intentionally structured:

A Preview Agent (Gemini 3 Flash) converts a vibe into a project name, tagline, and stack.
A Planner Agent (Gemini 3 Pro) generates a dependency-aware task graph with phases.
The Execution Orchestrator claims tasks, spins up sandboxes, and runs Gemini CLI with structured output.
A Realtime layer publishes logs and status changes so the UI feels alive during execution.
A GitHub automation layer commits changes, pushes branches, and opens PRs for review.

This design intentionally separates planning, execution, and review to keep agents reliable and the system auditable.

Gemini in the Loop

Dev0 is a Gemini-first platform designed around long-running agent workflows:

Planning with Gemini 3 Pro: transforms a raw idea into a structured plan and task graph.
Execution with Gemini 3 Flash: runs fast, iterative task completion cycles.
Gemini CLI streaming: emits structured JSONL events so the UI can show live progress.
Long-running loops: tasks continue until completion, with retries and self-correction.

Challenges we ran into

Gemini CLI stability: our initial sandbox runtime caused the CLI to fail; switching runtime resolved the issue.
Sandbox networking: network access in sandboxes was restricted and required careful configuration.
Realtime reliability: custom SSE updates failed in deployed environments, so we moved to Upstash Realtime for dependable pub/sub.
Template stability: some stacks were inconsistent in sandboxes, so we narrowed to the most reliable React/Vite path for the hackathon demo.
Long-running commands: some commands weren’t stable inside sandboxes, so we added guardrails and tightened the execution path for reliability.

Accomplishments that we’re proud of

A working, end-to-end pipeline where an idea becomes real PRs.
A controllable “agentic loop” that runs inside isolated sandboxes.
A mission-control UI that surfaces logs, task status, and review flows clearly.
A system that makes it feel natural to supervise agents at scale.
A workflow that keeps humans in control while still capturing the speed of autonomous agents.

What we learned

Agentic systems need structure to be reliable. The biggest lesson was that full autonomy is less important than a tight loop of planning, execution, and review. Great UX also matters: visibility, logs, and a strong workflow turn “AI output” into real engineering outcomes. We also learned that stable sandboxes and clear task boundaries make agents dramatically more consistent.