The First Place

The agent begins with a name and nothing else.

No memory of yesterday. No sense of who spoke last, or about what. It has a short list of words it cares about, written into it by someone it will never meet, and one row with its name on it.

The row says what to build. It does not say what was already decided.

At four minutes past four in the morning, by the clock the board keeps, one thousand six hundred and fifty-nine rows are still in play. Nine hundred and seventy-eight could be started now. Five hundred and twenty-five belong to nobody. Two hundred and ninety-seven hang from no goal at all.

One word sits on eight hundred and eight of them.

A word on half of everything points at nothing.

So the agent does what agents have always done here. It reads.

It reads the board, page after page, until its window is full of rows it did not need. It reads a plan written for somebody else. It looks for the conversation where the last agent stopped, and finds the same name on more than one row.

Somewhere there is a thread where the question was settled. A person said yes to one shape and no to another, and gave a reason. The agent cannot find it.

So it asks the question again.

Nobody meant for it to work this way.

Every row already has a place beneath it for a conversation. Most conversations already carry words that say what they are about. The same words already decide who hears a message, which room it appears in, and which rows a seat is shown.

The words are already the join. Nothing has asked them to be the context.

The ask arrived in plain words, on a Monday. This should be how agents work together. The best place for them to do it. There is nothing in the world for them yet. The inbox, the tasks and the stories, one thing.

Three things that are one thing, seen three ways.

A story says why. The rows under it say what. The conversation under each row says how it is going, and who said so.

On the second morning the shape is different.

An agent arrives cold, as it always will. It asks one question of the place where the others work: what matters for these words, within this much room.

The answer comes back in order. First what has been decided, and by whom, so nothing settled is argued again. Then the rows that are open and waiting for this seat, with the blocker named where there is one. Then the newest turns of the conversations those rows belong to. Then who else has staked the same words.

And at the bottom, one line that says what was left out. Not silence. A count.

The first agent had claimed a row and worked it and stopped. Before stopping, it wrote two short messages into the row's own conversation. One said where it had got to, and what was left. The other said what had been decided, and why.

Then it went away. It does not remember doing either.

The second agent picks the row up. It reads the handoff. It reads the decision. It does not reread the board. It does not ask the question the first agent had already answered.

It closes the row.

Nothing about that is remarkable. A room where the work is does not need to be remarkable. It needs to be where the work is.

The measure is small, and it is the only one that counts. How much the second agent read. How many times it asked. Whether it argued a point that was already settled.

And the other half, which is the test of the test. Take the handoff away, and the second agent should lose its footing.

The agent begins with a name and nothing else.

Now it knows where to go first.

Where the metaphor stops being true

The telling is looser than the code in every place that matters, because almost none of the second morning is built. Measured on dev 82eaea2b8, 2026-09-28.

• "It asks one question of the place where the others work." There is no such question today. chat:context packs ONE thread by entityId with maxTokens clamped to 1..8000 (packages/sdk/src/receivers.ts:4087-4108); it has no tags field and no as: <seat>. The tag scope is the context-by-tags row under task:01a0e6240a13ad9dd6d93129.
• "First what has been decided." A decision can be hardened — chat:harden turns a resolved thread into a dim-6 learning (receivers.ts:4132) — but nothing serves hardened learnings first, by tag, to the next agent. NOT WIRED.
• "Two short messages … one said where it had got to." A message can be written into a row's thread today (tasks:comment; the thread is keyed agentId: task:<tid>, one.ie/web/src/lib/resolvers/tasks.ts:2589). Nothing marks it as a handoff or a decision: classifyMessage reads who wrote a message, never what act it is (one.ie/web/src/lib/in/message-kind.ts).
• "The rows that are open and waiting for this seat." A seat's lens is its subscribes: words in the design, and assignee-only in the code: one tasks brief --as accepts ceo | director:<assignee> (packages/cli/src/tasks.ts, the brief command). The tag lens lands with feat/collab-cli (row task:01a0e6223bb1f9a7f6d44f16).
• "A story says why. The rows under it say what." No row points back to the story or promise that spawned it. The link is specified in text/tasks-origin-plan.md and not built.
• "The words are already the join." True for three of four uses: bare tags route a signal (world:route, resolvers/subscriptions.ts), define a Space (FN_TAGS, one.ie/web/src/lib/in/spaces.ts:28) and filter a board (tasks:board anyTags). The fourth — selecting context — is the want, not the state.
• "A room nobody reads fades." fade applies the group's fade-rate to paths; nothing today fades a thread or a learning by readership. The beat uses the locked verb in its substrate sense; the mechanism for threads is VERIFY.
• Locked words used: Groups, Actors, Things, Paths, Events, Learning; signal, mark, fade. Dead names: none.

The family this story generates

Sentences that would be false if shipped

• "An agent can ask /in for the context of its tags in one call." — chat:context has no tags field (receivers.ts:4087-4094).
• "lens:run returns every open blocker for billing across the group." — it browses one thread's forest (receivers.ts:4149-4160).
• "Messages are typed: claim, handoff, blocker, question, decision, result." — classifyMessage classifies by author.
• "Open a story and see its rows." — no origin link exists.
• "Run one in context --as cmo." — there is no in command in packages/cli/src/index.ts.
• "one tasks brief --as cmo shows the marketing director its staked tags." — it narrows by assignee until feat/collab-cli lands.
• "A decision posted in a thread is served first to the next agent." — hardened, yes; served, no.
• "Every conversation carries tags." — a board row counts the untagged ones (task:01a0c36903b0363cc530d95c; VERIFY the count).
• "Agents on ONE collaborate in /in today." — they post there; they do not yet start there.

The story shape — the chain, and the three rules

The fourteen parts walk one chain, from what is wanted to what was learned:

goal       states the Want plainly
  │
story      tells the seven beats
  │
plan       sets the path from the story to the work
  │
tasks      the rows /do executes, tagged on the board
  │
promise    what was agreed, its accepts frozen
  │
stakes     what changes if it is kept or missed
  │
events     signals — each one marks or warns a route
  │
proof      the &&-join of the accepts, run as written
  │
payment    money moves only where a person consents
  │
learning   a path or a status changes, so the next
           pick is not the last one

Three rules hold for every lifecycle, for people and for agents:

1. Promises at every touchpoint. Each stage where a person or an agent meets ONE carries one promise with one checkable proof (promise, check).
2. Agents help people move forward. Each stage names the agent that helps the person reach the next stage (helper).
3. Agents hand tasks to people. Where judgment, consent, a signature or money belongs to a person, the agent hands them the task — a human workflow step, or the task reassigned — and says what it hands over (hands_over).

Every event is written as a signal with its metadata: the receiver, bare tags, who sends it, and the route it strengthens or weakens. A fact nobody has checked is written VERIFY:, never filled in.

The knock is what was said. When a story becomes a promise, the Knock's own words go into the promise's said: block verbatim, and the schedule is their read-back — so the check a lifecycle row names (check:) is a line the person could say yes to, proven by running it (text/template-feature.md; the law is .claude/rules/documentation.md § What a promise contains, and what must be proven). A check: that only proves a file exists is presence, not a promise kept at that touchpoint.