PwrAgent
  • macOS · universal
  • Windows · x64
  • Linux · deb
  • MIT
  • Codex · Gemini · Grok · Kimi · Qwen

Run coding agents by the dozen.

An open-source desktop for running coding agents on machines you own. Start threads across every repo you have, each in its own git worktree so they never collide, on Codex, Grok, Kimi Code, or Qwen Code — whichever CLI you already pay for. Let one agent hand work off to a thread on another. Watch the diffs, track the PRs, and steer any of it from Telegram, Discord, Slack, Mattermost, Feishu / Lark, or LINE when you're nowhere near the keyboard.

Download for macOS Read the docs

Universal build (Apple silicon + Intel) · macOS 12 Monterey or later · signed and notarized, one Gatekeeper prompt on first launch

Other platforms

Free · MIT · built by PwrDrvr LLC

PwrAgent desktop in use — Directories lens grouping threads across two repos, a thread mid-conversation, four messenger status icons in the title bar, per-thread model / access / fast-mode / worktree controls above the composer.
Threads grouped by repo in the Directories lens, one of them mid-turn, with the per-thread provider / model / access / worktree controls above the composer — and four messengers paired in the title bar.

Features

One agent is easy. Twelve is the problem.

The hard part was never getting an agent to write code — it's keeping hold of six of them at once, across four repos, without stepping on each other's branches or losing track of which ones are finished. That's the app.

  • Runs whichever coding agent you already have

    Codex is the default. Point a thread at Grok, Kimi Code, or Qwen Code instead and PwrAgent drives that CLI over the Agent Client Protocol — the copy already installed on your machine, signed in to the account and plan you already pay for. The provider is a dropdown in the composer when you start a thread, sitting next to the model, access-mode, and fast-mode controls. PwrAgent opens no account, holds no model key, and adds nothing to your bill. It doesn't sandbox those CLIs either: an installed agent is a third-party local executable with its own credentials and its own reach, and PwrAgent says so rather than pretending otherwise.

    • Codex · Gemini · Grok · Kimi · Qwen
    • provider picked per thread
    • your CLI · your sign-in · your plan
    • no PwrAgent key

  • One agent can put the others to work

    A thread doesn't have to do everything itself. PwrAgent exposes its own tools to the agent running in it, so a thread can hand a task off to a different thread — and name the backend when it does. Put a strong reasoning model in charge of the plan and let it farm the mechanical passes out to cheaper threads on another agent entirely. It can also attach a directory, move a thread's workspace, kick off a review, or message another thread mid-run.

    • handoff_task · cross-backend
    • start_review
    • send_message_to_thread
    • sub-agents visible in the transcript

  • Stack three asks and walk away

    Send make a branch and PR for the OAuth refactor, then queue /review main, then queue squash and force-push. The composer dispatches them FIFO, one turn at a time. You walk away. By the time you come back, three things are done.

    • FIFO queue
    • one turn at a time
    • steer mid-turn
  • Beta channel

    Swarms that span every machine you own

    One laptop is a small fleet. Federation pairs separate PwrAgent instances — the desktop at home, the workstation at the office, a box in a closet — over an encrypted control channel, and from then on each can see and drive the other's work. Mount a remote thread in a viewer window with its transcript live, open an integrated terminal on the far machine, and search every connected instance at once with Command+K (Control+K on Windows and Linux). The Star Map puts the whole fleet on one screen — threads in orbit around the projects they belong to, per-machine load, filter chips, and fly-to-thread when you spot the one you want.

    This is the newest work in the product and it ships on the Beta release channel today, not Stable. Switch channels in Settings → General → Updates if you want it now.

    • encrypted instance-to-instance
    • Tailscale · Cloudflare Tunnel · SSH · local
    • remote threads + remote terminals
    • Star Map

  • Steer it from wherever you happen to be

    Pair a bot once and the whole thing follows you out of the house. Approvals, follow-up prompts, "what did you ship while I was at lunch" check-ins — from Telegram, Discord, Slack, Mattermost, Feishu / Lark, or LINE. The agents keep running on your machine; the messenger is only the steering wheel. Fine on cellular and on hotel WiFi that drops every two minutes.

    • six platforms
    • start · resume · steer · approve
    • closed by default

  • Isolated profiles for work, personal, side projects

    Open as many PwrAgent windows as you want, each on its own profile, each with its own Codex sign-in. Work threads in one window, personal in another, the side project in a third. Thread state, settings, and messaging credentials never cross.

    • one window per profile
    • separate Codex sign-in
    • --profile <name>

  • Your code and your credentials stay where they are

    The agents work in the checkout they were pointed at, on the machine that already has your toolchain and your keys. PwrAgent's own state sits under ~/.pwragent/, one directory per profile, and bot tokens are encrypted at rest by your operating system's credential store. Messaging is closed by default: only user IDs you allowlist can reach the bot, and shared spaces need the space and the user. Details in Privacy.

    • ~/.pwragent/
    • OS-encrypted tokens
    • closed by default
    • two-keyed allowlists

  • Free, MIT-licensed, dogfooded

    The author uses it as their primary coding environment. Hundreds of PRs in this repository and others were created or reviewed through PwrAgent. It's signed on every platform, and free. The full source — Electron app, messaging adapters, replay test harness — is on GitHub. Same philosophy as its sibling, PwrSnap.

    • MIT
    • signed on all three platforms
    • single contributor
    • hundreds of PRs shipped

Privacy

Nothing leaves your machine unless you say so.

There is no PwrAgent cloud. The agents run on your own machines, next to your checkouts. Settings and credentials live under ~/.pwragent/. There is no PwrAgent-owned server in the loop: your messenger talks to your machine, and your machine talks to the agent CLI you picked for that thread — on the sign-in and the plan you already pay for, whether that's Codex, Grok, Kimi Code, or Qwen Code.

Federation is between machines you enroll, and nobody else. When you pair two PwrAgent instances, they talk to each other directly over an encrypted channel on a transport you choose — your LAN, Tailscale, a Cloudflare Tunnel, or SSH. There is still no PwrAgent-operated relay in the middle, and an instance you haven't enrolled cannot see anything. It's off until you set it up.

Messaging is closed by default — and stays that way. Only platform user IDs you have explicitly allowlisted can reach the bot. Inside shared spaces (Slack workspaces, Discord servers, Telegram supergroups) authorization is two-keyed: the space has to be on the allowlist and so does the user. Inviting the bot into a workspace doesn't authorize anyone in it. Unauthorized attempts are denied and surfaced in the messaging activity log, so you can see who tried and from where.

What leaves your machine
DataWhere it goesDefault
Threads, prompts, your code Nowhere. PwrAgent's own state — thread metadata, settings, messaging bindings — lives under ~/.pwragent/profiles/<name>/. Transcripts stay in the agent CLI's own store, on the same machine. Your code stays in the checkout it was always in. Never leaves
Agent requests Through the agent CLI you picked — Codex, Grok, Kimi Code, or Qwen Code — to the provider that CLI is signed in to, billed to the plan you already have. PwrAgent holds no model key and runs no server of its own. Your agent's plan
What a turn costs Shown to you, not reported anywhere. PwrAgent estimates each turn and thread from the providers' published rates and displays it next to the transcript; you can set a spend alert on a turn or a thread. The estimate is computed locally and never sent. Local estimate
Messenger traffic Between your laptop and the platform you paired — Telegram, Discord, Slack, Mattermost, Feishu / Lark, or LINE — exactly like any other message you send there. No PwrAgent relay sits in the middle. Only what you send
Bot tokens Nowhere. Encrypted at rest through Electron safeStorage, which hands off to your OS credential store — Keychain on macOS, DPAPI on Windows, libsecret / kwallet on Linux. Never leaves
Update check A plain HTTPS request to GitHub's release feed. No account, no device ID. GitHub only
Telemetry, analytics, crash reports None. There is no PwrAgent server to send them to. Never

Install

Up and running in five minutes.

Signed builds for macOS, Windows, and Linux, straight from GitHub Releases. Install it, point it at a repo, and start a thread on whichever agent CLI you already have — the first-run wizard walks through providers, profiles, and (if you want it) pairing a messenger with a one-time code. Per-platform walkthroughs live in the docs.

  • macOS

    Most tested
    Download .dmg
    • Universal binary — native on Apple silicon (M1+) and Intel.
    • macOS 12 Monterey or later.
    • Developer ID-signed and notarized by Apple: first launch is one Gatekeeper prompt, no right-click-open dance.
    • Open the DMG, drag PwrAgent to Applications, launch it.
    • The largest desktop end-to-end test matrix of the three, and the author's daily driver.

  • Windows

    Download .exe
    • x64 installer for Windows 10 and 11.
    • Authenticode-signed by PwrDrvr LLC through Azure Artifact Signing — SmartScreen sees a known publisher.
    • Per-user install under your profile; no admin prompt, and you can pick the install directory.
    • Native window chrome, process-tree cleanup, and Git-for-Windows command execution are all wired up.
    • Verify before you run it: right-click the installer → Properties → Digital Signatures should name PwrDrvr LLC.

  • Linux

    Download .deb
    • Debian packages for x64 and arm64.
    • Install with sudo apt install ./PwrAgent-linux-x64.deb.
    • Desktop launcher integration, so it shows up in your application menu.
    • Stable download aliases, so the URLs above always point at the latest release.
    • SHA256SUMS published with every release.

Downloads track the Stable channel, and the messaging surface carries daily use — the author's own work depends on it. The honest roadmap lists what's still missing. Want what's next before it's stable? Settings → General → Updates has two controls: a release channel (Stable or Beta) and an update track (Latest or Prerelease). Older versions, release notes, and checksums live on GitHub Releases.

FAQ

Things you might ask.

  • Do I need an account?

    Not a PwrAgent one. Download, install, pair: there is no sign-up, no license key, and no PwrAgent server to sign in to. What you do need is an agent CLI on your machine that you're already signed in to — Codex, Grok, Kimi Code, or Qwen Code — and the work is billed to that plan, exactly as it would be if you ran the CLI in a terminal yourself.

  • Which platforms does it run on?

    macOS, Windows, and Linux — all three are supported, all three ship signed builds with every release. macOS is the most tested: it carries the largest desktop end-to-end test matrix in CI and is the author's daily driver. Windows and Linux are real targets rather than build-only artifacts — both have had substantial work and a long tail of fixes, and both are exercised on every change.

    macOS needs 12 Monterey or later; Windows is x64 on 10 and 11; Linux ships Debian packages for x64 and arm64.

  • Which coding agent does it run?

    Whichever of these you already have installed: Codex, Grok, Kimi Code, or Qwen Code. Codex is the default — a new thread lands there when it's available — and the others are driven over the Agent Client Protocol. Each one appears in Settings → AI Providers whether or not it's installed, so you can see at a glance what PwrAgent found and where; when you start a thread, the provider is a dropdown in the composer next to the model, access-mode, and fast-mode controls. Nothing is installed on your behalf: PwrAgent looks for the CLI on your PATH and in each vendor's usual install directory, and you can point it at an exact binary instead.

    PwrAgent adds no key and no account of its own — the request rides the CLI's own sign-in and bills to your plan. Worth knowing what that means for trust: an installed agent CLI is a third-party program running as you, with its own credentials and its own filesystem and network access. PwrAgent mediates the permission prompts it's asked to mediate; it is not a sandbox around someone else's binary.

  • What does it cost to run?

    PwrAgent itself is free, and it adds nothing to your bill: no PwrAgent API key, no markup, no metering. The model usage is whatever your agent CLI would have cost anyway on the plan it's signed in to — a personal subscription, a pay-as-you-go key, or a company plan.

    Because that's the part with a number attached, PwrAgent shows it. Each turn and each thread carries a running estimate computed from the providers' published rates, optionally alongside a Codex Credits estimate, and you can set a spend alert that fires when a single turn or a whole thread crosses a threshold you pick. It's an estimate at list prices, computed on your machine — the app says as much where it shows it, and real billed usage can differ.

  • Which messengers can I use?

    Six: Telegram, Discord, Slack, Mattermost, Feishu / Lark, and LINE. You pair a bot from Settings → Messaging → <your platform> with a one-time code — no IDs to look up, no JSON to paste. One workflow layer drives all six from the same code path, so a thread behaves the same wherever you're reading it. End-to-end setup for each platform is in the docs.

  • Is this safe to use for work?

    The controls are built for it: messaging is closed by default, only allowlisted user IDs can reach the bot, and shared spaces are two-keyed — the space and the user both have to be allowlisted. Inviting the bot into a workspace authorizes nobody. Every denied attempt shows up in the messaging activity log. Secrets are encrypted at rest by your OS credential store, and the agent's permission mode is set per thread.

    What the project can't tell you is whether your employer's policies permit any of this. Research and comply with your company's policies before installing PwrAgent on a work machine or connecting it to a work messaging platform — use your employer's approved platform, and walk the integration through your security team first. That call is yours, not the project's.

  • Does this replace Codex Desktop?

    No — it sits alongside it. On Codex threads PwrAgent uses Codex's thread store, its authentication, and its agent, so a thread started in either app shows up in the other. What PwrAgent adds on top is the desktop UI, the messaging surface, profile isolation, per-thread provider / model / access / fast-mode controls, worktree isolation with handoff, and a Markdown composer. When you want the two kept apart instead, profiles handle it. Threads you point at another agent are that agent's, and Codex Desktop never sees them.

  • Where does my data live?

    On your machine, in two places, both local. PwrAgent's own state — thread metadata, settings, messaging bindings — is under ~/.pwragent/profiles/<name>/, one directory per profile, on every platform. The transcripts themselves belong to the agent CLI and stay in its store, which is why a Codex thread opens the same in Codex Desktop. Bot tokens are encrypted at rest through Electron safeStorage, which hands off to your OS credential store (Keychain, DPAPI, or libsecret / kwallet) rather than leaving them in a config file. Your code never moves: the agent works in the checkout it was pointed at. Launch a second profile with --profile <name> and nothing crosses between them.

  • How do updates work?

    PwrAgent checks GitHub's release feed and offers the update in-app. Settings → General → Updates has two controls that compose: a release channel — Stable, the smoke-checked train, or Beta, which follows development — and an update track — Latest, also smoke-checked, or Prerelease, which is newer and may not install. New installs sit on Stable + Latest, so an alpha build can't land on you by accident. If a switch would move you backwards, the app offers that explicitly rather than telling you you're up to date with no way back. Linux .deb installs are upgraded manually from the stable download links above.

  • Is it really free? Who's behind it?

    Free and MIT-licensed, with the full source — Electron app, messaging adapters, replay test harness — on GitHub. PwrAgent is built by PwrDrvr LLC: one author, who uses it as their primary coding environment, alongside its sibling, PwrSnap. No investors, no upgrade tier, no plan to add one.

Something else? Open a GitHub issue or ask @PwrAgentAI.