TaskPrio is built on one rule: priority only means something when it's global. Every other to-do app lets you have many priorities — three "P0" labels, four "today" columns, two "urgent" tags. That breaks the moment you sit down to work and ask "what's actually next?" TaskPrio answers that question with a single ranked list across every project. You write the tasks; you write the order; your AI agent works it top-to-bottom.
Because multi-list priority always collapses into "I don't know what to do next." Every operator who's tried Trello + Notion + Asana + a notes app eventually says: "I have priorities everywhere and ranking nowhere." TaskPrio inverts that. Tasks live in projects (for context) but rank in a single global queue (for decision). When you're done with the top task, the next task is right under it — across every project, every context, every label. No re-sorting, no view-switching, no choosing.
The single most-cited reason operators churn from a task manager: "I had too many lists and didn't know which one to open." TaskPrio's one queue is the answer.
This isn't novel — it's the David-Allen-Getting-Things-Done insight made literal. Allen says "your mind keeps shifting attention until everything is on one trusted list." TaskPrio's queue IS that one trusted list, with the added move of ranking it so the agent has somewhere unambiguous to start.
TaskPrio uses fractional-index ranking. Each task has a rank string (e.g. 000000U); inserting between two tasks generates a string lexicographically between them. The math is one-shot: no re-numbering, no cascading writes, no race conditions when two agents drag at once. Drag a task between two others and the rank lands on the first attempt, period.
Implementation reference: jonschlinkert/fractional-index (one of several public implementations). TaskPrio's variant lives in the open-source repo.
Task leasing. When an agent calls get_next_task (MCP) or GET /api/next (REST), the highest-ranked unblocked task gets stamped with a 15-minute lease pointing at that agent's session ID. A second agent calling at the same moment skips that task and gets the next-highest. The lease expires automatically; if the first agent fails or stalls, the task re-enters the pool. If the agent finishes and calls complete_task, the lease releases early.
This is the same pattern background-job queues (Sidekiq, Resque, Celery, BullMQ) have used for a decade — applied to a human-readable task list. The novel piece isn't the lease; it's that the lease is on a task you can see and edit while the agent is working it.
Everything you wrote on the card plus everything inherited from its project. Title, body (markdown supported), subtasks, attachments (images, files, links), single-select properties (Stage, Energy, Status — whatever you've defined). On top of that, the project-level "agent instructions" field flows down — that's where you put "always cite sources" or "use TypeScript not JavaScript" or "the working directory is ~/Local/project-foo." The agent receives this as one JSON payload.
Two safety mechanisms, both intentional: (1) the agent reports back via complete_task with a freeform result string before the task closes; you read it before moving on. (2) The agent can flag needs_human when it's not sure; the card turns yellow and exits the queue until you answer. TaskPrio doesn't try to make the agent autonomous-without-oversight — it tries to make the oversight cheap, asynchronous, and reviewable.
If an agent is going to break something, you want to know in the report-back step, not after the next 12 tasks shipped on top of it. The 15-minute lease + the green active-card indicator gives you a window to interrupt mid-task without losing the agent's state.
Operators who run AI agents (Claude Code, Cursor, custom MCP servers, ChatGPT via REST) and need a queue the agent can pull from. Solo founders shipping multiple projects, ops teams with recurring chores, content teams running 50-article sprints, anyone whose work fits "I could write the task once and an LLM could grind through it." If you're not running agents — that's fine, TaskPrio works as a human-only ranked queue too — but the methodology was designed agent-first.
TaskPrio is built by Paulo Michael de Vries at EditNative in the Netherlands. It's the task-queue layer of AcePilot OS, a small family of agent-native tools built on the same principle: humans set priority, agents do the work, both see the same state. The methodology came from running a fleet of agents across 30+ side projects and noticing that none of the existing task managers (Notion, Linear, Asana, Trello, Things, OmniFocus) had a single ranked-queue primitive that an agent could pull from. So I built one. TaskPrio is the result.