PReCache: Efficient KV Cache Sharing for Multi-LoRA Agents via Low-Rank Precomputation and Neutral Reconstruction
Hyesung Jeon, Hyeongju Ha, Jae-Joon Kim
Seoul National University
Published September 28, 2026 · on the feed September 29, 2026 · ▲ 4 · arXiv 2609.34054
The abstract
Multi-LoRA agent systems enable efficient role specialization by sharing a common backbone model. However, each agent repeatedly processes the growing shared trajectory and constructs its own KV cache, introducing substantial memory and computation redundancy in long-horizon tasks. Existing KV cache sharing methods reduce this repeated prefill, but they either require additional training or architectural constraints or retain substantial model computation. Moreover, direct cache reuse causes the current agent to rely on cache states generated by the previous agent's adapter, weakening the role-specific behavior encoded by its own LoRA. We present PReCache, a training-free KV cache sharing framework with two designs, namely PreLRShared and ReBaseShared, that share the base cache computed using the pretrained weights and precompute a compact agent-specific low-rank (LR) cache. To remove repeated prefill, PreLRShared precomputes each agent's LR cache when the shared context is first processed, allowing the current agent to use its own LR cache without reprocessing context processed by previous agents. To improve sharing accuracy, ReBaseShared reconstructs the shared base cache from adapter-free hidden states, reducing the remaining error caused by the previous agent's adapted representation. To minimize its reconstruction cost, we propose two inference schemes tailored to single-stream inference and concurrent serving, performing the same reconstruction after each agent's turn or alongside its execution, respectively. Across multiple models and agent benchmarks, PreLRShared achieves up to a 3.1x TTFT speedup and a 2.3x improvement in per-request throughput over inference without KV cache sharing. ReBaseShared best preserves accuracy overall among the evaluated cache-sharing methods, with an average drop of only 1.1 points relative to inference without cache sharing.
The Brief
3:07A short podcast summary of the paper. Written and voiced by AI.
Transcript
PReCache. Efficient KV Cache Sharing for Multi-LoRA Agents via Low-Rank Precomputation and Neutral Reconstruction. By Hyesung Jeon and two others, from Seoul National University. Published on the twenty-eighth of September. Its code repository is worked out: about one hundred and forty source files, with a readme and a licence.
In a multi-LoRA agent system, several agents share one backbone model, and each gets its own role through its own LoRA adapter. That makes specialization cheap, but it hides a cost. As a long task unfolds, the shared trajectory keeps growing, and each agent processes it again and builds its own KV cache from it. Over a long horizon that is a great deal of repeated memory and computation.
Existing methods for sharing the KV cache do cut the repeated prefill, but they either need extra training, impose architectural constraints, or still leave a lot of model computation in place. There is a subtler problem as well. If the current agent simply reuses the cache as it stands, it is relying on cache states produced by the previous agent's adapter, and that weakens the role-specific behaviour its own LoRA is supposed to encode.
PReCache is a framework for sharing the KV cache that needs no training. Its core move is to separate what is common from what is personal. Every agent shares a base cache computed with the pretrained weights. Alongside it, each agent has a compact, agent-specific low-rank cache, which is precomputed. The framework comes in two designs, PreLRShared and ReBaseShared.
PreLRShared targets repeated prefill. When the shared context is processed for the first time, it precomputes the low-rank cache for every agent. After that, the current agent can use its own low-rank cache without reprocessing any of the context earlier agents already handled. The expensive pass over the context happens once, and each agent's personal part of the cache is ready before that agent's turn arrives.
ReBaseShared targets accuracy. It reconstructs the shared base cache from hidden states that carry no adapter, which reduces the remaining error that comes from the previous agent's adapted representation. That reconstruction has a cost, and to keep it down the authors offer two inference schemes. One suits single-stream inference and does the reconstruction after each agent's turn. The other suits concurrent serving and does it alongside the agent's execution.
Across multiple models and agent benchmarks, and compared with inference that shares no KV cache at all, the speed-oriented design, PreLRShared, reaches up to a three point one times speedup in time to first token. It also delivers up to a two point three times improvement in throughput per request. ReBaseShared is the most accurate of the cache-sharing methods evaluated overall, with an average drop of only one point one points relative to inference without cache sharing.
The two designs map onto the two things a shared cache can cost you. One is time, spent recomputing context that every agent has already seen, and PreLRShared goes after that. The other is identity, the risk that an agent reading a neighbour's cache stops behaving like itself, and ReBaseShared goes after that by rebuilding the shared part from a neutral starting point, one that belongs to no single agent.
Paper Quest · 7 chapters · about 41 min
Play this paper
Learn it by doing: make the calls the authors made, guess the result before you see it, and defend it in a viva graded on your own words. Chapter 1 is right here.
Chapter 1 🧩 · The problem
Many agents, one model, and a history that every agent keeps rereading.
You run several agents on one shared base model, each with its own small adapter for its role. They take turns on a long task, and the shared history keeps growing.
The road ahead
- 1 · The problem ~7 min Agents that share one model but wear different adapters each rebuild the same long history, and reusing each other's cache blurs their roles.
- 2 · What came before ~3 min
- 3 · The key idea ~9 min Split each agent's cache into a shared part from the pretrained weights and a tiny personal part, precomputed for every agent the first time text is read.
- 4 · Choose your own research ~3 min
- 5 · Build the method ~8 min Build a shared base cache, fill every agent's low-rank cache in the same first pass, then rebuild the base cache with adapters off.
- 6 · The experiment ~6 min You’ll guess: At best, how much faster to first token was PreLRShared than multi-LoRA agent inference with no KV cache sharing?
- 7 · The viva ~5 min Three questions from the examiners, answered in your own words. Win it for the paper’s trophy.
Free, with Google or an email address. Your stars and progress are kept.