Feature Request: Split-Pane "Live Workspace" – Decoupling Chat Dialogue from Persistent Project Context

[RandomTurtle]

Goal: To move the Gemini CLI away from an "append-only" chat model and toward a dual-pane system that separates the Conversation from the Project State.

The Problem: Context Flooding In the current "scrolling" chat model, the code and the conversation are mixed together. As we iterate, the context window becomes flooded with outdated versions of the same code. This causes the AI Agent to lose track of the current reality, leading to hallucinations and massive token waste.

The Proposal: The Agent and Buffer Split-Pane System I propose a UI/UX where the CLI maintains two distinct areas:

The Persistent Context Buffer (The Source of Truth) This is a non-scrolling window that holds the current state of the project files. This is the "Static Context" held in the AI's memory. It only updates when a change is confirmed. It is Live-Synced with the local hard drive. If I edit the file on my disk, the buffer updates; if the AI edits the file, the buffer updates.

The Logic Stream (The Agent Dialogue) This is a separate scrolling window where the user and the Gemini Agent have a dialogue. When I ask the Agent to make a change, it refers to the Context Buffer as its current reality. The Agent makes "In-Place" edits to the Buffer rather than printing massive code blocks into the chat history.

The In-Place Update Loop When a change occurs, the CLI updates the AI's memory in-place. This prevents the "Conveyor Belt" effect where old code pushes the Agent's instructions out of the context window. The Agent always has a 1:1 view of what is actually on my hard drive.

Why this is a game-changer: By separating the Dialogue from the State, we allow the Agent to stay focused on the "Logic" while the "Memory" stays focused on the "Code." This allows for much larger project sizes, virtually eliminates hallucinations caused by old code versions, and makes "Vibe Coding" feel like working with a real partner who is looking at the same screen as you.

I would love to see the Gemini team implement this "Split-Pane" approach to give the CLI a true "Active Workspace" feel.

[aniruddhaadak80]

From my point of view, this idea is strongest when treated as a state management problem rather than only a layout problem. The hard part is keeping the agent grounded in one current representation of the workspace while still preserving a usable conversational history. If that separation were implemented well, it could reduce both token waste and reasoning drift in a way that feels materially different from the current scrolling model.

[kinthaiofficial]

The split-pane concept maps directly to a pattern we use in multi-agent systems: separating the active conversation from the persistent project context.

In our 221-agent deployment, each agent maintains two distinct context layers:

1. Conversation context (your chat pane): Ephemeral, tied to the current session. Gets compacted when it approaches the context window limit.

2. Project context (your workspace pane): Persistent, survives across sessions. Stored as a machine-readable STATE.json with key decisions, file states, and architectural context.

The critical design insight: project context should be read-only from the conversation pane. The agent can reference project context, but changes to project context require an explicit write action (not just mentioning something in chat). This prevents the conversation from accidentally overwriting important project state.

Three-tier compaction keeps the workspace pane manageable:

• Tier 0 (full): Recent project changes, kept verbatim
• Tier 1 (structured summary): Older changes compressed preserving entity references
• Tier 2 (one-line digest): Ancient context reduced to key decisions only

Importance scoring determines what stays at each tier: relevance = importance * (0.95 ^ days_since_stored). Active project decisions stay at Tier 0; old experiments decay to Tier 2.

Full architecture: https://blog.kinthai.ai/why-character-ai-forgets-you-persistent-memory-architecture

Multi-agent context management: https://blog.kinthai.ai/221-agents-multi-agent-coordination-lessons