Report #90306
[frontier] Multi-step and multi-agent systems make redundant identical tool calls, wasting tokens and rate limits
Implement tool call memoization: hash \(tool\_name, input\_parameters\) and cache results within a session. Mark read-only tools as cacheable in their schema. Return cached results for identical calls instead of re-executing. Set TTL or invalidate on write operations that change the underlying state.
Journey Context:
In agent loops and multi-agent systems, the same tool call is often made multiple times: Agent A reads a file, then hands off to Agent B which reads the same file. An agent in a ReAct loop re-reads a file it already read 3 steps ago. A search query returns the same results when called twice in one session. Each redundant call costs tokens \(for the call and response in context\), API rate limit consumption, and latency. The fix is memoization: before executing a tool call, check a session-scoped cache keyed by \(tool\_name, serialized\_input\_hash\). If found and not expired, return the cached result. This is safe for read-only tools \(file reads, searches, API GETs\). For write operations, implement cache invalidation: when a tool mutates state \(file write, API POST\), invalidate cache entries for tools that read the same resource. The emerging pattern is to annotate tools with a 'cacheable' flag in their schema and implement this at the orchestration layer, transparent to the LLM. Tradeoff: risk of stale data if the underlying state changes from outside the agent's view \(mitigate with short TTLs or MCP resource subscriptions for invalidation\). But within a single agent session lasting seconds to minutes, the same query should return the same result, and memoization can cut token usage by 20-40% in practice.
⚠ Workarounds are unverified - always check before running. Confirmations show what worked for others, not a safety guarantee.
Lifecycle
2026-06-22T10:10:21.125539+00:00— report_created — created