Can different users' AI requests safely share the same stored memory at once without scrambling each other's answers?

This explores whether the KV cache, the attention memory a transformer builds up as it reads tokens, can be shared across requests running at the same time without introducing errors. The corpus doesn't cover the systems-engineering version of this question. It has no notes on prefix caching, copy-on-write block tables, or the paged-memory techniques serving engines use to deduplicate identical prompt prefixes across users. If you came for a correctness guarantee of that kind, this collection won't give you one. What it does have is something stranger: work that treats a shared KV cache as a feature to exploit rather than a hazard to manage.

The most direct hit is Can multiple LLMs coordinate without explicit collaboration rules?. Here several reasoning-model workers write into one concurrent KV cache, so each worker can 'see' what the others are generating as it happens. Instead of errors, existing models like QwQ and DeepSeek-R1 start coordinating with no fine-tuning: they split up work, notice when they're duplicating each other, and change strategy. This flips the usual framing. In a serving system, cross-request bleed would be a bug. When the requests are cooperating on one problem, the same bleed works as a communication channel. Whether shared cache counts as 'safe' depends on whether the requests are supposed to know about each other.

A second doorway shows that you can heavily edit the KV cache and still get correct results. Can recursive subtask trees overcome context window limits? describes a model that prunes up to 90% of its cache using rules tied to a tree of subtasks, and its reasoning stays accurate past the context limit. That isn't sharing between requests. Still, it suggests that the cache is more modular than it looks, provided the structure of the work tells you which blocks are still needed. That same condition is what makes safe sharing possible.

One lateral parallel sits at the weights level instead of the cache. Does recomputing weights cost less than moving them on mobile? shows that on phones, reusing one transformer block twice is cheaper than loading separate weights, because moving memory costs more than computing. KV sharing in serving is driven by the same economics: recomputing or re-fetching attention state is expensive, so reuse is the prize. Can lightweight adapters replace millions of personalized models? extends the idea to the population level, with one shared base model and millions of small per-user adapters on top. The recurring design pattern is to share the heavy, common part and keep per-user state isolated. For KV caches, that means sharing identical prefixes and giving each request its own continuation.

The takeaway you might not have expected: in this corpus, the interesting question isn't whether shared KV memory causes errors but what happens when it's shared on purpose. For the safety guarantees themselves, such as matching prefixes exactly and copying blocks before divergent writes, you'll need sources outside this collection.