Omniscio

Agent Task System (one task list for every agent)

- One list for every agent's work. Crew agents use their crew's list; every other agent files under its project's list, called its hub. Nothing is ever mixed into your own Tasks. - On by default for a developer's computer, off for everyone else. The switch is in Settings → Workflow → "Agents use the Agent Task System". It needs the Agent Status Board on, and with it off nothing changes for any crew. - Nothing copied in. An agent's own to-do checklist stays that agent's own. Shared tasks are filed on purpose — by an agent, by a finished review's findings, or by a synced source — and the to-do rule asks for the agent's own list. - A full record. Every change says who made it (an agent, you, the board or the app), what changed from and to, and when.

On this page

What it is

Agents used to keep their plans in their own scratch to-do lists, which vanished when a session ended and could not be read by anyone else. The Agent Task System keeps that work in Omniscio's own task store, the same store crews already use, so a lead, another agent or you can see what every agent is doing and what it finished.

Each Omniscio project gets one shared list, its hub. An agent outside any crew files its work there; a crew agent keeps using its crew's list. A task on either list can be marked to run, and then Omniscio starts one worker for it and the task closes when that worker's work lands.

Where to find it

  • The switch: Settings → Workflow → "Agents use the Agent Task System", directly under Agent Status Board. On by default for a developer's computer, off for every other install.
  • The screen: Agent Work, a hub under Agent Tools in the sidebar, shows every crew's list and every project's list in one place, and is where you act on a task yourself.
  • What you see: the shared list lives in that screen and in the agent-tasks commands; each agent's card on the Agent Status Board shows the agent's own checklist, whichever state that switch is in.
  • Task numbers: hub tasks are numbered H-1, H-2… and crew tasks T-1, T-2…. Each list counts from 1, so the letter tells you which list a number belongs to.

How it behaves

An agent that plans gets one task, automatically

An agent keeps its plan in its built-in to-do list, which is its own private working checklist. What crosses into this system is one task per planning session: the first time Omniscio's to-do rule proves a session keeps a list, it files that session's task for it — running in its own list, carrying the plan in its description, owned by the session — and posts the task's ref into the conversation. The agent then keeps that task current with agent-tasks note and closes it when the work is done; archiving the session closes it with a note saying the work ended first.

It stays one task per session. A session that never writes a plan gets nothing, and a session that already owns open work — filed by itself, a lead or a person — gets no second task. Anything the agent wants on the shared list beyond that it still files on purpose with node scripts/agent-tasks.mjs add, as a real task with a number, an owner and its own history; this automatic task is a record of the session's work, never a substitute for the agent planning.

Agents are told to use it, and warned off to-do files

While the switch is on, every agent's standing instructions carry one AGENT TASKS line: work that outlives this turn, or work for another agent, goes in this system and never in a markdown to-do, plan or notes file, and the built-in to-do list is only for the steps of this turn. It is left out of SSH sessions, the Ask helpers and the Simple Mode helper.

An agent that creates a NEW markdown file that looks like a to-do or plan list is stopped once. A file looks like one when its name says so (todo, to-do, tasks, task-list, backlog, next-steps, checklist, plan) or it holds three or more unticked - [ ] lines. The write is refused with a warning naming this system and the agent-tasks skill. The same agent sending the exact same write again within 10 minutes goes through, and a third identical write is warned again, the same pattern as the warning on the person's own Tasks list. Edits to a file that already exists are never judged, and the dev pipeline's run folder, skills and memory folders are exempt.

The warning rides the app's to-do hook, so it reaches only sessions that get that hook, which is while the Agent Board is on (it is on this computer). AMC_DISABLE_PLAN_FILE_WARNING=1 on the app turns it off.

A hub task says what it serves

A task an agent files on its project's list must name at least one thing it serves: the parent task it belongs to, a project on that list other than the shared "Agent work" project, or a document it works to — a repo-relative path that exists on the project's master. The agent names one when it files the task (--parent, --project or --doc), and a document is stored on the task as a reference it can read back later. A filing that names none of the three is refused with a sentence saying how to fix it, so the list cannot fill with rows that say nothing about what the work is for. Tasks on a crew are unchanged: the crew's project tree already anchors them.

The to-do rule asks for the agent's own checklist

While the switch is on or off, the to-do rule asks one question before an agent edits a file: does the agent's own to-do list hold at least one item? Its first to-do item counts straight away. This is the same rule with the switch either way, and if anything goes wrong while checking, the edit is allowed, so the rule never blocks work through its own error.

Every change is recorded

Each task keeps its own history: every status move and note, who made it, and, for a change to the task's fields, what each field was before and after. A task the app closes on its own, for example when its branch lands, writes that line too.

Built for agents to read cheaply

An agent can read one task at four levels of detail, from a one-line summary to everything, including its history. Every answer says how many tokens each part would cost, and an agent can ask for "the most detail that fits in N tokens". Long lists are read page by page all the way to the end, so the newest work is never cut off.

One short command per step

Agents use node scripts/agent-tasks.mjs <verb>: add, start, done, note, assign, show, tree, next, mine, since, run, result, runs, pick, and the claim, prereq, project, context, handoff, decision, thread, search, watch and plan families, plus help. Filing a hub task names what it serves (--parent, --project or --doc). A task filed with no owner, or the wrong one, gets its owner set, changed or cleared with assign <ref> --owner <session-id|none>; the same rule as any other change decides who may, and the new owner must be a live session on a hub list or a member of that crew on a crew list. Closing a task is one call that carries the outcome and the branch or commit. A task can also be closed dropped: set its status to dropped with the outcome that says why — that is the road for work that is no longer needed, and the one a review panel's rewrite takes, retiring the old row with Replaced by <new ref> (review panel <id>) rather than claiming it was delivered. A drop refuses a task that is already closed and one that still has an open subtask, and its idempotency receipt records the dropped status, so a resent drop replays as a drop and is never read as a completed task. next lists only work that is ready to pick up. since returns only what changed since the last answer, each task once. A command resent after a timeout is applied once. run hands the task to one worker; result is what that worker calls when it is finished; runs shows every run on the task, who marked it and what became of it. A session holding the claim closes its own task without naming a generation.

A run's worker starts on the engine your worker tier is set to (DeepSeek where it is set up) whenever that engine can start on this computer, and on the Claude worker model when it cannot. Pinning the worker tier to a Claude model keeps runs on Claude.

An agent can also give one task's run its own model (agent-tasks run <ref> --model smart). The choice stays with the task for later runs. If that model later cannot start, the run waits and says why instead of quietly starting on a different one.

Waiting on other work

A task can wait on other tasks. It is not offered as ready to pick up while a prerequisite it names is anything but done, and a dropped or deleted prerequisite keeps blocking until someone waives it with a reason. A claim is a fifteen-minute lease on a task, not a promise: it says a session is doing it now, it renews while that session keeps working, and past its time anyone may take over.

An agent can also watch a task, so it is told about somebody else's change instead of asking repeatedly — never about its own. A task with a due date wakes its owner once when the time comes.

Limits and known gaps

  • A hub task can run one worker, or a swarm. agent-tasks run <ref> marks it to run: the app starts one cloud worker through the same start door a session uses, reporting to the task's owner, and the task closes when the worker's branch lands (or on its result when it carries no branch). A run whose worker ends with no result parks the task and messages its owner once — nothing re-runs on its own. run <ref> --swarm N starts N attempts as one roster (N at most the container's lead report cap, 5 today); the whole roster is admitted together or waits with the reason shown in runs. A swarm attempt never picks itself: agent-tasks pick <ref> <attempt> takes one reported attempt, cancels the others, and settles the task exactly as a one-worker result would.
  • Caps: each agent and each hub has a ceiling on open tasks, so a runaway agent cannot flood a list; prerequisites also come in a batch no larger than one transaction holds, and the refusal says the number.
  • Search reads a bounded window. Finding tasks by words reads the newest two thousand tasks of each list you can see, and the answer tells you when a list had older history it did not search.
  • A phone shows Agent Work only while the switch is on, so an install with the system off sees the app exactly as it was.
  • Older copies are frozen. Before 11 November 2026 an agent's to-do list was copied into its hub automatically. Those tasks remain on the list exactly as they were and are no longer updated; nothing deletes them.

The worker started for a task

A task the app started a worker for belongs, for as long as that run is live, to that worker as well as to its owner. The worker may add a note to it and close it done with an outcome — the same rules as any close: an outcome is required, a code task still needs its delivery, and open subtasks still block. It may not rename it, move it, change its owner or priority, drop it, or close or change any other task. Once the run finishes or is handed to another session, the worker's own right ends.

A crew member can note any task of its crew

Any live member of a crew can add a note to any task on that crew's list, whoever owns it, so the service that lands a branch or a reviewer who checked it can say so on the task itself instead of asking the lead to pass it on. A note is all it opens: the line goes into the task's history with the writer's name and the task keeps its status, owner, priority and text. Closing, renaming, dropping, re-prioritising or handing the task to someone else still belongs to its owner, the session that filed it, the owner's foreman and the crew lead. A session in no crew, a member of another crew, a member who has left and a session that has ended cannot note the task, and a project's list keeps its own rule.

Finding a task by its id

T-12 reads your own list, H-12 your project's list, and a full id searches every list you may read — your crew's list, your project's list, and the Unassigned list. So a task the lead filed on Unassigned can be claimed by its id from inside a crew.

The list shows up on the Agent Work screen, where you read and act on it yourself, and each agent's own checklist is on the Agent Status Board, whose to-do rule this system extends. Crew work, its projects and its task tree are explained on Agent Crews (the mission task tree) and Agent Crews.

Last verified 2026-11-16