Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add curiositech/some_claude_skills --skill cost-optimizer -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/cost-optimizer/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/cost-optimizer/

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

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set180

The whole set →
skill-grader skill-grader grades Claude Agent Skills on 10 quality axes, assigns letter grades from A+ to F, and lists concrete fixes for each weak axis. Useful when auditing one skill, comparing several, or sweeping a whole library. CX Codex +1 147installs skillful-subagent-creator skillful-subagent-creator builds specialized subagents with preloaded skills for DAG workflows. It formats the four-section prompt and defines input-output contracts between nodes. CX Codex +1 147installs tech-presentation-interview tech-presentation-interview prepares you for reverse system design rounds: pick the right project, build a narrative arc, calibrate depth, and handle tough follow-up questions. CX Codex +1 146installs docker-containerization docker-containerization generates production-ready Dockerfiles, optimizes layer caching, and writes docker-compose setups for local development. CX Codex +1 143installs git-workflow-expert git-workflow-expert — a git skill covering branching strategies, merge conflicts, rebase workflows, and recovery commands like bisect and reflog. Handy when history gets messy or a commit goes missing. CX Codex +1 143installs microservices-patterns The microservices-patterns skill helps plan service boundaries and communication patterns. Use it when assessing a monolith or designing a distributed system. CX Codex +1 142installs output-contract-enforcer output-contract-enforcer is a Claude Code skill that checks DAG node JSON against its schema and traces mismatches when a downstream node receives unexpected input. CX Codex +1 141installs anthropic-technical-deep-dive anthropic-technical-deep-dive builds deep technical preparation for Anthropic interviews: Constitutional AI, RLHF, interpretability, scaling laws, MCP, agentic systems, and AI safety. CX Codex +1 141installs

Project sponsors

Companies that keep this analytics open