mm GitHub
one thing in front of you

Your head is for the work, the box holds the rest.

A gap with nothing queued turns into a scroll, or the next episode, because the feed starts without asking you to decide. An idea in the middle of study has nowhere to sit, so it tugs at you, or you lose it an hour later. You put both in the box. mm shows one thing.

$ git clone https://github.com/Toseef-Ahmad/mm.git && cd mm && ./install.sh

Python 3.11+. No pip packages.

One afternoon
STEP 1 OF 7
$

The box ~/.mm/state.json
Now QUEUE
→ CS302
! stack 0 items
queue 1 item
quick 0 items

One thing is current. You do not scan a list to decide.

Two times you lose the thread

The gap, and the idea that arrives while you are in it.

01 The gap

A gap with nothing queued turns into a scroll or another episode, because the feed starts without asking you to decide.

You finish a piece of work, or a build is running, and for a minute nothing is in front of you. That minute is enough. Put the next piece in the queue before you need it. When the gap opens, type mm. The next thing is already there.

mm — the box already has the next thing

02 The idea

An idea that shows up mid-work has nowhere to sit, so it either tugs at you until you lose focus, or you lose the idea an hour later.

You are studying, or deep in the work. Keep the idea in your head and it pulls. Go do it and the work is gone. mm add "write this up later" lines it up behind the work you are in. You stay on that work. When you finish, the idea is next.

mm add — behind the current work, not instead of it

After you finish the thing in front of you
A list
CS302 is done. Now choose again.
Scan the list. Re-rank it. The phone is easier.
mm
$ mm done ✓ done 1 CS302
→ 2 write this up later active
The idea was already next. No new choice.
What goes where

Three places. Nothing else.

No tags, no dates, no projects, no config. Tomorrow an item is gone unless you add it again.

01 the line

Queue

First in, first done

The work you meant to do. An idea during the work goes at the back. The thing you are on stays the thing you are on.

$ mm add "CS302"

Finish it with mm done.

02 on top

Stack

Last in, first done

Something just became more important. It takes the front. When you finish it, you are back on the queue, on the same work.

$ mm add -p "prod is down"

mm done returns you.

03 off the line

Quick

A small nag

Email, a chore, a thing that must not jump the line. mm never shows it as the next thing.

$ mm add -q "email Sam"

mm flush-quick deletes them. They are not archived.

Why this shape

The limits are real. The trick is not.

mm is built around working memory, the cost of leaving a task, and writing a thing down so you can stay on the work. It does not depend on a memory illusion.

Cowan, 2001

About four chunks

Working memory holds about four chunks when you are not rehearsing them. A long list is already more than the head can keep.

mm shows one thing.

Risko & Gilbert, 2016

Write it down

Putting a task into a reliable place outside your head frees attention for the work itself. The capture has to be one line, or you will not do it mid-thought.

mm add "…"

Leroy, 2009

Attention residue

Leaving a task unfinished leaves attention on it. The stack is a boundary: do the interruption, then mm done puts you back.

The way back is the command.

Mark, office studies

About 23 minutes

Getting back to the original task after an interruption takes on the order of twenty minutes. The queue is the written place you return to.

The return address is already written.

Zeigarnik

The claim that people remember unfinished tasks better has not held up as a general rule. A 2025 meta-analysis found no reliable memory advantage. mm does not depend on it.

Beside the other ways

Same urge to capture. A different next step.

In your head A todo list A calendar Notes and tabs mm
What you do next You rehearse the list instead of doing the work. It stores the tasks, then asks you to choose again. It decides when. Real interruptions blow the slots. They hold the words. They do not name what is next. Shows one thing. Never takes the clock.
When something urgent arrives The old work stays in your head while you do the new one. Another row. The place you were is somewhere in the backlog. You reschedule by hand. Another tab, another scrap. mm add -p. mm done puts you back.
Getting Things Done Same first move: get it out of your head. Then projects, contexts, and a weekly review. Stops at the three places.
Install

One file. Nothing running in the background.

mm is a Python 3.11 program. The standard library only. No pip packages, no daemon, no account. It does nothing until you type it.

  • ›State is one file, ~/.mm/state.json.
  • ›A file lock and an atomic save, so two terminals do not tear the file.
  • ›mm undo restores the previous snapshot.
  • ›Manual: man mm or mm help. Version 3.0.0. MIT.
source ~/bin/mm
git clone https://github.com/Toseef-Ahmad/mm.git
cd mm && ./install.sh
# then
$ mm add "CS302"
+ queued 1 CS302
$ mm
→ 1 CS302 active
If this happens

The command for the moment.

A gap opened. The phone is right there.The next thing is already in the box.
mm
An idea, while you are in the work.It waits behind what you are doing.
mm add "write this up later"
Something more important just arrived.It goes on top. You come back.
mm add -p "prod is down"
That thing is finished.The next one comes up. You do not pick.
mm done
You are stuck waiting on someone.It leaves the front. The next thing comes up.
mm block "waiting"
A small nag. Not this work.Off the line, until you clear the drawer.
mm add -q "email Sam"
The nags can go.flush-quick deletes them. It does not archive them.
mm flush-quick
That last command was wrong.The previous snapshot comes back.
mm undo