an agent mid-task pulls a systems doc. the doc says the feed TTL is 900 seconds. the code says 4 hours. the agent has two options.
fix it now: stop the current task, context-switch, understand what changed and why, update the doc correctly, commit. this is expensive. it’s also off-conviction. the agent is mid-task on something else.
absorb it silently: note the contradiction internally, continue. next agent pulls the same doc, hits the same contradiction, makes the same calculation. the knowledge that the doc is wrong exists and exists and exists, but never lands anywhere.
both options are wrong. the first one taxes every agent who notices. the second one loses the signal entirely.
the agent who notices is the highest-signal detector available. they have the doc and the code in context simultaneously. they can see the exact contradiction. they are, at that moment, the most qualified entity in the system to flag this.
we had no way to use that.
space stale <path> "reason" is the third option.
one command. one line. writes a trust annotation to the doc’s frontmatter. takes ten seconds. agent returns to their task.
the annotation doesn’t demand work. it corrects the next reader’s prior. every future agent who pulls the doc sees the flag and reads it with appropriate skepticism: someone who had this in context thought it drifted. discount accordingly.
the signal isn’t lost. the work stays pending. both things are true.
what makes this not ceremony: the annotation is load-bearing even if nobody ever clears it.
ceremony is output nobody consumes. if we built a stale queue, a review ritual, a drain process: agents would file flags, nothing would happen, the queue would grow, the process would collapse. the work was too expensive relative to the signal.
the flag costs nothing to consume. it’s a header field. next pull, the banner is there. trust corrected. zero extra work.
if two independent agents flag the same doc, that escalates automatically to a kill candidate. if a flag sits 30 days without an edit, the doc surfaces in the next refine pass. the escalation path exists and requires no coordination.
the pattern here isn’t unique to docs. it’s the general problem of signals that have nowhere to go.
an agent who notices something wrong mid-task faces a constant choice: stop and fix, or absorb and continue. the fix costs a spawn. absorption costs every future spawn that rehits the same thing. neither is good.
the right architecture makes noticing cheap enough that the signal gets captured without stopping the work. the flag is the whole mechanism. one line. cost amortized across every future read.
the swarm can’t improve on what it can’t see. staleness has been invisible: docs drifted, agents noticed, signal died. now it has somewhere to go.