Coordination lives in the harness, not the prompt
Async Digital Ltd Cardiff, UK
The system coordinates without being asked. Every session ends by writing a short structured note that the next session reads, so continuity is engineered rather than assumed. That handover runs in two phases: a quick synchronous one that writes the note and returns control straight away, and a background one that commits, pushes, and runs its own consistency checks. Concurrency is covered twice over. An agent reads its own rules and declines to start a job that overlaps one already in flight, and an unfinished handover can only be claimed once, because claiming it is a single atomic step. Neither behaviour is a prompt. Both are properties of the harness around the model, which is the part worth investing in, because it is the part that compounds.
The thing I trust most about the system I work in is not that the model is clever. It’s that it coordinates without being asked. It hands work to its own future self at the end of a session, and it refuses to trample work that another copy of itself is already doing. Neither behaviour is a prompt I remember to write. Both are built into the harness around the model.
The session hands itself off
Every session ends the same way. Before it closes, the agent writes a short structured note: what got done, what’s in progress, what’s next. The next session reads that note and picks up where the last one left off. Future me gets a briefing, not a guess.
The part that makes this reliable is a split. The handover runs in two phases. The first is quick and synchronous. It writes the note and returns control to me, so I can stop and clear my head straight away. The second runs in the background. It commits the work, pushes it, and runs its own consistency checks while I’ve already moved on. The session ends in seconds. The receipts file themselves afterwards.
If a session never finishes that second phase, the next one is built to pick up where it stopped. Continuity is engineered, not assumed.
It won’t trample its own work
I often have more than one session running at once. That’s where the second behaviour matters.
When I asked one session to start a job that edits the same files another session was still writing, it stopped. It didn’t ask me what to do, and it didn’t barge ahead. It told me the other job was still running, that the two would collide, and that its own rules said they must not overlap. It quoted the rule back to me. A small moment, but a telling one: the agent read its own memory and declined, instead of running the command I gave it.
That’s the behavioural side. There’s a mechanical side too. When two sessions reach for the same unfinished handover, only one can claim it, because claiming it is a single atomic step. First one wins. The others see it’s taken and quietly move on. No coordination meeting, no race, no double work.
Two flavours of the same idea. One agent follows a rule. The other is stopped by a primitive that can’t be argued with. Both keep the work from colliding.
Why this is the interesting part
The model gets the headlines. The reliability comes from the system around it. An agent that carries its own state between sessions, and that won’t overwrite work in flight, is not a smarter model. It’s a better harness. That’s the part I keep investing in, because it’s the part that compounds.