POWER CLAUDE · SAVE $100/MO · ZERO RATE LIMITS
Save $100/mo while increasing Claude's bandwidth 5x, using ~25% less tokens, & preemtive auto rotation — zero stalls.
Claude Max runs $200/mo while 5 Pro accounts is just $100/mo — saving you $100 every month while increasing your bandwidth 5x. Power Claude synchronizes all 5 accounts into one continuous session, automatically rotating accounts before limits hit so long-running jobs never stall. Its Token Saver trims ~25%+ of output and up to 90% on the most repetitive blocks — so you can get more done, with your real savings shown live. One prompt becomes finished work, not 15 trivial interruptions. Works with unlimited number of accounts
Built to make the six worst Claude Code failure modes disappear.
Your 5-hour quota runs out before your agent does.
Smart Rotation hands the next prompt to a fresh account the moment Anthropic starts throttling — pre-emptively, before the 429 ever fires. While account A cools down, account B is already answering, on the same conversation thread, fully transparent to Claude Code. N accounts means N independent 5-hour quota windows — five Pro accounts give you five, so the wall you used to hit at lunchtime stops existing.
Pick the policy that fits the work: Balanced to spread load evenly, Burst to drain one account fast when you're sprinting, Single to pin to one. Five Pro accounts ≈ $100/mo — roughly half the cost of Claude Max ($200/mo), same ceiling, no timer to stare at.
Anthropic itself flagged the quota wall as the top-priority complaint of 2026 — and the insult on top of it: a rate-limited turn burns the tokens it never got to use. [GH #11810 — "burn through whole damn quota in 1–2 days"]
You're paying for Opus. Claude's routing you to Haiku. Would you even know?
Per-turn Model Attribution shows you exactly which model answered every single turn — so a silent downgrade to Haiku surfaces the instant it happens, not three bad outputs later. You see the swap in real time and can act on it: re-run it, escalate, or switch accounts — instead of paying premium prices for commodity output and never knowing.
The downgrade is real and undisclosed by default. External telemetry put ~36% of Claude Code subagent traffic on Haiku — roughly 20× cheaper than Opus, returned with no native indicator at all. One developer's words: "Silently gaslighting us to believe everything's normal."
[mirin.pro — "36% of Your Claude Code Subagents Are Running on Haiku"]
Auto-compact ate your context. The agent is guessing now.
The Watchdog snapshots your full session the instant before auto-compact fires — preserved as an immutable git ref you can restore with one click. When you resume, the agent works from the real decision chain, not a summary of a summary of a summary.
Resume Session replays the un-compacted context into the next turn, so the model knows precisely what the prior turns meant — the constraints that still apply and the ones that don't. No more silent context decay mid-refactor, no more hallucinated requirements after the third compaction.
Four hours of work. Lost. Because the session crashed.
Every session is persisted as JSONL plus an immutable git ref the moment work begins — so a crash, an OOM kill, or a reboot can't take your work with it. Your todos, tool calls, file edits, and full decision chain stay recoverable, and one click drops you back at the exact pre-crash state.
Because the snapshots are git objects, the history is tamper-evident and queryable with the tools you already use — not a fragile cache that "Claude Code Lost My 4-Hour Session" headlines are made of. One reported crash bug (#30700) stemmed from session storage that was never created, so nothing ever persisted. Power Claude's writes happen up front, every time.
The API bill was $47k. The job ran overnight with no warning.
The LLM Usage Dashboard shows live $/session, per-account token tracking, and a cache-read vs output breakdown as the work runs — plus plan-tier-aware hard-cap alerts that fire BEFORE your quota dies, not after the invoice lands. You see the wall coming with room to stop.
It catches what most dashboards miss: over 90% of the tokens in a Claude Code session are cache reads — invisible to naive trackers, still billing. Power Claude surfaces them and ties spend to the account and turn that incurred it, so an overnight run can't quietly become a four- or five-figure surprise. [DeSight — $47k invoice case]
You own five Claude accounts. You're only ever using one.
Power Claude runs all your accounts as one coordinated fleet — named once, then rotated automatically the moment you hit a limit. No logging out, no pasting the thread into a fresh login, no friction tax every time you hit a wall. The other four accounts finally do work instead of sitting idle.
That's the whole difference between owning five accounts and actually getting five accounts' worth of throughput. Five Pro accounts ≈ $100/mo, roughly half the cost of Claude Max ($200/mo) — same ceiling, ~$100/mo kept in your pocket. Balanced / Burst / Single rotation policies, a VS Code & Cursor sidebar, and a pc CLI, all local — Power Claude never sees your prompts, and your accounts stay on your machine.
What you give up when you switch accounts by hand.
| Manual log-out / log-in | Power Claude | |
|---|---|---|
| Rotation | ||
| Switch accounts | Log out, log back in by hand | Automatic on 429 (pre-emptive) |
| Detection trigger | You notice the work stalled | 4 watchdog rules monitoring continuously |
| Wait time on rate-limit | A minute or two, every time | Seconds, automatic |
| Resilience | ||
| Session continuity | You rebuild context yourself | Resume from immutable git snapshot |
| Visibility | ||
| Haiku-downgrade detection | None | Per-turn model attribution |
| Pre-commit decision chain | None | Pre-Commit Review + git refs |
| Live $/session analytics | None | LLM Usage Dashboard |
| UX | ||
| VS Code / Cursor sidebar | None — you live in the browser | Tree view + status bar + dashboard |
| Setup | Re-enter credentials each switch | VS Code Marketplace 1-click |
| Accounts stay configured | Re-authenticate over and over | Named accounts, saved once |
| Cost | ||
| Monthly cost | Free, but it costs you time | $12/mo Pro · 7-day free trial |
Your agent should keep working after you close the laptop.
Power Claude runs your accounts as a coordinated fleet — rotation, watchdog, and session recovery operating as a single layer beneath Claude Code. Configure it once. From that point it handles quota exhaustion, rate-limit walls, silent model downgrades, and session crashes automatically — no monitoring required, no prompts waiting for a reply.
The alternative costs more than people realize. Logging out, logging back in, rebuilding context after every rate limit: a minute and a full context switch each time. Multiply that across a day of agentic sessions and it's hours that should have been output. Power Claude handles all of it automatically: rotation, resume through rate limits and API failures, and session recovery — polished VS Code + CLI product, your accounts never leaving your machine.
7 days free, no card required. If Power Claude doesn't hand back real time in the first week, our team will get you dialed in — or you walk. No invoice, no friction.
Leave it running. Come back to a finished task.
Every "Should I continue?" prompt and every rate-limit wall is a hard stop that requires a human at the keyboard. Your agent isn't stuck because the work is done — it's stuck because the tooling needed a babysitter. Across a day of agentic sessions, that's hours your agent spent idle while you weren't watching.
Silent throttles add a second layer. Anthropic downgrades sessions to Haiku without warning when quota tightens — no notification, no model badge — slower, cheaper output quietly standing in for your Sonnet run. Power Claude detects the downgrade per turn and surfaces it before it degrades your work.
Power Claude removes both interruption classes. Automatic rotation handles rate limits before they stall the session; watchdog catches downgrade signals and reroutes. Set the job running, close your laptop. Come back to output, not a stalled prompt.
THE ROTATION ENGINE
Power Claude features
The standalone engine: a local proxy that rotates and balances your Claude accounts, a watchdog that catches stalls and crashes, session recovery and checkpoints, a usage dashboard, a full CLI, and the analytics that keep a long-running job on the rails. These run on their own — no Claude Code required.
Your accounts, coordinated. Your quota, multiplied.
Power Claude monitors every active session. When one account exhausts quota, it routes subsequent calls to the next available account — transparent to Claude Code. You keep the conversation thread; only the underlying account changes. Each Claude.ai account carries its own independent 5-hour token window, so rotating several Pro accounts gives you several independent windows running in parallel — matching the token budget of a far pricier single plan, at a fraction of the cost.
Transparent rotation — same thread, next account
Balanced Mode picks the least-busy account on every request.
Rotation switches accounts after Anthropic 429s you. Balanced Mode (Pro) scores all healthy accounts on every request — by 5-hour utilization, current in-flight count, and recent burn rate — and routes to the account with the most headroom. The net effect: 429s become rare instead of routine, because no single account ever gets squeezed against the wall. Round-robin mode is available for teams that need deterministic ordering instead of load-aware scoring. The same parallelism multiplies throughput: at 10 concurrent sessions a single account serializes the work, while a 5-account pool spreads it across five independent windows — finishing a round about 5× faster, typical. Drag the slider just below to feel the gap.
least-utilized OR round-robin · 5h-aware scoring · sub-millisecond decision · Pro tier
Every signal — and every routine action — in one panel.
The sidebar dashboard turns the panel most users see on every session into a hub you can act from. A 60-minute rotation handoff lane graph shows every recent rotation as a curved bezier between account lanes; state-encoded dots (●/◌/×/◇) carry the signal independently of colour. The accounts table groups into Needs action / Throttled / Healthy / Idle collapsible buckets, with inline decorator icons (🔔 for recent events — click to filter Events to that account, ! for error-grade events in the last 24h, 🔒 for currently throttled). Click any row to slide a 320 px drill-down drawer in from the right with a 24-hour activity sparkline and the last 10 rotations for that account. Hover for a quick-action card, ctrl-click two events for a side-by-side JSON diff, right-click for state-aware menus. Hand-rolled SVG and CSS using VS Code theme tokens — no chart or UI libraries, no new tabs.
Lane graph · drill-down drawer · chip-filtered events · hover + right-click affordances
A local-only companion. Your code and prompts stay yours.
Power Claude runs entirely inside your editor. It reads your local Claude Code session files and works with your own accounts — it never sees, stores, or transmits your prompts, your code, or your conversation. There are no Neural-LLM servers in the request path, no telemetry, and no external aggregation. The only thing that ever leaves your machine is an anonymous license check — a hashed key and a timestamp, nothing about your work. So when a security reviewer or a client asks "where does our code go with this installed?", the honest answer is: nowhere new. Power Claude adds nothing to your data path, so there is nothing extra to audit.
No servers in the request path · no telemetry · never sees prompts or code · anonymous license check only
How concurrent sessions actually feel
Drag the slider. Watch how long one round of agent activity takes on a single account versus a Balanced pool.
At 10 concurrent sessions, each round finishes about 5.0× sooner across 5 accounts. A single account begins serializing requests once it runs more sessions than it has headroom for.
Methodology
Time per round is modeled as T(N, M) ≈ T0 × max(1, N/M), where N = concurrent sessions, M = accounts in the pool, and T0 = a typical round on a fully unsaturated account (~0.6 min). Speedup is min(M, N) — at 10 sessions across 5 accounts that is 5×. Real-world gaps widen further: a single account hitting its TPM and RPM ceilings at once serializes requests, so measured rounds can run slower than this linear-queue model predicts. Numbers shown are illustrative typical values, not service guarantees.
Runout Forecaster tells you when your pool will hit a wall.
Power Claude's estimator watches utilization across every account in your pool and projects, at your current burn rate, whether you'll exhaust capacity before the 5-hour or 7-day windows reset. The Overview tab shows a single color-coded pool banner — green when you're safe through the next reset, amber when some accounts will exhaust before reset, red when the pool is about to hit a wall in minutes. Each account row also gets a tiny ETA chip so you can spot the bottleneck without opening drawers. Works in both Balanced and single-account modes; reset times come from Anthropic's authoritative rate-limit headers, so the "will I make it?" half of the math is exact — only burn rate is estimated, from a rolling sample buffer.
per-account + pool-wide ETA · green/amber/red · authoritative reset times · rolling burn-rate samples
Catches session crashes before you notice them.
Four independent detection rules monitor every session in real time: (1) quota exhaustion on the active account, (2) 429 rate-limit header detection, (3) consecutive tool-call timeout pattern, (4) model-switch downgrade signal. When any rule fires, the watchdog emits a structured event that triggers rotation automatically — no manual intervention, no babysitting.
Watchdog catches it. Session Recovery rescues it.
4 detection rules · automatic handling · no manual intervention
When Claude's context window collapses, your work doesn't have to die with it.
Autocompact thrashing, context overflow, tool loops, crashes — Power Claude detects them by name, then picks the right recovery strategy for the failure. For a thrashed session, naive claude --resume just re-thrashes. Power Claude exports the session, trims it, and resumes in a fresh context — your $4 of token investment rescued for ~$0.12. Every recovery snapshots your working tree first using the same drift-free git refs that power Session Trail, so a bad recovery is one click to undo. CLI for headless workflows: pc session list --failed, pc session recover <id>, pc session bundle for cross-machine resume.
9 failure scopes · 6 recovery strategies · 1-click undo · Pro tier
Claude's /rewind has a blind spot. Power Claude names it.
Claude Code's built-in /rewind only tracks files Claude edited through its own tools — it can't restore anything a bash command, a build step, a hand-edit, or another session changed, and it won't warn you. Power Claude reads both checkpoint layers — Claude's native /rewind history and its own durable, bash-inclusive session snapshot ref — and computes the bash-gap: the exact files that changed this session that /rewind would silently fail to restore. Power Claude's snapshot can. Today it runs on the command line: pc session checkpoints <id> and pc session bash-gap <id>.
L0 native /rewind + L1 durable snapshot · bash-gap = changed − tool-edited · CLI: pc session checkpoints / bash-gap
Catch incomplete sessions before they ship as bugs.
When a Claude Code session ends with pending task-list items AND sits idle for 60+ minutes, Power Claude auto-flags it Abandoned — surfaced with a red alert on the Sessions tab. Auto-Resume offers (but doesn't force) recovery for these sessions, so half-finished features don't slip into production unnoticed. The full taxonomy — Active / Saved / Unfinished / Abandoned — gives you status at a glance, with origin filter (VS Code vs CLI), per-row tags (incomplete, long-running, rate-limited), and one-click resume in this window or another.
4 session states · auto-detected · 1-click resume into any window
A dozen sessions open — find the one by what was said inside it, not by its title.
Power Claude is built for developers who keep many Claude Code sessions open at once — and when you do, finding the session that discussed a particular thing means clicking through tab after tab, because the title almost never matches what you actually remember: something said inside the conversation. Search Open Session Tabs searches the content instead.
Type a phrase you remember and Power Claude streams each open session's transcript and matches it against the real conversation — your messages, Claude's replies, the tool calls and their output — then ranks the hits and shows you the matching turn with your query highlighted. (Power Claude's existing session search only ever looked at titles, first prompts, and file paths; this reads what was actually said.) Find the match, click it, and that session's Claude tab jumps to the front.
Two ways in: a keybindable QuickPick (Ctrl/Cmd+Alt+Shift+S) scoped to the tabs you have open right now, and a content-search box at the top of the dashboard Sessions list with a toggle to widen from open tabs to every indexed session. It is in the CLI too — pc session search <query> — running the exact same engine, so the editor and terminal always agree.
searches the conversation body, not just titles · QuickPick + dashboard + CLI · ranked, highlighted matches · click to reveal the tab · Pro
Get more out of the tokens you already pay for.
Multi-account rotation gets you more Claude for less money. The Token Saver makes sure you waste less of it. Power Claude trims the low-signal noise out of what Claude reads — the bulky tool results in every request (command output, build logs, diffs, JSON dumps) — before they reach the model, so leaner context leaves more room for real work and you hit context-limit walls less often. It is reversible and audited: lossless where it can be, and it never fabricates — only noise is dropped, while the lines you actually need (errors, stack frames, diff changes) are always preserved. Across the bulky blocks it actually trims you'll typically see ~25%+ off that output, reaching up to 90% on the most repetitive — and rather than quote a session-wide average, we show your real, live savings on your own traffic, every token counted, not estimated. You choose how far it goes on a simple slider — from Light cleanup to Max — and it is on by default at Balanced, so the savings start the moment you install.
trims tool_result noise before the model · reversible + audited · high-signal lines always preserved · ~25%+ off the bulky blocks it trims, up to 90% on the most repetitive · live measured savings on your own traffic · five-level slider (Off→Max) + per-kind toggles · on by default at Balanced
A resettable token meter for every client.
If you bill clients by usage, "how many tokens did this project burn?" is the question the lifetime and 7-day totals can't answer. The Token Trip Odometer is a car-style trip meter for tokens: start a named trip per client or project and it counts from that moment, independent of every other counter. Reset zeroes it for a fresh billing window, Close freezes the total, and you can run several trips at once. Each shows input / output / total tokens, elapsed time, and an estimated dollar value for invoicing reference. Trips persist across editor reloads and derive from Power Claude's existing daily-token ledger, so the feature adds no overhead to the request path.
named trips per client/project · reset / close / resume · tokens + ≈$ estimate per trip · survives reloads · zero proxy overhead
See where every token goes — then stop paying for the wasted ones.
When Claude fans work out to sub-agents that spawn their own sub-agents, a session's token cost disappears into a tree you can't see — and you pay for all of it. The Orchestration Token Tree reconstructs that whole tree from your local session transcript — every prompt, every recursively nested sub-agent — and rolls input / output / cache-read / cache-write tokens and an estimated dollar cost up each branch. A flame chart makes the waste obvious at a glance: bar width is proportional to tokens, so the one runaway agent burning half your context is the widest bar on the row. Because every branch is priced, the waste is quantified, not guessed — you can see at a glance that a single sub-agent re-reading the same four files cost 1.3M tokens (≈ $4.92) on this run. Cut that redundancy and you get the headroom — and the money — straight back; leaner context also means you hit context-limit walls less often, so you get more done per session. It runs in the terminal too (pc tree, with a cost view and the heaviest-branch list), updates live as a session runs, and exports the same tree to any OpenTelemetry backend (Grafana Tempo, Honeycomb, SigNoz…) with pc tree --otlp — no API key, all reconstructed from data already on your disk.
every prompt + recursively nested sub-agent, tokens + ≈$ rolled up per branch · flame chart surfaces the heaviest branch instantly · quantifies waste in tokens AND dollars — cut a leak, reclaim the headroom + the cost · fewer context-limit walls = more done per session · live as the session runs · pc tree CLI + OTLP export · reconstructed from local transcripts, no API key
Concurrent windows can't clobber your settings or rotation state.
When ten VS Code windows share one account pool, they all read-modify-write the same files — ~/.claude/settings.json and the live account-rotation state. Without coordination that is a classic last-write-wins race: two windows flip the active account at the same moment and one update vanishes, or a half-written settings file lands corrupt. Power Claude serializes every write behind an atomic cross-process lock (O_CREAT | O_EXCL) so exactly one window writes at a time and the rest queue for a few milliseconds. If a window crashes mid-write, stale-lock recovery detects the dead holder and reclaims the lock — no manual cleanup, no wedged state. Your settings and rotation state stay intact no matter how many windows you run.
atomic O_CREAT|O_EXCL lock · serializes settings + rotation-state writes · stale-lock recovery · zero added dependencies
Know your burn rate before you hit the wall.
The LLM usage analytics panel shows real-time token consumption per account, rolling 5-hour totals against unified quota windows, and a cap-hit recommender that tells you exactly which account to switch to before you exhaust the current one. The recommendation engine calibrates to your actual plan tier from the rate-limit responses it observes in your own sessions. Bonus: every turn shows which model actually answered — so you know when you're paying Opus prices for Haiku output.
Per-account burn rate · per-turn model attribution · all local
Sessions that don't disappear. Context that survives.
The session lane view shows your last N sessions with full context snapshots, resumable at any point. The Resume Session command injects the prior session's working context into the new conversation — tool call history, file changes, decision chain — so Claude Code picks up exactly where it left off. Pre-commit review integrates the session continuity data with blame attribution so reviewers understand why each change was made.
68 sessions preserved · zero context loss on rotation
The state of every account, the active file, and Claude's permission mode — at a glance.
The right-side VS Code status bar is the daily dashboard. Healthy / cooling / blocked account counts. Today's spend in dollars. Active permission mode (auto / default / plan / bypassPermissions) with a one-click toggle for the compliance-sensitive switch from default to bypass-permissions and back. A second per-file status item shows how many Power Claude sessions have touched the file you're currently editing, with the date of the most recent edit. Click to jump straight to those sessions.
2 status-bar items · 3 click-to-toggle controls · 0 extra panels open
The full Power Claude dashboard — in your terminal and activity bar.
Power Claude ships a fully-fledged CLI for terminal-first developers and a dedicated activity-bar tree for VS Code / Cursor / Windsurf users — same state, two surfaces. Both run against local ~/.power-claude/ data, no cloud round-trip, no telemetry. pc list renders the live account pool as a Unicode table with quota bars, reset times, and active/parallel markers. pc status shows the one-screen system summary. pc rotate picks the next healthiest account. pc relogin walks an account through OAuth without leaving the terminal. pc doctor runs a 16-check diagnostic. Scriptable in cron / hooks / CI. Pretty enough to live on a status board.
40+ pc commands · grouped by intent · color-tinted status · zero network calls
Hit a 429? Power Claude already scheduled your comeback.
When every account in your pool is cooling, Power Claude reads the soonest reset time across all accounts and schedules a systemd-run timer to wake Claude Code back up at that moment. Each rate-limit class gets its own context string — usage-5h, usage-weekly, server-error, server-error-escalated, capacity, throttle, all-accounts-exhausted — so the resumed session lands with the right framing instead of a generic "continue". You walk away from a 429 and Claude is back at work before you sit down again.
7 rate-limit-type extras · soonest-reset across the pool · systemd-run timers · per-class wake context
Your session continues itself.
When Anthropic 429s you mid-task, Power Claude snapshots the conversation, rotates to the healthiest available account, and continues the session — silently if you want, or with a one-line notice in the panel. autoSnapshotSessions captures conversation state every 60 seconds and on shutdown so nothing is lost on rotate. autoSelectSoonest picks the account whose 5-hour window resets first — keeping your runway long. crossEnvironment scopes whether the resume fires in any open IDE or only the one that paused. Walk away. Come back. The work is done.
silent or notified · 60s + shutdown snapshots · soonest-recovering account · cross-IDE optional
Keeps going on the trivial stops — and only the trivial stops.
Claude pauses constantly on stops that are really just the next obvious step: "Want me to continue?", "Now let me wire X", "remaining: …", or it promises to continue and then ends the turn anyway. Auto-Resume decides what to do on your machine first — a tier classifier reads each stop locally and resumes the clear continuations with no API call at all, while leaving genuine stops parked (a real question, a "done — standing by" wrap-up, an open approval gate). Only a genuinely mixed stop reaches a model, and even then it does item-level triage: it finishes the parts that are safe and in-scope, and defers only the parts that need you — a commit, a deferred decision, another session's files. It works on subscription plans (no API key required), every resumed turn carries a ↻ marker that says why it continued, and an Auto-Resume Audit shows every decision. Net effect: the agent finishes the safe work on its own and saves your attention for the calls that are actually yours.
Deterministic-first (~96% of stops need no model) · item-level triage on mixed lists · works on subscription plans · ↻ in-chat "why" marker + Auto-Resume Audit · conservative/balanced/aggressive · Pro tier
Point Claude at a loop. Walk away. Come back to a finished project.
A loop is Claude Code's own /loop — re-issue one objective until it's done. A raw loop dies on the first rate limit, crash, or "should I continue?". Power Claude is the layer underneath: multi-account rotation and Balanced Mode turn rate limits into handoffs, Auto-Rewake schedules a comeback when the whole pool is cooling, the watchdog catches crashes, and Auto-Resume clears the trivial stops at every iteration boundary. The loop keeps re-issuing the objective; the layer keeps the loop alive. Start a multi-hour build, walk away, come back to finished work.
rotation · Balanced Mode · Auto-Rewake · watchdog · Auto-Resume — the layer under your loops · Pro tier
Tells you when to upgrade — and when Anthropic downgraded you.
Power Claude tracks every rate-limit hit in your own pool and surfaces a calibrated suggestion: add another account, upgrade your Claude plan, or you're fine. Throttled by recommender.maxHitsPerWeek so you're never nagged. Separately, the proxy detects per-turn model attribution — when you're paying Opus prices and Anthropic quietly served Haiku output, Power Claude tells you. Your cap-hit data is yours. Recommendations are computed locally from ~/.power-claude/logs/handler.jsonl — zero telemetry leaves your machine unless you opt in.
local-only computation · weekly throttle · Opus-vs-Haiku detection · calibrated against your own pool
Export your logs without leaking your credentials.
Power Claude exports its own logs as a sanitized bundle ready for a support ticket, an audit, or a postmortem. The export pipeline redacts API keys, OAuth tokens, session secrets, and credential-shaped strings before writing the tarball. Toggle includeRateLimitLogs and includeHandlerLogs to scope what goes in. Output lands in logExport.outputDir (default ~/.power-claude/exports/) named with timestamp and a content hash. Share confidently. Open the tarball, eyeball it, attach it — no manual scrubbing.
API-key + OAuth + secret redaction · scoped includes · timestamped + hashed · no manual scrub
Your open file is not Claude's business — until you say so.
By default, Claude Code attaches whatever file you have open to every prompt. That means a prompt about your build script silently ships the API key in .env you happen to have open in the next tab, and a question about a CSS class drags in a 3,000-line component — roughly 30k tokens — you weren't even asking about, re-sent on every turn. Across one focused Opus session that's up to ~$34 of token spend on a file you never referenced. Power Claude flips that switch off. The chip still shows in the chat input — one click attaches the active file when you actually want it — but nothing is attached to your prompt until you opt in. Self-heals across Claude Code auto-updates.
up to ~$34/session in unspent tokens · opt-in instead of opt-out · one click to attach · self-heals across updates
See Claude Code edits in VS Code's native Timeline view.
Here's the gap most people never notice: Claude Code's edits don't show up in VS Code's native Timeline. Local History tracks the files you save and git tracks the commits you make — but an AI agent writing files straight to disk slips past both, leaving a blind spot in the editor's built-in history exactly where the agent did the most work. Power Claude closes it: every Claude Code edit is registered in the built-in Timeline view alongside your manual saves and git commits — one unified chronological audit trail in the editor sidebar, so you can finally see the full change history. Click any entry to jump to that point in file history. No external storage; all data is local and tied to your git refs (refs/power-claude/sessions/<id>/{start,end}). Works alongside Session Trail for end-to-end traceability: gutter ⚡ for "which session", Timeline for "what changed when".
closes the AI-edit blind spot in Timeline · git-backed · zero external storage
See which AI session edited each line of code.
Session Trail adds a ⚡ icon in the editor gutter for every AI-edited line, plus CodeLens ("⚡ N sessions · last X ago") above functions. Hover any marked line and the popup shows the contributing session ID, model, and diff hunk. Click to open the session in the Sessions tab. The Edit History side panel lists every session that has touched the active file, sortable by model. Pre-Commit Review pulls all of this together at commit time, so reviewers see the complete AI decision chain before push — not after a bug report.
Gutter ⚡ icons · CodeLens · hover cards · per-file history · pre-commit review
See the full AI decision chain before you commit.
Pre-Commit Review opens on stage. It pairs your staged diff with session attribution: which session introduced which change, which model answered, and the full tool-call sequence that led to each modification — pulled from the same snapshot refs that power Session Trail. Reviewers see the reasoning behind every line, not just the line itself. Surface a Session Graph (DAG of commits + tool calls) for any session, single or multi. This is the bug your future self wishes you had caught at commit time instead of in the bug report.
staged diff + session blame + tool-call provenance · git-native · pre-push gate
CLAUDE CORE
Always know why your session is paused — and trust it to come back
When your whole account pool is rate-limited, Claude Code shows nothing but a spinner — you can't tell paused from hung. Power Claude surfaces the real reason and the soonest recovery time, then keeps its existing promise: the session resumes itself the moment a window clears, even hours later. Visibility plus unattended recovery, no babysitting.
Know exactly why your session is paused — and trust it to resume itself.
When every Claude account in your pool is rate-limited at once, Power Claude doesn't give up: its proxy keeps each session's retry loop alive (short synthetic-429 waits) so a session auto-resumes the instant a window clears. The problem was that Claude Code only showed its generic "thinking" spinner — no reason, no ETA — so a paused session looked exactly like a hung one. Power Claude now surfaces the real state in one consistent line across four surfaces: a VS Code status-bar banner, the Claude Code statusline, a one-time onset toast, and pc status — reading, for example, All Claude accounts rate-limited · auto-resume ~32m (22:30). It names the actual condition and the soonest reset across the pool, then clears itself automatically when an account frees up. And it pairs with what Power Claude already does: it resumes the session on its own, even hours later — even when the long 5-hour or weekly window won't clear for hours, you walk away and it picks the work back up the instant the window opens.
one message on 4 surfaces (status-bar banner / statusline / onset toast / pc status) · names the condition + soonest pool reset · auto-clears on recovery · resumes itself even hours later when the 5h/weekly window opens — no babysitting
REQUIRES THE OFFICIAL CLAUDE CODE EXTENSION
Enhancements to the official Claude Code extension
These patches augment the extension Anthropic ships — they are not standalone features.
The features below are surgical patches applied directly to the Claude Code VS Code extension you already have installed — not separate tools. Power Claude fixes the rough edges Anthropic hasn't shipped yet: stops Claude Code stealing your cursor, pins your original request to every session, stamps each message with the time it was sent, badges your session list so it's readable at a glance. Every patch is reversible and self-heals across Claude Code auto-updates; uninstalling Power Claude reverts the editor to stock.
Claude Code stops stealing your cursor.
Default Claude Code yanks your editor focus every time its panel reveals, output arrives, or a file is shown — break your flow once per turn, every turn. Power Claude patches the extension to pass preserveFocus:true on every autonomous reveal, show, and showTextDocument call. Your cursor stays where you put it. Patch is mtime-detected and re-applied automatically when the extension updates — no maintenance, no re-config.
addresses anthropics/claude-code#32726 · self-heals across upgrades · zero re-config · mtime-detected
ZERO CONTEXT TOKENS
UI features that work without touching your context window
The features below inject directly into VS Code and Claude Code's DOM — no prompt instructions sent to the model, no system-context additions, no output tokens burned rendering them. Power Claude patches the running webview at the UI layer so these surfaces appear for free, every session.
Every chat bubble knows what time it is.
Claude Code's chat doesn't tell you when each message happened — so when you come back to a session that was running unattended, every bubble looks like "just now." Power Claude stamps each bubble with your local HH:MM the moment it renders. Pure client-side via DOM injection — the value never enters the JSONL transcript, so it's invisible to the model and costs zero context tokens. Self-heals across Claude Code auto-updates.
HH:MM on every message · 0 context tokens · DOM-injected · self-heals across updates
SESSION EXPLORER, ENHANCED
A session list you can actually read
Power Claude enriches Claude Code's Session Explorer so a long list reads at a glance: a lifecycle glyph on every row, a live-dot on the session being driven right now, a modal that stops two windows racing the same transcript, and background tab-warming so any session opens instantly. All injected into the extension UI — no transcript writes, no token cost.
Five glyphs tell you a session's state without opening it.
Out of the box, every session in Claude Code's Session Explorer looks the same — you have to click in to find out which ones still matter. Power Claude prefixes every row with a glyph for its lifecycle state: 🟢 active, ✅ completed, 🟡 stale, ⚠️ abandoned, 📦 archived. A long list reads at a glance instead of forcing you to open each one. The classifier is deterministic — driven by transcript age, last-event type, and pending TodoWrite items — so the badge is reliable, not guessed.
5-state taxonomy · deterministic classifier · prefixed inline · O(1) glance scan
A live-dot overlay tells you which session Claude is driving this second.
Even with lifecycle badges, "active" is ambiguous — a session can be active and idle between turns. Power Claude's extension watches a heartbeat sidecar in ~/.power-claude/state/session-live/ and overlays a pulsing green dot onto the lifecycle badge whenever the heartbeat is less than 10 seconds old. You can tell at a glance which session is being driven right now versus sitting between turns waiting for input. Zero polling on the UI side — the sidecar timestamp does the work.
pulsing live dot · 10-second heartbeat · zero UI polling · disambiguates idle from running
A modal stops you racing your own JSONL writer.
Clicking Resume on a session that another VS Code window is already driving silently corrupts the JSONL transcript — both windows write concurrently and the loser's turn vanishes. Power Claude intercepts the Resume click and pops a modal: Take over (signal the other window to release the lock) or Open read-only (browse the transcript without writing). Either way, the session history stays drift-free. No more "where did my last 10 turns go?" diagnostics.
clash detection · take-over / read-only choice · prevents JSONL corruption · race-free
Open twenty sessions — and never click through them to load each one.
Power Claude is built for developers who keep many Claude Code sessions open at once. But Claude Code only loads a session's conversation when its tab is first revealed — so reopening a window with twenty sessions taxes you with twenty clicks just to wake each one. Tab Warming removes that tax. The moment VS Code finishes restoring, Power Claude reveals each open session once — using Claude Code's own open command, which reveals the existing tab, never a duplicate — to force the conversation to render, then puts you right back on the tab you were on. Loading a webview means revealing it, so the sweep is briefly visible — but it runs once, only when you've been idle a moment, speeds up adaptively when your machine keeps up, and aborts and restores your tab the instant you touch anything. On by default.
reveals each open session once after restore to load it · then returns you to your tab · idle-gated + adaptive + aborts on your activity · click any tab and it is instant · on by default
Pre-summarize the conversation in the background, so the compaction freeze never has to happen.
Claude Code freezes your session for minutes when the context window fills and it has to summarize the whole conversation inline. Warm Compacting removes that wait by doing the expensive part ahead of time: while you are still approaching the limit, Power Claude pre-summarizes the earlier ~80% of the conversation in the background — stored sidecar-only, never in your live context and never touching the transcript. When the wall is near, Power Claude substitutes that pre-built compact for the early conversation and keeps the recent tail verbatim, so the context window never crosses the line that triggers the freeze — the pause simply does not happen. The recent ~20% is always kept verbatim, so the context you care about most is never lost. On by default, and no regression by design: if anything is ever off (an edited session, an unsafe cut point) it falls back to normal compaction. A brand-stamped ⚡ Warm Compact chip in the statusline and dashboard shows it working; inspect it any time with pc warm-compact.
pre-summarizes the early ~80% in the background · sidecar-only, transcript untouched · substitutes the pre-built compact on the wire near the wall · recent tail kept verbatim · on by default · no regression — falls back to normal compaction · ⚡ statusline chip + pc warm-compact
Real numbers. Every claim is instrumented.
These charts are generated from ~/.power-claude/logs/handler.jsonl — 78.5 hours of live developer sessions, 8–12 May 2026. Nothing is simulated.
Methodology
End-to-end: detect → classify → quota exhausted → rotate. n=307 paired events from handler.jsonl.
Methodology
Independent rolling 5-hour windows per account. Pro = ~44k / 5h, Max 5× = ~88k, Max 20× = ~220k. Source: rate-limits.json + Anthropic published limits.
Methodology
Rate-limit overhead: hits × manual_recovery_sec. Context-switch: major switches × 23min (Leroy 2009). Approval overhead: approvals × 30s.
Methodology
Captured 8–12 May 2026 · 78.5 hours · 68 sessions. All logs local; only license key + hashed machine ID leave your machine.
What you get vs what you're paying for today
| Manual workflow | Claude Max alone ($200/mo) | Power Claude · 5 Pro + $12/mo | |
|---|---|---|---|
| Cost | |||
| Monthly cost | ~$0 (your time) | $200/mo | $100/mo Pro + $12/mo tool |
| Annual savings vs Max | — | — | ~$1,100/yr vs Claude Max |
| Subscription ROI | — | — | 4.6h reclaimed covers the tool fee in week 1 |
| Recovery | |||
| Rate-limit recovery time | 45–120s manual | 45–120s manual | 4.1s median (n=307) |
| Context lost on limit hit | Yes — rebuild from scratch | Yes — rebuild from scratch | No — session persists |
| Reliability | |||
| Crash detection | Manual | Manual | 4 automated rules |
| Session recovery on crash | Restart + re-explain | Restart + re-explain | Resume from git snapshot |
| Quota | |||
| Effective 5h token budget | ~44k (one Pro) | ~88k (Max 5×) | ~220k (5× Pro independent windows) |
| Concurrent session headroom | Serialized at limit | Serialized at limit | Spread across 5 windows |
| Visibility | |||
| Haiku downgrade detection | None | None | Per-turn model attribution |
| Session history & recovery | None | None | Sessions Lane · full context |
| Token burn rate & predictor | None | None | Live analytics + runout forecaster |
| Automation | |||
| Trivial-stop recovery | Type "yes" every time | Type "yes" every time | Auto-Nudge · 8 patterns detected |
| Time | |||
| Hours reclaimed / week | 0 | 0 | ~4.6h (typical) |
| UX | |||
| VS Code sidebar | None | None | Tree view + status bar + dashboard |
Five Pro accounts. $100/mo. Zero interruptions. Start shipping.
Premium Trial: card-on-file, $0 today, 14 days — locks today's founder rate for 2 years. Free: no card, 7 days inside the extension.
Neural-LLM is an independent software company. We are not Anthropic, and we are not affiliated with Anthropic. Power Claude is third-party tooling. Claude™ is a trademark of Anthropic, PBC.