Orchestration for the AI-native SDLC
Turn your team’s AI subscriptions into a software team.
Code isn’t the bottleneck anymore — running the process is. SDLC Bot runs it end to end: planning initiatives, writing code in parallel worktrees, answering review comments, and merging clean PRs — pausing, by default, only where your judgment matters. And it runs on the AI subscriptions you already pay for. Any of them. All of them at once. No API keys, no metered bill.
Pooled compute
Bring the subscriptions your team already pays for.
Most agent platforms meter every token through an API — so every parallel agent multiplies the bill. SDLC Bot spawns CLI sessions on the flat-rate subscriptions your team already has instead. Every member connects their own account, the bot schedules sessions across whatever the team contributes, and you can use any provider — or all of them at once. More teammates online means more throughput, not more spend.
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 runs alongside the rest — pick the provider and model that fits each role.
Grok CLI rounds out the pool — every subscription on one board, all running at once.
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, and spawns a CLI session locally to do the work — statuses, PRs, and logs stream back 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.
The pipeline pauses at three decisions — is this worth doing, is the plan right, and, for standalone bugs and tasks, is this ready to build. Nothing is planned or built without your say-so. When you trust the flow, an optional Scrum Master agent can start crossing gates for you, one gate at a time.
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, pausing at the gates — yours by default. By the time a code PR reaches you it has been built, tested, and reviewed — you judge intent and risk, not syntax. 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 the PR Manager re-renders the plan and specs from your feedback. 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 review threads resolve and checks come back clean — you can review it at any point before it merges.
The system learns
A Retro agent mines finished work for learnings — what worked, what didn't — 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.
On the record
The agent that writes the code never merges its own work: developer sessions open PRs, and only the PR Manager merges them. Every gate crossing, comment evaluation, and merge decision lands in an audit log, so you can trace how any change got in.
Put your team’s AI to work.
If you already pay for an AI subscription or two, you already own the compute for a software team. Sign up, connect your GitHub Project, and start shipping the backlog.