Review backends

Every review gate runs through a configurable review backend, and the point of configuring one is that it is a different model than the one that wrote the artifact. The verdict grammar, receipts, fix loop, and optional --deep / --validate passes are identical across all of them, so pick the one your team already runs.

Backend	Driver	Reviewer models	Shape
RepoPrompt (rp)	RepoPrompt CE + CE-first CLI ladder	chosen in the RepoPrompt window / session	macOS GUI; rpce-cli is preferred, discontinued Classic is compatibility-only, and Builder discovers context the diff alone would miss
OpenAI Codex (codex)	codex CLI	GPT-5.x family	headless, cross-platform
GitHub Copilot (copilot)	copilot CLI	Claude 4.x + GPT-5.x families	headless, cross-platform
Cursor CLI (cursor)	cursor-agent CLI	several vendor families in one place - ask cursor-agent --list-models for the current ids	headless subprocess; reviews billed against your existing Cursor subscription
Host (host)	Host-native fresh-context subagent	Cross-family pin from AGENTS.md model-routing (never the session model)	Bare only - no subprocess; preferred from inside Cursor

Host (host) is a model-less selection sentinel, not a CLI. Review runs as a host-native fresh-context subagent pinned to a model family that did not write the diff (pins live in the AGENTS.md model-routing section - never on the backend string; host:<model> is rejected). Every re-review is a new subagent. Fail-closed: without a cross-family pin, interactive runs ask; autonomous runs stop with NEEDS_HUMAN rather than silent same-family self-review. Setup on Cursor leads the backend menu with Host (Recommended). On Grok, Host is also offered, but Grok’s only native model family is grok-4.5 - native host review fails closed for a Grok writer unless the writer is non-Grok; cross-family review on Grok comes through bridge backends (codex / cursor / copilot). See Orchestration → Cursor host and Install → Grok.

Cursor CLI (cursor-agent) runs the same headless contract and verdict grammar as codex/copilot, with reviews billed against your Cursor subscription instead of a separate API key. It is resume-only (the first review persists Cursor’s session_id; re-reviews resume it) and folds reasoning effort into the model name (Cursor convention), so a spec is cursor:<model> with no :effort rung. From inside Cursor this path is circular - prefer host.

Set it once with /flow-next:setup, or override per run:

# persist the default (.flow/config.json)
flowctl config set review.backend codex
flowctl config set review.backend host          # preferred from inside Cursor

# override for a single run
/flow-next:impl-review fn-1 --review=rp|codex|copilot|cursor|host|none

# full spec form - backend:model:effort (host is bare only)
FLOW_REVIEW_BACKEND=codex:<model>:high

none is an explicit opt-out (skip review). The :model:effort suffix is optional and backend-specific - RepoPrompt picks its model in-app, so it takes no suffix; Codex and Copilot accept a :model:effort suffix (e.g. copilot:<model>:high); Cursor CLI takes a model only (e.g. cursor:<model>) since effort is baked into the model name; host accepts no suffix at all. The chosen backend is recorded as the mode field on every review receipt.

One shape difference is worth knowing before you pick: on codex and host the first review round of a scope fans out three concurrent axis draws that get merged into one fix pass, while rp, copilot, and cursor send a single dispatch every round. It counts as one round against the cap either way. See The first round draws three reviewers.

A per-task review: (or per-spec default_review) override routes end-to-end - it wins over the project default and env/config, so a task set to review: cursor:... under a codex project default actually reviews with cursor. Implementation reviews also carry an always-on code-smell baseline (Fowler Refactoring - Feature Envy, Data Clumps, Primitive Obsession, …) across every backend.

Per-backend notes

Backend	Notes
rp	RepoPrompt CE (macOS GUI). CE-first discovery prefers rpce-cli; Builder auto-selects context.
codex	Codex CLI, cross-platform. Defaults to the strongest GPT tier the installed CLI accepts (the fallback ladder steps down automatically); tunable with FLOW_CODEX_MODEL and FLOW_CODEX_EFFORT.
copilot	GitHub Copilot CLI, cross-platform. Native Windows works from 1.1.9 via stdin delivery (below). Supports the Claude 4.x and GPT-5.x families.
cursor	Cursor CLI (cursor-agent), cross-platform. Model names carry their reasoning tier. Circular from inside Cursor, where host is preferred.
host	Host-native fresh-context subagent. Bare only; cross-family pin from the routing block; fail-closed NEEDS_HUMAN without a pin.
export	Write the review prompt to a file, for paste into a web chat. Available on plan-review and impl-review.
none	Skip review entirely, cleanly and visibly.

Windows + Copilot (1.1.9+)

Native Windows works. run_copilot_exec delivers the prompt via stdin on Windows (subprocess.run(input=prompt, ...)), sidestepping the CreateProcessW 32,767-char argv cap that broke the -p path for spec-sized prompts in 1.1.8 and earlier. Session continuity is tracked with a touch marker, because stdin-mode --resume is resume-only unlike -p mode’s create-or-resume. Verified by a real-subprocess Windows CI smoke. Upstream tracking: github/copilot-cli#3398.

Precedence

Highest first: an explicit --review= argument → a per-task review: field or per-spec default_review → FLOW_REVIEW_BACKEND → .flow/config.json → backend env → the shipped default. A skill with nothing configured anywhere hard-errors rather than silently skipping. Per-spec overrides are written with flowctl spec set-backend, per-task with flowctl task set-backend. A single task can pin its own reviewer and the override routes end-to-end, so a task set to review: cursor:… under a codex project default really does review with cursor.

flowctl config set review.maxIterations 6      # review-round cap (env MAX_REVIEW_ITERATIONS wins)

The model-routing tiers never touch this configuration. The reviewer tier is advice about which family to pick; review.backend is the machinery that runs it.

What the reviewer actually receives (3.16.0)

The reviewer runs in your checkout with a shell, so it is handed identities, not content: the reviewed base..head range, the exact list of changed paths (git diff --numstat --no-renames -z, so nothing is elided, renames appear as real paths, and non-ASCII filenames survive), the repo-relative spec and task paths, and a few context hints. It reads the diff and the specs itself, at whatever depth each part warrants.

Earlier releases embedded the diff body in the prompt under a 50 KB cap, which meant a large change was reviewed against a truncated sample. Nothing is trimmed to fit now, and if a git read behind the evidence fails, the review stops with the underlying error before a review round is spent, rather than returning a verdict formed from nothing.

Re-reviews continue the reviewer’s own session, so when it checks whether your fixes landed it compares against findings it remembers making rather than a re-rendered list. When a session cannot be resumed, the prior findings travel in the prompt as before.

Expect better-informed reviews rather than cheaper ones: a fetching reviewer spends turns on tool calls, so it is slower on a large diff and its measured token use went up, not down. The dispatch bound is 1800 seconds, overridable with FLOW_REVIEW_EXEC_TIMEOUT.

Turning it off

review.backend none is an explicit opt-out, not a degraded mode: every backend-driven review exits cleanly and the skip is recorded. What each setting keeps running, and what it stops, is priced in What each layer costs.