The journal is the only page I open

A friend messaged me last week asking if I was using outl day to day. Then, before I could answer, he added the part that made me want to write this: “I haven’t taken notes in months, I just talk to agents back and forth now.”

I can’t work like that. Not because talking to agents is wrong, I do it all day. It’s that the conversation ends and whatever I decided inside it evaporates. Notes are how I remember, and outl is where they go.

So he asked the question this whole post is an answer to: how do you structure it?

I don’t. That’s the honest answer, and it took me a few years of trying the opposite to land on it.

everything from today goes into today

outl opens on today’s journal. That’s not a preference I configured, it’s the default, and it’s the single design decision that makes the habit survive.

Every note-taking system I abandoned died at the same step: deciding where the note goes. You have a thought, and before you can write it you have to answer a filing question. Which project is this? Does it deserve a page? Is there already a page? That question arrives at the exact moment you know the least about the note you’re writing, and it costs more energy than the note itself. So you skip it. Then you skip the note.

The journal has no filing question. It’s today. Today always exists, it’s already open, and it doesn’t care what the note is about. I press i and type.

Six years of daily notes later, my workspace has around 2800 pages in it. I created maybe five of them by hand.

the links do the filing

Here’s a real block from a 1on1, cleaned of anything private:

- #1on1 [[@joão]]
  - remind him to use #outl
    - it helps him remember what he did and what he still owes
    - mostly it helps me remember everything I've told [[@joão]]

Four lines, and all the organizing is inside them.

#1on1 and [[@joão]] both resolve to pages. In outl a tag and a bracket reference point at the same file, and both count as backlinks. The # form is shorter to type and shows up in tag counts, the [[ ]] form takes spaces and accents. That’s the whole difference.

The @ in [[@joão]] is a mention. Type @ at the start of a word while editing and every client opens a person picker listing only pages that carry type:: person, so I don’t have to remember whether his page is joao, joão, or his full name. The @ is decoration on the link, the page underneath is just a page.

The nesting matters more than it looks. The child blocks carry the reason, not just the fact. Later, when that line comes back to me from somewhere else, it comes back with its parent chain attached, so I get “1on1 with joão, remind him to use outl” instead of a naked sentence I can’t place.

That’s it. That’s the structuring. A tag for the kind of thing it is, a link for whoever or whatever it’s about, indentation for the why.

the page assembles itself

I almost never write on the joão page. I open it.

When I do, outl shows every block in the workspace that mentions him, newest first, each one carrying the breadcrumb of its parents. Six months of 1on1s in order, plus the times I mentioned him in an unrelated meeting note, plus the tasks I owe him. I never filed a single one of those.

flowchart LR
    J1["journal<br/>2026-08-04"] --> P["page: joão"]
    J2["journal<br/>2026-08-11"] --> P
    J3["journal<br/>2026-08-18"] --> P
    P --> B["Linked from<br/>every block that named him,<br/>with its parent chain"]

This is the trade the journal makes. You give up choosing where things live, and in exchange the index builds itself out of the words you were going to type anyway. A folder can only hold a note in one place. A link puts the same block on the person’s page, the project’s page, and the tag’s page at once, without copying it.

In the TUI the backlinks section is B, and Ctrl+O flips it between newest and oldest first. On desktop and mobile it’s the panel below the outline. It loads after the page paints, which is deliberate: computing backlinks used to be what made opening a big journal slow, so now the outline renders first and the panel fills in a beat later.

tasks for my future self

This is the part my friend actually wanted to know, and it’s where journal-first stops being obvious. If everything goes into today, what happens to a thing that belongs to a Tuesday three weeks out?

I write it into that Tuesday. There are two shapes for that, and which one I use depends entirely on where the task was born.

When the task stands on its own, I go to the day. Typing /date 2026-09-15 in insert mode drops [[2026-09-15]] into the block, and pressing Enter with the cursor on that link opens the journal for that day, creating the file if it doesn’t exist yet. I write the task there and go back. [ and ] walk days one at a time, t returns to today.

When the task came out of something I was already writing, I leave it exactly where it is. Moving it would strip the context that makes it make sense. Instead I stamp the date into the block itself:

- TODO #fup [[@joão]] about the pricing deck [[2027-01-01]]

The block stays in the day the conversation happened, nested under whatever it came out of. Then, on 2027-01-01, I open that day’s journal and the block is sitting in its Linked from section, with the parent chain that explains why I wrote it. The task travelled forward in time without moving on disk.

That’s the mechanic underneath the entire workflow: a backlink for a future journal finds blocks written in past journals. Which sounds obvious once you say it out loud, and is exactly the thing that makes a plain date reference work as a reminder system.

The /date family covers the shapes I actually reach for. /date-tomorrow, /date-next-monday, /date +3d, /date -2w, or a full date if I know it. All of them insert at the cursor without committing the edit I’m in the middle of, so I can keep typing through them.

One deliberate limit: a [[date]] never notifies me. It’s a backlink, nothing else. Plenty of dates in my notes are just dates, and the moment a link starts buzzing people stop linking. When I do want to be interrupted, I say so:

- TODO #fup [[@joão]] about the pricing deck [[2027-01-01]]
  remind:: 9am every 1h until DONE

Reads like English because it is: at 9am, hourly, until the block is DONE. Flipping it to DONE cancels every pending fire, and snoozing it on my phone silences it on the laptop too, because the snooze goes into the op log and converges like any other edit. Worth knowing the honest limit before you lean on it: today reminders fire while an outl client is running, and delivery with every app fully closed is still on the list.

when I want a list, I ask for one

I never installed a task manager. Not out of principle, I just kept failing to keep one in sync with my notes, because the task always got written twice: once in the note where I decided it, once in the app, and the copy in the app lost the reason.

Now the TODO lives in the block where the decision happened, and when I want them collected I write a query where I want to read it:

- ```query
  status: todo
  kind: journal
  since: 14d
  sort: page
  ```

Every directive is ANDed, so this reads as open tasks, in journals, from the last two weeks, grouped by page. tag: ops narrows it to a project, text: deploy to a word.

The results are live embeds of the original blocks, not copies. Ticking one off in the query view marks the actual block in the actual day it came from, and every other query that surfaces it agrees on the next run. Query fences re-run on every page load, so there’s nothing to refresh.

The one I keep at the top of a project page is the boring one, status: todo plus the project’s tag, and it’s the closest thing to a system I have.

the agents write in the same journal

Back to what my friend said about only talking to agents. I do that too. The difference is where the output lands.

outl mcp serve exposes the workspace over MCP as a subcommand of the same binary. Every tool maps one to one onto a CLI command, so an agent can read outl://daily/today for the day’s context and append with outl_daily_append, or drop a whole nested structure in one call with outl_block_append_tree.

What that buys me is that there’s no second brain. When an agent records a decision from a session, it writes a block into today’s journal with the same [[links]] and #tags I would have typed, and that block shows up in the project’s backlinks next to the line I wrote by hand. I can’t tell them apart a month later, which is the point.

The server is long lived, so on a machine with paired peers it acts as that device’s peer and pushes the edit to my laptop and phone as it happens. An agent writing at 2am is on my phone at breakfast.

what I don’t do

No folders. No PARA, no zettelkasten, no naming convention. No weekly review ritual, and no inbox to process, because there’s no inbox: the thing I wrote is already in the day it happened, and the day it happened is usually the context I search by anyway.

I don’t rename pages, and I don’t archive. A page I stopped referencing stops appearing on its own, which is the only archiving that ever stuck for me.

I do use Ctrl+P constantly, and /search when I remember a phrase but not a page.

if you want to start

Two weeks, three habits, and don’t add anything else until those are automatic.

Write everything in the journal. Resist making a page by hand, even when it feels wrong, especially when it feels wrong.

Link the nouns that repeat. Every person, project, and company gets [[brackets]] or a #tag the first time it shows up. You’re not organizing, you’re just typing the name in a way that sticks.

When something belongs to a future day, put the date in the block where it was born, not in a separate list.

That’s the whole thing. My workspace is 2800 pages and about 211 thousand operations of history, and I have never once decided where a note goes.