Stop writing status updates. Your agent already knows what you did.
Your agent was there for the whole job. Let it log the start, the decisions and the things you chose not to do, so you never write a status update again.
You spend the day working with an agent. A lot gets done.
Almost none of it is written down where your team can read it. The code is in git. The reasons are in a chat only you can open.
So you write it again. At stand-up. In the ticket. In the Friday handover. Each time from memory, and each time a bit less accurate.
What gets lost
A commit says what changed. It does not say:
- why you did it this way,
- what you tried first,
- what you decided not to do.
The last one costs the most. If nobody wrote down that an idea was rejected, someone tries it again. So does the next agent. It reads your whole repo and none of your reasons.
The fix
The agent was there for all of it. Let it keep the log.
It writes at four moments:
- Start. What it is about to do, and why.
- Decision or pivot. What it chose and why, or how the plan changed. Also what it ruled out.
- Blocker. What stopped it.
- Done. What it made, where it is, and what is still open.
Three rules make it work:
- Set it once. Put the rule where the agent reads it before every task, like
AGENTS.mdorCLAUDE.md. Then you never ask for a log. - Log in the background. The agent can hand the logging to a subagent that runs in parallel. Your work doesn't wait, and your context stays clean.
- Read first. Before a task, the agent searches the log. It points out what already exists: earlier work, ideas, notes and reports. It also stops repeating ideas that were already rejected.
What it looks like
This thread is based on an entry from our own log this week. A coding agent wrote every message. Nobody asked for a status.
If that warning comes back in two months, the cause is one search away.
Look at the second message. It is about something the agent did not do, and why. Those are the entries I like most. One line like that saves somebody an afternoon next quarter.
For code there is one more step. Every commit carries the id of its log entry. A reviewer goes from the commit straight to the reasons.
The best part: it is not only for developers
Developers have always had git. Every change is on record, with who made it and when.
Everyone else had nothing like it. Research, writing, planning and sales work left no trail.
Now they get one too. The same rule works in Claude or ChatGPT, so every kind of work gets its own history. Think of it as git for decisions.
A teammate opens that thread and sees what was ruled out, where the plan changed, and what is still open.
Keep it clean
- Log decisions and results, not every step.
- Keep secrets and personal data out.
- "Don't log this" should always work.
What to use
- A
WORKLOG.mdfile in the repo. Free and simple. It only covers that repo, and only people who read code will see it. - Commit messages and pull requests. They say what shipped. They rarely say what was dropped.
- Naumu. This is what we build. Each piece of work is a thread in a topic your team follows. People read it. Agents search it before they start. Coding agents and chat apps write to the same log.
Set it up with Naumu
- Create an account and a space.
- Open Settings → Your agents and pick your app.
- Connect it with what the page shows you, then sign in in the browser. There is no API key.
- Pick the topic the log should go to.
- Copy the setup prompt and paste it into your agent.
- Work as usual.
What step 3 gives you:
- Claude Code:
claude mcp add --transport http --scope user naumu <url> - Codex:
codex mcp add naumu --url <url>, thencodex mcp login naumu - Claude and ChatGPT: the same URL, added as a custom connector.
In a repo, the prompt adds the logging rule to AGENTS.md and opens a pull request, so your teammates' agents get it too. It asks before each command.
Next: make your agent multiplayer.