Tasks from your coding agent

You spend an hour with your coding agent deciding what to do next. From 1.4.4, the last sentence of that hour can be: make tasks out of everything we said we would do. The agent files them into the Todo Backlog widget on your canvas, in the order you agreed, under the steps you named. You do not retype anything.

This works from Claude Code, Cursor, Antigravity, Hermes Agent, and any IDE or agent that speaks MCP, through the same @mnemosyne_os/mcp bridge that lets them read your memory. The tool is called mnemosyne_todo_add.

What it looks like

You, at the end of a session:

Make tasks out of everything we said we would do, in a new list called Sprint 12, grouped by step.

The agent calls the tool once and reads back:

Filed 9 tasks into "Sprint 12" (list created). They appear in the To-do widget in the order given, under their steps.

Open the widget (Ctrl+4, or the dock) and the tasks are there, with a header for each step where the step changes.

Before it works

1. Mnemosyne OS 1.4.5 or later

   With the app window open, the widget's own store applies the change. With the window closed, the app writes the file itself, with the same guards. On a dev install the headless daemon serves the tools with the app closed too; an npm install has no daemon and needs the app running, and says so instead of writing nothing in silence.

2. The MCP connected

   Follow Connect Claude to Mnemosyne OS. The tool shipped in @mnemosyne_os/mcp 1.7.0. The recommended config runs the package through npx -y, which fetches the current version; if your agent still lists 14 tools, restart it so the server is reloaded.

3. No permission dialog to expect

   The MCP bridge is first-party and declares the todo:write scope itself, so nothing pops up in the app. A cartridge you install has to ask you for that scope, like any other permission.

What to say

The tool refuses to guess, so a good request names three things:

• The list. Say in WIP, in my Blog list, or in a new list called X. Names match the labels you see in the widget, case does not matter, and the three original lists answer to their translated names too. If you name a list that does not exist and did not ask for it to be created, the agent is refused and handed the names that do exist, so its next call picks one instead of guessing. If you say nothing about the list, the tasks go to the first original list, WIP.
• The steps. Say grouped by step, or name them yourself. Each step becomes a header inside the list, drawn where the group changes. A step is a heading on the tasks, not a list of its own.
• The order. The order the agent sends is the order you get. Ask for execution order if the conversation did not settle it.

A colour for a new list is optional; the app picks the next swatch otherwise.

Said that way, this is what the agent sends:

{
  "tasks": [
    { "text": "Draft the three mockups", "group": "Step 1 · Mockup" },
    { "text": "Pick one together", "group": "Step 1 · Mockup" },
    { "text": "Cut the CSS tokens", "group": "Step 2 · Build" }
  ],
  "list": "Sprint 12",
  "create_list": true
}

Tasks sharing a group are drawn under one header, in the order you see here.

The argument is create_list, in snake case, and it defaults to false: without it, an unknown list name is refused rather than created.

What the agent reads back

Every answer is a sentence the agent can act on, and every failure says that nothing was written.

Situation	The sentence
Filed	Filed 9 tasks into "Sprint 12" (list created). They appear in the To-do widget in the order given, under their steps.
Unknown list	No list by that name. Lists that exist: "WIP", "Perso", "Other", "Blog". Pick one of them, or call again with create_list: true to make a new one — never assume a default.
Empty list name	The list name was empty. Name an existing list or pass create_list: true with a name.
Only blank tasks	Nothing to file: every task was blank after trimming.
No app, npm install	The backlog lives in the Mnemosyne OS app window and no window is open. Start the app (Infinity Edition) and call again; the headless daemon cannot show a To-do.
No answer in 15 s	The app did not answer in time. Nothing was written. Is the canvas open? Try again once the window is up.
Write refused	The app refused the write — the backlog file was not readable yet, or the disk said no. Nothing was written; try again in a moment.

Read, change, remove (1.4.5)

Adding was the whole door until 1.4.4, so every correction landed back on you. Since 1.4.5, @mnemosyne_os/mcp 1.9.0 gives the agent the rest:

Tool	What it does
mnemosyne_todo_list	Reads the backlog back: the lists, and every task with the id needed to change it.
mnemosyne_todo_update	edit, complete, move, remove a task. remove archives (recoverable); permanent: true deletes for good and has to be asked for.
mnemosyne_todo_categories	Create, rename, recolour or remove a list. A list that still holds tasks is refused, with its count.
mnemosyne_agenda_add	Put an appointment or a deadline in the Agenda widget, with an optional reminder and recurrence.
mnemosyne_agenda_list	Reads the calendar back, with ids.
mnemosyne_agenda_update	Move, rename, re-time or re-remind an appointment.
mnemosyne_agenda_remove	Removes appointments. The calendar has no archive, so each one is named by title and start time in the answer.

Every change names an id the read handed back, never a title. "Delete the task about the invoice" is how the wrong task goes, in a sentence that reads perfectly either way; the tools say so in their own descriptions, so the model is told before it guesses. A batch applies in order as one save, and each operation reports its own outcome, so a stale id does not sink the others.

The ask, at the end of a review:

Read my To-do, complete the two tasks we finished, and move the invoice one to Next week.

The agent calls mnemosyne_todo_list, then mnemosyne_todo_update with the ids it read, and reads back one line per operation.

Limits

• One list per call, up to 200 tasks, 300 characters per task, 80 per step name. Longer text is cut, blank lines are dropped.
• No duplicate check. Asking twice files twice.
• The whole plan is one write: either every task lands or none does. There is no half-imported plan to untangle.

The same door from the chat

The chat window has the same feature without an agent: the toolbox button Tasks from this conversation (Turn what this conversation decided to do into an ordered task plan. You review it, pick the list, and only then are the tasks created.). The model drafts a plan from the conversation, with memory recall switched off so nothing you never discussed sneaks in, and a dialog titled New tasks from this conversation shows it first: Nothing is created until you press Create. Edit, remove, pick a list. If the conversation decided nothing, it says so: Nothing to do was found in this conversation.

For cartridge builders

The same door is an SDK call, sdk.todo.add, on the local SDK server (port 7799). It takes tasks (strings, or { text, group }), an optional list, createList (default false) and color, and answers { ok, added, created, listLabel } or { ok: false, error, lists } with the codes of the table above. It needs the todo:write scope in your manifest; being granted vault writes does not hand an app the backlog.

Since 1.4.5 the door has four more calls: sdk.todo.read and sdk.todo.apply (scopes todo:read, todo:write), sdk.agenda.read and sdk.agenda.apply (agenda:read, agenda:write). Reading someone's backlog is not the same act as writing to it, so the read scopes are their own: an app that wants both asks for both. sdk.agenda.add files an appointment.

Your backlog stays yours

There is never more than one writer. With the window open, the request is handed to the widget's own store, the only writer of that file while it is up, and the same guards apply as when you type a task yourself: nothing is written before the file has been read, and nothing is written if the window did not answer. With the window closed there is no store and nothing that would save over it, so the app applies the same pure functions straight onto the file, through a temporary file and a rename: a process killed halfway leaves your previous backlog, never half of the new one. A readable JSON file that is not a To-do file is left alone. What the agent files is exactly what you see.