Autonomous vs quick-fix processing

Ideafy has three processing types — background jobs that run the agent against a card without an open terminal. Each type runs a different workflow and has different expectations about how long it takes and what card state it starts from.

The three types

Type	Column requirement	What it does	Typical runtime
`evaluate`	Ideation	Reads the card + product narrative, calls `save_opinion` with verdict	2–10 min
`autonomous`	Any (detects phase)	Full workflow: plan → implement → generate tests. Creates a worktree.	5–30 min
`quick-fix`	Bugs	Short, targeted fix. No worktree ceremony.	1–10 min

Each type is triggered from a button in the card modal header. While a type is running, the card is locked — you can't edit it — and the processing indicator on the card surface shows an animated ring.

`evaluate`

Use when you have an Ideation card and you want the AI's take on whether it's worth doing.

What the agent does.

Loads the card description
Loads docs/product-narrative.md (or your configured narrative)
Analyses the idea against the narrative's non-goals, target users, success metrics
Calls save_opinion with the full template (Summary Verdict, Strengths, Concerns, Recommendations, Priority, Final Score) and a positive/negative verdict

When it finishes. The card has an Opinion tab you can read, and the card surface shows a Brain icon with a green check or red cross.

`autonomous`

Use when a card is ready to ship and you trust the agent to drive.

What the agent does.

Detects the phase from card state: no plan → plan first; plan exists → implement; implementation done → generate tests
For the plan phase: reads relevant source files, drafts a plan, calls save_plan → card moves to In Progress
For the implement phase: creates a git worktree, starts a dev server on an allocated port, writes code, commits
For the test phase: calls save_tests with acceptance criteria → card moves to Human Test

When it finishes. The card is in Human Test, the worktree is live, the dev server is running on its allocated port. You verify the acceptance criteria by hand and then merge from the card modal.

This is the closest Ideafy gets to "AI does the whole thing." You still verify and merge.

`quick-fix`

Use when there's a bug with a narrow scope and you just want it fixed.

What the agent does.

Reads the card description
Makes targeted edits in the worktree
Commits the fix
Leaves the card in the Bugs column (quick-fix doesn't auto-move status)

When it finishes. You still review. Quick-fix is the fastest path but has the least ceremony — there's no enforced plan or test generation, just "fix this thing."

Locking and interruption

When a processing job is running, the card is locked in the UI — no edits, no drag-drop, the modal is read-only-ish. The lock is visible in the card surface as an animated indicator.

If you need to stop a running job, use the Clear processing option in the card modal header. That sets processingType = null and kills the process. You keep whatever state was already written (partial plans, partial commits) — recovery is manual.

How autonomous differs from interactive chat

Autonomous, quick-fix, and evaluate all run the agent without session resume — every invocation is a fresh CLI call with the full system prompt. The chat panel in the card modal is the opposite: it resumes the previous CLI session via --resume, so the conversation feels continuous across days.

Autonomous also always runs with --dangerously-skip-permissions and --output-format json. It has to — nobody's at the keyboard to approve prompts, and the result has to be machine-parseable so Ideafy can update the card. Interactive chat uses elevated permissions only on the Tests tab (for cards at In Progress and beyond); everywhere else it uses the default confirmation flow.

For the full permission-flag matrix and session resume mechanics, see Interactive CLI sessions.

What to pick

Scanning an idea queue? → evaluate in a loop. Fast feedback on which ideas are worth building.
Well-scoped feature with a clear description? → autonomous.
A small, well-understood bug? → quick-fix.
A large, vague feature? → Don't use processing. Plan interactively in the Solution tab chat, then run autonomous once the plan is solid.

Processing types are not magic. They work best when the card already has enough context. If Detail is empty, the agent is guessing — and guessing isn't faster.

Prev: MCP tools reference Next: Interactive CLI sessions Up: User guide index