Skip to main content
Understanding how ZeroTwo handles context helps you get better responses, avoid the AI “forgetting” earlier parts of a conversation, and design effective workflows that carry the right information forward across sessions.

​
How Context Works

Every time you send a message in ZeroTwo, the platform constructs a context payload and sends the entire thing to the selected model. This payload contains:
  1. The full conversation history — every message from both you and the AI in the current chat, from the very first message to the one just before your current input
  2. Your current message — the new prompt you are sending
  3. System context — any active project instructions, custom instructions from Settings → Personalization, and relevant memory entries
  4. Tool results — if web search, file attachments, or other tools were used, their outputs are included
The model sees this entire payload with each message. It does not have a separate persistent “memory” of the conversation between turns — it re-reads everything from the beginning on each turn. This is why long conversations can approach the model’s context window limit.

​
Context Window Limits

Every AI model has a maximum context window — the total number of tokens (roughly, words and punctuation) it can process in a single request. When a conversation grows large enough to exceed this limit, older messages are dropped to make room for new content. ZeroTwo displays context window information in the model capabilities tooltip in the model picker.

​
Common Context Windows

ModelContext WindowApproximate Length
Gemini 2.5 Pro1,000,000 tokens~750,000 words
Claude Sonnet 4.6200,000 tokens~150,000 words
Claude Opus 4.6200,000 tokens~150,000 words
GPT-4o128,000 tokens~96,000 words
GPT-5128,000 tokens~96,000 words
Mistral Large128,000 tokens~96,000 words
DeepSeek Chat64,000 tokens~48,000 words
Smaller models8,000–32,000 tokens~6,000–24,000 words
For most conversations, context limits are not a practical concern. Even lengthy chats rarely approach these limits unless you are pasting in large documents, uploading multiple files, or running many rounds of detailed analysis.

​
When Context Gets Too Long

If a conversation grows beyond the model’s context window, ZeroTwo handles it by truncating the oldest messages to make room for new content. The most recent messages are always preserved. Signs that context truncation has occurred:
  • The AI seems to have “forgotten” something mentioned early in the conversation
  • The AI asks for information you already provided
  • Responses lack awareness of earlier decisions, constraints, or established context
What to do:
  • Start a new chat — open a new conversation and summarize the key context in your opening message (see the tip below)
  • Use a larger-context model — switch to Gemini 2.5 Pro (1M tokens) or Claude Sonnet 4.6 (200k tokens) for very long sessions
  • Break long tasks into focused chats within a project — instead of one giant conversation, use a series of shorter focused chats that share context via the project instruction
When starting a new chat to continue a long-running task, open the previous chat, copy a concise summary of the key context (decisions made, constraints established, current state), and paste it as the first message in the new chat. This gives the AI everything it needs without the accumulated noise of the full history.

​
Starting Fresh

Starting a new chat gives the AI a completely clean slate — no prior conversation history. This is intentional and useful:
  • Switch topics cleanly. When you are done with one task and starting another, a new chat prevents any spillover context from the previous conversation affecting responses.
  • Reset incorrect context. If a conversation went in the wrong direction and is now full of noise, a fresh chat with a refined prompt often produces significantly better results.
  • Conserve premium quota. Very long conversations generate large context payloads, which consume more tokens per message. Starting a new chat resets this.

​
Persistent Context Across Sessions

ZeroTwo provides several mechanisms for context that persists beyond individual chats, so the AI always has background information about you and your work.

​
Memory

ZeroTwo’s memory system automatically learns personal facts about you from your conversations — your role, technical preferences, writing style, and more. These facts are categorized as preferences, general facts, or profile information and are automatically injected into the context of every new conversation.
  • Free plan: Up to 5 memory entries
  • Pro+: Unlimited memory entries
Memory entries are created automatically as ZeroTwo notices relevant patterns, or you can add them manually. You can view, edit, and delete any memory entry in Settings → Personalization → Memory, or turn off auto-memory creation entirely. See Memory: How It Works for full details.

​
Project Instructions

Each project has an optional instruction set — a system prompt that is automatically injected into every chat within that project. This is ideal for maintaining consistent AI behavior across many sessions about the same topic. Example project instruction:
“You are helping me build a SaaS product called Acme. The tech stack is Next.js, Supabase, and Stripe. Always write TypeScript. Prefer functional React components. Assume production-grade code quality.”
Every new chat in that project starts with this context without requiring you to re-enter it. This is the most powerful form of persistent context in ZeroTwo — it transforms a collection of individual chats into a coherent ongoing workspace.

​
Custom Instructions

Settings → Personalization → Custom Instructions lets you set global instructions that apply to all new chats across your entire account, regardless of which project they are in. There are two fields:
  • “What should ZeroTwo know about you?” — your role, background, preferences, technical context
  • “How should ZeroTwo respond?” — tone, format, length, specific behaviors
Custom instructions are a good place for universal preferences like “always respond concisely,” “format code with TypeScript,” or “I am a senior backend engineer.”

​
How Switching Models Affects Context

When you switch models mid-conversation, the full conversation history is sent to the new model. The new model has complete context of everything discussed before the switch. Things to be aware of:
  • Different models may interpret or reference earlier content with slightly different nuances
  • Switching to a model with a smaller context window than the current model may result in earlier messages being truncated if the conversation is already long
  • Not all models support all tools — switching to a model that lacks tool-use support disables active tools like Web Search and Agent Mode
Switching models mid-conversation does not lose any context. The new model receives the complete history. Check the context window size in the model capabilities tooltip before switching on very long conversations.

​
Context Flow Summary

Every message you send triggers this payload construction: 
Memory entries (personal facts about you)
         +
Project instructions (if chat is inside a project)
         +
Custom instructions (global settings)
         +
Full conversation history (current chat, from first message)
         +
Current message (your new input)
         +
Tool results (web search, file contents, etc., if applicable)
         =
Context payload sent to the model
Understanding this flow helps you debug unexpected AI behavior, design effective project workspaces, and write better opening prompts.
If you need the model to remember a critical fact mid-conversation — especially in a long chat — explicitly re-state it: “Reminder: we decided to use Postgres, not MongoDB.” Re-stating key constraints at important junctures is more reliable than assuming the model will track them through a long conversation.

​
Related Pages