Automate the delivery.
Keep the judgment.
IssueFlow runs your GitHub issues through a delivery workflow you design — triage, design, build, review, test, merge and deploy — using the AI coding agents you already pay for.
You set the stages, the prompts, the checks each change must pass, and exactly where a human has to approve. Between those points the work keeps moving without you. When an agent reaches a decision you’ve reserved for yourself, it comes to you.
Design ready for your approval — the spec is published on the issue.
You decide when. IssueFlow handles how.
IssueFlow doesn’t decide where you belong in the loop. It gives every agent a way to stop and ask — and makes sure the question reaches the right place.
You write the rule
Each agent’s charter says what’s worth stopping for: a design choice, a missing credential, a spec that can’t be built as approved — whatever matters to you.
You build the ladder
Choose who answers first and how many tries each level gets. Mine uses two agent resolvers before it reaches me. Yours can go straight to you.
IssueFlow runs the mechanism
The agent pauses mid-stage and the work waits safely. The question climbs your ladder and lands in your Waiting-on-you queue — or you answer from a GitHub comment. The same stage resumes with your answer.
Here’s mine. Yours can look nothing like it.
The workflow IssueFlow uses to build itself: a couple dozen stages, one human gate, independent reviews, two lanes to ship, and every failure routed by its reason.
A failed review goes to a dedicated rework stage, and requires-design-change goes back to design. merge-conflict gets a conflict-resolution stage, ci-red goes to rework, and a transient merge block simply retries.
I approve the design before any code is written. Everything after it keeps moving unless something needs me.
A security violation, or anything no route covers, escalates — two agent resolvers first, then me.
Start from a template and make it yours“I gate design because that’s where my judgment matters most. Gate the PR, the deploy, every stage, or none — IssueFlow enforces whatever you decide.”
Motty Chen, founder
Queue everything. It runs in your order.
Hand IssueFlow the backlog for every product you’re building. It admits work in the priority order you declare, runs what it can in parallel, and parks what has to wait.
Your priority order. Name the levels — urgent, high, normal, low, or your own — and work is admitted in that order.
Concurrency and dependency guards. Parallel runs on the same repo don’t trip over each other, and an issue that depends on another waits for it.
Triage and decomposition. A vague report becomes concrete issues in the right repositories; an epic splits into sub-issues that ship together.
Multi-repo solutions. One workflow governs a product that spans several repositories.
One queue for everything that needs you.
Every gate, question and escalation waiting on you, with its context and evidence — and an alert when spend, failures or stale work cross the limits you set.
- Token spend exceeds your limit over your window
- The failure ratio rises above your limit
- The cache-hit ratio falls below your floor
- Attempts exceed your limit
- Stale issues exceed your limit
You set every threshold and its window. Nothing is watched that you didn’t ask for.
See where the time and the tokens actually went.
Ledger, token spend, bottlenecks, cost attribution, reliability, composition, rework and PR staleness — filterable by solution, repo, stage, framework, model, workstation and complexity. These are IssueFlow’s own numbers, from building itself.
Any agent, any script, any person.
Give each stage the executor that fits it, and change one without touching the rest of the workflow. Models are a per-stage setting.
You bring the agent subscriptions and API keys. IssueFlow charges a flat platform fee and never marks up your usage.
See every capabilityIssueFlow builds itself.
IssueFlow runs its own engineering through the workflow above — and delivery for Aligned On Purpose, a real multi-repository product. Every change is triaged, designed, built, reviewed and merged through the same rails you’d use.
Run your repo through the same rails
Pay for the orchestration, not the tokens.
A flat platform fee. Your own agent subscriptions and API keys.
Wire up one repo and one worker and watch a governed pipeline ship on your own code. No card.
- 1 solution, single repository
- 1 connected worker
- 1 user
- 3 concurrent stages
- Full triage → merge pipeline
- Configurable workflow & human gates
- Community support
For the solo builder running real, multi-repo work across their own machines.
- Up to 3 solutions, multi-repo
- 2 connected workers
- Up to 5 users
- 5 concurrent stages per worker
- Bring your own agent & LLM keys
- Reconciler: lost & stale-worker recovery
- Failure-aware routing & rework loops
- Email support
For a team that wants coordinated, auditable delivery with room to grow.
- Everything in Starter
- Unlimited solutions & repositories
- 5 connected workers
- Unlimited users
- Unrestricted concurrency
- Full attempt-level audit trail
- Priority support
A solution is one governed pipeline — its repositories, its workflow, and the workers that run it. Every paid tier is a flat platform fee: you bring your own agent subscriptions and LLM keys, and pay us nothing for tokens.
Not ready to sign up? Follow the build.
Occasional notes on loop engineering, governed agentic delivery, and what it actually takes to make agent loops production-grade. No spam, unsubscribe anytime.
Spend your judgment where it moves the needle.
Connect a repo, start from a template, and decide where you step in. Change anything after that.
Start freeFree forever on one repo and one worker. No card required.