How to Fork an AI Conversation Without Losing the Magic

The first time you fork a conversation in Reverie, the temptation is to fork everywhere. A reply you don't love? Fork. A choice you regret? Fork. Curious what the other answer would have been? Fork.

A week later you have 14 branches off the same trunk and you can't remember which was the version you actually liked.

Forking is one of Reverie's most powerful features, and one of the easiest to misuse. This is a field guide to using it like a writer instead of a save-scummer.

What forking actually does

In Reverie, every message has a fork point. Forking from a message creates a new branch that:

Inherits everything up to that point - the same history, the same long-term memory, the same character state.
Diverges from that point onward - the new branch has its own conversation history, its own memory accumulation, its own summaries.
Doesn't talk back to the original - whatever happens in the branch never bleeds into the main thread. The character in the original branch never "learns" what happened in the alternate.

You can name and label branches, switch between them, and there's no practical limit on how many you have.

That last property - branches are sandboxed - is the whole reason forking is useful. It's also the thing most users forget when they go fork-happy.

Forking vs. swiping: which to use when

These two features overlap and most users conflate them. They shouldn't.

Swipe / regenerate creates variants of the same reply. It's a small, local operation. The character is rephrasing one turn. The next message you send picks one of the variants and continues. Use it when:

The reply has the right intent but the wrong wording.
You want to compare two ways the same beat could land.
You want to nudge pacing within a turn without changing direction.

Fork creates a new timeline. It's a structural operation. Everything downstream of the fork point becomes a separate branch with its own future. Use it when:

You want to try a fundamentally different path - a different answer, a different scene, a different mood.
You've made a choice you want to back out of without erasing what came before.
You want to keep the current arc safe while you experiment.

Rule of thumb: swipe within a beat, fork between scenes. If you're choosing between two versions of what the character says, swipe. If you're choosing between two versions of what happens next, fork.

Three good reasons to fork

These are the cases where forking earns its keep:

1. The "what if" you don't want to commit to

Your character is about to make a decision. You're genuinely torn. Fork before the decision, play it out one way in the branch, see how it lands. If you like it, switch your reading there. If not, the original is untouched.

This is the version of forking most writers reach for. Treat it like an outline draft - cheap, throwaway, useful for seeing whether a direction has legs.

2. The mistake you want to undo cleanly

You sent a message you regret - revealed something too early, used a tone that broke the scene, accidentally pushed the character into a corner. Fork from before the bad message, redo it, and don't look back at the original until you actually want it.

The trap to avoid: deleting messages instead of forking. Deletion is irreversible; forking is. Forking is also cleaner - the original arc keeps existing in case the "mistake" turns out to have been interesting after all.

3. The parallel arc you want to keep separate

Same character, two stories. Maybe a slow-burn romance arc and a "what if we'd never met" arc, running side by side. Forking keeps them genuinely separate - the romance branch doesn't know about the alternate, the alternate doesn't have the romance's memories.

Combine this with user identities and you can run entirely separate lives with the same character without bleed.

Three reasons that look good but aren't

These are the patterns that produce branch sprawl:

Forking because the model's reply felt mid. That's swipe territory. Forking for one mediocre reply gives you a branch you'll never go back to and clutter you'll never clean up.
Forking instead of editing memory. If the character "keeps forgetting" something, the answer is the memory panel (guide), not a new branch.
Forking to "save" the conversation before something risky. Reverie auto-saves. The branch isn't a save file. If you fork before every dramatic beat, you're not exploring - you're hoarding.

How to manage branches without drowning

A few habits keep the tree readable:

Name forks the moment you make them. Use the label - "softer confession," "they don't say it," "alt: she's the one who leaves." A week later, "Branch 5" tells you nothing.
Keep one canonical branch. Pick the version that's "the story" and don't fork off it lightly. Treat the others as experiments, not equals.
Prune. If a branch hasn't been touched in two weeks and you remember why you forked it but not what happened in it, delete. It's not load-bearing.
Fork at scene boundaries, not mid-line. Forking in the middle of an emotional beat creates two half-finished scenes. Fork after the beat resolves, when there's a natural breath point.

What forking won't do

Setting expectations correctly avoids a lot of frustration:

Branches don't merge back. There's no "take the good parts of branch B and apply them to branch A." If you want both, you have to manually carry context.
The character has no cross-branch awareness. They don't know "in another timeline we kissed." They literally don't have the data. Don't reference branch content from outside that branch.
Forking doesn't reset the character. Their personality, voice, scenarios, and long-term-memory state at the fork point all carry over. Forking is "what if I'd made a different choice here," not "fresh start."

For a real fresh start, start a new conversation - that's a separate primitive.

Putting it together: a workflow

A common rhythm that works:

Run your main arc normally - swipe to pick variants, don't fork.
Hit a real branch-point - a moral choice, a confession, a decision the character would lose sleep over.
Fork once. Name both branches clearly ("she says yes" / "she says no").
Play each out for several beats - not just one reply, several.
Pick the one you want to keep going with. Don't delete the other yet; sit on it for a session.
If a week later you haven't returned to the abandoned branch, prune it.

This is how writers use revision drafts. The point isn't to keep everything - it's to commit to a version, with the knowledge that the experiment was real, not just speculative.

How this stacks with the rest of Reverie

Memory - each branch maintains its own memory accumulation; pinning a key fact in one branch doesn't carry to others.
Pacing - if a scene needs an entirely different opening, fork before swiping endlessly trying to find the right first reply.
Identities - for keeping parallel arcs fully separate (different name, different memory, different relationship), identities go further than forks.
Character writing - a sharper character makes branches diverge more meaningfully. A vague one produces three slightly different versions of the same reply.

The takeaway

Fork like you're writing a draft, not playing a save state. Branch on real decisions, swipe on lines, name everything, and prune what you won't return to.

The magic of forking isn't in having every possibility open - it's in being able to commit to a version, knowing the road not taken is still there if you need it.