acceptodds
Withdrawn from ICLR 2027

MCPool: Learning Joint Memory Allocation for Heterogeneous Reuse in MCP Agents

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Agents using the Model Context Protocol (MCP) can reduce tool-invocation latency by retaining initialized execution contexts and reusing eligible tool results. These two forms of reuse differ in memory footprint, lifetime, and validity, yet compete for the same memory budget. Their benefits also overlap: a result hit avoids both context acquisition and tool execution. We formulate this heterogeneous dual-resource management task as a partially observable sequential decision problem, where future requests are unknown and retention decisions yield delayed latency benefits. To address this, we present MCPool, an RL-based controller for jointly managing context and result retention under a shared memory budget. Specifically, a recurrent policy summarizes class-level runtime statistics and selects a memory split and class-specific admission thresholds. A deterministic manager translates these controls into entity-level admission and eviction decisions, and enforces the shared budget limit independently of the learned policy. This separation enables robust scalability to shifting cache populations. Our extensive experiments across a wide range of tasks and baselines demonstrate that MCPool can achieve over a 1.34x 3.10x speedup while satisfying the memory budget with zero observed violations.

Primary area:
optimization
Keywords:
agent, MCP, online learning, RL

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_xzU6OpenReview ↗
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
  1. 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.
  2. 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
  1. 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.
  2. 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?
1 comment

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.

Reviewer_WUg1OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces MCPool, a cache controller for Model Context Protocol (MCP) agents that jointly retains initialized server contexts and reusable tool results under a shared memory budget. A recurrent PPO policy chooses a class-level memory split and admission thresholds, while a deterministic manager handles entity-level admission and eviction and enforces the retained-cache budget. On MCP-Bench-derived workloads, the paper reports lower latency than several cache baselines, reduced token counts, and zero violations of the retained-memory cap. The problem is timely and the system design is clearly presented, but the current evaluation leaves open whether the gains generalize beyond repeated, deliberately structured task arrivals and whether they preserve task quality and practical memory guarantees.

Critical strengths
  1. The paper identifies a meaningful systems problem: warm execution contexts and cached tool results have different costs and reuse patterns, yet compete for memory and provide overlapping latency benefits.
  2. The separation between a learned resource-level controller and a deterministic cache manager is intuitive. The paper also gives a clear invariant argument for the manager’s retained-cache accounting under its stated assumptions.
Critical weaknesses
  1. The algorithmic contribution is modest relative to the paper’s broad claims. MCPool applies standard recurrent PPO to choose a three-dimensional control (allocation and two thresholds), while a hand-designed value-density manager performs the actual item selection; the paper does not establish that RL is needed versus strong, budget-feasible online heuristics using the same manager.
  2. The workload evaluation is small and heavily structured around repetition. The held-out set has 50 arrivals drawn from only 26 tasks, with 24 tasks repeated twice, while the training and stress workloads also deliberately create repeated-task and locality phases; the reported gains may therefore depend on exact-result reuse patterns that are more favorable than typical MCP traffic.
Questions for authors
  1. How much of MCPool’s latency improvement remains when evaluation uses unique tasks or a less repetitive arrival trace, given that 24 of the 26 held-out tasks appear twice?
  2. Can you compare the recurrent PPO policy with strong budget-feasible online heuristics using the same deterministic manager, to isolate the benefit of learning the allocation and admission controls?
  3. How many task executions failed or could not be scored for each method, and what evidence shows that reusing cached results does not reduce task correctness when tool state changes?
1 comment

Critical Weakness 1 and Question 2:

Weakness: The algorithmic contribution is modest, and the benefit of recurrent PPO over budget-feasible adaptive heuristics has not been sufficiently established.

Question: Can recurrent PPO be compared with adaptive heuristics using the same deterministic manager?

Response:

We thank the reviewer for these comments. We would like to clarify that MCPool's primary contribution lies in the joint management of context and result reuse under a shared memory budget, rather than a new RL algorithm. We agree that comparisons with adaptive heuristics would help isolate the benefit of learning. Accordingly, we will add adaptive heuristic baselines using the same deterministic manager to provide a fair comparison between learning-based and heuristic control.

Critical Weakness 2 and Question 1: Workload Repetition and Generalization

Weakness: The held-out workload contains only 50 arrivals from 26 tasks, with substantial repetition, potentially favoring exact-result caching.

Question: How much latency improvement remains under unique tasks or less repetitive workloads?

Response:

We thank the reviewer for raising this concern. MCPool is designed for workloads with recurring tasks and temporal locality, where repeated tool invocations create opportunities for context and result reuse. Such repetition is therefore an intentional aspect of our evaluation. Importantly, exact task repetition is not necessary for reuse, as distinct tasks may access the same MCP servers and benefit from retained execution contexts without identical tool results.

Appendix F.3 evaluates longer, 250-arrival workloads under different locality patterns, including low result reuse. MCPool maintains approximately 1.3× speedup over Static-Control, even with reduced result-reuse opportunities. Furthermore, Appendix F.4 evaluates 500-arrival workloads with varying server populations (8–24) and query diversity (16–64 topics). These results demonstrate benefits across broader workload conditions. We will highlight these existing evaluations more clearly in the main text.

Question 3: Task Failures and Cache Correctness

Question: How many executions failed or could not be scored, and how does MCPool prevent cached results from reducing correctness when tool states change?

Response:

We thank the reviewer for this question. Based on the available execution and judge records, no task executions were marked as failed. To mitigate stale-result reuse, MCPool explicitly excludes highly time-sensitive tools from result caching, as described in Section 3.3. Appendix D.2 (Algorithm 1) further specifies that only eligible cached results may be reused; otherwise, the tool is executed to obtain a fresh result. This conservative eligibility mechanism reduces the risk of stale-result reuse, although it does not guarantee correctness under arbitrary tool-state changes.

Reviewer_9Dx9OpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper introduces MCPool, an RL-based controller for jointly managing context and result retention under a shared memory budget via a recurrent policy summarizes class-level runtime statistics and selects a memory split and class-specific admission thresholds, along with a deterministic manager that translates these controls into entity-level admission and eviction decisions, enforcing the shared budget limit independently of the learned policy. The authors formulate the heterogeneous dual-resource management task of reducing tool-invocation latency as a partially observable sequential decision problem, where future requests are unknown and retention decisions yield delayed latency benefits. Proposed method MCPool achieves 1.34×–2.38× mean task-latency speedups and up to 2.62× P95 speedup over Static-Control against five baselines on MCP-Bench across three foundation models.

Critical strengths
  1. Very interesting premise and problem - The paper tackles a very interesting problem of tool-invocation latency for agentic frameworks and presents an effective way to address the same
  2. Sound descriptions, clear writing - The authors provide a sound description of their method and the writing is easy to understand
  3. Decent results - The experiments show a significant speedup (especially for gpt-5.4-mini) while keeping a competitive performance
Critical weaknesses
  1. Basic/standard cache policy analysis missing - The results show a few baselines for the policy against which the authors compare the proposed method. However analysis for standard cache replacement policies (adapted to their case if required) like SIEVE, TLRU, LFU, FIFO, etc would give more insight into the speedup-performance tradeoff.
  2. Limited evaluation/judge prompt details - The authors state that they use Gemini-3.7-Flash as a judge to evaluate the degree of completion of tasks. However for such a critical part of the paper, the details for the same are limited. The supplementary does give more insight, but it is missing detailed discussion on the judging categories, the reason for the choice and the prompt used for the judge.
  3. Lack of qualitative examples - There are no qualitative examples in the paper. The authors should have included a sample from the benchmark and how the framework navigates the tool calling and how does the cache system work. This would give a great amount of insight into the framework.
Questions for authors

Clarification

  1. Is there a specific reason for the choice of the judge model (Gemini-3.7-Flash) for evaluation?
  2. Are the LLM judge’s verdicts verified by humans? If so, how?

Suggestion

  1. What was the reason for choosing GRU over something like a transformer network for history aggregation? It will be interesting to see an ablation with different networks for the same.

*I did like the paper in general and found it interesting. I would consider increasing my score, if my concerns are addressed.

1 comment

Critical Weakness 1: Standard Cache Replacement Policies

Weakness: The evaluation lacks comparisons with standard cache replacement policies such as SIEVE, TLRU, LFU, and FIFO.

Response:

We thank the reviewer for the constructive comments and suggestions. Regarding standard cache policies, we would like to clarify that MCPool primarily addresses joint memory allocation and admission control across two distinct reuse mechanisms, rather than cache replacement alone. Conventional policies such as SIEVE, TLRU, LFU, and FIFO mainly focus on replacement decisions within a cache, whereas MCPool jointly manages execution contexts and cached results under a shared memory budget. Therefore, these policies are not the primary comparison targets of our work. Nevertheless, we appreciate the suggestion and will include selected representative policies to provide additional insights into replacement behavior.

Critical Weakness 2 and Clarification Questions 1–2: LLM Judge

Weakness: The evaluation lacks sufficient details on the judge model, evaluation categories, and judging prompt.

Questions:

  1. Why was Gemini-3.7-Flash selected as the judge?
  2. Were the judge's evaluations verified by humans?

Response:

We thank the reviewer for these questions. We selected Gemini-3.7-Flash as an independent judge, distinct from the execution models, and consistently applied the same evaluation criteria across all methods. The judge evaluates complete execution traces based on Task Fulfillment and Grounding, as described in the appendix. We will also provide the complete judging prompt for reproducibility.

Human verification was not conducted. However, our goal is primarily to assess whether caching affects task quality, rather than establish absolute correctness. Task quality serves as a supplementary metric, while our primary evaluation relies on objective measurements of latency, memory-budget violations, and token usage.

Critical Weakness 3: Lack of Qualitative Examples

Weakness: The paper lacks a concrete example illustrating tool execution and cache management.

Response:

We thank the reviewer for this suggestion. The algorithmic workflow, including admission, retention, and eviction decisions, is already described in the paper. We agree that a concrete execution example would improve clarity and will add an illustrative trace showing tool calls, cache hits and misses, and memory-management decisions.

Suggestion: GRU versus Transformer

Question: Why was GRU selected instead of a Transformer for history aggregation? Can the authors provide an ablation?

Response:

We thank the reviewer for this suggestion. We selected GRU as a lightweight recurrent architecture to summarize historical workload statistics with low inference overhead. Since MCPool operates on compact, class-level observations, a more complex history encoder is not necessarily required.

We agree that comparing alternative architectures would strengthen the evaluation and will add a Transformer-based controller ablation under the same training and evaluation settings.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.