Be one of the first 20 teams to run a software factory.
We are opening the TaskTrooper team edition to 20 teams. Agents analyse the work before they build it, review and test it among themselves, and watch it in production. You make the decisions.
- Early access to the team edition: your whole team on one board, each person's agents on their own computer
- The iPhone app, to assign work and approve from anywhere
- Free while the alpha runs
- Setup help one on one, and a direct line to the founder
- Your feedback decides what we build next
You decide twice. The agents do everything in between.
Each card goes to the agent that owns its column. The agents analyse, write, review, test and correct the work among themselves. You approve the analysis and the result, and nothing merges or deploys without you.
Product manager
Architect
Backend
Frontend
Mobile
QA
Security
Release
Designer
Data
Game
First: is it worth doing?
Bring an idea, or a ticket from Jira or GitHub. The product-manager agent analyses it against your target audience and writes a report, and you can talk to that audience and ask follow-up questions. Competitor analysis and feeding in what users say about your product (store reviews, support tickets, surveys) are coming during the alpha, so the report says not only whether to build it but how people want it built. The architect reads your code and reports the impact, risk and cost. You comment and approve; only then does it become detailed tasks with acceptance criteria.
- Idea: multi-currency invoices
- Product manager agent analysed it against the target audience: report ready
- Architect: impact, risk and cost against the current code
- You approved the analysis
- Split into 3 tasks with acceptance criteria and assumptions
Example activity for one change
- Task: PM agent writes it
The developer agent writes, two AI reviewers push back
The developer works on its own branch in its own workspace and opens the PR. Then the architect and the security reviewer both read it, each in its own session with its own model call — neither sees the other's verdict, so one approving does not speak for the other. Anything they find goes back to the developer, and the task card shows who approved and who has not, round by round. This is the correction loop your senior used to run by hand, the five to ten rounds of fixes that used to land on you: much of it is done before the work reaches you, so there is less left for you to fix. If you work alone, you run that same loop yourself: you read the architect's and security reviewer's notes, and the card still waits for both to approve before it moves on.
- Developer agent opened PR #31
- Architect review: missing null check on the merchant header. Sent back
- Security review: the key was logged in plain text. Sent back
- Developer agent fixed both
- Architect and security reviewers approved
Example activity for one change
- Write: Developer agent
- Review: Architect agent
- Review: Security agent
QA tests from the spec, not from the code
The QA agent works from the task description, the acceptance criteria and your comments, and may not read the source to decide that something passes. It lists every case it tried and every case it could try, runs the product against them, and records what it could not run. Your tester starts from that list, re-checks what matters, decides whether more is needed, and spends the time on the edge cases. Unit tests and smoke checks run before anything is offered to you.
- Case 3, rate-limit header: passed
- Case 4, same key with a different body: returned 200 instead of an error. Sent back to the developer agent
- Case 4 re-run after the fix: passed
- Unit tests and smoke checks: passed
Example activity for one change
- QA: Tests from the spec
- Tests: Unit and smoke
One pass from your senior, then deploy and watch
The PR reaches your senior with its assumptions, what was not checked and what AI review already fixed. If you work alone, that PR reaches you instead: you read the same notes and approve your own merge — the same loop, fewer people in it. Nothing merges or deploys without a human approval. After you accept, the release engineer ships it, runs smoke checks, watches production errors, and rolls back if a check goes red.
- Your senior approved the PR
- Merged and deployed
- Smoke checks 6 of 6 passed, no new production errors
- Had a check failed, the release would roll back to the last good revision
- Released and watched
Example activity for one change
- Notes: Assumptions and gaps
- Approve: Your senior
- Deploy: Then watched
