- Rating
- 1
- Confidence
- 3
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
This paper presents MCPool, a framework for jointly caching warm MCP execution contexts and reusable tool results under a shared memory budget. A recurrent PPO controller adjusts the memory split and admission thresholds for the two cache types, while a deterministic manager performs admission and eviction and enforces the budget. Experiments on MCP-Bench across three LLMs report 1.34–2.38× mean task-latency speedups over a static allocation baseline, with no observed retained-cache budget violations.
Critical strengths
None
Critical weaknesses
- The practical importance of the problem and the novelty of the method remain unclear. The paper identifies cold-start and memory overheads but does not clearly establish their impact on end-to-end task execution in a reasonably optimized deployment. The method mainly combines standard GRU and PPO components with hand-designed caching rules. The contribution appears to be primarily an application of these techniques to MCP; I do not yet see a clear methodological advance or new design insight.
- The experiments do not sufficiently establish the benefit of RL over simpler alternatives. It is unclear how Static-Control was tuned, and comparisons with competitive, simple adaptive heuristics using the same budget manager are missing. The paper also does not report the total costs of data collection and policy training, making it difficult to assess whether the runtime gains justify the additional training and maintenance effort.
Questions for authors
- With the same budget manager, how much additional benefit does RL provide over well-tuned static policies and simple adaptive heuristics? This is my main criterion for judging whether RL is warranted.
- What are the time and API costs of data collection and policy training, and how many subsequent tasks are needed to offset these costs? Is retraining required when the model, tool set, or workload changes?
Critical Weaknesses 1 Response:
We thank the reviewer for these comments. To be honest, we believe the reviewer completely missed the point in this work. First of all it is not true that the MCPool is primarily an application of GRU and PPO; its contribution concerns the joint resource-management problem and the architecture used to address it.
Practical significance. Recent studies have highlighted the scalability challenges of MCP deployments [1], quantified connection-establishment overhead [2], and demonstrated the importance of reducing repeated orchestration costs in MCP-based workflows [3]. MCPool addresses memory management even when context reuse is already available. Our profiling across 28 MCP-Bench environments shows that retaining all execution contexts requires over 1.85 GB, with context footprints varying by more than 2.5×. Crucially, MCPool reduces mean task latency by 38.0% relative to ContextOnly, which already retains initialized contexts, and achieves 1.34×–2.38× speedup over Static-Control across three execution models. These are end-to-end improvements beyond simply eliminating cold starts.
Design contribution. The key insight is that context and result reuse have coupled, overlapping benefits while competing for the same memory: a result hit bypasses both initialization and execution, whereas a retained context benefits requests whose results miss. MCPool coordinates these mechanisms through a fixed-dimensional resource-level controller and a deterministic entity-level manager. For Q resource classes, the controller uses 2Q-1 action dimensions regardless of the cached-entity population, while the manager enforces the retained-memory budget independently of policy outputs. Ablations support this decomposition: MCPool reduces latency by 25.4% relative to FixedSplit at 320 MiB and 28.6% relative to the controller without recurrent history at 240 MiB.
GRU and PPO are implementation choices, not the claimed novelty. The contribution is the joint-control formulation and architecture separating workload adaptation from budget enforcement, supported by end-to-end measurements and component ablations.
[1] Li et al. Scalable LLM Agent Tool Access in the Cloud. 2026.
[2] Varshney. The Cost of Saying Hello: An Empirical Study of Handshake Overhead in AI Agent Communication Protocols. 2026.
[3] Merchant et al. Evaluating Temporal Semantic Caching and Workflow Optimization in Agentic Plan-Execute Pipelines. 2026.
Critical Weaknesses 2 and Question 1 Response:
We thank the reviewer for these comments and appreciate the suggestion to include additional adaptive baselines.
We would like to clarify that Static-Control is tuned through an offline exhaustive search over the specified allocation and admission-threshold grid, rather than relying on arbitrary parameter choices. Under the same deterministic budget manager, MCPool achieves 1.23×–1.52× speedups over Static-Control across the evaluated memory budgets, demonstrating the benefits of adaptive joint control over well-tuned static configurations.
Recurrent PPO addresses the partial observability and delayed feedback inherent in retention decisions: the recurrent state summarizes workload history, and the policy learns joint allocation and admission decisions from subsequent latency outcomes. The current results support its effectiveness relative to static control. We agree that comparisons with simple adaptive heuristics would further quantify the benefit of learning-based adaptation. Accordingly, we will add these baselines under the same budget manager to isolate the learned controller’s contribution.
Question 2 Response:
We thank the reviewer for raising these concerns. Our evaluation focuses on runtime execution efficiency, while a comprehensive accounting of offline data collection and training costs, including a deployment-specific break-even point, is beyond the scope of this study. Importantly, MCPool uses a frozen policy during deployment, requiring no additional training or API-based policy optimization for individual tasks. Our additional policy-overhead experiments further show that policy inference introduces negligible overhead relative to task execution. Thus, offline training costs can be amortized over repeated executions.
Regarding generalization, changes in the execution model, tool set, or workload do not necessarily require retraining, as the controller operates on class-level runtime statistics rather than task-specific identities. This design allows the policy to respond to changing system conditions, although substantial distribution shifts may still affect performance. In such cases, the existing policy can potentially be fine-tuned rather than retrained from scratch.