Independent research
SlopCodeBench measured how coding agents degrade over long tasks — research we did not write. Orlanski, Roy et al. (2026), arXiv:2603.24755.
See the researchMission control for shipping software
Tickets, sprints, kanban and gantt in one Go binary — 41 AI specialists on isolated branches, and a review gate before merge.
Tickets, sprints, kanban, gantt and 41 AI specialists. One Go binary.
curl -fsSL https://get.flowforgesoft.com/install.sh | sh - Single Go binary
- No Node.js required
- Desktop TUI
EVIDENCE
Evidence
DELPHOS
A production medical AI system, built with this method by one developer.
Read the case studyTHE INDUSTRY CONDITION
Put order on chaos.
AI can build software fast. It can also build a mess.
Without a system
- Scattered repos Work sprawls across repos with no map of how it fits together.
- One shared database, no owners Everything writes to the same schema and nobody owns a table.
- Secrets in the git history Keys land in commits and stay there, one clone from exposure.
- A 15,000-line file One file keeps growing until no one is willing to open it.
Under FlowForge
- Blueprints first A ratified spec is the source of truth before a line is written.
- Boundaries with owners Every seam is drawn on purpose and has someone accountable for it.
- Gates that block the merge Review, tests, and line caps stop the merge — not a reminder.
- ACE separates signal from noise The orchestrator keeps the plan legible as the work scales up.
HOW IT RUNS
Blueprints in. Reviewed software out.
Describe it. Watch it get built — reviewed, the whole way.
You describe what to build
In your own words. No ticket syntax, no template to learn.
ACE plans a ForgePlay
A documented blueprint for the work — ratified before a line is written.
Specialists dispatched
Each on its own isolated branch, so nothing collides and nothing hides.
Independent review
A separate reviewer checks the work. It is not the agent grading itself.
Ratify at the gates
You approve at the points that matter — and only at those points.
Merge
It lands in your codebase, with the record of how it got there.
One orchestrator — ACE — and a bench of 41 specialists: the right one for each task, on its own branch. You are never alone against the machine.
Meet the specialistsTHE WAR ROOM
Ahead or behind. You can see it in seconds.
One room: epics, sprints, tickets, who is on what, and what is blocked.
-
Ahead, on track, or behind
Each sprint carries its own schedule read — how much is done against how much of the calendar is gone. You do not compute it, and you do not ask anyone for it.
-
Blocked work, and what is blocking it
When a ticket is waiting on another one to land, it says so — and it names the tickets it is waiting on.
-
Epics down to sub-tickets
Epics hold sprints, sprints hold tickets, tickets hold sub-tickets. Open one level or all four.
-
The board and the gantt, one key away
Lane counts at a glance; the full board one key away. The board for what is moving now, the gantt for what it does to the date.
-
Dispatch from where you are standing
Dispatch a ticket to a developer without leaving the room — no tab, no second system, no copy-pasted ticket number.
-
Waves
FlowForge reads the dependency graph, works out what can honestly run at the same time, and splits the sprint into waves.
HOW A WAVE IS COMPUTED
Wave 0
no dependencies
Wave 1
depend on wave 0
Wave 2
depend on wave 1
Every dispatchable ticket lands in exactly one wave. A cycle or a dangling edge is broken deterministically and flagged — never dropped, never guessed.
Fire a wave from a sprint header. See the board
WHAT'S INSIDE
Everything to keep AI-built software solid.
-
Tickets & Kanban
Every unit of work is a ticket on a board — visible, owned, and traceable end to end.
-
Velocity & cycle time
Analytics on throughput and cycle time so you see where work actually flows and stalls.
-
Documents & archetypes
Plans and specs render through purpose-built archetypes into client-ready documents.
-
ForgePlays
Templated, multi-step workflows that run a proven sequence instead of ad-hoc prompting.
-
ACE orchestrator
The coordinator that routes work to the right agent and keeps every branch in order.
-
Desktop TUI
A fast terminal cockpit for time tracking, ticket state, and agent dispatch.
-
Proof of Work
Time tracking tied to tickets and real output — paid for work done, not hours present.
-
Independent review gates
Nothing merges until it clears a gate — quality is enforced by construction.
THE BENCH
41 specialists. Each one you can name.
The right specialist for each task, dispatched to its own branch — architecture, security, database, TUI, design, review, docs.
Browse the full catalog- fft-requirements-analyst
- fft-architecture
- fft-project-manager
- fft-product-owner
- fft-code-explorer
- fft-api-designer
- fft-backend
- fft-database
- fft-design-architect
- fft-frontend
- fft-designer
- fft-web-designer
- fft-brand-architect
- fft-ios
- fft-android
- fft-flutter
- fft-tui-architect
- fft-tui-designer
- fft-tui
- fft-qa
- fft-code-reviewer
- fft-security
- fft-web-quality
- fft-devops-agent
- fft-github
- fft-documentation
- fft-documenter-br
- fft-documenter-es
- fft-content-strategist
- fft-social-media
- fft-cs-architect
- fft-cs-analyst
- fft-paid-media-architect
- fft-media-buyer
- fft-ml-architect
- fft-llm-openweight
- fft-rag-engineer
- fft-agent-frameworks
- fft-performance
- fft-medical
- fft-agent-creator
PROOF OF WORK
Every minute, tracked to the ticket it belongs to.
An honest, shared record of what was done — the kind you can put in front of your own clients.
-
Tracked to the ticket
Every tracked minute maps to the ticket, session, and event log it came from. Not a lump sum at the end of the week — a record you can open and read, line by line.
-
Production, not presence
The meter follows real work events — messages sent, agents run, tools called. When those stop, it pauses after five idle minutes. No credit for "the window was open."
-
When in doubt, it tracks less
If the meter is unsure, it errs in your favor. A long call with the session open is left out. A record that survives a question is worth more than one that counts every second.
FOR EVERYBODY
A layperson couldn’t build this alone.
A pro no longer has to.
The person shipping their first app, the lead who owns every architectural decision, and the shop that bills the hours to a client — all on the same tool.
-
THE OWNER
Building their first app
No team, no terminal. They describe what they want in their own words, and the desktop app turns it into real, working software.
- Plain words in, working software out
- The desktop app — no command line required
- ACE alongside for every decision they don’t yet understand
-
THE LEAD
Owning every ADR
A former developer, now leading a large delivery team and accountable for every architectural decision that ships.
- The specialists make sure her ADRs miss nothing
- ACE smooths every hiccup across the team
- With the team on FlowForge, the monthly reports nearly fill themselves
-
THE SOFTHOUSE
Billing the work to a client
An agency running several client projects at once. Every hour on the invoice has to be defensible to the person paying it.
- One board per client, and one place to see all of them
- Time tracked to the ticket — a record you can hand over, not a lump sum See how the record works
- The review gate is the answer when a client asks who checked this
One shared spine underneath all three: 41 specialists and ACE, with decades of engineering judgment encoded in every gate and every decision.
One subscription. Not ten.
FlowForge is one subscription that replaces the ten separate tools a team otherwise stitches together — ticket system, sprints and milestones, deadlines, kanban, gantt, dependency graph, parallel-wave execution, time tracked to the ticket, AI specialists on isolated branches, review gates at commit. One tool, one price, instead of ten.
Billed annually - $17.60/mo Solo, $28.00/dev/mo Team, $79.20/dev/mo Enterprise.
-
Solo
$22 /month
$17.60 /month billed annually $211.20 a year
SAVE $52.80 a year
- TUI Controller — mission control for AI dev
- 41 specialist agents on call
- 38 quality rules enforced at commit time
- Session persistence across conversations
- Billing-proof time tracking
- Multi-worker orchestration
- Priority support
-
Most popular
Team
$35 /dev/mo minimum 2 seats — from $70 a month
$28.00 /dev/mo billed annually $336.00 a year, per seat minimum 2 seats — from $56 a month
SAVE $84.00 per seat, per year
- Everything in Solo, plus:
- ForgePlay — complexity reality check
- Sprint board with velocity
- Time analytics across the fleet
- Token transparency across your fleet
- Per-developer seats, adjustable at checkout
Talk to us about TeamTeam is sold today — we will set the seats up with you.
-
Enterprise
$99 /dev/mo
$79.20 /dev/mo billed annually $950.40 a year, per seat
SAVE $237.60 per seat, per year
- Everything in Team, plus:
- Custom agent development
- Dedicated onboarding
- SLA
There is no free tier and there is no trial. FlowForge is a paid tool — a small price for what it does, and worth paying.
QUESTIONS
The things people ask before they pay.
What is FlowForge, exactly?
FlowForge is mission control for shipping software — formally, a development management system with AI specialists built in. Tickets, sprints, kanban, gantt and dependencies live in it, so you are not stitching five products together to answer one question. When work is ready to run, ACE dispatches specialists to isolated branches and an independent review gate holds every change until it earns the merge. Every minute is recorded against the ticket it belongs to. FlowForge does not write your code. It runs the shop the code is written in.
Do I need Node.js or npm?
No. FlowForge ships as a single Go binary. Install it with one command and it runs on your machine — nothing to install into your project, no runtime to keep current, no lockfile of ours in your repo.
Is this an IDE? Does it replace my editor or my coding agent?
No, and it is not meant to. You keep the editor and the coding agent you already use. FlowForge sits above them: it decides what gets built, who builds it, on which branch, and what has to be true before it merges. Your agent still writes the code.
Who writes the code — FlowForge or me?
Your AI coding agent writes it. FlowForge makes sure it is good code: a ratified blueprint before the work starts, an isolated branch per specialist, 38 rules enforced at commit, and an independent reviewer who is not the agent that wrote it.
What are the 41 specialists?
Named agents with narrow jobs — architecture, backend, database, security, TUI, design, QA, review, documentation, and more. ACE picks the right one for each task and dispatches it to its own branch, so a security question is answered by the security specialist rather than by whoever happened to be in the conversation. The full catalog is at /agents.
Is the time tracking a screen recorder?
No. Nothing watches your screen and nothing counts an open window. The meter follows real work events — messages sent, agents run, tools called — and pauses after five idle minutes. When it is unsure, it tracks less. A record that survives a question is worth more than one that counts every second.
Can I use my own ticket system?
Yes. FlowForge is provider-agnostic — GitHub, Jira, Notion and Linear are supported backends. Your tickets stay where your team already reads them.
Is there a free tier?
No — and there is no trial either. FlowForge is paid from the first day. The price is small for what it does, and paying it is part of the deal: you get a tool that is built to be worth it, and we get to keep building it. If it is not worth the money to you, it should not be in your stack.
Can I cancel?
Yes — cancel any time. Your subscription runs to the end of the period you have paid for.
Take the chair.
One command to install. A cockpit to keep it in order.
curl -fsSL https://get.flowforgesoft.com/install.sh | sh - Runs on your machine
- Single Go binary — no Node required