Cognitive Room Framework

Your brain already routes attention to different tools for different tasks. We're giving each one an address.
"You don't think in one place. You think in rooms. The terminal where you debug is not the terminal where you pitch. The tool where you write is not the tool where you close deals. Name the rooms. Give them rules. Watch the context-switching tax drop to zero."

The 3x3 Grid

Every knowledge worker's toolset maps to a grid with three rows (time horizons) and three columns (energy types). The rows are Strategy (long-term, high-stakes), Tactics (dynamic, market-facing), and Operations (deterministic execution). Each cell gets one verb โ€” one thing it does โ€” and that constraint is what makes it work.

A. Strategy โ€” The Substrate
B. Tactics โ€” The Collision
C. Operations โ€” The Crank
A1
๐Ÿ”’ WezTerm Vault
PROVE
First-principles validation. Mathematical proofs. IP protection. Nothing leaves without verification.
"Reads the examiner before the examiner reads the claim"
Example tool: WezTerm, a dedicated terminal for deep work
B1
๐Ÿงช Cursor Laboratory
TEST
Rapid prototyping. Smash ideas together. Speed over safety. Find out what breaks before you broadcast.
"The sandbox where hypotheses die or ship"
Example tool: Cursor, an AI-native IDE for experiments
C1
๐Ÿ”จ iTerm Builder
SHIP
Execution. The vector is locked. Decisions are made. Turn ideas into shipped features.
"The room that commands the other eight rooms"
Example tool: iTerm2, your build-and-deploy terminal
A2
๐Ÿ“ VS Code Architect
SEQUENCE
Strategic ordering. Roadmaps. Dependencies. See the whole war before you fight it.
"Catches what you said vs what you shipped"
Example tool: VS Code, your full IDE for architectural work
B2
๐ŸŽค Terminal.app Voice
BROADCAST
Content creation. Translate dense proofs into viral stories. Amplify signal at peak hours.
"Turns physics into poetry and poetry into pipeline"
Example tool: Terminal.app, clean writing environment
A3
๐ŸŽญ Alacritty Performer
CONVERT
Live delivery. Demos, pitches, presentations. Months of preparation into minutes of impact.
"Converts proof into demos and demos into revenue"
Example tool: Alacritty, fast and focused for live work
B3
๐ŸŽฉ Kitty Operator
CLOSE
Deal execution. Follow-ups, pipeline, revenue. Every conversation ends with a next step.
"Every deal is also a defensive position"
Example tool: Kitty, configurable for CRM workflows
C3
โ˜• Messages Network
CULTIVATE
Relationship maintenance. Strategic pings. Gratitude loops. The relational substrate.
"Silence speaks louder than outreach"
Example tool: Messages, your communication app

The terminal names are examples. Your WezTerm Vault might be Obsidian. Your Cursor Laboratory might be a Jupyter notebook. The framework is the constraint, not the tool.

The Flywheel Routing Test

When you catch yourself context-switching โ€” when three browser tabs, two terminals, and a Slack thread are all fighting for your attention โ€” run this test to find which room you belong in right now:

1
What am I doing? (Find the verb)
PROVING something? โ†’ Row A (Strategy). TESTING something? โ†’ Row B (Tactics). SHIPPING something? โ†’ Row C (Operations).
2
Who is it for? (Find the column)
For the record/posterity? โ†’ Column 1. For an audience/market? โ†’ Column 2. For a relationship/deal? โ†’ Column 3.
3
How long until it matters? (Confirm the row)
Months/years โ†’ Strategy (A). Days/weeks โ†’ Tactics (B). Hours/now โ†’ Operations (C).
4
Open that tool. Close everything else.
The room has rules. The rules prevent drift. The constraint is the feature.

One Verb Per Room

The core insight: each room does exactly one thing. Not "communications" โ€” that's a department. Not "development" โ€” that's a career. One verb. The verb is the gravity well that pulls scattered attention into focused output.

๐Ÿ”’ WezTerm Vault โ†’ PROVE โ€” validate claims against first principles
๐Ÿ“ VS Code Architect โ†’ SEQUENCE โ€” order dependencies, roadmap the battles
๐ŸŽญ Alacritty Performer โ†’ CONVERT โ€” preparation into live impact
๐Ÿงช Cursor Laboratory โ†’ TEST โ€” smash theories together fast
๐ŸŽค Terminal.app Voice โ†’ BROADCAST โ€” dense proof into viral story
๐ŸŽฉ Kitty Operator โ†’ CLOSE โ€” every conversation ends with a next step
๐Ÿ”จ iTerm Builder โ†’ SHIP โ€” idea becomes iron
๐Ÿงญ Rio Navigator โ†’ ROUTE โ€” triage, queue, hand off to machines
โ˜• Messages Network โ†’ CULTIVATE โ€” tend the relational substrate

If you're in the WezTerm Vault and you start drafting a tweet, you're in the wrong room. If you're in the iTerm Builder and you start questioning the strategy, you're in the wrong room. The verb is the boundary. The boundary is the productivity.

What We Learned From The Dumps

We ran a 69-agent swarm analysis across 5.7 million characters of actual terminal dumps โ€” everything typed into 8 of these rooms over months of real work. The finding that matters:

Rooms Evolve Beyond Their Assigned Verb

The WezTerm Vault (PROVE) became a patent examiner-psychology reverse-engineer. The iTerm Builder (SHIP) became command-and-control for 15 agents. The Rio Navigator (ROUTE) became a REM-state hacker that programs sleep. The Kitty Operator (CLOSE) became an infrastructure defense terminal disguised as CRM.

This is the product insight: your rooms will evolve too. The one-verb constraint doesn't prevent growth โ€” it channels it. The verb stays the same, but what the room actually does deepens. "PROVE" in month one is running equations. "PROVE" in month six is reverse-engineering how patent examiners read claims.

The framework works because the verb is a gravity well, not a cage. You'll discover what your tools actually do when you stop using them for everything and start using them for one thing.

WezTerm Vault evolved to
Examiner-psychology reverse-engineering
VS Code Architect evolved to
Real-time validation gate + strategic leak detector
Alacritty Performer evolved to
Strategic synthesis engine (demos_booked_48h)
Rio Navigator evolved to
REM-state hacker (programs sleep)
Terminal.app Voice evolved to
Dual-harmonic framing (diagnostic + unleash)
Kitty Operator evolved to
Infrastructure defense disguised as CRM
iTerm Builder evolved to
Command-and-control for 15+ agents
Messages Network evolved to
Commitment-scheme engineering (weaponized silence)
Cursor Laboratory evolved to
Kill-or-ship verdict engine (no open experiments)

The Dump Protocol

The most powerful workflow in the framework isn't a room โ€” it's the transition between rooms. Your brain accumulates unprocessed thoughts all day. Without a dump protocol, they leak into the wrong rooms. Here's how to pay the boundary tax once, cleanly.

Evening Dump โ€” Offload Before Sleep

At the end of your workday, open your Rio Navigator tool. Set a 15-minute timer. Dump everything โ€” unfinished tasks, half-formed ideas, frustrations, breakthroughs, things you noticed but didn't act on. Raw text into an LLM. Don't edit. Don't organize. Just offload.

The LLM categorizes it into rooms for you. "This is a WezTerm Vault item." "This goes to the iTerm Builder." "This is actually a Kitty Operator follow-up." Then turn on TTS and listen. Lie back. Let the AI read your sorted queue back to you โ€” what ships overnight, what waits for morning, what is blocked. Your brain hears its own thoughts returned in order. The racing stops because the external system has confirmed receipt. This is a handoff protocol. You are transferring custody of your open loops to a system that will not forget them. You wake up with a clean queue instead of racing thoughts.

When: End of workday. Duration: 5-15 min dump + TTS readback. Tool: Rio Navigator terminal.

Morning Dump โ€” Capture the Liminal State

The moments between sleep and full consciousness are gold. Your brain has been processing overnight โ€” making connections you didn't see yesterday. Open your Alacritty Performer tool before you're fully awake. Terminal.app Voice-to-text or type stream-of-consciousness. Don't filter. Don't judge. Capture.

Process it later when you're operational: feed the raw capture into an LLM with TTS output. Listen back. The distance between capture and processing is where insight lives. The cognitive prosthetic loop: speak โ†’ capture โ†’ LLM processes โ†’ TTS reads back โ†’ you hear your own thoughts with new ears.

When: First 10 min after waking. Duration: 5-10 min capture, process later. Tool: Your performance/capture terminal.

Why It Works: Boundary Tax

Context-switching has a cost โ€” the "boundary tax." Every time you move between rooms without cleaning up, you carry residue from the last room into the next one. The dump protocol pays this tax once, at the natural boundaries of your day (sleep/wake), instead of leaking it into every room transition. Capture when liminal. Process when operational.

For the full story behind this protocol, read: The Morning Dump Protocol

Build Your Own

You don't need 9 terminals. You need the framework. Here's how to map YOUR tools to rooms:

Step 1: List your tools. Every terminal, IDE, app, browser profile, notebook โ€” anything you do focused work in. Most people have 4-8.
Step 2: Find the verb. For each tool, ask: "When I open this, what am I DOING?" Not what it CAN do โ€” what you DO do. If you always debug in iTerm, the verb is SHIP. If you always research in one browser profile, the verb is SCOUT.
Step 3: Check for overlaps. If two tools have the same verb, merge them or differentiate. "I code in both VS Code and Cursor" โ€” but one is for architecture (SEQUENCE) and one is for experiments (TEST). Different verbs, different rooms.
Step 4: Assign coordinates. Place each tool on the grid. Row = time horizon (Strategy / Tactics / Operations). Column = energy type. The coordinate is the address.
Step 5: Write the rules. For each room: what BELONGS here, what does NOT belong here, and what gets HANDED OFF to which room. The handoff rules are the flywheel โ€” they're what connects the rooms into a system instead of a list.

Start with 4 rooms. You can always add more. The constraint is the feature โ€” fewer rooms with clear verbs beat more rooms with blurry boundaries.

Go Deeper