← Table of Contents
Chapter 5

Managing Conversations

Keep your test runs organized across multiple threads without losing any work.

Why Multiple Conversations

Every project can have as many conversations as you want. This isn't just a convenience feature — it reflects the reality of how character development actually works. You don't iterate on a character by running a single long chat from start to finish; you run many sessions, often exploring the same situations from different angles, testing whether a fix you made holds up under pressure, or pursuing a story thread that might not be the right direction for the character's final form.

Keeping these sessions separate prevents them from contaminating each other. A dozen turns of adversarial testing shouldn't be mixed into the same conversation you're using for a story arc you care about. Test conversations that went sideways shouldn't crowd out the reference sessions you use to check that baseline behavior is still correct. Multiple conversations let you give each thread a clear purpose and treat it accordingly.

Conversations are stored as conversation_NN.json files inside the project folder — plain JSON arrays of message objects. They're excluded from git history by default via the project's .gitignore, which means your character's version history captures your instructions and system prompt changes without accumulating every exploratory test chat you ran along the way. If you want to preserve a particular conversation in git — a reference session that documents a known-good behavior, for example — you can commit it explicitly or edit the gitignore to include it.

Creating a New Conversation

Click the New Chat button in the chat toolbar. A small dialog asks you to choose a session type. There are two options:

Each new chat is numbered automatically based on how many conversations exist in the project. Give it a meaningful name right away — the default name is just the number and type, which becomes meaningless the moment you have six of them. Naming immediately is a small habit that saves significant navigation friction later.

The Conversations Panel

Click the Conversations button in the chat toolbar to open the conversations panel. This lists every conversation in the current project, showing its type — a speech bubble for chat sessions, an image icon for image sessions — along with its name and the date it was last modified.

Clicking any conversation in the list switches to it immediately. The current conversation is saved automatically before switching, so you don't need to manually save before jumping between sessions. Click a conversation's name inline to rename it — the name becomes an editable field, save with Enter or by clicking away. The Delete button removes a conversation after confirmation; deletion is permanent and cannot be undone. For OPFS projects, use the Export button to save a copy before deleting — the file has no accessible path outside the browser. For FSA projects, the conversation is already a plain .json file in your project folder, so you can simply copy it in your file explorer before deleting.

Renaming Conversations

The names you give your conversations are the primary way you'll navigate a project as it grows. Vague names like "Conversation 3" or "test" become useless after a few sessions. Invest ten seconds in a descriptive name at creation time and you'll thank yourself later.

Effective naming conventions describe the scenario, the variable being tested, or the arc being explored:

You don't need to include dates — the Conversations panel shows modification times. Focus on what makes this thread distinct from the others.

Fork: Branch a Conversation

Every message in the conversation has a Fork button, visible when you hover over the message. Forking copies everything up to and including that message into a new conversation, leaving the original completely untouched. The new conversation appears in the Conversations panel named "Fork of [original name]" — rename it immediately to reflect what you're exploring in the branch.

Forking is how you explore alternate responses to the same setup without committing to one path. You can fork at the same message multiple times to create several independent branches, each starting from the same context but heading somewhere different. This is particularly useful at decision points — moments where the user's next message could go one of several ways and you want to test your character's behavior in each scenario without running a separate session from scratch every time.

Here's a typical Fork workflow for a scenario where something interesting just happened in the conversation:

You can fork as many times as you want from the same source conversation. Each fork is completely independent — changes in one don't affect any other.

Clone: Branch the Whole Project

Fork branches a conversation. Clone — accessible from the project menu in the toolbar — branches the entire project: instructions, system prompt, context files, configuration, everything. The clone is a full copy under a new name, and changes to either project have no effect on the other.

Clone is the right tool when a fork isn't enough — when what you're exploring affects the character definition itself, not just a conversation thread. Common situations:

The clone starts with no conversations — it opens fresh, with all the project files intact but a clean slate for testing. Run the same scenarios in both the original and the clone to directly compare how the two versions of the character behave before you decide which direction to commit to.

Collapse to Here: Summarize Long Conversations

As a conversation grows longer, the model's effective memory of its early portions degrades. Language models have a finite context window — the number of tokens they can attend to at once — and in a long conversation, early messages eventually fall outside that window entirely and are ignored when generating new responses. You may notice this as the character "forgetting" things established many turns ago, becoming inconsistent about facts or events that seemed settled earlier in the session.

The Collapse to Here button, visible on hover over any assistant message, is the solution to this problem. When you click it, Studio sends all the conversation history up to that message to the worker model along with a specialized summarization prompt. The worker generates a prose summary capturing the arc of the conversation: what happened, what was established, the emotional tone, any facts or agreements or turning points that matter for what comes next. That summary is saved as a new context file — context/Summary N.txt — so it's automatically included as background knowledge in every subsequent conversation.

After the summary is saved, a new conversation is opened containing only the messages after the collapse point. The character enters this new thread with the full benefit of the summary in context — it's as if all that history has been compressed and handed to them as a briefing — while the active conversation history is short enough to fit comfortably within the context window again.

The original conversation is preserved unchanged. You can always navigate back to it in the Conversations panel; it remains intact as a complete record. Collapse creates new things — a new conversation and a new context file — and never modifies what already existed.

Tip

After collapsing, open the new Summary N.txt file in the Context tab and read it carefully. The worker model's summary is good, but it will sometimes miss details that matter to your story — a specific name, a promise a character made, a fact established in passing that has implications later. Edit the summary to add or correct anything the worker got wrong before you continue. A summary you've reviewed is far more reliable than one you haven't.

Note

If you find yourself collapsing frequently, consider enabling the History Search agent (covered in Chapter 7). Rather than keeping the full conversation in context, the History Search agent lets the model search back through prior turns on demand — retrieving specific details when they become relevant rather than carrying everything forward at all times. This significantly extends how long a conversation can run before summarization becomes necessary, and is particularly valuable for long-running stories or roleplay campaigns where earlier events need to stay accessible across many sessions.

Import & Export

The Export button in the chat toolbar downloads the current conversation as a JSON file. The exported file preserves all message content, thinking blocks, role labels, and metadata — everything needed to reconstruct the conversation exactly. This is useful for sharing sessions with collaborators who want to see how a character performed in a particular scenario, for archiving important reference sessions outside the project folder, or for creating a backup of a conversation you're about to modify heavily.

The Import button brings an external conversation into the current project as a new chat session. Character Studio can import two formats:

In both cases, the imported conversation becomes a new, independent chat in the current project. Your existing conversations are untouched. The import is read-once — once the conversation is in the project, changes to it are saved locally and the original file is no longer referenced.

Note

Import is particularly useful for two scenarios. First, when you want to continue a conversation that someone else started — a collaborator or beta tester can export their session and hand it to you so you can pick up where they left off, using Studio's full editing and testing toolkit on their conversation. Second, when you have existing Venice.AI chat history you want to analyze or iterate on — import it and use Studio's message editing, forking, and mark-unacceptable tools to explore how the character might have responded differently.

Keyboard Shortcuts

When the chat area is in focus, a small number of keyboard shortcuts make it faster to move through long conversations:

Shortcut Action
Ctrl+Home Jump to the very top of the current conversation — the first message.
Ctrl+End Jump to the bottom — the most recent message.
Page Up Scroll up through the conversation one screen at a time.
Page Down Scroll down through the conversation one screen at a time.

These are standard scroll-container shortcuts and work exactly as you'd expect from a long document. They're most useful in long conversations where you're navigating back to a specific earlier moment without wanting to scroll manually through dozens of messages.