cost-optimizer — Claude Code skill: what it does, how to install
cost-optimizer monitors cumulative LLM expenses across DAG execution and downgrades model tiers or skips optional nodes to prevent budget overruns.
MIT 143 installs ★ 274 updated 2026-10-30
npx skills add curiositech/some_claude_skills --skill cost-optimizer -a claude-codeWhat cost-optimizer does
The skill tracks cumulative API spend while a task DAG runs. Before dispatching any node, it estimates token costs using past runs or tier baselines — about $0.001 for Haiku up to $0.16 for Opus — and checks whether the total stays inside the target limit.
When remaining budget drops below 20%, it downgrades Tier 2 nodes to Tier 1. At under 10%, every remaining step switches to Tier 1, and optional nodes are skipped. If the budget hits zero, execution halts and returns partial output with a detailed spending breakdown.
It operates via Read and Grep tools, accepting [dag-id] [budget-usd]. Aggressive early downgrading can backfire: failed attempts trigger retries, and retries cost more than running the intended model tier in the first place.
What it helps with
- enforce budget limits during DAG runs
- downgrade model tiers dynamically when funds run low
- drop optional execution steps before budget runs out
- generate post-run spending breakdowns per node
Example prompts for the agent
- Track cost budget for pipeline dag-build-99 with budget 0.75 USD
- Reduce cost and enforce 2.00 USD budget on dag-ingest-pipeline
- Analyze spending breakdown and model tiers for dag-summary-flow
How to install cost-optimizer
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill cost-optimizer -a claude-code2Manually: put the files in place
~/.claude/skills/cost-optimizer/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/cost-optimizer/
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill cost-optimizer -a codex2Manually: put the files in place
.agents/skills/cost-optimizer/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill cost-optimizer -a cursor2Manually: put the files in place
.cursor/skills/cost-optimizer/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install curiositech/some_claude_skills .claude/skills/cost-optimizer2Manually: put the files in place
.github/skills/cost-optimizer/SKILL.md1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill cost-optimizer -a gemini-cli2Platform CLI
gemini skills install https://github.com/curiositech/some_claude_skills --path .claude/skills/cost-optimizerManually: put the files in place
.devin/skills/cost-optimizer/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill cost-optimizer -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about cost-optimizer
How do I install cost-optimizer in Claude Code?
Run npx skills add curiositech/some_claude_skills --skill cost-optimizer -a claude-code. The skill file will be placed at ~/.claude/skills/cost-optimizer/SKILL.md.
What does cost-optimizer do?
It tracks total token costs across workflow DAGs in real time. It automatically steps down model tiers or aborts runs before they exceed a preset dollar limit.
Does cost-optimizer handle primary model routing?
No, general model selection belongs to llm-router. This skill only intervenes when spend threatens the allocated budget.
Source text
SKILL.md · MIT
---
name: cost-optimizer
description: Tracks cumulative LLM costs across DAG execution and makes real-time decisions to stay within budget. Downgrades models, skips optional nodes, or stops early when cost exceeds thresholds. Use
when managing execution budgets, analyzing cost breakdowns, or optimizing model routing for cost. Activate on "cost budget", "too expensive", "reduce cost", "cost optimization", "model downgrade", "budget
exceeded". NOT for LLM model selection logic (use llm-router), pricing comparisons across providers, or billing/invoicing.
allowed-tools: Read,Grep
argument-hint: '[dag-id] [budget-usd]'
metadata:
tags:
- cost
- optimizer
- cost-budget
- too-expensive
- reduce-cost
pairs-with:
- skill: cost-accrual-tracker
reason: The tracker provides the real-time cost data that the optimizer uses for budget decisions
- skill: llm-router
reason: Model routing is the primary mechanism through which cost optimization is enacted
- skill: cost-verification-auditor
reason: Post-execution auditing validates that optimization decisions actually reduced costs
---
# Cost Optimizer
Tracks cumulative LLM costs across DAG execution and makes real-time decisions to stay within budget: downgrade models, skip optional nodes, or stop early.
---
## When to Use
✅ **Use for**:
- Setting and enforcing cost budgets for DAG executions
- Real-time cost monitoring during execution
- Deciding when to downgrade model tiers mid-execution
- Identifying which nodes are most expensive and why
- Post-execution cost analysis and optimization recommendations
❌ **NOT for**:
- Choosing which model to use per node (use `llm-router`)
- Provider pricing comparisons (static data, not a skill)
- Billing or invoicing features
---
## Budget Enforcement Process
```mermaid
flowchart TD
N[Node about to execute] --> C[Check: spent + estimated_node_cost vs budget]
C --> S{Within budget?}
S -->|Yes, >20% remaining| E[Execute at planned model tier]
S -->|Yes, <20% remaining| W[Execute but downgrade to Tier 1 if possible]
S -->|No| D{Node optional?}
D -->|Yes| SK[Skip node]
D -->|No| H{Human gate available?}
H -->|Yes| A[Ask human: continue over budget?]
H -->|No| ST[Stop execution, return partial results]
```
### Budget Tiers
| Budget Remaining | Action |
|-----------------|--------|
| >50% | Execute at planned model tier |
| 20-50% | Log warning. Continue at planned tier. |
| 10-20% | Downgrade remaining Tier 2 nodes to Tier 1 (Haiku) |
| 5-10% | Downgrade ALL remaining nodes to Tier 1. Skip optional nodes. |
| <5% | Stop execution unless next node is critical path |
| 0% | Stop. Return partial results with cost breakdown. |
### Cost Estimation Per Node
Before each node executes, estimate its cost:
```
estimated_cost = (avg_input_tokens × input_price + avg_output_tokens × output_price)
```
Use historical averages for this skill + model combination. If no history, use defaults:
- Tier 1 (Haiku): ~800 input + 400 output = ~$0.001
- Tier 2 (Sonnet): ~2000 input + 1000 output = ~$0.012
- Tier 3 (Opus): ~3000 input + 1500 output = ~$0.16
### Post-Execution Report
```yaml
cost_report:
total_budget: 0.50
total_spent: 0.37
budget_remaining: 0.13
nodes_executed: 8
nodes_skipped: 1
nodes_downgraded: 2
model_breakdown:
haiku: { calls: 4, cost: 0.004 }
sonnet: { calls: 3, cost: 0.036 }
opus: { calls: 1, cost: 0.33 }
savings_recommendations:
- "Node 'deep-analysis' used Opus ($0.33) but downstream accepted on first try. Try Sonnet next time — potential saving: $0.32"
- "Nodes 'validate-a' and 'validate-b' are sequential but independent. Parallelize to reduce wall-clock time."
```
---
## Anti-Patterns
### No Budget at All
**Wrong**: Running DAGs without any cost tracking until the API bill arrives.
**Right**: Every DAG execution has a budget, even if generous. Track spend per node.
### Aggressive Downgrading
**Wrong**: Downgrading Opus nodes to Haiku at 50% budget remaining, causing quality failures that trigger expensive retries.
**Right**: Only downgrade when the alternative is stopping execution. Retries cost more than the original model tier.
### Ignoring Retries in Cost
**Wrong**: Budgeting for one attempt per node.
**Right**: Budget for avg_retries × cost_per_attempt. A node with 3 retries on Sonnet costs $0.036, not $0.012.
© curiositech · MIT · curiositech/some_claude_skills