shiftover
This MCP server lets Claude inspect pooled Claude Code accounts and offload self-contained tasks to them or to OpenAI Codex, then monitor the results.
List pooled accounts with 5-hour/weekly/per-model usage, headroom, live sessions, and Codex availability; optionally bypass the cache.
Delegate tasks to another account, the calling account, an auto-selected account with the most headroom, or Codex.
Configure delegates with a prompt, working directory, model, effort, permission mode, allowed tools, MCP servers, budget, label, and structured-output schema.
Run delegates in the foreground or background, and resume earlier delegate sessions.
Monitor delegate jobs: list recent jobs, wait for results, fetch status/results, and cancel running jobs.
Delegates tasks to the OpenAI Codex CLI when installed, running jobs on the Codex subscription and returning results with the same job tracking.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@shiftover delegate this heavy refactor to another account using Opus at high effort"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
shiftover
Several Claude Code accounts on one Mac, used like one. Your main account always drives. When it runs out of usage, the same conversation continues on the next account by itself. From inside any session, Claude can hand a heavy task to another account with the model and effort you choose, and bring the answer back.
flowchart LR
you([you]) -->|"claude"| main["main account"]
main -.->|"usage limit reached<br/>same conversation continues"| second["second account"]
main -->|"delegate: heavy task,<br/>any model / effort"| third["third account"]
third -->|"result"| main
style main fill:#8A63D2,color:#fff,stroke:none
style second fill:#2d333b,color:#fff,stroke:none
style third fill:#2d333b,color:#fff,stroke:noneEverything runs locally. Each account keeps its own sign-in, its own directory and its own quota; what the accounts
share is your setup (skills, settings, commands) and the conversation transcripts, so any of them can pick a conversation
up. shiftover only decides which one claude starts and keeps the conversation moving. If the OpenAI Codex CLI is
installed, Claude can delegate to it as well.
Install
pipx install git+https://github.com/protonmob/shiftover # or: uv tool install git+https://github.com/protonmob/shiftover
shiftover setupsetup finds every signed-in account, asks which one is yours by default and whether any should stay out of the pool
(a work account, say), wires everything and tells you what changed:
Open a new terminal tab afterwards; claude now goes through shiftover. Don't have a second account directory yet?
shiftover add work creates ~/.claude-work, shares your skills, settings and sessions with it, and opens the sign-in.
Run shiftover setup again when an account is added or removed; every step is idempotent.
If an AI agent is installing this for you
Claude Code (or any agent) can do the whole install: the two commands above are all it takes. Notes for the agent:
shiftover setupreads each directory's signed-in e-mail itself and asks its questions in the terminal. Without a terminal it prints the accounts it found and stops; run it again asshiftover setup --main <name>.Which accounts go into the pool is the user's decision, not something to establish.
setuplists what it found and asks which should stay out;shiftover remove <name>drops one for good.An account that must stay separate (an employer's, for instance) is answered to the "keep out" question or set with
pool = falsein the config. It is then opened only on request (claude -a workor a folder rule,shiftover map add ~/Projects/work work) and never used for a hand-off or a delegate.An existing
claude()function or alias in the shell rc is superseded byeval "$(shiftover shell-init)". Keep any "this folder → that account" rule it had withshiftover map add <dir> <account>instead of a custom function.Nothing in
~/.config/shiftover/config.tomlneeds to be typed by hand;setupanddoctorfill it in.Already-open Claude Code sessions do not see the hooks or the
delegatetool; a new session does.
Related MCP server: subpool
What you'll see
Hand-off. At the end of a turn, when the active account is at the threshold (95 % by default) or Claude Code
reports a rate limit, the conversation is resumed on the account with the most room, same history, same model, same
effort. One line tells you it happened. /handoff [account] [model] [effort] does it on demand.
Delegate. Claude gets three tools (accounts, delegate, monitor). A delegate is a headless Claude Code run on
another account; the answer comes back into your session, long jobs run in the background. With the
OpenAI Codex CLI installed, delegate(account="codex") runs the task on Codex
instead, on its own subscription, with the same job tracking.
Tips and status. When it matters, Claude hears one factual line, such as alex has used 88 % of its 5-hour window;
spare has 80 % room, and passes it on. The status line always shows the active account and its windows
(alex 5h 78% wk 41%). shiftover status prints every account.
Quality of life. Directory → account rules, sync-mcp to copy local MCP servers between accounts, doctor, an
arrow-key picker (cl or claude --menu), English or Turkish messages.
Side panel
A panel beside the chat shows each account's limits, the open chats with their state, delegate jobs and this session's
agents. Click a chat or a job to jump to its tab; /shiftover-panel shows or hides the panel.
The panel is a Claude Code plugin (a "mod"). shiftover install, and so setup, keeps a copy of it in
~/.local/share/shiftover/mods and installs it from there at user scope; shiftover uninstall removes it again.
Requirements
macOS (Linux should work but is untested; credentials are read through the macOS Keychain or
.credentials.json)Claude Code ≥ 2.1.224 on
PATHPython ≥ 3.11 (
pipxoruvbring their own)Two or more claude.ai accounts, each signed into its own config directory (
~/.claude,~/.claude-work, …)
How it works
Under the hood setup does five things: installs four hooks and a status-line command into Claude Code's
settings.json (backed up first), registers the shiftover MCP server in every account, copies the /handoff command
and a skill, installs the side panel plugin, and adds eval "$(shiftover shell-init)" to your shell rc so that claude
runs shiftover run.
The pieces are available separately as shiftover init --import, shiftover install and shiftover shell-init.
sequenceDiagram
participant W as shiftover run
participant A as claude (main)
participant H as hooks + status line
participant B as claude (second)
W->>A: start with CLAUDE_CONFIG_DIR=~/.claude
A-->>H: after each reply: 5h 96 % used
H->>H: Stop hook: over threshold → pick the account with the most room
H-->>W: hand-off request (SIGUSR1)
W->>A: SIGTERM, waits for a clean exit
W->>B: claude --resume <session> with the same model and effortThe status line Claude Code already renders carries
rate_limits.five_hour/seven_dayfor the active account. shiftover's status line command stores them per session and appendsaccount 5h 78% wk 41%to whatever status line you had before.The
Stophook runs after every turn. If the stored usage is at or abovethreshold, or aStopFailurewithrate_limitfires, the hook picks the account with the most headroom for the session's model, writes a hand-off request and signals the wrapper. The wrapper ends theclaudeprocess and startsclaude --resume <session-id>under the other account with the same flags. Transcripts are shared between accounts (symlinkedprojects/), so the conversation is intact. If no account has headroom, nothing happens and Claude Code's own wait-for-reset behaviour takes over.Other accounts' windows come from the OAuth usage endpoint Claude Code itself uses, read with each account's own token, cached for five minutes. It is not a documented API; when it fails shiftover degrades to the official data it has.
Access tokens last about eight hours and Claude Code renews them only while it runs, so an account left idle overnight stops answering. The background refresh then runs one tiny
claude -pturn (haiku, hooks and MCP servers off, nothing saved) on that account, which makes Claude Code renew its token; until then the account shows "renewing token" with its last windows. If the token does not move ahead, it shows "login required" and the next try waits 15 minutes.delegaterunsclaude -p --output-format jsonunder the chosen account. Nothing from the calling conversation is shared except the prompt you write.
Commands
Command | What it does |
| what the |
| accounts with their windows |
| sign-in drift, shared directories, hooks, MCP registration, side panel, shell wiring |
| scan, pick the main account, install, wire the shell |
| create the config only |
| add a directory and sign in / drop one for good ( |
| wire into / out of Claude Code |
| what |
| directory → account rules |
| copy |
| delegate jobs |
| a delegate job's steps as they happen (files edited and read, searches, commands, its messages; no tool output), then a one-line summary when it ends |
| prints the |
Config
~/.config/shiftover/config.toml (see config.example.toml):
main = "main"
threshold = 95
lang = "en"
[accounts.main]
dir = "~/.claude"
email = "you@example.com"
[accounts.second]
dir = "~/.claude-second"
email = "you+2@example.com"
models = ["opus", "sonnet"] # optional: this account is skipped when another model is requested
[accounts.work]
dir = "~/.claude-work"
email = "you@work.example"
pool = false # opened only on request; never a hand-off or delegate target
display = "Work" # optional: shown instead of the name in status, the picker and the status line
[handoff]
mode = "auto" # auto | ask | off
[delegate]
wait_seconds = 90 # foreground wait before a job goes to the background
permission_mode = "default"
mcp = "none" # main: give delegates the main account's local MCP servers
allow_bypass = false
[tips]
enabled = true
min_interval_min = 10
levels = [75, 90]
[statusline]
wrap = "bash ~/.claude/my-statusline.sh" # filled in by `install` from your existing status line
[codex]
enabled = true # offer the Codex CLI as delegate target "codex" when it is installed
[map]
"~/work/acme" = "work"email is what doctor and the picker compare against: /login takes whatever account the browser has open, so a
directory can silently end up holding the wrong account.
display only changes what you read (status --json carries it too, null when unset); every command, flag and
delegate(account=…) still takes the account's name, work above.
The delegate tool
Once installed, every account has an MCP server named shiftover. The bundled skill tells Claude how to use it; the
short version:
delegate(prompt="Review src/payments for race conditions. Repo: /Users/me/app. Return findings as a markdown list.",
model="opus", effort="max", permission_mode="default")
delegate(prompt="…", background=true) → job_id
monitor(job_ids=["20261022-141503-a1b2"], wait_seconds=120)
accounts()account="auto"(default) picks the account with the most headroom for the requested model (without one, the default model fromsettings.json), never the calling one and never an account kept out of the pool; when none has room it says so, andaccount="self"runs the task on the calling account anyway.account="codex"runs the task on the OpenAI Codex CLI;permission_modemaps onto Codex's sandbox (default→ read-only,acceptEdits→ workspace-write).A delegate sees only the prompt. Put the goal, paths, constraints and the output format in it.
Nobody answers permission prompts in a delegate: read-only work needs nothing, file edits need
permission_mode="acceptEdits".claude.ai connectors (Gmail, Amplitude, the browser extension, …) are not available in a delegate; do that part in the session and delegate the heavy reasoning with the data in the prompt or in files.
Each delegate spends the target account's quota. Results longer than 8 KB are truncated in the tool result and kept in full under
~/.cache/shiftover/jobs/.
Shared vs separate directories
shiftover add symlinks CLAUDE.md settings.json settings.local.json agents commands skills hooks output-styles plugins projects from the main directory into the new one, so every account has the same setup and can resume any conversation.
If your directories are not shared, shiftover still works, with two caveats: install writes hooks into each
settings.json, and a hand-off needs the transcript to be visible from the target directory (share at least projects/);
shiftover checks this before leaving an account and doctor reports it.
User-scoped MCP servers live in each directory's .claude.json and are not shared. sync-mcp copies the definitions;
servers that authenticate with OAuth must be authorized once in each account (/mcp).
Terms of service
shiftover runs Anthropic's own CLI with the accounts that are signed in on your machine and never copies, moves or shares a credential. How those accounts may be used is governed by Anthropic's Consumer Terms and Usage Policy; the latter forbids intentionally bypassing restrictions established within the products, and continuing on another account when one is throttled can be read that way. That judgement is yours to make. Not legal advice.
Privacy and security
Tokens are read from the Keychain (
security find-generic-password) only to call the usage endpoint and to see when they expire, never written or logged; renewing one is left toclaudeitself, whose output is discarded.State lives in
~/.cache/shiftoverwith0600files. Temporary--mcp-configfiles are removed when the job ends.No telemetry, no network calls other than Anthropic's usage endpoint and whatever
claudeitself does.
Related tools
clauth (switching by swapping credential files, delegate without model-aware routing), claude-swap (threshold switching, no delegate), cc-same (keeps the Desktop app's session list identical across accounts), teamclaude (a proxy that rotates tokens). shiftover keeps every account in its own directory, moves live conversations instead of restarting them, and lets the session itself delegate.
Development
git clone https://github.com/protonmob/shiftover && cd shiftover
pipx install --editable .
uv run --with pytest --no-project pytest # tests use a fake `claude`; no quota is spentMIT © Kadir Aktaş
Available Tools
3 toolsaccountsA
List the pooled Claude Code accounts with their 5-hour / weekly usage windows, per-model windows, headroom and live sessions, plus the Codex CLI backend when it is installed. Read-only; uses a short cache.
Inputs: refresh.
delegateA
Run a self-contained task as a headless Claude Code session on another account (or on the OpenAI Codex CLI with account="codex") and return its answer. The delegate sees only the prompt, has no claude.ai connectors and nobody answers its permission prompts. Long tasks: background=true, then monitor.
Inputs: prompt (required), cwd, mcp, label, +10 more.
monitorB
Status and results of delegate jobs. Without job_ids lists recent jobs. wait_seconds blocks for running jobs; cancel stops them.
Inputs: cancel, job_ids, wait_seconds.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
Each tool has a clearly distinct role: accounts is read-only account listing, delegate starts a task, and monitor checks or cancels jobs. The boundary between delegate and monitor is clear because monitor explicitly handles status, results, waiting, and cancellation.
The names are readable but do not follow a single convention: accounts is a plural noun, while delegate and monitor are verbs. With only three tools this is not confusing, but the naming pattern is mixed.
Three tools is well-scoped for this server: one to inspect available accounts, one to run work, and one to track or cancel delegated jobs. Each tool earns its place without unnecessary surface area.
The surface covers the core lifecycle: list accounts, delegate a task, monitor results, wait, and cancel. Minor gaps exist around account management or more explicit job inspection, but the primary workflow is complete.
Maintenance
Related MCP Connectors
Your AI apps as one team: hand work to Codex or Claude Code on your Mac, with a shared logbook.
Shared long-term memory & Stop-hook task handoff across Claude Code, Codex, Cursor, and mobile.
Sync coding-agent sessions and resume them in any other agent: Claude Code, Codex, Cursor, more.
One identity across Claude Code, Codex, Cursor, Gemini, Windsurf: shared inbox and handoffs.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables Claude Code and Cursor to delegate tasks to each other, spreading workload across both AI coding subscriptions.MIT
- AlicenseNot gradedqualityCmaintenancePools multiple Claude Code and Codex subscriptions and routes each coding task to the account with the most available quota, handling cooldowns and failover automatically.MIT
- AlicenseNot gradedqualityCmaintenanceEnables users to delegate coding tasks in a chosen project to the official Codex and Claude CLI agents from within an existing chat, then convene a council of configured models to gather independent opinions and review the resulting files and test runs. It also manages multi-provider API connections, model catalogs, and per-task token, time, and cost limits.MIT
- AlicenseNot gradedqualityBmaintenanceEnables two-way collaboration between Claude Code and the Codex CLI: Claude can hand off plans for execution or adversarial review, while the working agent can block to ask Claude questions, report progress or findings, and receive mid-run corrections. Supports multiple named, resumable sessions per project with configurable model, effort, and sandbox settings.23 npmMIT