Overview
Forking creates a new task from an existing one, carrying forward context so you can explore an alternative direction, continue work that a previous task started, or branch off from a good checkpoint.What forking does
When you fork a task, Whim:- Creates a new task linked to the original (the “source” task)
- Sets up a new Git branch based on the source task’s branch — including any uncommitted changes via a code snapshot
- Initializes the new task with context from the source, depending on the fork mode
- Launches the new task in its own container
Fork modes
Whim offers two fork modes that control how context is transferred:Session mode
Copies the full Claude session from the source task into the new task. The AI agent in the forked task has the complete conversation history — every file it read, every decision it made, every command it ran. Use session mode when you want to:- Continue exactly where a task left off
- Give a follow-up instruction that builds on all previous context
- Explore a “what if” branch from a specific point in the conversation
Summary mode
Starts a fresh session with a new prompt. The AI agent does not inherit the source task’s conversation history — instead, you write a prompt that includes whatever context is relevant. Use summary mode when you want to:- Take a different approach to the same problem
- Start clean but on the same codebase state
- Provide your own curated context rather than carrying forward the full history
In both modes, the forked task inherits the source task’s code state — all file changes, committed and uncommitted. The difference is only in whether the AI’s conversation history carries forward.
When to fork
Fork with session mode
- “Continue this task but also add tests”
- “The approach was right, now refactor the result”
- “Pick up where you left off after I made manual edits”
Fork with summary mode
- “Try a completely different approach to this problem”
- “Start fresh on this codebase state with new instructions”
- “I want a clean conversation but the same file changes”
Context inheritance
| What carries forward | Session mode | Summary mode |
|---|---|---|
| Code changes (committed + uncommitted) | Yes | Yes |
| Git branch state | Yes (new branch from source) | Yes (new branch from source) |
| AI conversation history | Yes (full session) | No |
| File attachments | No (reference in prompt if needed) | No |
| Task settings (provider, model) | Inherited from source | Inherited from source |
Branch implications
The forked task gets its own new isolated branch, created from the source task’s branch at the point of forking. This means:- The source task’s branch is untouched
- Any uncommitted changes in the source are captured via a code snapshot and applied to the new branch
- Both tasks can continue working independently without conflicts
- Each task can create its own pull request from its branch
Code snapshots ensure that even work-in-progress changes that haven’t been committed are preserved in the fork. You don’t need to commit before forking.
Forks can be nested up to 3 levels deep (original → fork → fork of fork). This prevents excessively long chains while still allowing iterative exploration.