Context Limits

TLDR:
Context = Everything the AI remembers about your project and conversation. More context = Better understanding = Better results!

Context in Emergent refers to the conversation memory and project knowledge that the AI agent maintains throughout your development session. Think of it as the agent’s “working memory” - it includes everything from your conversation history, the code that’s been written, architectural decisions made, bugs fixed, features added, and your project requirements.

Emergent uses a structured memory architecture that allows agents to maintain long sessions, preserve technical decisions, and coordinate work across sub-agents. This guide explains how that memory is stored, prioritized, and passed through the system.

Standard Context Window

All Emergent agents operate with a 200,000 token context limit as the primary context window.

What This Means:

• Sufficient for most full-stack MVP development
• Handles complex conversations with multiple features
• Supports extensive debugging and iteration

Emergent may reach limits on very complex, long-running projects - which is where Forking comes into play. Read about it here.

Main Agent Context Architecture

Emergent provides three types of main agents. Each one manages memory differently based on its purpose and workload.

Agent	Specialization	Best For
E1	Stable, comprehensive testing (production-ready)	Standard full-stack development with thorough testing
E1.5	Focused, complex long-running tasks	Extended development sessions requiring sustained focus
E2	Thorough and relentless problem-solving	Complex architectural challenges and difficult bugs
Mobile	Expo/React Native development	Mobile app development (paid users only)
Pro Mode	Custom agent creation	Specialized workflows and custom configurations

E1 Agent (Standard)

Context Window: About 200,000 tokens

Memory Management: Keeps the complete conversation history until the context limit is near

Context Retention: Holds all code changes, architectural decisions, and requirements throughout the session

This agent is best for standard full-stack development with thorough testing

E1.5 Agent (Focused)

Specialized Context: Tuned for complex sessions that run for long periods

Enhanced Memory: Better at maintaining continuity across extended development cycles

Context Prioritization: Organizes memory to support deep problem solving

Best agent for extended development sessions requiring sustained focus

E2 Agent (Comprehensive - Currently in Beta)

Production Readiness: Thorough and relentless problem-solving

Memory Allocation: Balances historical data with the need for ongoing quality checks

Best Suited For: Complex architectural challenges and difficult bugs

For starting out, E1 is the standard agent - it should be comfortably able to handle most starter to intermediate projects.

Sub-Agent Context Handling

Sub-agents receive a filtered snapshot of the main agent’s memory so they can operate with a narrow focus.

Testing Sub-Agents (Backend and Frontend)

Context Inheritance: Receive structured summaries from the main agent

Focused Memory: Store only testing criteria and conditions

Limited Scope: Ignore unrelated parts of the project

Integration Agent

API Context: Holds details about third-party services and configuration

Service Memory: Remembers authentication flows and integration patterns

Specialized Knowledge: Uses domain-specific context for external systems

Image Sub-Agent

Visual Context: Tracks image requirements and generation parameters

Asset Memory: Holds style preferences, sizing rules, and usage patterns

Context Window Management

Emergent organizes memory to support long sessions while protecting key project details.

1. Token Limits

   Main agents have about 200,000 tokens available. Sub-agents work within smaller windows that fit their responsibilities.

   A warning appears when sessions approach their limit. You can periodically push data to GitHub, or fork the session and continue. More on that later!

2. Memory Retention Strategies

   Full conversation history is maintained until space runs low. When memory must be compressed, only the essential information is preserved. The current codebase is always retained.

Context Passing Between Agents

Agents cooperate by sharing memory in a structured and predictable way.

For Main to Sub-Agents:

• Summarized project context
• Task-specific details
• The current project state when required

From Sub-Agents to Main

• Test results, generated assets, or integration output
• Memory updates that become part of the main context
• Full synchronization so the project remains aligned

Chat Forking for Context Management

Emergent creates new forks when the context approaches its maximum size. Forking preserves essential information and compresses older details. Here’s an overview of the parts of your project this feature touches:

Preserved Info

Project Goals

User Requirements

Tech Stack

Current Codebase

Recent Changes

Outstanding Tasks

To-Do Items

General Cleanup

For more details about Forking, including when to fork and when to start fresh instead, visit the Forking Section.