Up to 10 tabs per project. Each is a fully independent workspace. Tabs are aware of each other, so parallel work does not collide, and git operations never capture partial changes.

Per-tab state

What	Independent per tab
Active model	Yes (`Ctrl+L` inside the tab)
Forge mode	Yes (`Ctrl+D`: default, architect, socratic, challenge, plan, auto)
Session and messages	Yes
Checkpoint history	Yes (git tags namespaced by tab ID)
Agent dispatches and findings	Yes
Input history	Shared across tabs
Genome, LSP, MCP	Shared across tabs (one per project)

Run Sonnet on tab 1 for a refactor while Haiku runs on tab 2 for documentation. One tab in plan mode, another in auto. Same project, independent agents.

Tab awareness

Every tab knows:

Which other tabs are open, what they are named, and who is active.
Which files are claimed by which tab.
Whether another tab currently has agents dispatched.

When your agent is about to edit a file another tab has claimed, it sees a warning before writing and can decide to skip or proceed.

File claims

A claim is created automatically the first time a tab touches a file with edit_file, multi_edit, refactor, or shell writes (sed, >, tee, etc).

Other tabs see the claim and get an advisory warning if their agent tries to edit the same file. Edits still go through (advisory, not blocking), but the agent is told another tab owns it and usually skips to avoid stomping.

Claims release automatically:

5 seconds after the tab finishes its current prompt.
Immediately on Ctrl+X (abort).
When the tab closes.
After 5 minutes of inactivity (stale sweep).

No persistent locks. No deadlocks. Nothing to clean up manually.

Git is hard-blocked mid-dispatch

Git operations that modify the working tree (commit, stash, restore, branch switch) are blocked while another tab has active dispatch agents. This is the one hard gate: committing mid-dispatch in another tab would capture partial, half-written edits. Your changes stay intact.

The block is per-tab. A tab's own agents do not block its own git. When blocked, the tool returns a terminal error so the agent stops retrying (no token-burning loops).

Browser tabs are leased

File claims are advisory. Browser tabs are not: two agents typing into one page produce a form nobody filled out. So the desktop browser, which the whole window shares, hands each chat tab a lease on the browser tabs it drives. Every action refreshes it.

Your agent does this	What happens
Opens its own tab	Always allowed. This is the way out of a contended page.
Reads any tab (snapshot, screenshot, page text, inspect, audit)	Always allowed, including a tab another agent holds.
Clicks or types on a tab someone else holds	Refused by name: `driven by "Tab 3" (idle 12s)`. Your agent routes around it.
Works in a tab you cannot see	Runs at full speed. Background tabs keep their timers, and screenshots come from the page.
Closes the browser, clears cookies	Waits while another chat tab still holds a tab. Both actions hit every page in the window.
Stops a dev server	Only the tab that started it may stop it.

Opening a page never pulls the view off an agent mid-flow. A lease lapses after a minute of quiet and dies with its tab, so a stalled agent releases everything on its own.

Contention handling

If edit_file fails with old_string not found AND the target file is claimed by another tab, Empryo returns a terminal CONTENTION error instead of the normal retry-friendly error. The agent stops and surfaces the conflict to you instead of guessing.

Commands

/tab new                   open a new tab (Ctrl+T)
/tab close                 close current tab (Ctrl+W)
/tab rename                rename the active tab
/claim                     show all active claims across tabs
/claim release <path>      release one claim from this tab
/claim release-all         release every claim from this tab
/claim force <path>        steal a claim from another tab

Shortcuts

Key	Action
`Ctrl+T`	New tab
`Ctrl+W`	Close tab
`Ctrl+[` / `Ctrl+]`	Previous / next tab
`Ctrl+1` through `Ctrl+9`, `Ctrl+0`	Jump to tab N (0 = tab 10)
`Tab` / `Shift+Tab`	Cycle tabs (from the input)