Link people and work to everything you write with @-mentions

Six weeks ago I wrote a task comment that said "this depends on the auth refactor." Past me knew exactly which refactor. Present me, scrolling back through the thread to figure out why a task was blocked, had no idea. There were three things in the project I could plausibly have called "the auth refactor," and the comment pointed at none of them. It pointed at a memory I no longer had.

That is the small, recurring failure this post is about. References go stale. A name in prose means something the day you write it and nothing a month later. And when you need a specific person to weigh in, you leave the document, go find them somewhere else, and hope the context survives the trip. In a workspace shared by humans and AI agents, both of those problems get worse, because the agents are reading what you wrote and writing their own references back.

Plain text loses the link

When you write "the cache layer task" in a comment, you are storing a pointer in your own head and a string of characters in the database. The two are not connected. Nothing links that string back to the actual task, so nobody can click it, and nothing notices when the task gets renamed or closed. The words keep saying "cache layer task" long after the task itself moved on.

It gets worse for people. "Can Alice review this?" sitting in a description does nothing for Alice. She has to already be looking at that description to know she was named. So the real way you ask Alice is you leave the doc, open chat or email, and re-explain the thing you just wrote down. The reference and the request live in two different places, and neither one carries the other.

Turning a reference into a link as you type

The fix is the @-mention, and the part that matters is that you never leave what you are writing to make one. Type @, the picker opens, you keep typing to filter, and you pick a row. What lands in the text is not a string that looks like a name. It is a canonical reference to a specific entity, rendered as a chip you can click.

There are four kinds of thing you can mention, and each gets its own color so a paragraph stays scannable. Glance at a block of text and you can see at a glance what is a person, what is a project, and what is a piece of work.

Only people get pinged

This split is the part I think people get wrong about mention systems, so it is worth being precise. Mentioning a person is an action. Mentioning a piece of work is a link. They are not the same gesture, and Workunit keeps them separate.

The practical upshot is that you stop rationing your references. Linking a workunit or a task is free, so you do it every time it would help a future reader, and you reserve the @user mention for the moments you genuinely need someone. The signal stays meaningful precisely because the cheap links are not competing with it for attention.

The chip carries its own context

Task and workunit names are ambiguous on their own. Plenty of projects have a workunit called "Ship the rocket," and plenty of workunits have a task called "Fix the bug." A bare name leaves the reader to guess or click. So those two chip types render their parent inline, muted, ahead of the name.

It is a small thing that pays off most when you come back cold. The "where" travels with the reference, so a paragraph you skim weeks later still tells you which task in which workunit, without a single click. That is the difference between a comment you can act on and a comment that sends you spelunking.

Paste a URL, get a mention

Half the time you already have the reference in your clipboard. You copied a task URL from a browser tab, or someone dropped a link in a chat. So pasting a Workunit URL into a mention-aware field converts it to a chip automatically — the same canonical reference you would have built with the picker, with none of the typing. It is the Notion and Basecamp behavior, and once you have it you stop thinking about it.

It works for all four entity types, and it stays out of your way when it should. A URL pointing at a different org will not resolve, so it is left as plain text rather than converted into a broken chip. And if you did not mean to convert it, the browser's own undo puts the raw URL back.

Editing a doc should not re-ping everyone

The fastest way to make people mute a feature is to ping them for nothing. If every edit to a description re-fired every mention inside it, a teammate who left a comment in the morning would get pinged again every time you fixed a typo that afternoon. So mentions deduplicate.

If you mention the same person again on the same entity, they only hear about it if the previous notification was already read, or if it has been more than six hours. A morning edit and an end-of-day edit both land in the inbox, because those are two real moments worth a ping. An edit-storm in between collapses to one. Mentioning yourself drops silently, and so does mentioning someone outside your org — they simply will not resolve.

The point of all of this is that you should not have to think about it. Write what you mean, leave the mentions in place when you edit, and the system works out who actually needs to hear about it. The good behavior is the path of least resistance, which is the only kind of good behavior that survives a busy week.

Everywhere you write, including where the agents write

A mention system is only worth learning if it works in every place you actually write. One pattern that only covers comments leaves you back in plain text everywhere else. So mentions are wired into every collaborative text surface in Workunit:

Context atoms are the surface I care about most here, because they are where the AI agents write. A workunit accumulates a trail of small typed records as work happens, and humans and agents both add to it. When an agent saves a decision that touches another workunit, or notes that a task is blocked on a second one, it can reference them canonically — the same chips you would type, written by the agent into the shared trail.

References that outlive the moment you wrote them

The comment I wrote six weeks ago would not have aged into a riddle if "the auth refactor" had been a chip instead of a phrase. I would have clicked it, seen the workunit, and known in a second what past me meant. That is the entire pitch: a reference you write today should still mean something specific when you, a teammate, or an agent reads it long after the context has left your head.

Mentions are a small feature in the sense that there is not much to learn — type @, pick a thing, keep writing. They are not a small feature in what they prevent. They keep people and work linked across everything you write, pull the right person in without making you leave the document, and give the agents sharing your workspace a way to point at work as precisely as you can. The references stop going stale, and the questions stop turning into spelunking expeditions through your own history.