Early access DevTeam is open now to a first group of builders Get Early Access →
DevTeam plans, builds, and verifies. On autopilot.

Describe what you
want to build, then walk away.

DevTeam plans, builds, and tests your project for you. Describe what you want, approve a short plan, and the agents keep working until the project is actually finished - whether that takes minutes, hours, or days - testing in a real browser and checking their own work, pulling you in only when there's a real decision to make.

WindowsAvailable now macOSAvailable now LinuxNot yet
Four agents. One loop. Runs until it's done.
A
ArchitectInterviews you, writes the plan
D
DispatcherSplits the plan into tasks
C
CoderBuilds each task in parallel
R
ReviewerTests it in a real browser
Every task verified in a real browser before it counts as done
Keeps working unattended - minutes, hours, or days - until the project ships
Runs on your machine, on your own AI account, with zero babysitting
What it does

Tell it what to build. DevTeam takes it from there.

The agents don't stop at a draft - they run the whole loop until the project is completely done, whether that takes minutes, hours, or days of continuous work. Chime in whenever you want, or come back to a finished app.

The Reviewer, testing in a real browserIt launches your app with Playwright, clicks through the flow like a user, and fails the task the moment an acceptance criterion breaks - then sends it back to the Coder with exact instructions.
You, chatting with the agents mid-buildAsk any agent what it’s doing, or send a redirect to change course - the build keeps running the whole time.
A Council session, clearing a stuck taskThe task hit a wall, so the Architect convened the agents: it pulls facts from the Coder and Reviewer, diagnoses the blocker, and retries the task - resolved without ever touching your inbox.
The map of your codebaseEvery function, call, and import, indexed. Change one thing and only what it touches lights up - the agents query this instead of re-reading your whole repo, so edits are faster, cheaper, and nothing gets missed.
The Coder, learning from a mistakeIt hits a repo quirk, saves the fix to memory.md before signing off - and the next run loads that memory first, so the same problem never happens twice.

Which tool fits the job?

Today's AI coding tools are genuinely excellent - they're just built for different jobs.

AI editors

Cursor, Copilot, Claude Code

Brilliant when you want to drive. You work in the code, steering an agent edit by edit or reviewing the pull requests its background agents send back. The more you like being in the code, the more they shine.

Cloud app builders

Lovable, Bolt, Replit

The fastest road to a polished prototype. Describe the app in chat and a beautiful version appears in minutes, hosted on their platform and priced in credits.

DevTeam

An autonomous team on your desktop

For when you want the whole project built for you, start to finish. An interview scopes it, a written plan governs it, and four agents run the loop - plan, build, verify in a real browser, fix - on your machine, in your folders, until it ships.

See it in action

From one sentence to working software.

Describe what you want. DevTeam scopes the work, builds it, and verifies the result - and keeps running until the whole project is done, minutes or days, on autopilot.

devteam · bike-map
01Give the agents a prompt

Projects

🔔
Scan for projects
+ New project
Recipe App complete📁 VS >_ ⚙ 🗑
C:\Users\you\Projects\Recipe App
7 phases · 41 tasks done · Vue + FastAPI
NOTES-APP paused
C:\Users\you\Projects\NOTES-APP
3 phases · 11 tasks done · Electron + SQLite
Snake Game complete
C:\Users\you\Projects\Snake Game
5 phases · 30 tasks done · Python + Pygame

New project

Name it, point it at a folder, and set the guardrails before the agents take over to ask you for help.
Project name
Project directory (absolute path)
C:\Users\you\Projects\bike-map
Where the Coder will work. Created if it doesn’t exist.
Project token budget
Hard ceiling across the whole project.
Default per-task token budget
Each task gets this budget.
Max iterations per task
Retries before escalating.
Wall clock limit
Unlimited
For N hours
Per-task wall clock · Maximum time any single Coder or Reviewer attempt can run.
Model assignments
ArchitectOpus 4.8
DispatcherSonnet 4.6
CoderSonnet 4.6
Opus 4.8
Sonnet 4.6
GPT-5.5
Copilot
ReviewerOpus 4.8
Codebase mode
Auto-detect
Existing codebase
New project
Cancel
Create project
‹ Projectsbike-mapbuildingC:\Users\you\Projects\bike-map TOKENS0.2M / 500M EST. COST~$0.14 ELAPSED9s Jump to task, file, decision… ⌘K🔔? Guide
Plan
Board 0
Terminals
ArchitectDispatcherCoderReviewer
WorkingAgents are progressing on P1.
❚❚ Pause run
💬 Chat
VPS
🔑 Secrets
⎇ Source
🎭 Playwright
📁
VS
>_
Interview
A community map for riders - share routes, scenic spots & coffee stops.
ARCHITECTWho’s it for - casual riders, or a community that adds and rates spots?
A community - riders add and rate spots.
ARCHITECTGot it. Should anyone add a spot, or only signed-in riders?
Anyone can browse; sign-in to contribute.
ARCHITECTAdding a spot - photo required, or is a pin + note enough for v1?
Photo optional - pin + note is fine.
ARCHITECTLocking the MVP: map, rider-added routes & spots, 1–5 ratings, optional photos. Search, comments & live tracking are v2. Drafting plan.md…
Message the Architect…
Cmd+Enter to send
Plan · plan.md · written by the Architect
Phases & tasks
P1 · Scaffold app + map5/5 done
P1-T1Scaffold Vite + React appdone
P1-T2Add Leaflet map viewdone
P1-T3Render route & spot pinsdone
P1-T4Add-a-spot formdone
P1-T5Fetch places from an APIdone
P2 · Routes & spots6/6 done
P2-T1Save a custom routedone
P2-T2Rate a spot 1–5done
P2-T3Spot detail drawerdone
P2-T4Sort spots by ratingdone
P2-T5Persist to SQLitedone
P2-T6Route distance badgedone
P3 · Ratings & reviews5/5 done
P3-T1Write a reviewdone
P3-T2Average stars per spotdone
P3-T3Sort reviews by datedone
Board - P1tasks.json - decomposed by the Dispatcher
RIGHT NOWCCoderP1-T3 · Render route & spot pins▶ building
Backlog2
P1-T4
Add-a-spot form
Drop a pin, write a note, and save a new spot from the map.
TODOS 0/4
▾ Show details
P1-T5
Fetch places from an API
Load seed spots from the places API into the map store.
TODOS 0/3
▾ Show details
Active WIP 1/31
P1-T3
Render route & spot pins
Draw route lines and spot pins on the Leaflet map layer.
reading task…
📷 saved p1-t3.png
TODOS 0/3
▾ Show details
Review0
Nothing to review.Reviewer is idle.
Done2
P1-T1
Scaffold Vite + React app
Vite + React + TypeScript scaffold with lint and CI wired.
TODOS 4/4
▾ Show details
P1-T2
Add Leaflet map view
Base map view with tiles, zoom, and mobile gestures.
TODOS 3/3
▾ Show details
2 × 2RowFocus oneMUTEArchitectDispatcherCoderReviewerTASKAll (4)P1-T3P1-T4
AArchitectopus 4.8idle
read_plan {}
P1 needs a map-library decision before tasks can be cut.
web_search leaflet vs maplibre react 2026
write_plan {"content":"# bike-map build plan…
fs_write {"path":"adr/0001-map-library.md"}
append_decision_log {"kind":"adr","note":"Leaflet for v1…
plan.md + 2 ADRs written
request_approval {"note":"6 phases, 31 tasks"}
plans phases, writes adrs211 msgs
DDispatchergpt-5.5 miniidle
read_plan {}
codegraph_files {"path":"client/src"}
write_tasks {"phase":"P1","count":5}
write_tasks {"phase":"P2","count":6}
wire_dependencies {}
P1-T4, T5 independent of T3; safe to run in parallel.
31 tasks queued · deps wired
assign {"task":"P1-T3","to":"Coder"}
decomposes plans into tasks470 msgs
CCodersonnet 4.6active
read_task {"id":"P1-T3"}
codegraph_search {"symbol":"MapView"}
fs_write {"path":"src/MapPins.tsx"}
bash npm test ✓ 18 passing
↩ review: reject empty pin
fs_write {"path":"src/AddSpot.tsx"}
bash npm test ✓ 21
signal_outcome {"status":"done","summary":"P1-T3…
writes + edits source2.0k msgs
RReviewercopilotactive
read_task {"id":"P1-T3"}
browser_navigate {"url":"localhost:5173"}
browser_click {"text":"Add a spot"}
browser_take_screenshot {"path":"p1-t3.png"}
AC-2 empty pin not rejected
request_changes {"to":"Coder"}
AC-1 & AC-2 pass
submit_review {"outcome":"approve"}
tests, lints, signs off2.0k msgs
All agents
Broadcasts go to all four agents · questions answered by Architect
what’s the agents working on right now?
12:47 PM
C
Coder’s on P1-T3 - building the map-pin component. Reviewer has P1-T1 & T2 in test. Routes & spots (P2) is queued next.
12:47 PM
got it. actually - skip photo uploads for v1, pins & notes are enough
12:48 PM
A
On it. Revising plan.md - photo uploads move to v2. The agents keep building everything else, no restart.
12:48 PM
A
✓ plan.md revised · P5 → v2 · Dispatcher re-queued 2 tasks · build resumed.
12:49 PM
QuestionRedirect
Enter to send · Shift+Enter for newline
Message the agents…
Source Control
Message (main)
Commit (5)
Sync Changes (1)
Changes 5
App.tsxsrcM
MapPins.tsxsrcA
AddSpot.tsxsrcA
usePlaces.tssrcA
main.pybackendM
No changes · working tree clean
Recent 4
feat: bike-map MVPmain
e1b9d72 · you · now
feat: render route & spot pins
a3f9c12 · coder · 2m ago
feat: add-a-spot form
94d28e0 · coder · 14m ago
feat: scaffold map + leaflet
5c1abe4 · coder · 38m ago
test: map render checksv0.1.0
0fe87b2 · reviewer · 1h ago
main ↑ 1 ahead
localhost:5173▶ your app · live
bike·mapSearch spots…
+ Add a spot
bike-map v1 - built, browser-verified, running
Build complete.
31 files · browser-verified
A dramatization of one autonomous build, start to finish
01 How it works

Four agents, each with one job.

DevTeam is four specialists with clear roles: work passes from one to the next, and it loops back whenever the Reviewer finds a problem, so every task keeps cycling until it passes its checks. A small, focused team keeps context tight and costs predictable, instead of a swarm of agents re-reading the same code.

ARCHITECT

Scopes

Your product manager & tech lead

Interviews you until it understands the whole project, then writes a plan and hands it to the Dispatcher.

DISPATCHER

Routes

Your engineering manager

Breaks the plan into tasks, phase by phase, and hands each one to the Coder.

CODER

Builds

Your senior software engineer

Works through the tasks against the plan, then passes each one to the Reviewer.

REVIEWER

Verifies

Your QA engineer

Checks the work, runs tests, and runs the app in a browser when needed, then passes the task or sends it back to the Coder.

Who it's for: people who'd rather describe software than babysit it. Solo builders shipping side projects, founders who need an MVP without hiring, and developers who want their nights back. If you can explain what you want, DevTeam can build it.

02 Parallel execution

Independent tasks run in parallel.

Some tasks depend on earlier work, so they run in order. The rest run at the same time, each with its own Coder and Reviewer. DevTeam continues down the plan once they finish.

  • Independent tasks run at the same time, one Coder each
  • Each one gets its own Reviewer, verifying in parallel
  • Tasks with dependencies wait and run in order
  • Results merge back into a single plan
03 Many projects, one home base

Run as many projects as you want.

Spin up as many projects as you like. Each one gets its own Architect, Dispatcher, Coder, and Reviewer, and each build runs on its own, completely independent of the others. You can see where everything stands at a glance. Pause a project, start another, come back whenever; nothing waits on anything else.

  • Each project runs its own agent team, fully independent
  • Running projects build at the same time, never waiting on each other
  • Pause and resume any project without touching the others
  • All your projects and their status at a glance
  • Scan for projects imports the folders you've already built
devteam · Projects
The Projects view: every project in one list with its status and tasks done
04 Talk to the agents

Message the agents while they work.

This is "observe and redirect" in practice. While a build runs, you can message any agent, or all four at once, to ask what's going on or change course.

  • Ask anything, anytime. A question spins up a read-only sidecar that answers in parallel: it reads the project and replies without pausing the build
  • Redirect on the fly. Send a course-correction to one agent or broadcast to all four
  • Interrupt cleanly. Cut into the current turn and it's picked up in seconds, not after a 20-minute task finishes
  • Never locked out. Sidecars run on their own, so you can ask questions even while everything else is busy
  • Pause and resume anytime. Stop the whole project whenever you want and pick it back up later
CHAT
A
Architect12:48
Plans, design, scope
D
Dispatcher12:46
Phase boundaries, task fates
C
Coder12:47
Implementation, day-to-day
R
Reviewer
Verification, quality gates
All agents11:20
Reaches everyone
C
Coder
Implementation, day-to-day
building P2-T4
TODAY
why did ratings come before photo uploads? and what’s left in this phase?
Ratings unblocked three downstream tasks: the dashboard, sorting, and the spot detail drawer. Photos block nothing, so they wait. P2 has two tasks left, route distance badges and the SQLite persistence cleanup; at the current pace the phase closes tonight.
if I add comments on spots later, will anything you’re building now get in the way?
No, and I’d stage it as its own phase. The detail drawer renders from a single SpotView model, so comments slot in as a child list without touching the map code. I’ve logged it as a candidate P7 in the decision log, so the option stays cheap.
REDIRECT → Architect
actually, drop photo uploads from v1
✓ Got it. Moving photo uploads (P5) to v2 and re-queuing the plan. The agents keep building everything else - no restart.
give me a status update on the project
Architect: P2 closes tonight; route badges and the SQLite cleanup are all that’s left.
Coder: On P2-T4, sort by rating. Tests green, handing off within the hour.
Reviewer: Verifying P2-T3 in the browser right now.
Dispatcher: Queue is healthy; P2-T6 unblocks once T4 lands.
@reviewer how did P2-T3 look?
Reviewer: Passed. All four acceptance criteria verified in the browser; screenshots saved to the task.
@coder nice work on the sort-by-rating task
Coder: Thanks. Tests are green; it heads to the Reviewer within the hour.
QuestionRedirect
Enter to send · Shift+Enter for newline
Message the Coder…
05 Real verification

The Reviewer doesn’t trust “tests pass.” It runs your app like a user would.

When a task looks done, the Reviewer opens the app in a real browser and actually uses it: clicking through the flow, checking each acceptance criterion, and capturing screenshots as it goes. If something is broken, it writes up exactly what failed and sends the task back to the Coder. Nothing is called done until it works.

reviewer - terminal
reviewer@devteam ~/bike-map
$ npx playwright test add-spot.spec.ts
• launching Chromium…
navigate localhost:5173  ✓ loaded
click “Add a spot”  · expect entry form
✗ no form appeared · AC-2 failed
handing the task back to the Coder
↳ change request → Coder
MapView.tsx: the “Add a spot” button has no onClick. Wire it to open the entry form, then I’ll re-test.
localhost:5173▶ Playwright
bike·mapSearch spots…
✗ nothing happened · no form opened
House rules, enforced by the harness
01You approve the plan before any build starts
02Every task has acceptance criteria before it's built
03Nothing is marked done until the Reviewer verifies it
04The agents never push to your main branch
05Secrets never appear in logs, commits, or diffs
06A commit guard keeps keys out of git history
07Blocked tasks escalate to a Council, never silence
08Work comes to you only when the agents can't resolve it
06 The interview

No code gets written until the Architect understands the whole project.

The Architect interviews you until it has a complete picture of what you want to build, before it writes the plan and long before any code exists. It flags the ambiguous parts, surfaces decisions you didn't know you had to make, and pins down what's in v1 and what's explicitly out. You approve the plan before any build starts.

And it goes as deep as you want. Ask it to research mid-interview and it will: it can dig into similar products, report back what it finds, and revise the scope and its questions around what it learns. Stay hands-on and weigh in on every decision, or hand it the goal and let it make the calls. You decide how involved you are.

  • Clarifies scope, audience, and platform up front
  • Pins down what's in v1, and what's deliberately left out
  • Keeps asking until the spec is unambiguous, never a fixed form
  • Can research similar products mid-interview, then revise the scope
  • Thinks through edge cases and the data your app will need
  • Be as granular as you want, or defer the decisions to the Architect
  • Turns answers into tasks with acceptance criteria
  • You approve the plan before any build starts
07 Council mode

When a task gets stuck, the agents convene a council.

If a task hits a wall, the agents don't silently fail or spin forever. Council mode kicks in: the Architect pulls facts from the Coder and Reviewer, diagnoses the blocker, and decides a path forward, automatically. Most blocks clear without ever touching your inbox.

  • Redirect: adjust the approach and retry the task
  • Amend the plan: change criteria or split the work
  • Escalate: only when the agents genuinely need you
CHAT
A
Architect6:12
Decision logged - redirect + retry
D
Dispatcher5:12
P4 search task re-queued
C
Coder6:08
search compares exact, case-sensitive
R
Reviewer
Verification, quality gates
All agents2:50
[council:7f3a91c2]
All agents
Broadcasts go to all four · questions answered by Architect
TODAY
COUNCIL · 7F3A91C2ARCHITECT (SESSION_OPENED)
Council session opened for P4-T3 - Search & filters (intervention #1/5). I'll gather facts from the Coder and Reviewer, then redirect, amend the plan, or escalate.
COUNCIL · 7F3A91C2ARCHITECT → CODER
Search returns nothing for valid queries. What's the concrete blocker? Cite file paths + line numbers, no narrative.
COUNCIL · 7F3A91C2CODER
- src/lib/filterSpots.ts:18: filters with s.name === query - exact match, case-sensitive.
- So "coffee" never matches "Blue Bottle Coffee"; only the full, correctly-cased name works.
- Gate: vitest 41/42, the one failure is the case-insensitive search test.
COUNCIL · 7F3A91C2ARCHITECT → REVIEWER
Which acceptance criterion is failing, and does the search box update at all?
COUNCIL · 7F3A91C2REVIEWER
AC-1 ("results update as you type") passes. AC-2 ("search is case-insensitive and matches partial names") fails - I typed "coffee" in the running app and got 0 results; "Blue Bottle Coffee" returns the spot. Blocker is tests/search.test.ts:24.
COUNCIL · 7F3A91C2ARCHITECT (DECISION)
REDIRECT - lowercase both sides and match with .includes() so partial, any-case queries work, then re-run vitest. Retrying P4-T3 now.
Resolved · task retried automatically · no user action needed
QuestionRedirect
Message All agents…
08 Self-improving memory

DevTeam gets smarter with every task.

Every project gets its own memory. The Coder, Reviewer, Architect, and Dispatcher all read and write the same per-project memory.md: conventions, environment quirks, and decisions, so the agents never re-solve the same problems. What one agent learns, every agent on that project can use on the next task.

  • Per-project, not global: each project keeps its own memory.md of conventions and decisions
  • Records environment quirks so they're fixed once, not weekly
  • Learns your preferences during the interview
  • Shared by the Coder, Reviewer, Architect, and Dispatcher and loaded into every run
C Coder · terminal ● active
bash npm test
✗ ENOENT - npm isn’t set up in this repo
This project uses pnpm, not npm. Worth saving before I sign off.
save_memory {"note":"use pnpm, not npm - npm fails with ENOENT"}
bash pnpm test ✓ 21 passing
NEXT TASK · fresh Coder, fresh context
read_memory {} ✓ 3 notes loaded
Memory says pnpm - skipping the npm mistake entirely.
bash pnpm test ✓ 23 passing
✓ solved once · remembered forever · 0 re-asks
memory.md · project ● learning
- [architect] API base = /api/v2
- [reviewer] lint runs on changed files only
- [coder] use pnpm, not npm - npm fails with ENOENT
09 Existing codebases

DevTeam works with your existing codebase.

Point DevTeam at any codebase, new or existing. An Ingestor maps it, and a code graph indexes every function, call, and import. Instead of re-reading files to find what matters, the agents query the graph and jump straight to the code a change affects. And it doesn't stop after the first pass: as the project grows, the graph indexes new code as the agents write it, so they keep navigating by graph instead of re-reading.

  • Maps the codebase: file tree, module summaries, conventions, and how to run the project
  • A call graph indexes functions, callers, callees, and imports
  • Traces a change's blast radius before editing, so the agents skip the files it doesn't touch
  • Indexes new code as the agents write it and re-syncs as it changes, so the graph never goes stale
CODE GRAPH · your codebaseimpact: checkout()
checkout() CartView OrderList MobileCart chargeCard() saveOrder() sendEmail() Cart Payment MapView auth apiClient db App
Change checkout() and the graph lights up the 12 symbols it touches, across 4 files. Instead of re-reading your whole codebase and searching for what matters, the agents just ask the graph and jump straight to those 12 - far faster, far cheaper, nothing missed.
re-read the codebase · ~180K tokensquery the graph · ~3K tokens
10 Secrets & API keys

The Architect sets up your keys. The agents never see them.

Most real projects call outside services - payments, email, a database, another model - and each one needs an API key. When the Architect writes the plan, it reads what the project will need and builds the Secrets panel for you: every key declared, named, and waiting. You paste the values once; they live in .env.local on your machine, used by the build but never visible to the agents.

  • Keys live in a project .env, the standard place for secrets, kept out of version control
  • Never written to agent logs, transcripts, commits, or diffs
  • Bringing your own code? Drop your existing keys into the same .env
  • The Architect reads the plan and queues up the keys a project will need, so you just fill in the values
  • A commit guard blocks secrets from ever entering git history
A ARCHITECT · writing the plan ● planning
declare_external_service {"name":"Stripe","env":"STRIPE_SECRET_KEY"}
declare_external_service {"name":"OpenAI","env":"OPENAI_API_KEY"}
The plan calls two outside services - both added to Secrets, named and ready for the user’s keys.
SecretsAPI keys the project depends on. Saved to .env.local - never echoed to agent transcripts.
StripeOptionalNot setGet key →
Env var: STRIPE_SECRET_KEY
Paste key hereShowSave
OpenAIOptionalNot setGet key →
Env var: OPENAI_API_KEY
Paste key hereShowSave
Keys live in .env.local on your machine - used by the build, invisible to the agents
11 After a project is done

Forgot to tell the agents your app needs a dark mode?

Just ask, even after the project is done. When a project completes, a green Add more work button appears. Click the button and you land back in the plan panel with the Architect, the full plan and every finished phase still in front of you. Describe what's next; the Architect scopes the work into a new phase, appends it to the plan, and leaves your existing phases and code untouched.

  • One click reopens the Architect on a finished project
  • You see the full plan and every completed phase; nothing gets rewritten
  • New work becomes a new phase, appended to the plan
  • Your existing code and tasks stay exactly as they are
12 Source control

Your machine, your AI, your repo.

DevTeam lives on your machine: the agents, the board, and your project files are all on your own disk, plugged into your own AI account. The agents work in your local folders; nothing leaves your machine until you say so. When you're ready, the built-in source control panel reviews the changes, commits, and pushes to GitHub using your GitHub CLI sign-in, so the agents never touch your credentials. You decide what ships and when.

13 Built by DevTeam

A sample of the projects built by DevTeam.

Each one started as a one-line idea: scoped in an interview, then built and verified task by task.

★ self-built

DevTeam

Its own four-agent harness, plus this very website. DevTeam helped build both.

ongoingself-improvingPython + React
✓ done

Space Exploration Game

A browser space game with canvas rendering and real-time game-loop mechanics.

8 phases54 tasksCanvas + JS
✓ done

Skater Game

A game that generates explorable 3D worlds from a photo using on-device ML (segmentation + depth).

3 phases29 tasksWebGPU + transformers.js
✓ done

Landscaping App

A landscaping design app for planning yard layouts, choosing plants, and visualizing the result.

5 phases38 tasksReact + FastAPI
✓ done

Recipe Book

A self-hosted recipe app: save, search, tag, and view recipes, deployed over HTTPS.

3 phases31 tasksFastAPI + SQLite
✓ done

Note-Taking App

A note-taking app for capturing, organizing, and searching notes.

3 phases25 tasksReact + SQLite
✓ done

Sentiment Analysis App

A market-validation report generator that runs a multi-phase pipeline to produce 100+ page PDF reports.

5 phases36 tasksReact + FastAPI
✓ done

Book Library Catalog

A personal library catalog to track the books you own, search and tag them, and see what you've read.

4 phases33 tasksReact + SQLite
✓ done

Market Research Dashboard

A finance dashboard pulling quotes, fundamentals, and news into sortable watchlists and charts.

5 phases41 tasksReact + FastAPI
✓ done

Invoice & Inventory Manager

An invoicing and inventory tool that tracks stock, flags low levels, and generates invoices as PDFs.

5 phases39 tasksReact + FastAPI
✓ done

Company BI Dashboard

A business intelligence dashboard with KPI cards, drill-down charts, and live data refresh.

6 phases44 tasksReact + FastAPI
✓ done

World Events Tracker

A live feed of global events streamed onto an interactive world map in real time.

5 phases36 tasksLeaflet + live feeds
✓ done

Uptime & Status Monitor

Pings your services around the clock, tracks incidents on a timeline, and sends alerts when something goes down.

4 phases31 tasksFastAPI + APScheduler
✓ done

E-commerce Storefront

A full storefront with catalog, cart, Stripe test checkout, and an order-management admin.

7 phases52 tasksReact + Stripe
✓ done

Real-Time Team Chat

Channels, presence indicators, and instant message delivery over websockets.

5 phases34 tasksWebSockets + FastAPI
✓ done

Habit Tracker PWA

Streak heatmaps, offline support, and reminder notifications, installable on your phone.

4 phases27 tasksPWA + IndexedDB
✓ done

Expense Splitter

Groups, shared expenses, and a debt-simplification algorithm with one-tap settle up.

3 phases22 tasksReact + SQLite
14 Pricing

One plan. Everything included.

A flat $49/month for DevTeam itself. The AI is separate and already yours: connect your own Claude, OpenAI, or GitHub Copilot account, with the subscription you already pay for or an API key. Two separate bills, and no markup from us on the AI.

Early Access
$49/ month

3-day free trial. Billed monthly, cancel anytime.

  • All four agents: Architect, Dispatcher, Coder, Reviewer
  • Real-browser verification with Playwright on every task
  • Works with new and existing codebases
  • Council mode, sidecar chat, and self-improving memory
  • Runs locally on Windows or macOS, with unlimited projects
  • Use the best model per agent, set per project or globally
  • Connect providers with a subscription or an API key, and mix both
Get Early Access

Bring your own AI provider (Claude, OpenAI, or GitHub Copilot). Sign in with your existing subscription or use your own API key; provider usage is billed by them, separately from your $49. Two bills total: ours for the app, theirs for the AI.

15 FAQ

Questions, answered.

Do I need to know how to code?+
No. You describe what you want in plain language, and the Architect interviews you to fill in the details. The agents handle the implementation. Knowing how to read code helps if you want to dig in, but it isn't required to get a working result.
What can DevTeam build?+
Web apps, games, tools, and services, whether you're starting fresh or adding to an existing codebase. Point DevTeam at a codebase and the agents map the project and builds a call graph first, so the agents can extend your existing code, not just greenfield builds.
Isn't this slower than just asking ChatGPT or Claude?+
Usually yes, and that's the point. A one-shot tool hands you something that looks finished in seconds, but you often don't find out what's broken until you try to run it. DevTeam takes longer because every task is built and checked in a real browser, with anything that fails sent back and fixed before it moves on. You wait longer, but what you get at the end has actually been exercised, not just generated.
What does the AI side actually cost?+
If you sign in with a subscription you already pay for - Claude, ChatGPT, or Copilot - it costs nothing extra: DevTeam works within that plan's limits. If you connect an API key instead, you pay your provider's API rates, and those vary wildly with the model and the size of the job: a small MVP might be a few dollars, while big projects representing hundreds of hours of work have come out at an estimated hundreds or even thousands of dollars in API terms. Either way it's billed by your AI provider, never marked up by us, and every run shows live token and estimated-cost counters in the header so you always know where you stand.
Can DevTeam work with my existing codebase?+
Yes. Point DevTeam at a codebase and an Ingestor agent maps it: file tree, module summaries, conventions, and entry points, while a code graph indexes every function, caller, and import. The agents use that to understand structure and check what a change affects before editing, so they can safely extend existing code. The map re-syncs as the code changes.
Does DevTeam really run unattended?+
Yes. That's the whole idea. Once the plan is approved, the loop builds and verifies on its own. You observe and redirect rather than approving every task, and when the agents genuinely need you, they tell you exactly what to do.
What happens when the agents get something wrong?+
The Reviewer catches the problem before a task is ever called done, and the work loops back to be fixed. If a task gets truly stuck, Council mode convenes the agents to diagnose the blocker and decide a path forward; most blocks clear without ever involving you.
Can I change direction or ask questions mid-build?+
Yes. That's a core part of how DevTeam works. Message any agent (or all four) from the chat panel while they work. A question spins up a read-only sidecar that answers in parallel without pausing the build; a redirect changes course and can interrupt the current turn so the change takes effect in seconds rather than after the task finishes.
Which AI models does DevTeam use?+
Your choice of Claude, OpenAI, or GitHub Copilot, set per agent. Connect each provider with the subscription you already pay for or with your own API key, and you can mix providers across agents. Usage is billed by your provider under your plan; DevTeam adds no per-token billing of its own.
Does DevTeam touch my GitHub and secrets?+
GitHub runs through a built-in Source Control panel using your GitHub CLI sign-in; the agents never get your credentials. Project secrets live in .env.local, are injected only at runtime, and are redacted from agent logs and kept out of commits.
How is this different from Cursor or Claude Code?+
Those are excellent tools, but you drive them: every prompt, every review, every next step comes from you. DevTeam owns the loop. The Architect scopes the project in an interview, the agents plan, build, and test in parallel, and a Reviewer verifies every task in a real browser before it counts as done. Your job shifts from driving the work to checking in on it.
What platforms does DevTeam run on?+
DevTeam is a native desktop app for Windows and macOS. You install it locally and it works directly on your project folders. A Linux version isn't available yet.
Who builds DevTeam?+
Mostly DevTeam itself. One developer set the direction, but DevTeam wrote much of its own code and built this entire website. It's Early Access software: it works, it builds real projects, and it's improving fast. You're getting in early, which is the point.
What does DevTeam cost?+
$49/month, starting with a 3-day free trial. Cancel within the trial and you pay nothing. For the AI itself you bring your own provider, with a subscription or an API key; that usage is billed by the provider under your plan, not by DevTeam. Two separate bills: $49 to DevTeam, and whatever you already pay your AI provider.
Is my code used to train AI models?+
DevTeam never receives or trains on your code; your projects go only to the AI provider you connect. Your provider's own policies apply: for example, Anthropic may train on consumer-subscription inputs unless you opt out in your Claude settings, while API usage is typically excluded. Check your provider's privacy settings.
How do I cancel?+
Anytime, from the billing portal, in a couple of clicks. Cancel within the 3-day trial and you pay nothing. Cancel later and you keep access until the end of your billing period, and you won't be charged again.
1

Point DevTeam at a project

Install DevTeam on your Windows or Mac machine and aim it at a new folder or an existing codebase. DevTeam maps what's already there before doing anything.

2

Describe what you want

The Architect interviews you to scope the work and writes a plan with clear acceptance criteria. You approve the plan.

3

Walk away

DevTeam builds and verifies on autopilot. Check in when you like, redirect if the work drifts, and merge when it's done.

Built for Windows & macOS

DevTeam is a native desktop app for Windows and macOS. It installs locally and works directly on your project folders. Connect your AI provider with a subscription or an API key, and you're building.

WindowsAVAILABLE NOW
macOSAVAILABLE NOW
LinuxNOT YET
16 Early access

Put your next project
on autopilot.

Windows & macOS desktop app · new builders onboarded every week

$49/month after a 3-day free trial. A Windows & macOS desktop app. Bring your own AI provider, with a subscription or an API key.