NEURAL-LLM · POWER AGENTS · CLAUDE · GROK · CODEX · KIMI · ~$117+/MO VS MAX
Power Agents save you $117+/mo. Host-specific Claude, Codex, Grok & Kimi — try FREE for 14 days.
One local engine, independent purchases per host. Replace $200/mo Max with five $20 Pro accounts and save $117+/mo — or get 2.5x the usage for the same price. Pick Power Claude, Power Codex, Power Grok, or Power Kimi.
As if that wasn't enough… Tired of losing work when a task never quite finishes? Health Check recovers stalled sessions in ~60s.
- Tired of losing work when a task never quite finishes? Health Check recovers stalled sessions in ~60s.
- Stop re-explaining the same job next session — Continuity rewakes unfinished work instead of skipping it.
- See the whole agent run as a live flow chart — every step, branch, and stall on one graph.
- Unmatched granular profile, session, and workflow insight so you know exactly where tokens go.
- Smart Token Saver trims excess noise without code-quality regression — more room for real work.
- Pre-emptive Auto-Rotation Engine (opt-in) keeps long jobs shipping through rate limits.
- Session Recovery pulls work back when Claude's context collapses — the run doesn't die with the window.
- Checkpoints name rewinds Claude can't — go back to a known-good state without guessing.
- Auto-nudge only on the trivial stops so agents keep moving without babysitting every prompt.
- Pre-commit review and session trails catch incomplete work before it ships as a bug.
- By popular demand: Model tabs for Claude, Grok, Codex, Gemini, and Kimi — auto-discover what you install, hide noise.
- We've expanded beyond Claude-only chrome: pin agentic hosts you use — Kimi K3, Fable-class Claude, Grok, Codex in one fleet.
- Multi-host isolation keeps Claude / Grok / Codex / Kimi seats from clobbering each other's state.
- Watchdog catches crashes before you notice; the status bar shows which seat is driving now.
- Token Tree + trip odometer show burn rate before you hit the wall — plan capacity, not panic.
Premium Trial: $0 today (card on file, then $12/mo) — or Basic no-card trial for 7 days. Start shipping and stop overpaying — never look back.
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.
MULTI-PRODUCT COMPANY
Products from Neural-LLM
Power Agents — buy the host version you run.
Neural-LLM is a multi-product company. Power Agents is the primary product family: purchase Power Claude, Power Codex, Power Grok, or Power Kimi independently. Each install is host-scoped — see the family hub.
Per-SKU purchase · host-scoped licenses · catalog-driven
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 — scheduledly, 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 ≈ $83/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 ≈ $83/mo, roughly half the cost of Claude Max ($200/mo) — same ceiling, ~$117/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.
Your agent should keep working after you close the laptop.
Power Claude runs your accounts as a coordinated fleet — watchdog and session recovery as a single layer beneath Claude Code, with multi-account tools for seats you own. Official mode pauses on usage limits; optional Auto-Rotation is available when you opt in.
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 the recovery work: session recovery, watchdog auto-resume, and multi-account routing tools — polished VS Code + CLI product, your accounts never leaving your machine.
14-day Premium Trial (card on file), or 7 days free with no card. 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 hard stop that needs a human at the keyboard steals hours from agentic work. Your agent isn't stuck because the work is done — it's stuck because the tooling needed a babysitter. Across a day of sessions, that's idle time you didn't notice until you returned.
Silent throttles add a second layer. Anthropic may downgrade sessions to Haiku without a clear badge — slower, cheaper output quietly standing in for your intended model. Power Claude detects the downgrade per turn and surfaces it before it degrades your work.
Power Claude removes the babysitting classes that matter: auto-nudge clears trivial stops, watchdog detects stalls and crashes, and same-profile auto-resume keeps continuity on the seat that started the job. Optional Auto-Rotation Engine (off by default, opt-in with risk notice) can coordinate additional seats you own. Come back to progress, not a stalled prompt.
Community savings
$3,765,149 saved and counting*
Estimated savings across Power Claude users who run multiple Claude Pro seats they own instead of stacking Max plans — derived from our public cross-store install count.
How we calculate this
- Active users are estimated at 40% of our public cross-store download count — deliberately conservative; most installs are trials or second machines.
- Each active user is assumed to otherwise need ~1.5 Claude Max 20× plans ($200/mo each) to match the throughput of multiple Pro seats they own.
- What they run instead: five Claude Pro seats they own ($83/mo total) plus Power Claude Pro ($12/mo) — so one user's estimated saving is $205/mo.
- The cumulative figure integrates a linear adoption ramp from 2026-05-01 to today — early months count for less, not full weight.
- This is an estimate derived from public install counts, not a measured total. Once opt-in usage telemetry reaches a meaningful threshold, this counter switches to tracked, real figures.
Read the full cost breakdown: Claude Max vs pooled Pro accounts
*Estimated total based on opt in telemetry of Power Claude usage.
ALL AGENTIC MODELS · ROTATION ENGINE
Power Claude features — every agentic model
By popular demand we expanded beyond Claude-only chrome. One control plane for <strong>Claude, Grok, Codex, Gemini, and Kimi</strong> (Model tabs · auto-discover · pin/hide), plus the rotation engine, watchdog, session recovery, Token Saver, usage dashboard, and CLI. Public money/trial chrome stays honest on Claude savings; multi-host isolation keeps fleets from clobbering each other.
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 — buy the host version you run.
Neural-LLM is a multi-product company. Power Agents is the primary product family: purchase Power Claude, Power Codex, Power Grok, or Power Kimi independently. Each install is host-scoped — see the family hub.
Per-SKU purchase · host-scoped licenses · catalog-driven
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
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 (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
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
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 profile list 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. CLI how-to · Help hub.
40+ pc commands · grouped by intent · color-tinted status · zero network calls · same state in terminal + VS Code
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
CLAUDE CORE
Always know why your session is paused — and trust it to come back
When your whole profile list 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
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 |
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.
Start Saving $117/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.