Context Limits

TLDR:
Context is everything the AI remembers about your project and conversation.
More context = better understanding = better results.

In Rofy, context refers to the conversation memory and project knowledge maintained by AI agents during your development session.

You can think of context as the agent’s working memory. It includes:

• Your conversation history
• Generated code
• Architectural decisions
• Bugs that were fixed
• Features that were added
• Your project requirements

Rofy uses a structured memory architecture that allows AI agents to maintain long development sessions while preserving critical technical decisions.

This guide explains how context is stored, prioritized, and shared between agents.

Standard Context Window

All Rofy agents operate with a 200,000 token context window.

This means the AI can process a large amount of project information at once.

What this allows

• Full-stack MVP development
• Complex feature discussions
• Extended debugging sessions
• Continuous development conversations

Tip:
Very long projects may eventually reach the context limit.
When that happens, you can fork the session and continue development with preserved project memory.

Main Agent Context Architecture

Rofy provides multiple AI agents.
Each agent manages context differently depending on its role and workload.

E1 Agent (Standard)

Context Window: ~200,000 tokens

Memory Behavior

• Maintains the complete conversation history
• Tracks all code changes
• Preserves architectural decisions
• Stores project requirements

Info:
E1 is the recommended agent for most projects, including typical SaaS applications and MVP development.

E1.5 Agent (Focused)

This agent is optimized for long-running development sessions.

Key characteristics

• Enhanced memory continuity
• Better handling of extended conversations
• Improved context prioritization

Best for:
Projects that involve deep reasoning or extended development cycles.

E2 Agent (Advanced – Beta)

E2 focuses on complex problem solving and architecture.

Capabilities

• Advanced debugging
• Complex system design
• Deep reasoning for difficult problems

Best suited for:
Challenging architectural issues or hard-to-diagnose bugs.

Sub-Agent Context Handling

Rofy uses sub-agents to handle specialized tasks.

Instead of receiving the entire project context, they receive a filtered snapshot from the main agent.

This allows them to focus only on the information relevant to their task.

Testing Sub-Agents

Backend Testing Agent

Focuses on:

• API validation
• Server logic testing
• Response validation

Frontend Testing Agent

Focuses on:

• UI behavior
• Component rendering
• Interaction validation

These agents store only testing-related context.

Integration Agent

The integration agent manages third-party services and APIs.

Context includes

• API credentials and configuration
• Authentication flows
• Integration patterns
• Service-specific logic

Image Sub-Agent

Handles visual asset generation and management.

Maintains context for

• Image styles
• Design preferences
• Size rules
• Asset usage patterns

Context Window Management

Rofy organizes memory carefully to support long development sessions.

Token Limits

• Main agents → ~200,000 tokens
• Sub-agents → smaller specialized context windows

When the context grows too large, the system begins optimizing memory usage.

Memory Retention Strategy

Rofy prioritizes important information when managing context.

The system keeps:

• Current codebase
• Important architectural decisions
• Key project requirements

Older conversation details may be compressed into summaries when space becomes limited.

Context Sharing Between Agents

Agents collaborate by passing structured context between each other.

Main Agent → Sub-Agent

The main agent sends:

• Project summaries
• Task-specific information
• Relevant code sections

Sub-Agent → Main Agent

Sub-agents return:

• Test results
• Generated assets
• Integration outputs
• Updated context information

This ensures the entire project stays synchronized.

Chat Forking for Context Management

When the context window approaches its limit, Rofy may create a fork of the conversation.

Forking allows the system to:

• Preserve essential project information
• Compress older conversation data
• Continue development without losing context

This helps maintain long-term project continuity without hitting memory limits.

Tip:
If your project grows large, consider periodically:

• Pushing code to GitHub
• Starting a new forked session
• Continuing development with preserved project memory