The idea: pick how much checking you want
More checking means higher quality and more tokens. Less checking means a faster, cheaper run with fewer safety nets. Rather than force one answer, Castforge lets you choose per project with a quality tier, and the tier decides which review gates run.
There are three tiers, and three gates. This guide covers all three.
The three quality tiers
You pick a tier when you create a project (the Quality tier control in the setup step), and Standard is selected by default. The choice is a project-level default; an individual phase can carry its own tier when the plan sets one, and that per-phase value takes precedence for that phase.
| Tier | What runs | Relative cost |
|---|---|---|
| Draft | Plan and code only. Both review gates are turned off. | Light |
| Standard | Adds the plan-check gate, goal verification, and phase verification. | Balanced |
| Max | Adds research and testing on top of the full gate stack. | Full |
Put plainly: Draft is code only, Standard adds plan-check and verification, and Max adds research and testing.
Cost bands
Before a run, Castforge can show a one-line notice with the rough token band for the active tier, so a bigger bill is never a surprise. The bands are approximate expectations, not billing promises:
- Draft: roughly 500 to 1,500 tokens per phase (plan and code only).
- Standard: roughly 1,500 to 3,500 tokens per phase (plan-check and verification included).
- Max: roughly 3,500 to 8,000 tokens per phase (research and full gate stack included).
Actual usage varies with the size of the work. A small change costs far less than a large feature at the same tier. You can dismiss the notice for a run.
Honest "skipped by tier" provenance
When a tier turns a gate off, Castforge says so rather than pretending the gate passed. On the gate panel you see a "Skipped (Draft tier)" chip with a tooltip explaining why, and the decision ledger records a matching "Skipped (tier)" entry with an amber accent. A gate that did not run is never shown as a silent pass. The fail-safe direction is to keep gates on: an unrecognized tier value leaves the gates enabled rather than disabling them.
The Lead Plan-Check Gate
The first gate runs before any code is written. When the Lead produces a plan, it also critiques that plan against the work's acceptance criteria, and the result appears as a plan-check panel on the plan card in chat. The point is to catch a weak or incomplete plan early, when fixing it is cheap.
The panel reads one of three ways:
- Plan check passed (mint): the plan looks sound. Nothing more is needed.
- Plan check found issues (amber): the panel opens to a list of findings. A Revise plan button sends those findings back to the Lead for one capped revision round.
- Plan check skipped (muted): the check could not run, or the tier turned it off. You can still approve the plan.
This gate is assistive, not a hard stop. It surfaces its findings above the plan's action row, but it never blocks you from approving the plan yourself. If you also have plan approval turned on, you still get the Approve, Edit, and Reject controls described in "Your AI dev team."
The Goal-Backward Verification Gate
The second gate runs at the other end, when the work settles. Instead of asking "did the tasks run," it works backward from the goal: it checks the delivered work against the acceptance criteria the team set out to meet. The Reviewer performs this goal-check, and the result surfaces as a goal verification panel in the workspace.
The panel only appears when there is something for you to decide, that is, when the check finds gaps:
- Goal check found gaps (amber): the panel lists the unmet criteria. You get two actions.
- Re-run sends the work back for another pass (capped at one round).
- Accept as-is dismisses the gate and lets the run settle as delivered.
- On a clean pass or a tier-skip, the panel stays out of your way (a pass needs no action, and a tier-skip shows the small skipped chip so it is never silent).
The framing is deliberately assistive: it says "found gaps," not "failed," because the goal is to help you close the last mile, not to grade the team.
The Phase Verification Gate
The third gate runs when a whole phase finishes, that is, when every card in the phase is marked done. Rather than trusting that each card passed on its own, Castforge runs a verification turn that actually exercises the phase as a whole: it runs the project's build, runs its test suite, and works through the key flows the phase's cards deliver, checking that the pieces integrate and not just that each one passed in isolation. This is the Tester seat's job.
The outcome decides what happens next:
- Pass: the phase is recorded as verified, with the evidence behind it (the commands that were run and a trimmed excerpt of their output), and the run advances to the next phase.
- Fail: the phase is held, and Castforge automatically creates fix cards in that same phase, one per problem the verification found, so the team can address them and the phase is checked again once they are done. This can repeat for up to two fix rounds. If the phase still has not passed after the second round, the run pauses with a summary of what is still unmet so you can step in, rather than looping without end.
Because the fail path loops back into the same phase and re-verifies once the fix cards are done, a phase that needs a couple of passes heals itself; because the loop is capped at two rounds, it can never run away.
Like the other gates, this one honors the quality tier. On the Draft tier the phase verification gate is skipped and the record always reads "skipped (tier)", never a pass. A project that has no build or no test setup to run is skipped loudly as "skipped (infrastructure)" and keeps moving, again never shown as a pass. Every pass, fail, and skip is written to the project's verification.md artifact and to the decision ledger, so the evidence is durable and never silent. For the artifact itself, see "Project memory and the decision ledger."
Clarify before planning
Planning a new phase or milestone starts from the request you give the Lead. When that request has genuine gray areas, real ambiguity about what you want, the Lead asks you a few structured multiple-choice questions first and plans from your answers, so it builds the right thing instead of guessing. In Autonomous mode there is no one to ask, so the Lead decides for itself and records every assumption it made in the project's decisions log and in the plan, so you can see exactly what it chose and why. A clear, unambiguous request skips the questions entirely and goes straight to planning, so you are never slowed down by friction you did not need.
The Unreal card verify gate (Unreal Engine projects)
For an Unreal Engine project, a card also carries its own verify gate before it can be marked done, on top of the three tier gates above. This one is per card, always on, and not something a quality tier turns off.
When a Coder finishes work on an Unreal card, the verify hop checks two things before the card is allowed to settle:
- A functional gate: Castforge confirms your Unreal editor is reachable and the card's target actually loads, not just that the change compiles.
- A visual grade: a screenshot of the Unreal viewport is captured and sent to your Designer role for a check against the card's intent, the same kind of look a Designer gives a running web app.
Both have to pass. If either one does not, the card cannot be marked done: it loops back through the Coder, Tester, and Reviewer roles (the handoff chain described in "Your AI dev team") for another pass, instead of settling with unverified work.
You see the result as a verify chip in the Unreal panel header (see "Preview and iterate" for the panel itself):
- Verified (mint): the functional gate and the visual grade both passed.
- Verify flagged (amber): the visual grade raised minor notes; this is advisory and does not block the card.
- Verify failed (red): a gate did not pass; the card cannot be marked done yet.
- Not verified yet: the verify hop has not run for this card.
Web projects keep their existing visual-verify check unchanged. This section covers only the Unreal-specific functional-plus-visual gate.
How the verdict badges read in chat
Both gates use the same visual language, so you can read them at a glance without learning two systems:
- Mint with a check icon means a check passed.
- Amber with an alert icon means a check found something worth your attention (plan issues, or goal gaps).
- Muted with a neutral icon means a check was skipped, with a tooltip that says why.
The same outcomes are recorded in the decision ledger as gate-outcome entries, so you can revisit any verdict later in Project Memory. See "Project memory and the decision ledger" for that history.
Choosing a tier
- Reach for Draft on throwaway work, spikes, and quick experiments where you want speed and low cost and will eyeball the result yourself.
- Keep Standard (the default) for most real work: you get the plan-check before you commit to a plan and the goal verification when it settles, at a balanced cost.
- Step up to Max when the work is important enough to warrant research up front and testing on top of the full gate stack.
You set the tier at project creation, and a plan can raise or lower it for a given phase, so you are never locked into one level of rigor for the whole project.
Common questions
Do the gates block my work? No. Both are assistive. The plan-check surfaces findings but never stops you approving a plan, and the goal-check gives you Re-run or Accept as-is rather than refusing to settle. You stay in control.
What is the difference between the plan-check and the goal-check? The plan-check runs before work starts and critiques the plan. The goal-check runs at settlement and verifies the delivered work against its acceptance criteria. One guards the input, the other guards the output.
Why did a gate say "skipped"? Either the check could not run, or your quality tier turned that gate off (Draft turns both off). The panel and the ledger both record the reason so it is never a silent pass.
Can I change the tier after creating the project? The tier is chosen at project setup and defaults to Standard, and a plan can set a different tier for a specific phase, which takes precedence for that phase.
How many times will it re-run or revise? Every gate caps its loop so it can never iterate without end: one plan revision after a failed plan-check, one re-run after a goal-check that found gaps, and up to two fix rounds on the phase verification gate before the run pauses for you.
Where do I see past verdicts? In the Project Memory tab. Every plan-check and goal-check outcome is written to the decision ledger, where you can filter to gate outcomes and expand any one for its findings.
How is the Unreal card verify gate different from the three tier gates? The tier gates (plan-check, goal verification, phase verification) apply to any project and can be turned down by choosing Draft. The Unreal card verify gate only applies to Unreal Engine projects, runs on every card regardless of tier, and checks two specific things: that your Unreal editor is reachable and the target loads (the functional gate), and that a Designer-graded screenshot of the viewport looks right (the visual grade). See "The Unreal card verify gate" above.