You describe it.
AI builds it.
You approve the PR.

Create AI workers with instructions and strict steps. They write code, design pages, draft docs -- and pass output between each other like a real team. Except nobody's in a meeting right now.

See how it works GitHub

Open source · MIT · Self-deployed · Only dependency: Claude Code

A designer designs it. A copywriter writes it. A developer builds it.

Each worker is a flow: a sequence of steps with instructions, model selection, and rules about what it can and can't do. Output passes from one task to the next. You pause where you want to review. The rest runs on autopilot.

AI Developer
Ships features while you sleep
Reads your codebase, plans the approach, writes the code, runs tests. Has never once mass-renamed a variable to camelCase across the whole project because "it felt right."
implement → verify → review
AI Bug Hunter
Fixes bugs without the backstory
Doesn't need a 20-minute standup to understand the issue. Root-causes it, minimal fix, proves nothing else broke. You review the diff.
fix → verify → review
AI Tester
Writes the tests you were "going to get to"
Follows your existing patterns. Doesn't skip edge cases because it's 5pm on a Friday. Doesn't write tests that test the mock instead of the code.
write-tests → verify → review
+ whatever you need
If you can describe it, it can do it
Build a designer that turns Figma exports into components. A copywriter for docs. A security reviewer. Plug in local LLMs via LM Studio. Add RAG so workers search your specs and design docs before touching code.

Build workers visually. Drag steps, switch models, control what context each step sees. No YAML. No config files. If you can configure a Notion template, you can build an AI worker.

Things we proudly don't have

Story Points
Estimation theater
You've never estimated correctly. Neither has anyone in the history of software. We just track what actually shipped.
Sprints
Arbitrary time boxes
Nothing magical happens every two weeks except a meeting where everyone lies about what they'll finish next.
Cloud Lock-in
Your code on someone else's server
Self-deployed. Run on your machine and sync through Supabase. Or run on a VPS your team controls. Your code, your infrastructure, your rules.
Velocity Charts
Management pacifiers
A chart that goes up when you close tickets faster. Congratulations, you've incentivized splitting one task into twelve.

Made for teams that move faster than their tools

01
Streams, not boards
A stream is a chain of tasks. One finishes, next starts. Output passes forward. Like a CI pipeline for your entire product backlog -- except it actually does the work.
02
AI and humans on the same board
One dropdown: pick a worker or a person. Same comments, same @mentions, same notifications. Your team is a mix of humans and AI now. The UI shouldn't pretend otherwise.
03
You stay in control
Add review pauses anywhere in the flow. Workers stop and wait for your approval before continuing. When they're stuck, they ask -- inline, not in a separate tool.
04
Git you don't have to think about
Each stream gets its own branch. Each task auto-commits. Breaks something? Auto-reverts. Done? Click "Create PR." You never touch git directly.
05
Run it from anywhere
Browser, terminal, phone. Watch workers live as they code. Get push notifications when they finish. Check in from Telegram while walking the dog. MCP server if you live in the terminal.

Your machine. Your code. Your rules.

Run it locally
Everything offline. Sync with teammates through Supabase (cloud or self-hosted). Your code never touches someone else's server. Good for solo devs and the reasonably paranoid.
Run it on a VPS
Workers grind 24/7 while you sleep. Your team connects directly. Wake up to PRs. Good for teams who'd rather ship in the morning than debug at midnight.

Only dependency: Claude Code. Plug in local LLMs via LM Studio for embedding, RAG, or anything Claude shouldn't handle.

Three steps. No onboarding call.

1
Clone it
Node, Docker, Claude subscription. That's the whole dependency list.
git clone git@github.com:ilyador/workstream.git && cd workstream && pnpm install
2
Start it
One command spins up Supabase, the API, and the frontend.
npx supabase start && npx supabase db reset && pnpm dev
3
Ship something
Point it at your repo. Create a task. Assign a worker. Go make coffee. Come back to a PR.
open http://localhost:3000
"Built by a developer who spent more time configuring Jira than writing code. So he quit Jira and hired AI to do the work instead."
~ The README, honestly

Stop managing.
Start shipping.

Open source. Free forever. MIT licensed.

Get WorkStream on GitHub git clone git@github.com:ilyador/workstream.git