Neural-LLM · Power Agents · KEEP THE RUN GOING
The session died. The job didn't.
Start a session, close the laptop, come back to a finished run — not a frozen chat. Works under Claude Code, Codex, Grok, or Kimi, on your machine.
What every host gets Power Agents: Claude, Codex, Grok, and Kimi — buy the host you run.
- Power Agents: Claude, Codex, Grok, and Kimi — buy the host you run.
- Multi-account: more throughput on seats you already own.
- One license per host. Host-only extras live on each product page.
- Token Saver: ~25% off noisy tool output — more work from seats you already buy.
- Dashboard: see burn, health, and which seat is driving.
Built to make the worst coding-agent failure modes disappear.
The seat hits a wall. The job is half done.
The session pauses and tells you — it does not die on a spinner. Every seat you own is named once, per host, with its quota and next reset visible. If you opt in, the next prompt continues on a fresh seat you already pay for; the Auto-Rotation Engine is off by default and shows each provider's terms before you switch it on.
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 — after snapshotting your working tree so a bad recovery is one click to undo. You do not paste the whole job back into a blank chat.
Tool dumps burn the tokens you already paid for.
Token Saver trims bulky tool output before the model reads it. Typically ~25%+ off those noisy blocks, up to 90% on the most repetitive — measured live on your own traffic, reversible, with errors, stack frames, and diff changes always kept.
You cannot leave the laptop. The agent needs a babysitter.
Watchdog, auto-resume, and auto-nudge keep long jobs moving after a stall, crash, silent hang, or a trivial "should I continue?" stop. Walk away. Come back to progress on the host you licensed.
The overnight loop ran up a bill you did not see coming.
Analytics show burn rate per account and per session while it runs — cache-read versus output tokens, a cap-hit recommender that names which seat to switch to before the current one exhausts — and the Runout Forecaster tells you hours ahead when a pool will hit its wall, so you stop with room to spare instead of discovering the invoice.
You pay for seats that sit idle while one seat queues everything.
Balanced Mode spreads concurrent sessions across the seats you own — least-utilized or round-robin — and account groups scope a pool per job so Work, Job A, and Client B never share context. Same engine on every host, always on that host's own seats.
Your agent should keep working after you close the laptop.
Every coding agent fails the same four ways: a seat hits its wall mid-job, a session dies with the context it built, tool output burns tokens you already paid for, and a trivial "continue?" prompt parks the run until you come back. The FAQ above shows how each one is handled; this note is about why it matters.
Babysitting is the hidden cost. Logging out and back in, rebuilding context after every wall, checking the tab every ten minutes — each one is a full context switch, and across a day of agentic sessions they add up to hours that should have been output. The engine exists so that time comes back to you.
Start a Premium Trial for $0 today, or download free with no card. Pick the agent you run below. If the engine does not hand back real time in the first week, cancel the Premium Trial before day 14 and nothing is charged — or simply let the no-card trial lapse.
Leave it running. Come back to a finished task.
A run that needs a human at the keyboard is not unattended. Every "Should I continue?" prompt, every hard stop, every wall that waits for a login is a place the work sits until you notice.
Leave it running means exactly that: close the laptop after the first prompt and the engine keeps the run moving on the seat that started it. Multi-account rotation stays opt-in — seats you already own, on your machine.
Come back to a finished task, or to a named stall with the reason attached — never a spinner. Pick the agent you run below; host-only extras live on that product page.
Power Claude community savings (Claude-only math)
$4,306,955 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 one Claude Max 20× seat ($200/mo) to match the throughput of the Pro seats they own — the same basis as the per-user figure quoted across the site.
- 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 $105/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
*Estimate from public install counts — see "How we calculate this". Switches to tracked figures once opt-in telemetry clears its threshold.
ONE ENGINE · CLAUDE · CODEX · GROK · KIMI
The engine every Power Agent ships with
Proven on Power Claude first; the same engine ships in Power Codex, Grok, and Kimi — any capability still maturing on a host is labelled on that product page.
Recovery, Token Saver, watchdog, dashboards, messaging, analytics — one local engine, the same code under Claude Code, Codex, Grok, and Kimi. Screenshots below are from the editor and the terminal.
More throughput from the accounts you already pay for — without babysitting the seats.
Name every seat you legitimately own once — per host, so Claude seats never mix with Codex, Grok, or Kimi seats — and the engine keeps them healthy: per-account quota bars, next reset times, and a status bar that shows which seat is driving. When a seat hits its wall the session pauses and tells you instead of dying on a spinner. Want the next prompt to continue on a fresh seat automatically? The Auto-Rotation Engine is opt-in and off by default, with a plain grey-area warning before you switch it on. Host-specific seat math lives on each host's own page.
per-host seat pools · quota + reset visibility · pause-and-tell on limits · Auto-Rotation opt-in, off by default
Spread concurrent agent sessions across seats you own.
Run 10 agent sessions on a single seat and they queue behind each other — every request waits its turn on the same quota, and the work serializes. Balanced Mode (Pro, opt-in) scores every healthy seat you configured — current utilization, in-flight requests, recent burn — and sends the next request to the seat with the most headroom. Want deterministic ordering instead? Switch to round-robin. The seats are yours and the scheduling runs on your machine. The throughput model below is illustrative typical math, not a service guarantee: at 10 concurrent sessions, one seat queues everything, while five independent seats finish a round sooner in a simple queue model. Drag the slider to feel the gap.
least-utilized or round-robin · opt-in · illustrative model · Pro
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 capacity from the seats you already own. The Token Saver makes sure you waste less of it: it trims the low-signal bulk out of the tool results in every request — command output, build logs, diffs, JSON dumps — before they reach the model, so the model reads leaner context, keeps more room for real work, and hits context-limit walls less often. On the bulky blocks it trims you will typically see ~25%+ off that output, up to 90% on the most repetitive.
It runs on your machine and is reversible and audited: lossless where it can be, and it never fabricates — only noise is dropped, and the lines you actually need (errors, stack frames, the changed lines in a diff) are always kept. We do not quote a session-wide average: the editor view and the CLI show your real, live savings on your own traffic — every token counted, not estimated. You choose how far it goes on a five-level slider from Off to Max, and it is on by default at Balanced, so the savings start the moment you install.
runs on your machine · trims tool-result noise before the model reads it · reversible + audited · errors, stack frames, diff changes always kept · ~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.
Auto-Resume picks a stopped session back up on the same profile — without you noticing the stall, reopening the thread, or typing "continue". The engine snapshots conversation state every 60 seconds and on shutdown, so when a session stops for a recoverable reason — a rate-limit that clears — it resumes exactly where it left off: silently, or with a one-line notice in the panel. Scope it to the editor window that paused, or let any open editor pick it up. Opted into multi-account rotation? The resume can land on the seat that recovers soonest instead of waiting on the one that stalled. No more overnight stalls you discover in the morning, no more half-done threads rebuilt by hand. A hard subscription cap still pauses until its window resets or you choose an official option — nothing pretends otherwise. Walk away. Come back. The work is done.
silent or one-line notice · snapshots every 60s + on shutdown · same-profile resume · soonest-recovering seat when rotation is opted in · one editor or any open editor
Hit a 429? Power Agents already scheduled your comeback.
When a session stops for a recoverable reason on the same profile, Power Agents can schedule the comeback for you: a local resume timed to the soonest reset across your profiles, with a timer armed via systemd-run where available. Each of the seven rate-limit classes it recognizes carries its own wake context, so your agent picks up with the right framing instead of 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 classes · soonest reset across your profiles · systemd-run timers · per-class wake context
Sessions that don't disappear. Context that survives.
Your agent's recent sessions are kept as resumable snapshots, working context intact. Pick one from the session history in the editor or the CLI and Resume Session hands that context — tool-call history, file changes, the decision chain — to the new conversation, so the agent picks up exactly where it left off. A session that ended with work still open is resumed, not skipped, and the same record feeds pre-commit review, so a reviewer sees why each change was made — not just what changed. You stop re-explaining the job every time a session ends.
resumable snapshots · context intact on resume · editor or CLI
Point your agent at a loop. Walk away. Come back to finished work.
A loop is your agent re-issuing one objective until it's done — a migration, a refactor, a test suite that has to go green. On its own, a loop dies at the first rate limit, crash, or "should I continue?" stop. Power Agents is the layer underneath: multi-account rotation (opt-in, on seats you already own) and Balanced Mode turn rate limits into handoffs, Auto-Rewake schedules the 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 loop · Pro tier
Runout Forecaster tells you when your pool will hit a wall.
Runout Forecaster watches utilization across every account in your pool and projects, at your current burn rate, whether you'll run out of capacity before the usage window resets. The dashboard's Overview tab shows one color-coded pool banner — green when you're safe through the next reset, amber when some accounts will exhaust before it, red when the pool is minutes from a wall. Every account row also carries a small ETA chip, so you spot the bottleneck without opening a drawer, and the same forecast is one command away in the CLI. It works in Balanced and single-account modes. Reset times are read from your provider's rate-limit headers, not guessed, so the "will I make it to the reset?" half of the math is exact; only burn rate is estimated, from a rolling sample of recent requests. You find out about the wall while there is still time to pace the work or bring another seat online — not when a session stalls mid-task.
per-account + pool-wide ETA · green / amber / red · exact reset times, estimated burn rate · dashboard + CLI
Know your burn rate before you hit the wall.
The usage analytics panel shows live token burn per account, rolling totals against the quota windows your provider actually enforces, and a cap-hit recommender that names exactly which account to switch to before you exhaust the current one. It calibrates to your real plan tier from the rate-limit responses it observes in your own sessions, not from a pricing page. Every turn also records which model answered and whether a fallback kicked in, so spend is attributed to what actually ran, not what you assumed was running. Nothing leaves your machine: the numbers come from your local session logs, whichever agent you run.
Per-account burn rate · per-turn model attribution · cap-hit recommender · all local
Flow Explorer: see what your agent actually did — try it free in your browser.
Agent runs are not chat scrollback. One prompt fans out into sub-agents, tool calls, gates, and evidence, and the transcript hides most of it. Flow Explorer turns the run into a map you can walk: Blueprint (what the harness will run), Session (what this run actually did), and Combined (the path taken on the map), with a taken-path walk, evidence I/O on every node, and Mermaid export from the CLI. You stop guessing which sub-agent ran what, or why a gate halted. One explorer, every Power Agents host.
Start here, no install: try Flow Explorer with the harness-aware demo scenario. The browser demo runs on synthetic data; your real sessions stay local in the extension.
Free browser demo · harness-aware scenario · Blueprint / Session / Combined · taken-path walk · evidence I/O · Mermaid export
Every gate, branch, and sub-agent — mapped before anything runs.
Power Agents runs a real pipeline around every edit your agent makes — placement and policy gates, save-time linting, approval reviewers, and sub-agents that fan out on demand. The Harness Flow Graph maps that whole pipeline statically — what will run, for any agent client, without running it: every lifecycle event, tool matcher, blocking gate, and agent-spawn point, with per-client adapter modes (native, translated, or disabled) marked inline. It is the same picture in three places from one shared engine: the workflow command in the product CLI, an interactive graph in VS Code, and the diagram on this page. All three are generated from the real pipeline manifest, so the map cannot drift from what the harness actually does. You stop discovering a gate the moment it blocks you.
static map of the whole pipeline — events, matchers, gates, agent-spawn points · per-client adapter modes inline · one engine → CLI + VS Code + this page · generated from the real manifest, zero drift
Every signal — and every routine action — in one panel.
The sidebar dashboard groups every seat into Needs action / Throttled / Healthy / Idle buckets under a 60-minute handoff lane graph, so you stop guessing which login died and which seat is driving. Click any row for a drill-down drawer with a 24-hour activity sparkline and that seat's last ten handoffs; hover for a quick-action card, or compare two events side by side. Hand-rolled SVG and CSS on your editor's theme tokens — no chart libraries, no new tabs, all rendered locally.
60-min handoff lane graph · 4 status buckets · 320 px drill-down drawer · all local
Local-only. Your code and prompts stay yours.
Power Agents runs on your machine — inside your editor or terminal, beside the coding agent you already use. It works from the session files that agent already keeps on disk and the accounts you already own. It never sees, stores, or transmits your prompts, your code, or your conversation. There are no Neural-LLM servers in the request path and no external aggregation. No usage telemetry beyond the license check unless you opt in. What the license check, trial check, and heartbeat send to Neural-LLM: your license key (sent over TLS, kept only as a one-way hash), a hashed machine ID, the extension version and build hash, and aggregate counters — requests, rotations, and the host accounts configured for rotation. Never prompts, code, session content, or host credentials. So when a security reviewer or a client asks "where does our code go with this installed?", the honest answer is: nowhere new. It adds nothing to your data path, so there is nothing extra to audit.
No usage telemetry beyond the license check unless you opt in · key over TLS (kept as a hash), hashed machine ID, platform, version, counters; the no-card trial adds hashed anti-abuse signals · never prompts or code
Catches session crashes before you notice them.
A crashed or stalled session doesn't announce itself — it goes quiet, and the work stops with it. The watchdog polls every live session’s lifecycle markers every 30 seconds for the deaths that do not come with a rate-limit signal: a stale heartbeat, a truncated tool call, a killed process, a session that ended with tasks still pending, compaction thrash, and context overflow. Rate limits and quota are the rotation engine’s job, not the watchdog’s. When any rule fires, it emits a structured event that names the failure, so you can resume on the same profile that started the job, clear a trivial stop, or — only if you switched on the opt-in Auto-Rotation Engine — continue across seats you already own.
Watchdog catches it. Session Recovery rescues it.
4 detection rules · same-profile resume · Auto-Rotation Engine opt-in, off by default
When your agent's context window collapses, your work doesn't have to die with it.
Context overflow, tool loops, crashes, a session abandoned mid-turn — Session Recovery detects the failure by name and matches the recovery strategy to it. A session that has been thrashing on its own context can't simply be resumed; a naive resume re-thrashes it. So the engine 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 to a git ref first, so a bad recovery is one click to undo. Headless too: the CLI lists failed sessions, recovers one by id, or bundles a session to finish on another machine.
Recover one by hand, or finish them all at once. The CLI's resume-stalled sweep finds every abandoned or stalled session inside the window you give it (1d for the last day), resumes each in its own isolated git worktree in parallel, and merges the finished work into your local main — nothing is pushed. It checks the live-session registry first, so a session you still have open is skipped, never taken over. Older sessions are rebased on your current main and checked against work already done before anything changes, so finishing a stale session can't undo newer work. You get a readable report back: what each session was, what got finished, what merged, and what still needs you.
10 failure scopes · 7 strategies · every stalled session finished in parallel — open ones skipped, newer work never regressed · Pro tier
Catch incomplete sessions before they ship as bugs.
Power Agents watches every session for the quiet failure: it ended with work still on its task list. When a session ends with pending task-list items and then sits idle for 60+ minutes, the engine flags it Abandoned and raises a red alert on the Sessions tab. Auto-Resume offers recovery for those sessions but never forces it — resume in this window or another with one click. Four states — Active, Saved, Unfinished, Abandoned — give you status at a glance, with an origin filter (VS Code vs the CLI) and per-row tags (incomplete, long-running, rate-limited) so the session that matters is easy to find. Half-finished features stop slipping into production unnoticed.
4 session states · auto-flagged at 60+ min idle with pending items · 1-click resume into any window · never forced
Account groups: a pool per job, not one flat rotator.
Name a group for Work, Job A, or Client B and put only that engagement's seats in it. Activate it when the job is live: the group becomes the whole pool (manual switching and opt-in rotation stay inside it), and isolated groups keep projects and memory apart, so Client B never inherits Job A's context. Flat rotators dump every login into one list; a second config dir only separates logins. Groups add the missing layer: group → pool that set → run that engagement. Drag membership in Profiles → Account groups, or script it from the CLI. Credentials stay private per account.
scoped pool per job · isolated memory · one active group · dashboard + CLI
Sessions that talk to each other — not only to their children.
Run several coding sessions on one machine and they coordinate instead of colliding. Most agent stacks let a session talk only to the sub-agents it spawned; two top-level sessions cannot see each other. Power Agents adds a signed, local inter-session message bus — the same engine under every host — for peer notes, work claims, lock ETAs, broadcast freezes, and an optional wake of a parked session. Message bodies stay on your machine: a local bus, not a cloud chat, with no Neural-LLM server in the path.
It prevents the classic fleet failure: two sessions editing the same file, or one reverting the other's half-finished refactor. Send from the CLI too. Deep dive: sessions that talk on one machine.
signed local bus · peer notes · work claims · lock ETA · optional wake · no cloud body path
Link coding sessions across laptops, bastions, and servers.
Coding sessions rarely all live on one box. When a laptop, a bastion, and a build server do not share a home directory, the local session bus cannot reach across them. The Power Agents engine closes that gap with an opt-in remote link: pair machines with a signed token (MagicSync-style pairing), and sessions on either side trade peer notes, replies, and acks over a shared volume or SSH. Set it up from the guided setup UI.
It stays off until you enable it. Every pair is signed and starts in observe mode, so remote messages arrive as untrusted peer data an agent can read but never run as instructions. Message bodies travel machine to machine with no Neural-LLM cloud hop. The setup UI, fed by the engine's remote-insight pack, shows what is paired — so a session on another machine stops being a black box you SSH into to check on.
Default OFF · observe mode first · signed pairs · shared volume or SSH · no cloud hop for message bodies
A dozen sessions open — find the one by what was said inside it, not by its title.
Keep a dozen agent sessions open and the one you need is rarely the one whose title you remember — it is the one where a specific thing was said. Search Open Session Tabs searches the conversation itself. Type a phrase, and the engine streams each open session's transcript and matches it against the real exchange — your messages, the agent's replies, the tool calls and their output — then ranks the hits and shows the matching turn with your query highlighted. Click one and that session's tab comes to the front. Title search tells you what a session is called; this tells you what happened in it.
Two ways in from the editor: a keybindable QuickPick (Ctrl/Cmd+Alt+Shift+S) scoped to the tabs open right now, and a content-search box above the dashboard's Sessions list, with a toggle to widen from open tabs to every indexed session. The product CLI runs the exact same engine — session search <query> — so editor and terminal always agree.
searches the conversation body, not just titles · editor QuickPick + dashboard + CLI · ranked, highlighted matches · click to reveal the tab · Pro
A resettable token meter for every client.
If you bill by usage, “how many tokens did this project burn?” is the one question lifetime, today, and 7-day totals can’t answer. The Token Trip Odometer is a trip meter for tokens: start a named trip per client or project and it counts from that moment, independent of every other counter — input, output, and total tokens, elapsed time, and an estimated dollar value to reference on the invoice. Reset zeroes it for a fresh billing window, Close freezes the total, and several trips can run side by side. Trips survive editor reloads and read from the daily token ledger the engine already keeps, so they add no overhead to your requests — whichever coding agent is doing the work.
named trips per client or project · reset / close / resume · tokens + ≈$ estimate per trip · survives editor reloads · zero request overhead
See where every token goes — then stop paying for the wasted ones.
When your coding agent fans work out to sub-agents — and those spawn their own — a session's token cost disappears into a tree you can't see, and you pay for all of it. The Orchestration Token Tree rebuilds that tree from the session transcript already on your disk: every prompt and every nested sub-agent, with input, output, cache-read, and cache-write tokens plus an estimated dollar cost rolled up each branch. Because every branch is priced, waste is quantified, not guessed: in the run shown here, one sub-agent re-reading the same four files cost 1.3M tokens (≈ $4.92). Cut that redundancy and the headroom — and the money — come straight back; leaner context also means fewer context-limit walls, so more gets done per session.
A flame chart makes the waste obvious — bar width is proportional to tokens, so the one runaway sub-agent is the widest bar on the row. The tree updates live while the session runs, prints in the terminal through the product CLI with a cost view and a heaviest-branches list, and exports to any OpenTelemetry backend. No API key: everything is reconstructed from data already on your machine.
every prompt + every nested sub-agent · tokens + ≈$ rolled up per branch · flame chart: the heaviest branch is the widest bar · waste quantified in tokens and dollars — cut the leak, reclaim the headroom and the cost · fewer context-limit walls = more done per session · live as the session runs · same tree in the product CLI + OpenTelemetry export · rebuilt from local transcripts, no API key
One permission floor for every agent you run.
One allow/deny policy for every coding agent you run. A deterministic permission classifier sits in front of each tool call and checks the command against portable rule files: git push --force and rm -rf / are denied; git status and ordinary edits pass straight through. It never calls a model, so it costs zero tokens and gives the same verdict every time. Hosts with their own auto-approve mode get a second check; hosts without one get a hard floor. Run several agents side by side and a force-push or a wiped tree cannot slip through on the one host you never hardened.
Zero-token · portable rule files · fails closed · one policy, every host
Concurrent windows can't clobber settings or rotation state.
Run 10 VS Code windows against one profile list and every one of them read-modify-writes the same two files: the agent's settings file and the live rotation state. Without coordination that is a classic last-write-wins race — two windows flip the active seat in the same instant and one update vanishes, or a half-written settings file lands corrupt. Power Agents serializes every write behind an atomic cross-process lock (O_CREAT | O_EXCL): 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 — the same lock, whichever agent you run.
atomic O_CREAT|O_EXCL lock · one writer at a time for settings + rotation state · stale-lock recovery · zero added dependencies
The state of every seat, the active file, and the agent's permission mode — at a glance.
The editor status bar is the daily dashboard — nothing to open, nothing to run. One item carries the state of every seat you own (healthy / cooling / blocked), today's spend, and the permission mode the agent is running under, with a one-click toggle for the switch compliance cares about most: whether the agent must ask before it acts. A second, per-file item shows how many agent sessions have touched the file you are editing and when the last edit landed — click it to jump straight to those sessions. Terminal-first? The same one-line summary pipes into a tmux status line. You stop asking "is it still working?" and "who touched this file?" — the answer is already on screen.
2 status-bar items · 3 one-click controls · 0 extra panels to open
The full dashboard in your terminal and activity bar — same state, two surfaces.
Every Power Agent ships a full CLI for terminal-first developers and a dedicated activity-bar tree for VS Code, Cursor, and Windsurf — same state, two surfaces. Both read the local data already on your machine: no cloud round-trip, no telemetry.
list renders your live profile table with quota bars, reset times, and active/parallel markers. status is the one-screen system summary. rotate moves the job to the next healthiest seat when you say so. relogin walks a seat back through sign-in without leaving the terminal. doctor runs a 25-check diagnostic.
Scriptable in cron, hooks, and CI. Pretty enough to live on a status board. Check on a run over SSH or gate a pipeline on doctor without opening the editor — no more guessing whether the agent is still working from a box that has no IDE.
40+ CLI commands · grouped by intent · color-tinted status · reads state with zero network calls · same state in terminal + editor
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 one. Default is grok-4; pick another at the prompt or pass --model on the product CLI. The model is told to keep both sides’ intent, and nothing is written until you confirm. Same prompt from the VS Code Command Palette or the product CLI, on every Power Agents host — the resolver is its own engine, so the agent you run does not dictate the model that fixes your merge. Unattended landing never raises this prompt, so a scheduled run is never parked waiting on your answer. Auto-resolve merge how-to.
Default grok-4 · always selectable · nothing written until you confirm · Command Palette + product CLI
Keeps going on the trivial stops — and only the trivial stops.
Coding agents pause constantly on stops that are really just the next obvious step: "Should I continue?", "Now let me wire X", a "remaining: …" list, or a promise to keep going followed by an ended turn. Left alone, an overnight run stalls at the first one. With Auto-Nudge on, the agent finishes the safe work on its own and saves your attention for the calls that are actually yours.
Auto-Nudge decides on your machine first: a stop classifier reads each stop locally and resumes the clear continuations with no model call at all, while genuine stops stay 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 triages item by item: it finishes the parts that are safe and in scope and defers only the parts that need you — a commit, a decision you parked, 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 the Auto-Resume Audit lists every decision.
Deterministic-first — ~96% of stops need no model call · item-level triage on mixed stops · subscription plans, no API key · ↻ marker says why it continued · Auto-Resume Audit · conservative / balanced / aggressive · Pro tier
Tells you when to upgrade — not before.
Whichever agent you run, usage limits are real — and you usually find out mid-task. The recommender reads the rate-limit and usage events already logged from your own sessions on this machine and, once the hits form a pattern, tells you the next best move: favor the seat with headroom, add another, or step up a tier. It is throttled to a weekly budget, so one bad afternoon does not turn into a nag. Everything is computed on your machine, and no telemetry leaves it unless you opt in. You stop buying capacity on a hunch — and stop stalling because you under-bought.
reads your own session logs · suggests the next seat, another seat, or the next tier · weekly throttle · local-only computation · opt-in telemetry only
Export your logs without leaking your credentials.
Every Power Agent exports its own logs as a sanitized bundle for a support ticket, an audit, or a postmortem. Before the tarball is written, a redaction pass strips API keys, OAuth tokens, session secrets, and anything shaped like a credential, then reports what it caught. Two toggles scope what goes in — rate-limit logs and handler logs — and every bundle lands in the export directory you choose, named with a timestamp and a content hash. Share it with confidence. Open the tarball, eyeball it, attach it — no manual scrubbing, no live token sitting in a support thread.
API-key + OAuth + secret redaction · scoped includes · timestamped + hashed · no manual scrub
See every agent edit in VS Code's Timeline.
Here's the gap most people never notice: your coding agent's edits don't show up in VS Code's Timeline. Local History tracks the files you save; git tracks the commits you make. An agent writing files straight to disk slips past both — a blind spot in the editor's built-in history exactly where the agent did the most work. Power Agents closes it. A lifecycle hook registers every agent edit in the built-in Timeline view alongside your manual saves and git commits: one chronological audit trail in the editor sidebar. Click any entry to jump to that point in the file's history. The same hook stamps lifecycle heartbeat markers for the session itself — start and end — into the local session log. All data stays local: tied to snapshot refs in your own git repo, no external storage, and it works even without the host's official VS Code extension.
closes the agent-edit blind spot in Timeline · lifecycle markers in a local log · git-backed · zero external storage
See the full agent 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 local snapshot refs the engine keeps for every session. Reviewers see the reasoning behind every line, not just the line itself. Surface a session graph (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
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. No synthetic data: the measured charts come straight from those logs, and the modelled ones show their inputs under the chart.
Methodology
End-to-end: detect → classify → quota exhausted → rotate. n=307 paired events from handler.jsonl.
Methodology
Modelled, not measured: each account carries its own tokens-per-minute ceiling, so N independent accounts give N× the ceiling. The bars use illustrative bases — Pro 1,000 TPM, Max 1,750 TPM — and your real per-minute limits vary by plan and change over time. The 5-hour session budgets (~44k per Pro, ~220k per Max 20×) are a separate limit; they are compared in the table below, not in this chart.
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. Captured with the opt-in Auto-Rotation Engine enabled (off by default). No telemetry beyond the license check unless you opt in — your key (sent over TLS, stored only as a hash), hashed machine ID, platform, extension version, and aggregate counters, plus hashed anti-abuse signals when you start the no-card trial. Nothing about your work.
What you give up when you babysit the agent by hand.
| Manual log-out / log-in | Power Agents | |
|---|---|---|
| Rotation | ||
| Switch seats | Log out, log back in by hand | Named seats, opt-in rotation |
| Detection trigger | You notice the work stalled | Watchdog rules monitoring continuously |
| Wait time on a wall | A minute or two, every time | Seconds — auto-rewake schedules it |
| Resilience | ||
| Session continuity | You rebuild context yourself | Recovery resumes the same job |
| Trivial "continue?" stops | Type "yes" every time | Auto-nudge clears them |
| Tokens | ||
| Noisy tool output | Paid for, read by the model | Token Saver trims it first |
| Visibility | ||
| Burn-rate visibility | None | Dashboard + runout forecaster |
| Session history | None | Flow explorer + searchable sessions |
| UX | ||
| Editor + terminal surfaces | None — terminal scrollback only | Sidebar, status bar, product CLI |
| Cost | ||
| Monthly cost | Free, but it costs you time | $12/mo per host · 14-day Premium Trial |
CLAUDE · CODEX · GROK · KIMI
Pick the agent you already run.
The same engine ships in every host — proven on Power Claude first. Codex, Grok, and Kimi run the same code; anything still in host validation is labelled on that product page.
Power Claude
Claude Code seats that keep shipping — plus opt-in Claude account rotation, lockout visibility for the Claude usage windows, checkpoints, and optional patches for the official extension.
- 14-day Premium Trial — $0 today, card on file, then the plan price unless you cancel
- Or download free — 7-day, no card
- One license for Power Claude only · matching download
- Host-only extras on the Power Claude page
Power Codex
The same engine under Codex: recovery, Token Saver, watchdog, dashboards, and messaging on the Codex seats you own — shared engine, in validation on Codex.
- 14-day Premium Trial — $0 today, card on file, then the plan price unless you cancel
- Or download free — 7-day, no card
- One license for Power Codex only · matching download
- Host-only extras on the Power Codex page
Power Grok
The same engine under Grok: recovery, Token Saver, watchdog, dashboards, and messaging on the Grok seats you own — shared engine, in validation on Grok.
- 14-day Premium Trial — $0 today, card on file, then the plan price unless you cancel
- Or download free — 7-day, no card
- One license for Power Grok only · matching download
- Host-only extras on the Power Grok page
Power Kimi
The same engine under Kimi: recovery, Token Saver, watchdog, dashboards, and messaging on the Kimi seats you own — shared engine, in validation on Kimi.
- 14-day Premium Trial — $0 today, card on file, then the plan price unless you cancel
- Or download free — 7-day, no card
- One license for Power Kimi only · matching download
- Host-only extras on the Power Kimi page
Pick the agent you already run.
Claude, Codex, Grok, or Kimi — the same engine, one license per host.
Premium Trial: card on file, $0 today, 14-day — locks the founder rate for 2 years. Or download free: 7-day, no card.
Neural-LLM is an independent software company. We are not affiliated with, endorsed by, or sponsored by Anthropic, PBC, OpenAI, xAI, or Moonshot AI. Power Agents products are third-party tooling. Claude™, Codex™, Grok™, and Kimi™ are trademarks of their respective owners, used here only to identify the software each product works with.