Orchestration for the AI-native SDLC
Turn your team’s AI subscriptions into a software team.
sdlc-bot runs your delivery pipeline with AI agents — planning initiatives, writing code in parallel worktrees, answering review comments, and merging when CI is green. Every teammate contributes compute from the subscription they already have. Humans keep the approvals.
Pooled compute
Bring the subscriptions your team already pays for.
Every member connects their own AI account, and the bot schedules agent sessions across whatever the team contributes. No new inference bill, no shared API keys — just more parallel throughput with every teammate who plugs in.
Deep-reasoning planning, development, and review sessions through the Claude Code CLI.
Codex CLI sessions slot into the same pipeline — assign them any role, from planning to PR fixes.
Gemini CLI rounds out the pool — mix providers per role, per project, per teammate.
How it works
One centralized board. Everyone’s machines.
The board is the single source of truth for every project. Each teammate runs the sdlc-bot desktop app: it watches the board, claims whatever is ready — any item, any agent role — and spawns CLI sessions locally on that member’s own subscription to do the work. Statuses, PRs, and session logs stream back to the board for the whole team.
Work, statuses, PRs, and session logs live in one shared place. Nothing is siloed on a laptop — everyone sees the same live state.
Every desktop app can claim any ready item and run any agent role. More teammates online simply means more work moving at once.
Claimed work executes as CLI sessions on that member's machine, on their own subscription — and reports back to the board as it goes.
What you get
The whole lifecycle, not a code assistant.
Work flows through a GitHub Project your team already uses. Issues in, plans and pull requests out — statuses sync both ways, automatically.
Agents stop and wait at the decisions that matter: what to build, whether the plan is right, and the final review. Nothing ships without a person saying so.
Every task runs in its own git worktree on its own branch. Dependency-aware waves keep parallel work from colliding.
Review comments get triaged and answered, CI is watched, fixes are routed back to the developer agent, and green PRs get merged.
Retro agents mine every finished initiative for lessons, and distilled learnings feed the next run's context. The bot gets better at your codebase over time.
One bot, many repositories. A live dashboard streams every agent session across every project your team runs.
The pipeline
From idea to merged PR.
A relay of specialized agents carries each piece of work through the lifecycle, and the bot pauses at three human gates along the way. Here is who does what.
File it
Drop an Initiative on the board — or a Bug or one-off Task for the fast path. When it's worth doing, mark it Ready for planning.
The plan gets drafted
The Planning Agent explores your codebase and writes the plan: scope, a spec for every task, and the dependency waves between them. A Plan Reviewer agent critiques and iterates it until it holds up, then a Plan PR is opened for you.
You approve the plan
Review the Plan PR like any other PR. Leave comments and a Refinement agent applies your feedback directly to the specs. Approve it when it's right — nothing is built before this.
The plan becomes tasks
The Plan Syncer converts the approved plan into tracked tasks on your board, wired with dependencies and grouped into execution waves.
Agents build in parallel
Developer agents implement tasks concurrently, each in an isolated git worktree — writing code, running your build and tests, self-checking as they go. A Reviewer agent validates every implementation requirement-by-requirement before its PR opens.
PRs get shepherded home
The PR Manager watches every open PR: it triages each review comment, routes real feedback back to a developer agent, and merges once reviews and CI are green. Your review is the last gate.
The system learns
A Retro agent mines the finished work for learnings — what the codebase punished, what worked — and feeds them into every future agent's context.
The fast path
Standalone bugs and small tasks skip the plan ceremony. A Task Planner agent triages the issue against your current codebase — closing out anything stale — then enriches it with an implementation analysis. Once you mark it Ready, it goes straight to a developer agent.
Put your team’s AI to work.
Sign up, connect your GitHub Project, and let the subscriptions your team already has start shipping the backlog.