Cost-Optimized Tool Sequencing Prompt

This prompt is for agent developers and AI cost engineers who need to order a set of required tool calls to minimize total execution cost while satisfying all data dependencies. Use it when your agent must call multiple tools with different per-call costs, and the order of execution affects the total bill. The core job-to-be-done is producing a sequenced call plan with cost rationale—not deciding which tools to call, not allocating a budget, and not decomposing a task into new subtasks. The ideal user already knows the exact set of tools required and needs the cheapest valid execution order.

This is not a tool selection prompt. It assumes the set of required tools is already decided. If you need to decide which tools to call under a budget constraint, use the Cost-Aware Tool Selection System Prompt instead. If you need to decompose a task and assign per-step budgets, use the Budget-Conscious Agent Planning Prompt. This prompt also does not enforce spend caps, handle rate limits, or trigger human approval—those concerns belong to sibling prompts like Agent Spend Cap Enforcement Prompt and Budget-Aware Human Approval Trigger Prompt. The prompt produces a plan, not an execution trace; wiring it into a live agent requires additional harness logic for dependency validation, cost tracking, and mid-plan correction when tool outputs change the dependency graph.

Before using this prompt, confirm that you have: (1) a complete list of required tool calls with their per-call costs, (2) a dependency map showing which calls depend on outputs from which other calls, and (3) a clear understanding that the model will reason about ordering but will not execute the calls itself. The prompt works best when costs vary significantly across tools and when dependency chains create multiple valid orderings. If all tools cost the same or the dependency graph is strictly linear, the sequencing problem is trivial and this prompt adds unnecessary latency and token cost. Start by testing against a naive ordering baseline—such as topological sort without cost awareness—to measure whether the optimized plan actually reduces spend in your production traces.

The following prompt template is designed to be dropped into an agent planning or orchestration step. It accepts a list of available tools with their estimated costs and dependencies, then produces a sequenced call plan with a clear cost rationale. The template uses square-bracket placeholders so you can inject tool metadata, constraints, and output schema requirements directly from your application layer without modifying the core instruction.

textCopy
You are an agent planner optimizing tool call sequences for minimum total cost.

## AVAILABLE TOOLS
[TOOLS]

## CONSTRAINTS
- You must satisfy all declared dependencies before invoking a dependent tool.
- You may invoke each tool at most once unless explicitly marked as repeatable.
- Total estimated cost must stay within the budget cap: [BUDGET_CAP].
- If the budget cap cannot be satisfied, return a partial plan with the highest-priority tools and flag the shortfall.

## OUTPUT SCHEMA
Return a valid JSON object with this structure:
{
  "plan": [
    {
      "step": <integer>,
      "tool": "<tool_name>",
      "estimated_cost": <number>,
      "depends_on": ["<tool_name>", ...],
      "rationale": "<why this tool at this step>"
    }
  ],
  "total_estimated_cost": <number>,
  "budget_remaining": <number>,
  "unresolved_dependencies": ["<tool_name>", ...],
  "warnings": ["<string>", ...]
}

## PRIORITY RULES
1. Resolve dependencies before invoking dependent tools.
2. Prefer lower-cost tools when multiple tools satisfy the same dependency.
3. If a tool's output is required by multiple downstream tools, invoke it once as early as possible.
4. Flag any tool whose estimated cost exceeds the remaining budget at the point it would be invoked.

## RISK LEVEL
[RISK_LEVEL]

## EXAMPLES
[EXAMPLES]

Now produce the cost-optimized sequence for the tools above.

To adapt this template, replace [TOOLS] with a structured list of tool objects, each containing at minimum a name, estimated_cost, and depends_on array. The [BUDGET_CAP] should be a numeric value in your cost unit. Set [RISK_LEVEL] to low, medium, or high to adjust the conservatism of the plan—high-risk contexts should produce plans that leave larger budget buffers and include explicit abort conditions. The [EXAMPLES] placeholder should contain one or two worked examples showing correct sequencing with cost trade-offs, which dramatically improves output reliability. After copying the template, validate that your tool list includes all dependency names referenced in depends_on arrays to prevent the model from hallucinating missing tools.

The Cost-Optimized Tool Sequencing Prompt is designed to be called before a multi-step agent execution loop begins. It takes a task description, a list of available tools with their estimated costs and dependencies, and returns an ordered plan. The application layer should treat this prompt as a planning step that runs once per task, not as a runtime decision-maker inside the execution loop. This separation keeps cost optimization logic out of the agent's step-by-step reasoning, where it can conflict with task completion goals.

To wire this into an application, first construct the input payload with three required components: the [TASK_DESCRIPTION], a [TOOL_CATALOG] array where each tool includes name, estimated_cost (in your chosen unit, such as USD or tokens), required_inputs, and produces_outputs fields, and a [CONSTRAINTS] block specifying the maximum total budget and any mandatory ordering rules. The model should return a JSON array of steps, each containing step_number, tool_name, estimated_cost, depends_on (an array of step numbers), and rationale. Validate this output before execution: check that all depends_on references resolve to earlier steps, that the sum of estimated_cost does not exceed the budget, and that every required input for a tool is produced by a prior step or provided in the initial context. If validation fails, retry once with the validation errors appended to the prompt as feedback. If it fails again, fall back to a naive dependency-respecting ordering and log the failure for review.

For production deployment, run this prompt on a fast, cost-efficient model such as GPT-4o-mini or Claude Haiku, since the planning step should be cheaper than the tool calls it optimizes. Log every plan alongside the actual execution trace, including real costs incurred, so you can compare planned versus actual spend and detect systematic underestimation. Set a hard circuit breaker: if the agent's cumulative tool spend exceeds 120% of the planned budget, pause execution and escalate for human review. This prompt is not a substitute for runtime rate-limit handling or tool error recovery—those belong in separate prompts that operate during execution. The sequencing prompt's job is to produce a cost-aware order before the first tool call fires.