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.
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.
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 coding-agent process — Claude Code or Codex — in an embedded terminal you can watch or type into. Sessions are resumable, and orphans are reconciled when you reopen a project.
A real CLI, in a real terminal
Polynomic spawns the actual coding-agent CLI in an embedded terminal. You can watch its progress in real time or console in to provide input. Sessions persist across app restarts.
Claude Code or Codex
The harness a session runs is chosen per step, task or project, and it applies to everything — a Codex task is also reviewed, questioned and planned by Codex. Polynomic branches on what a harness can do, never on its name, and says out loud when one can't do something rather than quietly running without it. One circuit can implement with one vendor's agent and review with another's: two models from the same lab share blind spots, two from different labs share fewer.
One agent, several logins
An Agent Config is a named config home — its own credentials, settings, skills and plugins — picked per project, so a work project and a personal one run the same agent as two different people. A project stores the config's name, which is the part that travels; the path and the credential stay on the machine they belong to.
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.
Circuits
Starting a task used to mean one fixed sequence: cut a worktree, run an agent, review, merge. A Circuit makes that sequence yours — typed Steps, written as a tree you edit from the keyboard or wired as a graph, that you choose before you Start. It can be a single agent run, exactly what Start always did, or it can retry, branch, and run steps in parallel — and a Trigger can start one on a schedule while you sleep.
Merge this work?
Both reviewers passed. Approve to merge.
Tree Circuits, written as an outline
Inspired by behaviour trees: Control Steps with plain names —
In order,
First that works,
Together,
Race,
Retry ×3,
Timeout,
Budget,
If / Else — decide
when the work at the leaves runs. Every step succeeds or fails with
a reason, so a failure that reaches the top lands the Task in Needs
Attention saying why, with no error wiring. Any step can clean up
after itself with On failure,
and a fix pass can quote exactly what the reviewers found with
{{failure}}.
You build it in a keyboard-first outliner, and a running tree is
shown as the tree you wrote.
Simulate, retry from here, and see what works
Simulate plays a circuit before any Task runs it: you say how each step went and watch what the circuit would do, with undo and rewind. Retry from here reopens a failed run at the step that failed, keeping everything that already succeeded. And Insights lays each step's record over the tree — how often it works, how long it takes, how many retries it needs, and where runs fail — read straight from your own Ledger.
Triggers and the Circuits home
A Trigger starts work without you pressing Start — “every Monday at 09:00”, when an Action fails, or when you ask the chat. It makes a Task from a template and starts it, so what it did is an ordinary Task you can read and review. Circuits can ask an agent questions that aren't code, make tasks, and propose work for you to keep or discard, which is how Weekly research turns a Monday-morning scan of the market into tasks you chose. ⌘⇧C opens the Circuits home: what is running now, what fires next, and what just finished, all from the keyboard.
Graphs, for parallel steps, branches and bounded loops
Two wires out of the same output run at the same time — that's the whole mechanism for parallelism, no special syntax. Each step finishes on a named output and the wire from it decides what happens next, so branches can rejoin and the step where they meet fires exactly once. Wire a step back to an earlier one and you have a loop; guard it with a condition on attempts and it stops itself. Every circuit also has a hard step limit, so a mis-wired loop fails in seconds rather than burning tokens all night.
Built-ins in both shapes, and a designer for the rest
Standard is the old fixed pipeline drawn as a graph, and it's the default — you never have to open the designer. Implement, evaluate, fix shows what the graph is for: two reviewers read the same diff at once, and a failure loops back to a fix pass that resumes the original conversation, bounded at three rounds. Each has a tree twin, beside Work sub-tasks, Unattended and Weekly research. Press ⌘⇧C then d to write your own — or just describe it to the Circuit Assistant.
Runs survive quitting the app
A run isn't held in memory — it's recorded in the Ledger, one Event per step boundary. Close Polynomic mid-run and it picks up at the step it was on: an agent that was mid-thought is offered for you to resume, an unanswered question is still waiting. Each run also carries a snapshot of the circuit it started with, so editing one never disturbs work already in flight.
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.
worktree · pol-189
worktree · pol-189
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.
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.
@ 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.
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.
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.
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.
Independent AI Review
A fresh, headless session — not the agent that wrote the code — reads the diff and reports two things: one anchored, rated finding per problem, and exactly one verdict for the diff as a whole, including a statement of what it could not check. Its tool profile withholds everything that would let it change state or merge, so it structurally cannot decide.
A queue, not a pile
⌘⇧R opens every diff waiting on you, ordered by what you can do next rather than by how alarming it looks — and a diff still being written to sinks, however long it has waited. Finishing one hands over the next with ⇧J. Inside a diff, n walks the unresolved findings by severity, r and ⇧R resolve and dismiss, and v marks a file read.
Request changes, or send it back
Add your own findings, then press r to request changes. Send to agent resumes the original session with the unresolved findings, each with its severity spelled out — and it says what it is not sending, because an agent handed a finding you already dismissed goes and does the work anyway. Blockers only is offered beside it.
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. If you want a pull request as well,
Create PR
pushes the branch and opens one through the
gh CLI — a parallel
artifact, not a replacement for the local review or merge.
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.
Local-first architecture
Everything is local by default. Your tasks, events, and code references live in SQLite — one Ledger database per Project — kept entirely separate from your git repos. Cloud sync is opt-in and additive, per project; without it there is no cloud dependency and no seat fees at all. Your source stays in git; your task data stays separate; you own both.
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.
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.