Open source · local-first · bring your own subscription

Mission control for every repo you're shipping.

You don't work in one repo — you've got eight, each with failing checks, open PRs, half-finished agent sessions. Polaris is the desktop command center that shows what needs you across all of them, and dispatches the work back.

$ go install github.com/Scarcrux/polaris/cmd/polaris@latest
Polaris — Command Center
The Polaris command center: a command inlet to message a project or broadcast a goal, live fleet status, and a cross-project attention list showing which repos need review or have failing checks.
One native macOS window A single Go binary underneath claude · codex · gemini · aider No hosted backend, no telemetry

The interface

Not another coding agent. The window that runs them all.

Every tool is great inside one project and blind across them. Polaris lives above all of them — one surface for status, review, planning, and dispatch.

Plan

One roadmap across every project

A cross-project kanban board. Drag a card to restatus and it writes straight back to that project's roadmap, comment-preserving.

  • Later / Next / Now / Done, every repo in one view
  • Task checklists, due dates, and GitHub-issue links
  • Author locally, sync up — never the system of record you can't leave
Roadmap
A cross-project kanban roadmap board with Later, Next, Now, and Done columns holding cards from several repositories, some with task checklists and issue links.

Review

Review agent work like a teammate

Every PR awaiting you, across repos, in one inbox. Open the diff, get an AI review, and post it back to GitHub as a real review — approve, comment, or request changes.

  • PRs from all your projects, not one repo at a time
  • AI review that becomes a genuine peer-review participant
  • Secret-redacted diffs, staging, and inline commentary
Peer review
A peer-review inbox listing pull requests from multiple projects with author, age, and branch, ready to open and review.

Context

Every agent session, one map

claude, codex, and gemini sessions across all your repos, drawn as a single graph. Jump into any project's chat, code, activity, and roadmap from one window.

  • Agent-agnostic — coordinate them, don't marry one vendor
  • Per-project chat with tools, diff review, and recipes built in
  • Cross-project memory: recall how you solved it in another repo
Session graph
A constellation-style graph of coding-agent sessions across projects, each conversation drawn as a branching chain of nodes.

Insight

Know where the work actually went

Commits, finished agent runs, check transitions, and deploys — an activity feed and rollups across projects, plus a weekly digest. No timesheet.

  • A cross-project activity feed, newest first
  • Per-project throughput at a glance
  • Real Claude usage in the menu bar, from your subscription
Activity
A horizontal bar chart of activity by project, showing relative commit and run counts across five repositories.

Why it's different

Four things a single-repo tool can't do

Because they live inside one project — and this lives above all of them.

Cross-project

What needs you, everywhere

One attention-bucketed view across every repo: failing checks, PRs to review, agents awaiting approval. Answers "what should I do right now?", not "what's happening."

Agent-agnostic

Route the best agent per project

claude, codex, gemini, copilot, aider — per project or per task. Polaris coordinates them; it isn't tied to any one vendor's agent.

Unattended, safely

Run to a goal without babysitting

Autopilot works in a throwaway git worktree (never your tree), refuses "done" until your tests pass, and is seeded with how you solved it in your other repos. Guardrails before autonomy.

Local-first

Your data never leaves your machine

A single Go binary. No accounts, no hosted backend, no telemetry. Bring your own Claude subscription. On-device and local models are first-class for cost + privacy.

Under the hood

The same power, fully scriptable

The app owns no business logic — it's a shell over one local binary. Everything the window does is also a keyboard-first command, so it drops straight into your shell, pipes, and cron.

$ polaris status                      # "what needs me right now?" across every repo
$ polaris open backend --agent codex  # route the best agent per project

# Run it unattended, safely: isolated git worktree, gated on tests,
# seeded with how you fixed this in your other repos.
$ polaris autopilot api "fix the retry race" --worktree --verify "go test ./..."

$ polaris recall "flaky retry"        # how did I solve this before? (any repo)
$ polaris status --json | jq          # --json on every verb; ~80 of them

Try it now

See it work — in your browser, no signup

Two demos that run 100% client-side. No server, no tokens spent.

One binary. Every repo. On your machine.

Install it, point it at ~/Code, and see what needs you.

$ polaris scan && polaris status