I stopped keeping work in my head

A few weeks ago I gathered the support context into a single folder.

Configs, project notes, instructions, analytics and the route from ticket to logs all ended up there.

It made investigations much easier.

And then the next problem showed up.

Work isn’t only made of files.

There are tasks. Projects. Decisions. Tickets. Conversations. People. Metrics. And the reasons why something was done a particular way three months ago.

All of it exists at the same time.

And it’s usually held together by one rather unreliable component.

A human.

Memory as infrastructure

For most of the working day I don’t create new information at all.

I recover old information.

What have we already figured out about this project?

Why doesn’t this access work?

Who did we discuss the problem with?

Is there a ticket?

What’s left to do?

What’s the name of the agent we need?

Where does the config live?

What did the developer say two weeks ago?

Every individual answer exists somewhere.

The problem is the word “somewhere”.

You can keep Jira in good order. You can write carefully in Slack. You can put documents into folders. You can maintain a task list.

But the connectivity between them still has to be rebuilt by hand.

You end up with a strange architecture:

Jira ──────┐
Slack ─────┤
files ─────┤
metrics ───┤── human ── decision
tasks ─────┤
notes ─────┘

The human here isn’t only working as an engineer.

They’re also manually acting as a database.

I started getting tired of that.

I set up yet another system

That sentence sounds dangerous.

It’s usually how a story begins that ends with seven boards, three calendars and a person spending twenty minutes each morning noting that today they intend to work.

So for a long time I didn’t want another layer.

But at some point I tried using Notion not as a notebook and not as a task manager.

But as a map of connections.

A very simple model came out of it:

Direction
    ↓
Project
    ├── Tasks
    └── Knowledge

Direction is a permanent contour.

Main work, a project of my own, or a personal site, for instance.

Project is a finite result inside it.

Something that can one day be finished.

A project has actions and accumulated context.

And it suddenly turned out that this is already enough.

You don’t need to invent a perfect classification of life.

You just need to stop keeping different kinds of things in one list.

The board turned out not to be the point

The structure by itself isn’t especially impressive.

People were building task databases long before language models appeared, and probably kept building them instead of working.

The interesting part is elsewhere.

That structure is now read not only by me.

Today I can tell an agent: look at a particular direction, find the related project, pull up its notes, check the working discussions and understand what happened before.

Not retell the history by hand.

Not hunt for five links.

Not start every session with:

Right, a bit of context first, about four thousand tokens.

The context already exists outside.

That changed how I think about LLM memory quite a lot.

The model doesn’t have to remember

There’s a lot of talk about agent memory right now.

About how much context fits into a model. What it forgot. What needs saving between sessions. How to build infinite memory.

It increasingly seems to me that part of the problem is framed wrongly.

The model isn’t obliged to remember my work.

The work should exist in a form the model can restore.

Those are different things.

I don’t need an agent to remember the history of some project for life.

I need it to be able, when necessary, to see:

project
  ↓
current tasks
  ↓
decisions made
  ↓
instructions
  ↓
sources

And not start from nothing.

In that sense good external context resembles a file system more than it resembles human memory.

I don’t remember the contents of every file on my computer.

But I know the information exists and can be found.

The next layer

After that it gets more interesting.

Notion knows the structure of the work.

Slack holds the conversations.

Jira holds the formalised problems.

Grafana knows what’s happening with the system right now.

Spreadsheets hold the results.

You get a different route:

ticket
  ↓
project
  ↓
context
  ↓
discussions
  ↓
data
  ↓
action

And the agent can walk it itself.

A problem comes in, say.

It opens the ticket.

Works out which project it belongs to.

Looks at the internal documentation.

Finds the earlier discussion.

Checks the data.

Records the result.

And the human joins where a decision is genuinely required, rather than to carry information between tabs.

This isn’t the autonomous employee from the slide deck yet.

Thank God for that.

It’s just a decent way to stop using a human as an integration bus.

An external brain

Notion often gets called a “second brain”.

I don’t much like the expression.

There’s no second brain in there.

There’s no brain in there at all.

There’s structure.

And that, I think, is its main value.

I can not remember a task if it’s written down.

Not remember a decision if I saved the reason.

Not hold a whole project in my head if connections exist between its parts.

And spend the freed attention on the work itself.

For a human that’s convenience.

For an agent it’s infrastructure.

The environment again mattered more than the model

In the piece about the support kit I arrived at a fairly simple thought: instead of trying to make the model smarter, it’s more useful to give it a decent environment to work in.

Now I’d add one more line.

The environment should be able to remember on its behalf.

Not everything.

Not forever.

Not every phrase from every conversation.

Just enough that tomorrow a human or an agent can understand why the system looks the way it does.

That’s probably the most useful automation of memory there is.

Not remembering more.

Starting over less often.