# Turning notes into tasks on a Mac, feature by feature

To turn notes into tasks on a Mac you need something that reads the prose once and hands back the tasks already wired, because transcription is exactly where a plan you wrote down stops being a plan you work from.

- URL: https://swiftfox.studio/handbook/turn-notes-into-tasks-on-mac
- About: https://swiftfox.studio/apps/plexus
- Published: 2026-08-03
- Updated: 2026-09-05
- Publisher: Swiftfox Studio (https://swiftfox.studio)

## In short

- Plexus extracts the tasks from pasted prose in a single pass, names the flow itself and draws the ordering it can infer from the text.
- It draws two kinds of link: a dependency means do this one first, a subtask means this is part of that, and only the second one rolls up.
- A task is next-actionable when every prerequisite and every subtask under it is done, which is the same rule behind the canvas rings and the inspector's Blocked by list.
- Ready collects every startable task across every flow, and Plan my day fits today's into the time you have - the model picks the order, the app does the arithmetic that decides what fits.
- The model runs on your own Mac through Apple Intelligence, hand-drawn links are never overwritten by a re-analysis, and any flow exports as a Markdown checklist.

## Why a plan you wrote down is not a plan

Most plans start life as prose. A brief from a client, the notes you took in a
meeting, an email you sent yourself at eleven at night. The thinking is all
there, in order, with the reasons attached, and none of it is a plan you can work
from - because working from it means reading the whole thing again and deciding,
once more, what to do first.

The fix everyone knows is to transcribe it into a task list. The reason it does
not happen is that transcription is boring, takes twenty minutes, and produces a
flat list that has thrown away the one thing the paragraph actually contained:
which parts have to wait for which.

[Plexus](https://swiftfox.studio/apps/plexus) is a macOS app that does that step for you, with a model
that runs on your own Mac. Everything below is in the shipping version.

## Paste the paragraph, get a named flow

New flow from text is one dialog with two fields: a name, and a box labeled
"Describe it for AI" that takes whatever you have. A brief, a transcript, three
bullet points, a whole email thread.

![The Plexus new flow dialog with the name Conference talk and a pasted paragraph in the Describe it for AI box, with Cancel and Create with AI buttons](https://swiftfox.studio/plexus/listing/shot-2.jpg "Paste the prose and press Create with AI: the extraction and the wiring happen in the same pass.")

**Create with AI** reads it once and comes back with the tasks pulled out, the
flow named and the ordering it could infer already drawn. You do not have to name
the flow yourself either; leave the field empty and the model names it from the
content, which is usually better than the placeholder you would have typed.
**Create flow** next to it makes an empty flow, for when you already know the
shape and just want the canvas.

Two honest edges. Prose with no tasks in it comes back as "No tasks found"
rather than an invented list. And very long input is truncated at roughly twelve
thousand characters with a warning, because the on-device model has a small
context window and a silent truncation would be worse than a visible one.

## The ordering it infers, and the ordering it refuses to guess

The interesting part of the extraction is not the list. It is the arrows.

![The Plexus main window with the sidebar of flows, six colour-tagged task cards wired into a dependency graph, a reference file pinned beside one of them, and the inspector open on Fix the crash on export](https://swiftfox.studio/plexus/listing/shot-1.jpg "Six tasks, wired. The inspector spells out what the selected task is blocked by and what it blocks.")

Plexus draws two different kinds of link, and keeping them separate is what stops
the flow turning into a diagram nobody reads.

A **dependency** means do this one first. Recording the demo has to happen before
the launch post that embeds it, so the post stays blocked until the recording is
done.

A **subtask** means this is part of that. Here the parent does not block its
children; it is the other way round, and the parent only becomes available once
everything under it is finished. Leaves light up first, and the branch rolls up.

What it does not do is guess. The instruction the model works to is to propose a
dependency only when the order is genuinely required, not merely common. Two
tasks you happen to always do in the same sequence are left unlinked, because a
false arrow costs more than a missing one: a missing arrow is a link you draw in
two seconds, while a false one hides a task you could have started.

## What "next" means, and what fits in the day

A task is next-actionable when nothing unfinished stands in front of it. Every
prerequisite is done, and every subtask under it is done. That is the whole rule,
and it is worth stating precisely, because everything else here is built on it.

Those tasks get a ring, and everything else is visibly waiting. Tick one and the
graph recomputes, so whatever it was holding up lights up in the same moment. The
inspector shows the same thing from the other end: select any task and it lists
**Blocked by** and **Blocks**, each row clickable to jump to that task. Both
lists come from the same computation that draws the rings, so the canvas and the
panel cannot disagree with each other - a class of bug that makes a graph view
untrustworthy the first time you catch it.

Around those two lists sits the rest of a task: notes, a status of pending, in
progress, done or paused, a priority, a start and due date with Today, Tomorrow
and 1 week shortcuts, and an estimate in minutes.

**Ready** is that rule applied to everything at once. It is a route of its own at
the top of the sidebar, and it collects every startable task across every flow
you have, with a count beside it. Sort it by flow, by due date, by priority or by
how recently a task appeared - and whatever you scheduled to start today is
lifted out of that order and pinned above it as its own group.

![The Plexus Ready list with today's planned work numbered at the top and the remaining tasks grouped by flow](https://swiftfox.studio/plexus/listing/shot-5.jpg "Ready is the cross-flow answer: every task nothing is holding up, wherever it lives.")

That settles what you *can* start. It does not settle what fits before lunch, and
those are different questions. **Plan my day** is the second one: say how long you
have, from a grid of chips or a number you type, and it comes back with today in
order.

![The Plexus day planner showing the tasks that fit the time available, a line where the time runs out, and the tasks that did not make it below](https://swiftfox.studio/plexus/listing/shot-6.jpg "The model orders the day. The arithmetic that decides what fits is the app's own.")

The split inside that dialog is worth knowing about, because it is the difference
between a plan you can trust and a number a model made up. The model **orders**
the tasks, which is a judgement and the thing it is good at: it can see that three
of them belong to the same project and should sit together. The app does the
**arithmetic**, walking that order against your budget and admitting what fits -
which has a right answer, and which a small on-device model gets wrong. So the
line where the time ran out is computed rather than guessed, and everything under
it is still on screen rather than hidden.

Accept the plan and it writes itself into Ready: those tasks move into the Today
group, numbered in the order the plan gave them, and draggable into a different
one if you disagree. Finish the second and the rest renumber, because the number
a row shows is its position now, not the rank it was handed when you pressed the
button.

Dates work the same way round. A start date is a commitment, and it is what puts
a task into Today. A due date is a deadline, and Plexus will tell you about it on
the day if you let it post notifications, with an optional daily summary naming
the first thing waiting. Both are off until you allow them.

## Breaking one line into the five it really is

"Record the 60-second demo" is one line and about six jobs. Plexus will do that
expansion for you: select the task, choose **Break into subtasks with AI**, and
optionally type a sentence of context to steer it.

![The Plexus generate subtasks dialog for Record the 60-second demo, with a description typed into the Describe it for AI box and a Generate subtasks button](https://swiftfox.studio/plexus/listing/shot-4.jpg "The description is optional. It is there for when the obvious breakdown is not the one you want.")

It returns between two and six subtasks, phrased as imperatives, wired under the
parent as a branch. A second pass puts a duration estimate on each one, and the
prompt behind it is specific about what it is counting: the time the person doing
the work is actually working, not the days spent waiting on a review or a
delivery. Estimates that quietly include waiting are the ones nobody trusts
twice.

## The lines that arrive later

The other half of the problem is the todo that shows up while you are doing
something else. Quick Capture is a floating panel on a global shortcut, **Command
Shift Space** by default and rebindable, and it opens over whatever you are in
whether or not the main window is open.

![The Plexus quick capture panel floating over the desktop with a typed task and a flow picker set to Company admin, with Cancel and Save buttons](https://swiftfox.studio/plexus/listing/shot-3.jpg "One field, one picker, Enter. The picker remembers where the last capture went.")

One field, one flow picker, Enter. The picker defaults to wherever your last
capture went, and deliberately does not try to route the line with AI: a guessed
destination is a decision you would have to check every single time, which costs
more than the click it saves. Once the line is saved the model does run, linking
the new task against its recent neighbors, so a captured one-liner is wired in
rather than left floating on its own.

The shortcut is registered through Carbon, which is why Plexus needs no
Accessibility permission for it. The only permission the app ever asks for is
notifications, and only once you turn a reminder on.

## A canvas you can actually read

A graph gets hard to read at about thirty cards, and three small things are about
pushing that number up.

**Colour.** A task takes one of nine colour tags, drawn as the card's border
rather than a wash over it, so the tag never fights the card's own text. The
toolbar filter then narrows the canvas to any set of them, untagged included,
which turns "everything I own" into "the design work" without moving a card.
Separately, the app itself has six accent palettes in Settings, for when violet
is not your colour.

**Size.** Drag a card's bottom-right corner to resize it, or turn on **Size cards
by estimate** in Settings and let the footprint follow the minutes on the task.
An effort-sized graph is legible in a way a grid of identical rectangles is not:
the afternoon-long jobs are visibly the big ones.

**References.** Drop a file onto the canvas and it becomes a card of its own;
drop it onto a task and it attaches, drawn with a line back to the task it
belongs to. Images and PDFs preview, everything else gets a type chip and a size.
The bytes are copied into Plexus's own store, capped at 20 MB per file, and the
original path is never kept - no bookmark, no link back. Move or delete the
original afterwards and the card is untouched, which is the trade: the reference
survives, at the cost of a copy.

## When the model is wrong, and when it is not there

Two failure modes matter more than the feature list.

**The link is wrong.** Delete the connection, or drag from a task's port and draw
the one you meant. Hand-drawn links carry a different provenance from inferred
ones, and a later re-analysis replaces only what the model drew, so your own
edits are never quietly overwritten. Anything that would create a cycle is
refused outright with the reason on screen, rather than accepted and left to
deadlock the graph.

**Apple Intelligence is not available.** On a Mac that cannot run it, or where it
has simply not been switched on, a banner says which of the two it is and offers
a link straight to the right settings pane when that would fix it. Everything
manual keeps working: add tasks, draw and delete dependencies, arrange the canvas
with the tree layout, search, export, and the Ready list with its own sort
orders. Only the four AI entry points go quiet.

Whatever the state of the model, the tasks come back out. Any flow exports or
copies as Markdown, as a nested checklist where indentation follows the subtask
branches and ordering dependencies are written inline as *(after: X)*, so it
pastes into a note, an issue or a pull request without losing the structure.

## What it deliberately does not do

Nothing you paste leaves the Mac. The analysis runs on Apple's on-device model,
which is why it needs macOS 26 in the first place: there is no API key to enter,
no account to make, and no version of this that sends a client brief to a server
so a better model can read it.

It does not sync. One flow lives on one Mac, and there is no iCloud toggle hidden
in Settings - which is a real limitation, and the price of the paragraph above.

It never rewrites your prose. The model reads a paragraph and pulls tasks out of
it; it does not improve the wording, invent work that was not there, or add the
step it thinks you forgot. What it is unsure about it leaves for you, which is
also why the ordering it refuses to guess is refused out loud.

There is no calendar and no Reminders integration. Start and due dates are
Plexus's own fields; a deadline reaches you as a notification from Plexus, and
nothing is written into Calendar, Reminders or anything else on your Mac.

And there is nobody else in it. No assignees, no shared flows, no comments. This
is one person working out the order of their own work.

## What it costs, and what else to look at

Plexus needs **macOS 26 or later** and takes about 12 MB. The build is universal,
so it runs on an Intel Mac too; the AI features need Apple Intelligence to be
available, and the rest of the app does not.
It is a **one-time $10.99 purchase** rather than a subscription, with a 30-day trial
that needs no card and no email. The full specification is on
[the Plexus page](https://swiftfox.studio/apps/plexus).

The reason any of this can run locally at all is recent, and worth understanding
before you trust it. There is a wider look at what "on-device" does and does not
promise in [on-device AI apps for Mac](https://swiftfox.studio/blog/on-device-ai-apps-for-mac).

And if a graph is more structure than your day needs, the opposite shape is
[Anchored](https://swiftfox.studio/apps/anchored), which holds exactly one task and its countdown in the
menu bar and asks nothing else of you - feature by feature in
[a menu bar task timer for Mac](https://swiftfox.studio/handbook/menu-bar-task-timer-for-mac).