Neural-LLM · KEEP THE RUN GOING
Keep agents shipping. Walk away. Come back to finished work.
Power Agents keeps Claude, Codex, Grok, and Kimi shipping locally. One license per host, matching download. Claude Max-vs-Pro savings live on Power Claude ($117+/mo vs Max on seats you own).
As if that wasn't enough… Power Agents: Claude, Codex, Grok, and Kimi — buy the host you run.
- Power Agents: Claude, Codex, Grok, and Kimi — buy the host you run.
- Buy only what you run — expand when a second agent earns its seat.
- Power Claude: replace Max with Pro seats you own — save $117+/mo.
- Token Saver: ~25% off noisy tool output — more work from seats you already buy.
- Power Claude: 2.5x the usage for the same money you are paying now.
- Stalled mid-task? Recovery brings the job back instead of starting over.
- Watchdog catches the dead spinner before you notice.
- Power Codex: finish the feature Codex left hanging mid-patch.
- Power Grok: keep Grok seats shipping after a wall — do not lose the speed.
- Power Kimi: stack seats with published credit math you can check.
- Auto-nudge: "should I continue?" should not kill an overnight run.
- Multi-account: more throughput on seats you already own.
- Local by design: prompts stay on your machine, not a cloud middlebox.
- Merge conflicts: pick a model, confirm, keep both sides.
- Dashboard: see burn, health, and which seat is driving.
See it in action · then start free
Watch what you get — then start the Premium Trial at $0 today.
Organize Max and Pro Claude Code profiles in one place. Power Claude surfaces usage limits in under a second, lets you run independent sessions in parallel, and wakes itself back up on the same profile — so your work recovers instead of dying quietly.
Power ClaudeSee it in actionPremium locks founder pricing for 2 years. Free trial is full Pro for 7 days inside the extension.
THREE STEPS
How it works
You already pay for an agent. Power Agents keeps that seat shipping — then you can add another host later.
Pick the agent you already run
Claude Code, Codex, Grok, or Kimi — start with the seats on your machine. No bundle required.
One product · one host
Start that product only
Checkout is one unit of the host you chose. Codex does not unlock Claude. Grok does not unlock Kimi.
Cancel anytime
Install and let it finish the job
Each product has its own downloads page. Recovery and Token Saver keep overnight runs moving while you sleep.
Local · private
SHARED WITH CLAUDE, CODEX, GROK, KIMI
The engine that keeps every host shipping
Recovery, Token Saver, and watchdog are the same local stack. Host-only extras (Claude Core, Codex adapter, Grok, Kimi credits) live on each product page.
Stalled sessions come back. You do not re-explain the job.
When an agent dies mid-task, recovery names the failure, trims the wreckage, and resumes the same work in a fresh context.
Resume instead of restart
Burn less noise. Keep the tokens you already pay for.
Token Saver strips bulky tool dumps before the model reads them. Typical ~25% off those noisy blocks — measured on your traffic.
~25%+ off trimmed tool output
Catch the stall before you notice the spinner.
Watchdog watches quota, rate-limit walls, and silent failures. When a rule fires, the session is recovered instead of sitting dead.
4 detection rules · local
The stalls every coding agent hits — and how the engine removes them.
The seat hits a wall. The job is half done.
Rotation and recovery keep the work on seats you already own. When one account is spent, the next prompt can continue on a fresh seat instead of sitting on a spinner. Buy the host you run — Claude, Codex, Grok, or Kimi — and install that product only.
The session dies mid-patch. You re-explain the job.
Session recovery names the failure, trims the wreckage, and resumes the same work in a fresh context. You do not paste the last twenty minutes back into a blank chat.
Tool dumps burn the tokens you already paid for.
Token Saver strips bulky tool output before the model reads it. Typical ~25% off those noisy blocks — measured on your traffic. Same engine on every host product.
You cannot leave the laptop. The agent needs a babysitter.
Watchdog plus auto-resume keep long jobs moving after a stall, crash, or silent hang. Walk away. Come back to progress — on the host you licensed.
Come back to a finished task — not a stalled prompt.
Every hard stop that needs a human at the keyboard steals hours from agentic work. The shared engine removes the babysitting classes that matter: watchdog, same-profile resume, and Token Saver. Host-only extras (Claude Core, Codex adapter, Grok, Kimi credits) live on each product page.
Unattended · local · one license per host
POWER CLAUDE
Claude-only features
Max-vs-Pro savings, Claude Core, Health Check, and Claude Code chrome. Not marketed on Codex, Grok, or Kimi.
POWER CODEX
Codex features
Finish the feature Codex left hanging — recovery and seats you own. Claude Max math stays on Power Claude.
POWER GROK
Grok features
Keep Grok seats shipping after a wall. Speed without inheriting Claude Core.
POWER KIMI
Kimi features
Published credit economics you can check — plus the shared recovery engine.
Why five Pro accounts beat one Max plan — and how Power Claude makes that usable.
The money math most people miss: Anthropic’s Claude Max 20× is about $200/mo for a single high-cap seat. Five legitimate Claude Pro seats (about $16.66/mo each on annual billing) total about $83/mo — so you keep roughly the same 5-hour session capacity class while saving $117+/mo vs Max. Or keep spending ~$200 and run more Pro seats for ~2.5× the pool instead of one Max login.
Why that works: Max’s premium is mostly a higher ceiling on one account. Five Pro profiles each carry their own session budget; pooled capacity ≈ one Max 20× session class without paying Max’s single-seat markup.
What Power Claude does: it manages seats you already own (profiles + config dirs) so you see health, pick the right seat before work, and keep each session on its originating profile by default — no silent account hopping. When a seat hits a limit, Power Claude pauses and tells you (wait, switch plan, or API mode). Optional Auto-Rotation Engine (off by default; explicit opt-in with grey-area warning) can continue across seats you own after you turn it on — never a silent install default.
$200/mo Max vs ~$83/mo five Pro · save $117+/mo · seats you own
Expanded by popular demand — Claude, Grok, Codex, Gemini, and Kimi in one chrome.
Power Claude started as deep Claude Code orchestration. Operators asked for the same control plane on every agentic host they already run. Model tabs now scope Home, sessions, usage, and settings by host family: Claude · Grok · Codex · Gemini · Kimi (plus Mixtures / All when you need them).
What ships: auto-discover seats and API keys (e.g. KIMI_API_KEY / Moonshot), pin the hosts you care about, hide the rest so the strip stays quiet. Universal account list and pool chrome — same verbs on every host, not a Claude-only fork.
Honest scope: public Marketplace SKU stays Claude-first for money/trial chrome; multi-host tabs unlock with lab or host products. When Anthropic is AUTH-DEAD, gateway mixtures can still route brains like Kimi K3 under contracts — not a fake “one model forever” product.
Model tabs · auto-discover · pin/hide · Kimi K3 + Fable-class fleets
Power Agents — multi-account coding agents that finish the job.
Turn the AI coding seats you already own into a productive fleet. Choose Power Claude, Power Codex, Power Grok, or Power Kimi — buy only the product you run. Recovery, Token Saver, and local privacy included. See the Power Agents family.
Buy only what you run · multi-account · local privacy
Spread concurrent Claude Code sessions across seats you own.
When you run many Claude Code sessions at once on a single seat, work serializes. Balanced Mode (Pro) scores healthy seats you configured — by 5-hour utilization, in-flight count, and recent burn — and prefers the seat with the most headroom for new work. Round-robin is available when you want deterministic ordering. The interactive model below is illustrative typical math, not a service guarantee: at 10 concurrent sessions, one seat queues everything, while five independent seats can finish a round sooner in a simple queue model. Drag the slider to feel the gap.
least-utilized OR round-robin · illustrative model · Pro tier
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 your profiles, 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.
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. Token Saver how-to · Help hub.
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
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. Auto-Resume how-to · Help hub.
silent or notified · 60s + shutdown snapshots · soonest-recovering account · cross-IDE optional
Hit a 429? Power Claude already scheduled your comeback.
When a session stops for a recoverable reason on the same profile, Power Claude can schedule a local resume (including timed wake via systemd-run where available) with reason-aware context — not a generic "continue". Subscription limits still pause until the official window resets or you choose an official option. Walk away from a recoverable stop; come back to progress on the same profile.
7 rate-limit-type extras · soonest-reset across your profiles · systemd-run timers · per-class wake context
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
Point Claude at a loop. Walk away. Come back to a finished project.
A loop is Claude Code's own /loop or /goal — 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
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. Runout Forecaster how-to · Help hub.
per-account + pool-wide ETA · green/amber/red · authoritative reset times · rolling burn-rate samples
Drain seats about to reset — leave nothing on the table.
When multi-account rotation is selecting among seats you own, Reset burn-down prefers accounts near a 5h or 7d usage-window reset that still have residual capacity — so quota is not left unused when the window rolls. Urgency ramps over the remaining window (steepest near reset). Far-from-reset seats stay available for later work.
Defaults: powerClaude.proxy.resetBurnDown = true; pairs with parallelMode = smart. This is usage-window reset (Anthropic rate-limit headers), not subscription billing renewal. Does not invent capacity or force auth-dead seats. Reset burn-down how-to · pairs with Runout Forecaster.
default ON · near-reset residual first · 5h + 7d · smart parallel
Unattended, end to end
Leave it running. Close the laptop.
Come back to a finished task.
A long agent job runs for hours — the watchdog answers benign stops, same-profile resume keeps state, and the run finishes on its own. No babysitting, no restarts.
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
Flow Explorer: see what the agent actually did — try it free in your browser.
Why it matters: agent runs are not chat scrollback. They fan out into sub-agents, tools, gates, and evidence. Flow Explorer turns that into a map you can walk — Blueprint (what the harness will run), Session (what this run did), Combined (path on the map) — with Taken-path walk, Evidence I/O, and Mermaid export (pc tree --format mermaid).
Start here (no install): Try Flow Explorer — harness-aware demo · all scenarios · how-to guide. Synthetic data only in the browser demo; your real sessions stay local in the extension.
Free browser demo · harness-aware scenario · Blueprint/Session/Combined · Mermaid · evidence I/O
Every gate, branch, and sub-agent in the harness — mapped before it runs.
Power Claude's harness runs a real pipeline around every edit — placement and policy gates, save-time linting, approval reviewers, and sub-agents that fan out on demand. The Harness Flow Graph lets you see that whole pipeline statically — what will run, for any LLM client, without running it: each lifecycle event, tool matcher, blocking gate, and agent-spawn point, with per-client adapter modes (native, translated, or disabled) shown inline. It is the same picture in three places from one shared engine: pc workflow in the terminal, an interactive graph in VS Code, and the diagram on this page — all generated from the real pipeline manifest, so the map can never drift from what the harness actually does.
static map of the whole pipeline — events, matchers, gates, agent-spawn points · per-client adapter modes inline · one core → CLI + VS Code + this page · generated from the real manifest, zero drift
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 session 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
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 so you can resume on the same originating profile, clear a trivial stop, or — only if you enabled Auto-Rotation Engine — continue across seats you own.
Watchdog catches it. Session Recovery rescues it.
4 detection rules · same-profile resume · optional engine opt-in
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.
Recover one session by hand, or finish them all at once: pc resume-stalled 1d finds every abandoned or stalled session inside the window you give it, resumes each in its own isolated git worktree in parallel, and merges the finished work into your local main — nothing is pushed. It reads Claude Code's live-process registry first, so a session you still have open is skipped, never taken over. Old sessions are safe too: each is rebased on your current main and verifies the work is not already done before it changes anything, so finishing a stale session can't undo newer work. You get back a readable report — what each session was, what got finished, what merged, and what still needs you. Resume stalled how-to · Help hub.
9 failure scopes · 6 strategies · finish every stalled session in parallel — open ones skipped, stale work never regressed · 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>. Checkpoints how-to · Help hub.
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
Account groups: scoped pools for each job — not one flat rotator.
Name a group for Work, Job A, or Client B. Put only those Claude seats in it. Pool within that set, activate it when that engagement is live, and hard-isolate projects/memory so other jobs never inherit the context. Flat rotators dump every login into one pool; dual config dirs only separate logins. Groups add the missing layer: group → pool that set → run that engagement. Drag membership in Profiles → Account groups or pc scope create|add|use. Credentials stay private per account. Deep dive · docs.
scoped pool per job · isolation · active group · pc scope CLI
Sessions that talk to each other — not only to their children.
Most agent stacks isolate top-level sessions. Power Claude surfaces a signed, local inter-session message bus (hurc harness engine) so independently opened coding sessions can coordinate: peer notes, work claims, lock ETA, broadcast freezes, and optional wake of parked sessions. Bodies stay on your machine via Neural-LLM — local bus, not a cloud chat. Deep dive: Claude Code sessions that talk to each other. Across machines: remote session link.
signed local bus · work claims · lock ETA · optional wake · zero cloud body path
Link coding sessions across laptops, bastions, and servers.
When agents do not share a home directory, the local bus cannot reach them. Power Claude surfaces the harness opt-in remote link plane: MagicSync-style token pairing, default observe mode (note/reply/ack as untrusted peer data), volume or SSH transport, and a setup UI that consumes the harness remote-insight pack. No Neural-LLM cloud hop for message bodies. Deep dive: Link AI coding sessions across machines · local bus: sessions that talk on one machine.
default OFF · observe first · signed pairs · volume/SSH · insight pack UI
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
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 (any compatible telemetry backend) 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
The same auto permission safety — for Claude, Grok, Codex, and every agent you run.
Multi-host permission safety. Power Claude’s zero-token classifier is the portable allow/deny floor for Claude Code, Grok, Codex, Cursor, and other agents — including hosts with no native permission auto. One policy, every client.
Zero-token · portable rules · works when native auto is missing · one policy across agents
# Same floor on every host
# deny: git push --force · rm -rf /
# allow: git status · safe local edits
# Configure: onboarding or Settings → Permission classifierConcurrent windows can't clobber your settings or rotation state.
When ten VS Code windows share one profile list, they all read-modify-write the same files — ~/.claude/settings.json and the live profile-organization 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
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 / work aroundPermissions) with a one-click toggle for the compliance-sensitive switch from default to work around-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
Merge conflicts: pick a model, confirm, keep both sides.
When git stops on conflict markers, Power Agents asks you whether to resolve via a model — and which model. Default is grok-4; pick another at the prompt or with pc merge-resolve --model. Nothing is written until you confirm. The parser lives in @cj-hurc/merge-resolve; the CLI is hurc-harness auto-resolve-merge. Unattended land-branch does not pop this prompt. Auto-resolve merge how-to.
Default grok-4 · always selectable · confirm before write · CLI + Command Palette
pc merge-resolve
auto-resolve-merge: 2 file(s)
src/foo.ts
default/selected model: grok-4
Resolve via model? [Y/n] (m=pick model)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. Auto-Nudge how-to · Objective Mode · Auto-Resume & Rewake.
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
Tells you when to upgrade — and when Anthropic downgraded you.
Power Claude can surface local recommendations from your own logs (for example plan options when limits are frequent). Throttled so you are not nagged. Recommendations are computed locally — zero telemetry leaves your machine unless you opt in. Your session data stays yours.
local-only computation · weekly throttle · opt-in telemetry only
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
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 (scheduled) |
| 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 |
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
OPTIONAL · REQUIRES THE OFFICIAL CLAUDE CODE EXTENSION
Enhancements to the official Claude Code extension
Optional. These patches augment the extension Anthropic ships — toggle each off in settings, or remove them anytime, and keep using Power Claude.
Everything in this section is optional. These 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. Turn any single one off, or uninstall Power Claude entirely, and the editor returns to stock — the core of Power Claude (session orchestration, the savings, and auto-resume) works fully without any of them.
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
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. Tab Warming how-to · Help hub.
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. How-to guide · Self-help hub.
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 | $83/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 |
MULTI-PRODUCT COMPANY
Products from Neural-LLM
Power Agents — multi-account coding agents that finish the job.
Turn the AI coding seats you already own into a productive fleet. Choose Power Claude, Power Codex, Power Grok, or Power Kimi — buy only the product you run. Recovery, Token Saver, and local privacy included. See the Power Agents family.
Buy only what you run · multi-account · local privacy
Save $117+/mo vs Max on seats you already own.
Replace a Max plan with Pro seats you control. Power Claude keeps the run shipping — rotation, recovery, Token Saver. Money math lives here, not on Codex or Grok.
$117+/mo vs Max · 14-day Premium Trial
Token Saver: burn less waste on the seats you already pay for.
Bulky tool dumps get trimmed before the model reads them — typically ~25% off those noisy blocks. Same engine on Claude, Codex, Grok, and Kimi. Measured on your traffic, not a made-up bill cut.
~25%+ off trimmed tool output
Finish the feature Codex left hanging mid-patch.
Codex dies mid-feature. Power Codex recovers the work and orchestrates seats you already own — no copied Max-vs-Pro dollar claim.
Recovery + Token Saver on Codex
Keep Grok seats shipping after a wall.
Grok is fast until a seat hits a wall. Power Grok recovers the work and keeps speed — no copied Max-vs-Pro dollar claim.
Recovery + Token Saver on Grok
Stack Kimi seats with published credit math.
No invented token meter. Power Kimi uses Kimi-published credit units so you can compare plans with numbers you can check — plus the same recovery engine.
Published credits · not guessed tokens
Merge conflicts: pick a model, confirm, keep both sides.
Command Palette or the product CLI asks before it writes. Default Grok 4; you choose another model. (Claude SKU CLI: pc merge-resolve.)
Default grok-4 · always selectable · confirm before write
Set up in under a minute
Installed and orchestrating in five steps
One line in the terminal you already have open — no config, no keys to create.
Pick the agent you already run.
One license per host. No forced bundle. Power Claude, Codex, Grok, or Kimi.
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.