PwrAgent
  • macOS · universal
  • Windows · x64
  • Linux · deb
  • MIT
  • no account · no telemetry

Your coding agent, driven from your phone.

An open-source desktop coding agent that runs on your laptop, where your checkout and your credentials already are. Pair it once with Telegram, Discord, Slack, Mattermost, Feishu / Lark, or LINE — then start, resume, steer, and approve from wherever you happen to be reading. No cloud relay, no account, no telemetry.

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 · not affiliated with OpenAI

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.
The desktop with four messengers paired — Telegram, Discord, Slack, Mattermost — and per-thread controls live.

Features

The agent stays home. You don't have to.

Your laptop already has the checkout, the toolchain, and the credentials. PwrAgent leaves the work there and moves only the steering wheel — into the messenger you're already reading on the couch, on the train, in a queue.

  • Code keeps moving when you're away from the keyboard

    Approvals, follow-up prompts, "what did you ship while I was at lunch" check-ins — all from your phone. The agent runs on your laptop where it belongs. Your messenger is the steering wheel, not the engine. Works fine on cellular and on hotel WiFi that drops every two minutes.

    • start · resume · steer · approve
    • cellular-friendly
    • laptop does the work

  • 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

  • Isolated profiles for work, personal, side projects

    Open as many PwrAgent windows as you want, each on its own profile, each bound to its own Codex identity. Work threads in one window, personal in another, the side project in a third. Threads, authentication, and messaging credentials never cross.

    • one window per profile
    • separate Codex identity
    • --profile <name>

  • Works alongside Codex Desktop

    Shares thread state with Codex Desktop by default — start a thread in either app, finish it in the other. When you want isolation, profiles handle it. PwrAgent adds per-thread model / access / fast-mode controls, worktree isolation with handoff, a Markdown composer, and the messaging surface — things Codex Desktop doesn't have today.

    • shared thread store
    • per-thread model · access · fast mode
    • worktree isolation + handoff
    • Markdown composer

  • No cloud, no account, no telemetry

    PwrAgent runs entirely on your machine. State lives under ~/.pwragent/. Bot tokens are encrypted at rest by your operating system's own credential store. There's no PwrAgent-owned server in the loop — the messenger talks to your laptop, your laptop talks to Codex.

    • ~/.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 · no telemetry
    • 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 agent runs on your laptop, next to your checkout. Threads, settings, and credentials live under ~/.pwragent/. There is no PwrAgent-owned server in the loop: your messenger talks to your laptop, and your laptop talks to Codex — the same Codex sign-in and the same plan you already pay for.

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. Thread history and settings live under ~/.pwragent/profiles/<name>/; your code stays in the checkout it was always in. Never leaves
Agent requests Through the Codex install on your machine to the provider it is signed in to, billed to the plan you already have. PwrAgent holds no model key and runs no server of its own. Your Codex plan
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, then pair a bot from Settings → Messaging with a one-time code — no IDs to look up, no JSON to paste. 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.
    • Checksums ship next to every release as PwrAgent-windows-SHA256SUMS.

  • 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.

PwrAgent is in beta, and the messaging surface is stable enough for 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? Switch to the Beta channel in Settings. Older versions, release notes, and checksums live on GitHub Releases.

FAQ

Things you might ask.

  • Do I need an account?

    No. Download, install, pair. There is no sign-up, no license key, and no PwrAgent server to sign in to. The agent itself runs on the Codex sign-in you already have, billed to the plan you already pay for.

  • 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 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. 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 model / access / fast-mode controls, worktree isolation with handoff, and a Markdown composer. When you want the two kept apart instead, profiles handle it.

  • Where does my data live?

    Everything is under ~/.pwragent/ — thread history and settings in ~/.pwragent/profiles/<name>/, one directory per profile, on every platform. 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. Pick a Stable or Beta channel in Settings; Stable only ever resolves to a suffix-free stable release, so an alpha or prerelease build can't land on a Stable install. If a channel 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.