Features

Everything Polynomic does

Polynomic is the control plane for agentic coding. It handles the loop from idea to merged code: capture tasks in a keystroke, shape them with AI, dispatch agents into managed worktrees, approve their tools from one hub, review the diff, and merge — all without leaving the keyboard. Run the whole loop on many tasks at once and always know what needs you next.

Download for macOS Read the docs

Task management

You manage Tasks; agents do the work behind them. A Task spans your repos, references the exact code it touches, runs an Agent Session to implement itself, and produces a reviewable diff before anything merges.

polynomic — Tasks
Search tasks
POL-156 Add Code-Tree filter to task list Todo
POL-189 MCP token scoping per session In Progress
POL-192 Event-sourced projection rebuild In Review
POL-201 Native sandbox integration Changes
POL-178 Keyboard shortcuts help modal Done

Capture anywhere

Press c from anywhere and a task is captured in seconds. No forms, no triage tax. Open the command palette with ⌘K to capture from there too.

Organize and filter

View tasks as a List or Board (kanban, drag-to-change-state). Organize with initiatives, labels, priority, and assignee — all filterable from the sidebar. The Code-Tree view rolls up task counts per file and directory, so you can filter by the part of the system the work touches.

Event-sourced ledger

A Task is an event ledger, not a row you mutate. Every change — status, comments, edits, code refs — is an immutable Event, and the state you see is a projection folded from those events. The Ledger is append-only and rebuildable at any time.

Agent Sessions

Starting a Task builds a Workspace and spawns a real claude process in an embedded terminal you can watch or type into. Sessions are resumable, and orphans are reconciled when you reopen a project.

POL-189 — Agent Session
✓ Reading MCP server implementation...
✓ Analyzing token scoping requirements
●
Editing src/mcp/server.rs
Adding per-session token validation...
Session running · Press Enter to console in

Real claude process

Polynomic spawns the actual claude CLI in an embedded terminal. You can watch its progress in real time or console in to provide input. Sessions persist across app restarts.

MCP integration

The agent talks to Polynomic over a loopback MCP server, scoped to its Task by a token. It can read and update the Task, add comments, create sub-tasks, and report when it needs attention. Polynomic verifies against real commits before transitioning states.

Plan or implement

Start in plan mode for a Planning Session (shape scope, pin files, break out sub-tasks) or start directly in implementation mode. The choice is a keystroke: x implements, ⇧P plans.

Pop out to external terminal

Detach a running session from the embedded terminal and continue it in iTerm, Ghostty, or Terminal.app. The agent resumes with the same session and MCP connection — come back to Polynomic when you're done.

Token cost tracking

See exactly what each task costs. Token usage (input, output, cache) is tracked across all sessions and displayed as an estimated USD cost in the task header and a full breakdown in the sidebar.

Multi-repo support

Real work spans repos. A Task can touch multiple repos in a Project, and Polynomic lays a git worktree of each one side by side in a single Workspace. One agent session gets full cross-repo context.

POL-189 — Workspace
polynomic

worktree · pol-189

3 files changed
polynomic-cli

worktree · pol-189

2 files changed
Agent Session rooted at Workspace

Editing src/mcp/server.rs and src/token.rs across both repos…

~/.polynomic/workspaces/189a4c2b/

Automatic worktrees

When you Start a Task, Polynomic builds a polynomic/<id>-<slug> branch and worktree for each touched repo, all laid side by side in ~/.polynomic/workspaces/<task-id>/.

Unified workspace

The agent is rooted at the Workspace directory, so it sees all touched repos at once without switching branches or juggling paths. Cross-repo edits just work.

Per-repo diffs

Every Task produces a reviewable branch diff per repo. Review each diff independently, then merge each repo's branch back to its default branch when you approve.

Centralized tool approvals

When agents want to run a command, edit a file, or hit the network, the request queues quietly in one central hub — across every running session. Press a from anywhere to triage them all.

Tool Approvals
POL-189 Edit src/mcp/server.rs
POL-201 Bash cargo build --release
POL-156 Edit src/ui/task_list.rs
POL-192 Bash cargo test ledger::

Unified queue

The approval center is a triage surface, not a one-shot popup. A left rail lists every pending request — tool name, the Task it belongs to, and the command or path at a glance. The right pane shows full details and working directory.

Three decisions

Allow a permits this one call. Allow always ⇧A remembers the decision for the session. Deny d rejects the call.

Read-only auto-approved

To keep the center signal-rich, read-only and clearly safe tools skip it entirely: file reads, searches, web search, and a small allow-list of read-only git commands run without a prompt.

Code References

Point Tasks at code with @repo/path syntax — autocompleted over git ls-files. References resolve live and are marked stale when their target moves, so a Task always knows the files it concerns.

POL-189 — Code References
Referenced files 4 files
polynomic/src/mcp/server.rs
polynomic/src/session/mod.rs
polynomic-cli/src/token.rs
polynomic-cli/src/auth/verify.rs stale
Type @ to add more files

Live resolution

References are resolved against the real filesystem on every view. If a referenced file is renamed or deleted, the reference is marked stale so you know immediately.

Code-Tree view

The Code-Tree rolls up task counts per file and directory. Filter the task list by clicking a file or folder to see only tasks that touch that part of the system.

Agent context

When an Agent Session starts, it receives the Task's code references so it knows exactly which files the work concerns. This pins the agent's focus and reduces hallucination.

Global chat

A project-wide AI chat panel accessible from any view — independent of any specific task. Ask questions, explore ideas, or get advice without creating a task. Press ] to toggle it from anywhere.

Chat
How does the MCP token scoping work in our codebase?
Each agent session receives a unique token when spawned. The MCP server validates this token on every request, ensuring sessions can only access their own task…
3 sessions in history Press ] to close

Independent of tasks

Global chat is scoped to the project, not a task. Use it for quick questions about the codebase, architectural discussions, or working through a problem before you're ready to capture a task.

Session history

Each conversation is a separate session. Click the clock icon to see past sessions listed by title and time, or start a new chat with the compose button. Sessions persist across app restarts.

Cloud Sync

Sync your project's event ledger to the cloud for team collaboration and multi-device access. Built on Hybrid Logical Clocks for conflict-free merging — no manual conflict resolution needed.

Settings — Cloud Sync
Synced Last synced 4s ago
polynomic-team 2 members

polynomic-server.fly.dev

Team collaboration

Multiple users can join the same cloud project. Each instance syncs independently — task creates, status changes, comments, and sessions all replicate across the team in real time.

Hybrid Logical Clocks

Events are ordered using HLCs, ensuring conflict-free merging without central coordination. Your local ledger and the cloud converge deterministically regardless of network conditions.

Still local-first

Cloud sync is optional and additive. The local SQLite ledger remains the source of truth — the app works fully offline and syncs when connectivity returns. Your code never leaves git.

Review & merge

Nothing reaches your main branch until you've seen it. Every Task produces a per-repo branch diff with Review Comments you can anchor to a file and line. An independent AI Review reads the diff and posts comments. It never changes state or merges anything.

polynomic/src/mcp/server.rs — Diff
@@ -42,8 +42,11 @@ impl McpServer {
  pub fn handle_request(&self, req: Request) {
+   let token = req.headers().get("X-Task-Token");
+   if !self.verify_token(token) {
+     return Err(McpError::Unauthorized);
+   }
    self.dispatch(req)
  }

AI Review

Token verification looks good, but consider what happens if get("X-Task-Token") returns None. The verify_token signature should handle Option explicitly.

R Request changes M Rebase & merge

Independent AI Review

A fresh, headless /review session — not the original agent — reads the diff and posts line-level comments. It's an independent perspective with no memory of the implementation.

Request changes

Add your own review comments, then press r to request changes. The Task routes to a Changes state. Run an AI Fix to resume the original Agent Session with your comments, or console in yourself.

Guarded local merge

Press m to rebase the branch onto the freshly-fetched base and merge locally with --no-ff. Conflicts route to Needs Attention; on success the worktrees clean up automatically.

Keyboard-first interface

Polynomic is built for speed. Command palette, single-key shortcuts, vim-style navigation. Capture, dispatch, review, and merge without reaching for the mouse. Press ? in the app for the full shortcut list any time.

Open command palette ⌘K
Capture a task c
Start task (implement) x
Start task (plan mode) ⇧P
Open tool approvals a
Request changes r
Rebase & merge m
Change status s
Navigate list j / k
Open selected task Enter
Search tasks /
Show keyboard help ?

Local-first architecture

Everything is local. Your tasks, events, and code references live in SQLite — one Ledger database per Project — kept entirely separate from your git repos. No cloud dependency, no API keys, no seat fees. Your source stays in git; your task data stays separate; you own both.

~/.polynomic/projects/4a8c2e1f/
polynomic.db 42.3 MB
•
events table
Append-only event stream
18,493 rows
•
task_projection
Folded from events
247 rows
•
code_refs
Live file references
1,089 rows
No external dependencies
All data stored locally · Event-sourced · Rebuildable

SQLite Ledger

One polynomic.db file per Project, stored in ~/.polynomic/projects/<project-id>/. The Ledger is append-only: every status change, comment, edit, and code reference is an immutable Event.

Separate from git

Task data never touches your git repos. Your source stays clean, and you can delete the Ledger without losing any code. Code References are resolved live from git, not stored paths.

Event-sourced projections

Current state is a projection folded from the Event ledger. Projections are pure caches: they can be dropped and rebuilt from the Ledger at any time. An append writes the Event and re-folds the projection in one transaction.

Native isolation

Beta

Run agents truly unattended with OS-enforced sandboxing. Wrap each Agent Session in a macOS Seatbelt sandbox or Apple container VM and let it run with --dangerously-skip-permissions. The OS draws the boundary, not a prompt you have to answer.

Seatbelt sandbox

The default. Wraps the entire claude process in a macOS Seatbelt sandbox via @anthropic-ai/sandbox-runtime. Process-level isolation that runs on any macOS with no extra install, and keeps the agent on your real toolchain.

Apple container

The stronger boundary. Runs the agent inside a lightweight Linux VM per session via Apple's container CLI (Virtualization.framework) — kernel-level isolation. Used when a Project names a Linux agent image. Requires Apple Silicon + macOS 26+.

Opt-in per Project

Turn it on per Project with a Sandbox toggle (off by default while in beta). Once on, sandboxed sessions skip the Tool Approvals center entirely and run start-to-finish without a click. Everything downstream is unchanged: sessions still land commits on branches, and you still review the diff before it merges.

Everything you need to run a parallel agentic fleet

Capture, shape, dispatch, approve, review, and merge — all from the keyboard, all local-first, all in one place.

Download for macOS Read the docs