Product management for the agentic age

Stop managing agents.
Start managing the work.

You spawned a dozen agents last week. The agents weren't the problem; keeping the work coherent was. Polynomic is a task manager wired directly into your code: Tasks that span your repos, reference your files, and run a full cycle from capture to merge.

Download for macOS Install instructions

Universal build for Apple Silicon & Intel. Windows and Linux coming later.

polynomic — Tasks

Search tasks C Capture

POL-204 Stream agent stdout into the session log polynomic In Progress

POL-198 Code-Tree counts should include subtasks polynomic In Review

POL-211 Worktree cleanup on task discard polynomic-cli Changes

POL-187 Append-only migration for the Ledger polynomic Done

POL-219 Capture task from the command palette polynomic-www Todo

The shift

Coding agents got good. That changed where the bottleneck is. The hard part is no longer generation; it's deciding what to build, scoping it to the right code, and reviewing the result before it lands.

Most tools in this category are built for agent management: orchestrating runs, watching processes, babysitting sessions. That solves last year's problem. When agents are reliable workers, you don't want a control panel for workers. You want a place to manage the work. Polynomic manages Tasks the way Linear manages issues, except each Task is worked by an Agent Session and references the exact code it touches. The agent is an implementation detail. The Task is the thing.

Code-aware

It knows your codebase. No other PM tool does.

A Task carries Code References: pointers into source at file or symbol granularity, entered with @-syntax. The Code-Tree View shows your repo with a count of Tasks touching each node, so you navigate work spatially, by the part of the system it affects.

polynomic/src — Code-Tree

polynomic 12

src 9

ledger 4

events.rs 3

store.rs 1

session 5

review.rs 2

Cargo.toml

The core idea

A Task is a curated context boundary.

Assemble everything an agent needs to succeed in one place. Start a Task and Polynomic lays a git worktree of each touched Repo side by side in one Workspace, with full cross-repo context, the exact files the work concerns, and the Skills the agent should use. Get the context right at the Task level and the agent's job becomes tractable.

POL-198 — Workspace

polynomic

worktree · pol-198

polynomic-cli

worktree · pol-198

Code References

src/ledger/events.rs#append

src/ledger/store.rs

Skills

event-sourcing rust-review sqlite-migrations

Review

Nothing reaches main until you've seen it.

Every Task produces a reviewable branch diff per Repo. An independent AI Review session reads the diff and posts comments; it never changes state or merges anything. You decide what moves forward.

polynomic/src/review.rs — Diff

@@ -18,6 +18,7 @@ impl Review {

fn post_comment(&self, line: u32) {

+ let token = new_task_token();

- let token = None;

self.ledger.append(token);

}

AI Review

new_task_token() can fail; the result is unwrapped before reaching the Ledger. Consider propagating the error so a failed append doesn't land silently.

Keyboard-first and fast

Command palette, single-key shortcuts, vim-style navigation. Capture a task, start an Agent Session, review the diff, and merge without reaching for the mouse.

Local-first, by design

Your tasks, events, and code references live in a local SQLite Ledger: an append-only, immutable record, the single source of truth. No cloud dependency, no API keys, no monthly seat fees. Your source stays in git; your task data stays separate. You own both.

Command palette

Type a command…

Start agent session S

Capture task C

Open review R

Go to Code-Tree G T

A product-management tool that finally understands code.

Tasks that span your repositories, reference your files, carry the skills an agent needs, and run a full development cycle from capture to merge. Local-first, keyboard-first, every change reviewable before it lands.

Download for macOS