Arcade Tool Recommendation: When Does It Cut Costs?

Your agent can access every tool it needs and still waste money before it does any work. If each request sends a long catalog of tool definitions to the model, you pay to supply descriptions for actions the agent will never use. Arcade.dev’s Tool Recommendation offers a different approach—but its headline savings need careful reading before you change a production workflow.
The verdict: test it against your tool catalog, not the headline
Arcade reports up to 37% lower modeled input-token cost for Tool Recommendation against an assistant loaded with a fixed list of 100 tools. That is not a promise to cut your firm’s input tokens—or its total AI bill—by 37%. The relevant question is whether your own agent repeatedly receives enough unused tool definitions to make discovery cheaper than a fixed list.
Arcade’s launch post gives several results that measure different things:
| Measure | What Arcade reports | What it does not establish |
|---|---|---|
| Modeled input-token cost | Up to 37% lower, with the maximum in single-request sessions | A guaranteed saving for every agent |
| Modeled input-token cost in a typical conversation | About 20% lower | A reduction of the same size in the total bill |
| Tokens used for tool definitions and recommendation responses over a 10-turn session | Up to 91% fewer | A 91% reduction in all input tokens; this measure excludes conversation text and tool results |
| Paired end-to-end evaluation | A 7.6% reduction in the combined input-and-output token bill across 408 sessions and 64 workflows | A result that will carry over unchanged to your workload |
Arcade reports a 95% interval of 2.5% to 12.6% for that paired bill reduction and says task completion did not change in those runs. Those are more useful production signals than the headline maximum, but they remain Arcade’s results under its own evaluation conditions.
The practical takeaway is narrower and stronger than “save 37%”: if your agent has a broad allowed tool catalog but uses only a few tools per task, stop assuming that sending every definition on every request is free. Measure the cost of that choice. If the agent already has a small, stable set of tools, leave it alone until you have evidence that discovery would help.
What Tool Recommendation changes in an MCP workflow
Tool Recommendation replaces an upfront list of allowed tool definitions with a discovery step. Under Arcade’s current MCP gateway documentation, the gateway exposes Arcade.SelectTools and Arcade.UseTool in place of the allowed tools: the agent describes its task, receives matching tools and their input schemas, then calls the selected tool.
Arcade.SelectTools returns up to five matching tools per task by default. Arcade’s REST select endpoint permits a top_k of up to 20. A larger result can give the agent more choices, but it also returns more schema text; tuning that value is a relevance-versus-context decision, not an automatic improvement.
Consider an agent handling a customer’s request to update an appointment and notify the account owner. A conventional setup may put definitions for calendar, CRM, messaging, invoicing, and unrelated actions into the model context before the agent reads the request. With recommendation, the agent first asks for tools relevant to the appointment and notification task. It then sees the schemas it needs to make a valid call, rather than the entire allowed catalog.
That does not make the agent better authorized. Arcade’s docs say the gateway recommends only tools the gateway already allows. If an agent must not send messages or change records, those restrictions belong in gateway permissions and the rest of your authorization design—not in the wording of its discovery request.
It also does not make tool selection infallible. Arcade warns that vague or near-identical tool descriptions can produce poor recommendations. If two actions both say “update customer,” the selector has little basis for deciding whether the task calls for changing contact details, account status, or a CRM note. Discovery makes clear tool descriptions more important, not less.
When a fixed tool list is the better design
A fixed list is often cheaper and simpler when the agent has few allowed tools. Arcade’s cost model puts the crossover at roughly 25–28 tools: below that range, supplying the fixed list is cheaper in its model. Its documentation also says gateways with fewer than about ten tools generally gain little from recommendation because discovery adds a round trip.
Those thresholds are useful screening criteria, not rules for every application. A good initial decision looks like this:
| Your agent’s situation | Sensible starting point | Why |
|---|---|---|
| A narrow workflow with a small, stable tool set | Keep a fixed list | Discovery adds a step without removing much context |
| A larger catalog where each task needs only a few actions | Test recommendation | Avoid loading definitions for actions the task will not use |
| Many similarly named actions | Improve descriptions before rollout | Selection quality may suffer even if token use falls |
| Large tool outputs retained in conversation history | Fix result handling as well | Savings from shorter definitions can be overwhelmed by retained results |
The last row matters. Arcade says its modeled savings fall to about 5%–7% when a client leaves large tool results inline in the conversation. If a lookup returns a lengthy record and you carry that entire response into each later turn, optimizing tool definitions addresses only part of the input bill.
There are reasons to use a fixed list even above a modeled cost crossover. A tightly scoped agent may benefit from predictable tool visibility, straightforward debugging, and no discovery round trip. Conversely, a growing platform integration may benefit from recommendation before it reaches a neat threshold if the fixed list is becoming difficult to maintain. Measure the complete workflow rather than choosing by tool count alone.
Arcade says its broader catalog exceeds 8,000 tools and that loading all their definitions would require more than 1.75 million tokens before a user message. That illustrates why discovery exists at platform scale. It does not mean a small business agent connected to a handful of approved actions has the same problem.
Audit your agent’s context before changing tools
The quickest way to find an avoidable token bill is to trace what the model receives on each request. Separate tool definitions from conversation history, tool results, and the user’s task; otherwise, you may optimize the wrong component and attribute the outcome to Tool Recommendation.
For a representative set of real tasks, record:
- Allowed tools: Which actions can this agent actually call? Count the tools exposed to this workflow, not every tool available somewhere in your organization.
- Tools used: Which definitions were needed to complete each task? Note whether the agent had to inspect several candidates before selecting one.
- Context carried forward: Are tool definitions resent each turn? Are full search results, email bodies, or CRM records retained after their useful fields have been extracted?
- Outcome: Did the agent complete the task correctly? Did it select the right action and supply valid inputs?
- Operational cost: What did the run consume in input and output tokens, tool calls, retries, and elapsed time?
A simple trace record is enough to start. The following is an illustrative logging format, not Arcade’s API schema:
{
"task": "Update an appointment and notify the account owner",
"selection_mode": "fixed_or_recommended",
"allowed_tool_count": 0,
"tools_selected": [],
"input_tokens": 0,
"output_tokens": 0,
"tool_calls": 0,
"completed_correctly": false,
"selection_error": false
}
Replace the zero values with counts from actual runs. Keep task descriptions and any stored tool inputs free of sensitive customer data unless your logging system is designed and approved to hold it.
The most actionable finding may have nothing to do with discovery. If the agent has a compact tool list but repeatedly carries full tool responses forward, trim or summarize those responses. If it frequently picks the wrong tool, rewrite overlapping descriptions and tighten the allowed set before trying to save tokens. A cheaper failed run is not an improvement.
Roll out recommendation without weakening the workflow
A safe rollout changes tool visibility while keeping permissions, task inputs, and success criteria stable. Start with a workflow whose completed runs you can inspect, compare fixed-list and recommendation modes on the same tasks, and keep a route back to the fixed list if selection quality drops.
Use this sequence:
- Reduce the allowed set first. Remove actions the workflow should never perform. Recommendation can search only within gateway-allowed tools, but it should not be used as a substitute for restricting access.
- Make descriptions discriminative. State what each action does, when to use it, and what it does not do. Give near-identical tools distinct purposes in their descriptions.
- Define a successful run before testing. For an appointment update, success might mean the right record changed and the intended person received the notification. A run that uses fewer tokens but updates the wrong record fails.
- Compare paired tasks. Run the same representative task set in both modes. Keep the model, prompts, gateway permissions, and result-handling behavior consistent so you can see what the selection change contributes.
- Inspect failures, not just averages. Look for missing relevant tools, incorrect recommendations, invalid inputs, extra selection attempts, and tasks that finish only after a retry.
- Roll out to a limited workflow. Watch completion, token use, tool calls, and latency together before expanding access.
Treat the returned input schema as a contract for making a tool call, not proof that the recommended action is appropriate. For actions that change customer records, send messages, or trigger other external effects, keep the same validation and approval boundaries you would require with a fixed list.
If recommendation returns an unhelpful set, do not immediately increase top_k and call the problem solved. First check whether the task description was specific, whether the correct tool was allowed, and whether its description clearly distinguishes it from nearby actions. Returning more candidates can help a recall problem, but it can also restore some of the context you set out to remove.
Calculate the bill that matters to your business
Evaluate total cost per correctly completed task, not just the input tokens used to present tools. Input-token savings are real only if they outweigh any extra discovery activity, output tokens, retries, tool-call charges, and operational work introduced by the new design.
You can compute a comparison from your own usage records without assuming that Arcade’s modeled percentage applies to you:
def cost_per_correct_completion(total_cost_usd, correct_completions):
if correct_completions == 0:
return None
return total_cost_usd / correct_completions
fixed = cost_per_correct_completion(
total_cost_usd=fixed_total_cost_usd,
correct_completions=fixed_correct_completions,
)
recommended = cost_per_correct_completion(
total_cost_usd=recommended_total_cost_usd,
correct_completions=recommended_correct_completions,
)
Populate total_cost_usd with the charges relevant to your setup and the period tested. Report token costs separately as well: that makes it possible to see whether lower model input cost was offset by other usage. Alongside the cost calculation, retain completion and error counts. Otherwise, a mode that silently fails more often may appear cheaper.
For an illustrative example using round numbers, suppose one mode costs $100 across 100 correctly completed tasks, while another costs $90 across the same 100 correctly completed tasks. That is $1.00 versus $0.90 per correct completion. Those are example inputs for the calculation, not Arcade results or a prediction for your agent.
Check platform charges before estimating a return. Arcade’s published pricing page lists Team at $25 per month plus usage and tool calls at $0.01 each; check the current page for the terms and allowances that apply to your account. Arcade says Tool Recommendation is available to Arcade Cloud users, while enterprise customers are being rolled out separately. VentureBeat reported that the feature had no separate charge for Arcade Cloud customers at launch, but normal platform and usage fees still applied.
The decision is not “Can this feature reduce tokens?” Arcade’s evaluation indicates that it can under its tested conditions. The decision is whether your allowed catalog, task mix, result handling, and pricing make it a net improvement without reducing correct completions.
How BizFlowAI approaches this
BizFlowAI builds practical AI automations for solopreneurs and small teams. When evaluating an agent or MCP integration, review the context sent to the model, the tools the agent needs, and the cost of a correctly completed task.
Tool Recommendation is one possible fix when a broad catalog is the source of waste. A smaller permission set, clearer tool descriptions, or shorter retained results may matter more for a particular agent. The production decision should follow the trace and a paired test—not Arcade’s maximum modeled saving.
Work with BizFlowAI
If you'd rather have this built for you, that's what we do: production AI automation for solo founders and small teams — agents, integrations, and document pipelines that actually ship.
Request a free discovery call — 30 minutes, we map the highest-ROI automation in your workflow. No pitch deck, just engineering.
More guides like this on the BizFlowAI blog.
Frequently asked questions
When does Arcade Tool Recommendation save an AI agent money?
It is most likely to help when an agent can access many tools but uses only a few for each task. Instead of sending every tool definition to the model upfront, the agent requests relevant tools and their schemas. Compare complete runs on your own tasks, including discovery calls, retries, and output tokens, before assuming a saving.
Should I use Arcade Tool Recommendation if my agent has fewer than 10 tools?
Probably not without evidence that the fixed list is causing a problem. Arcade says gateways with fewer than about ten tools generally gain little because discovery adds a round trip. Its cost model also finds a fixed list cheaper below roughly 25–28 tools, though your results may differ.
How do Arcade.SelectTools and Arcade.UseTool work in an MCP gateway?
Arcade.SelectTools lets an agent describe its task and receive matching allowed tools with their input schemas. The agent then invokes a selected action through Arcade.UseTool. The gateway returns up to five matches by default, so the agent need not receive the full allowed catalog upfront.
Does Arcade Tool Recommendation change which tools my agent is allowed to use?
No. Recommendation selects from tools the MCP gateway already allows; it does not grant new permissions. Set restrictions on actions such as sending messages or editing records through gateway permissions and your broader authorization design, not through the discovery prompt.
How should I test whether dynamic tool selection reduces my agent's costs?
Run representative tasks with a fixed tool list and with recommendation while keeping permissions and success criteria the same. Record input and output tokens, tool calls, retries, elapsed time, selection errors, and task completion. Also track retained tool results: large responses carried into later turns can outweigh savings from shorter tool definitions.