Skip to main content Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/tools-only/X-Skills --skill engineeringThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... More from this repository
Related occupations SOC
Based on SOC occupation classification
title Cost Caps & Budget Management description Hard budget controls for AI spending. Real-time spend tracking, automatic shutoffs, team quotas, and financial safeguards to prevent runaway costs. category Cost wordCount 3200 readTime 16 featured false order 2 tags ["cost","budget","spending","quotas","optimization"] prerequisites [] relatedPlaybooks ["01-multi-agent-rate-limits","09-cost-attribution"]
API costs can spiral quickly when running multi-agent workflows at scale. This playbook provides proven strategies for implementing cost controls, monitoring spend in real-time, and optimizing Claude API usage without sacrificing quality.
Understanding API Costs
Anthropic Claude Pricing (January 2025)
Model Input (per 1M tokens) Output (per 1M tokens) Context Window Claude 3.5 Sonnet $3.00 $15.00 200K Claude 3.5 Haiku $0.80 $4.00 200K Claude 3 Opus $15.00 $75.00 200K
Reality Check : A single code review session can cost:
Small file (500 tokens): $0.0075 (Sonnet)
Large file (5,000 tokens): $0.075 (Sonnet)
Full repository (50,000 tokens): $0.75 (Sonnet)
Hidden Cost Drivers
const response = await claude.messages .create ({
model : 'claude-3-5-sonnet-20241022' ,
max_tokens : 4096 ,
messages : [{
role : 'user' ,
content : `Review this entire codebase: ${fs.readFileSync('monorepo.txt' )} `
}]
});
Cost Tracking
1. Real-Time Token Counting import Anthropic from '@anthropic-ai/sdk' ;
interface CostMetrics {
inputTokens : number ;
outputTokens : number ;
inputCost : number ;
outputCost : number ;
totalCost : number ;
model : string ;
}
class CostTracker {
private costs : CostMetrics [] = [];
private pricing = {
'claude-3-5-sonnet-20241022' : { input : 3.00 , output : 15.00 },
'claude-3-5-haiku-20241022' : { input : 0.80 , output : 4.00 },
'claude-3-opus-20240229' : { input : 15.00 , output : 75.00 },
};
track (usage : Anthropic .Usage , model : string ): CostMetrics {
const prices = this .pricing [model];
const metrics : CostMetrics = {
inputTokens : usage.input_tokens ,
outputTokens : usage.output_tokens ,
inputCost : (usage.input_tokens / 1_000_000 ) * prices.input ,
outputCost : (usage.output_tokens / 1_000_000 ) * prices.output ,
totalCost : 0 ,
model
};
metrics.totalCost = metrics.inputCost + metrics.outputCost ;
this .costs .push (metrics);
return metrics;
}
getTotalCost (): number {
return this .costs .reduce ((sum, c ) => sum + c.totalCost , 0 );
}
getCostByModel (model : string ): number {
return this .costs
.filter (c =>model === model)
.reduce ((sum, c ) => sum + c.totalCost , 0 );
}
getAverageCostPerRequest (): number {
return this .getTotalCost () / this .costs .length ;
}
}
const tracker = new CostTracker ();
const response = await claude.messages .create ({
model : 'claude-3-5-sonnet-20241022' ,
messages : [...]
});
const cost = tracker.track (response.usage , response.model );
console .log (`Request cost: $${cost.totalCost.toFixed(4 )} ` );
console .log (`Total spent: $${tracker.getTotalCost().toFixed(2 )} ` );
2. Analytics Daemon Integration The @claude-code-plugins/analytics-daemon emits cost events:
interface CostUpdateEvent {
type : 'cost.update' ;
timestamp : number ;
conversationId : string ;
model : 'claude-3-5-sonnet-20241022' ;
inputCost : 0.0045 ;
outputCost : 0.012 ;
totalCost : 0.0165 ;
currency : 'USD' ;
}
const ws = new WebSocket ('ws://localhost:3456' );
ws.onmessage = (event ) => {
const data = JSON .parse (event.data );
if (data.type === 'cost.update' ) {
updateBudget (data.totalCost );
}
};
3. Daily Budget Dashboard Query costs via HTTP API:
curl http://localhost:3333/api/sessions | jq '.sessions[] | {id, plugins, totalCost}'
curl http://localhost:3333/api/status | jq '.watcher'
Budget Enforcement
Strategy 1: Hard Caps with Circuit Breakers class BudgetEnforcer {
private spent = 0 ;
private dailyBudget : number ;
private lastReset : Date ;
constructor (dailyBudgetUSD : number this .dailyBudget = dailyBudgetUSD;
this .lastReset = new Date ();
}
async executeWithBudget (
fn : () => Promise <{ result : T; cost : number }>
): Promise {
if (this .isNewDay ()) {
this .spent = 0 ;
this .lastReset = new Date ();
}
if (this .spent >= this .dailyBudget ) {
throw new Error (
`Daily budget exceeded: $${this .spent.toFixed(2 )} / $${this .dailyBudget} `
);
}
const { result, cost } = await fn ();
this .spent += cost;
if (this .spent >= this .dailyBudget * 0.8 ) {
console .warn (
`⚠️ 80% of daily budget used: $${this .spent.toFixed(2 )} / $${this .dailyBudget} `
);
}
return result;
}
private isNewDay (): boolean {
const now = new Date ();
return now.toDateString () !== this .lastReset .toDateString ();
}
getRemainingBudget (): number {
return Math .max (0 , this .dailyBudget - this .spent );
}
getSpendPercentage (): number {
return (this .spent / this .dailyBudget ) * 100 ;
}
}
const budget = new BudgetEnforcer (50.00 );
try {
await budget.executeWithBudget (async () => {
const response = await claude.messages .create (...);
const cost = calculateCost (response.usage );
return { result : response, cost };
});
} catch (error) {
console .error ('Budget exhausted for today' );
}
Strategy 2: Tiered Budgets by Priority enum Priority {
CRITICAL = 'critical' ,
HIGH = 'high' ,
MEDIUM = 'medium' ,
LOW = 'low'
}
class TieredBudget {
private budgets = new Map ([
[Priority .CRITICAL , new BudgetEnforcer (100 )],
[Priority .HIGH , new BudgetEnforcer (50 )],
[Priority .MEDIUM , new BudgetEnforcer (20 )],
[Priority .LOW , new BudgetEnforcer (5 )],
]);
async execute (
priority : Priority ,
fn : () => Promise <{ result : T; cost : number }>
): Promise {
const budget = this .budgets .get (priority)!;
return await budget.executeWithBudget (fn);
}
getStatus (return Array .from (this .budgets .entries ()).map (([priority, budget] ) => ({
priority,
spent : budget.getSpendPercentage ().toFixed (1 ) + '%' ,
remaining : '$' + budget.getRemainingBudget ().toFixed (2 )
}));
}
}
const tiered = new TieredBudget ();
await tiered.execute (Priority .CRITICAL , async () => {
const result = await debugIncident ();
return { result, cost : 0.50 };
});
await tiered.execute (Priority .LOW , async () => {
const result = await reviewCode ();
return { result, cost : 0.05 };
});
Strategy 3: Per-User Quotas class UserQuotaManager {
private userBudgets = new Map ();
private userSpent = new Map ();
constructor (private defaultQuota : number = 10 setQuota (userId : string , quotaUSD : number this .userBudgets .set (userId, quotaUSD);
}
async executeForUser (
userId : string ,
fn : () => Promise <{ result : T; cost : number }>
): Promise {
const quota = this .userBudgets .get (userId) || this .defaultQuota ;
const spent = this .userSpent .get (userId) || 0 ;
if (spent >= quota) {
throw new Error (
`User ${userId} quota exceeded: $${spent.toFixed(2 )} / $${quota} `
);
}
const { result, cost } = await fn ();
this .userSpent .set (userId, spent + cost);
return result;
}
getUserStatus (userId : string const quota = this .userBudgets .get (userId) || this .defaultQuota ;
const spent = this .userSpent .get (userId) || 0 ;
return {
userId,
quota : `$${quota} ` ,
spent : `$${spent.toFixed(2 )} ` ,
remaining : `$${(quota - spent).toFixed(2 )} ` ,
percentage : `${((spent / quota) * 100 ).toFixed(1 )} %`
};
}
}
Optimization Strategies
1. Model Selection by Task
const models = {
sonnet : {
input : (10_000 / 1_000_000 ) * 3.00 ,
output : (1_000 / 1_000_000 ) * 15.00 ,
total : 0.045
},
haiku : {
input : (10_000 / 1_000_000 ) * 0.80 ,
output : (1_000 / 1_000_000 ) * 4.00 ,
total : 0.012
},
opus : {
input : (10_000 / 1_000_000 ) * 15.00 ,
output : (1_000 / 1_000_000 ) * 75.00 ,
total : 0.225
}
};
function selectModel (task : AgentTask string {
if (task.requiresReasoning ) {
return 'claude-3-5-sonnet-20241022' ;
} else if (task.isSimple ) {
return 'claude-3-5-haiku-20241022' ;
} else {
return 'claude-3-5-sonnet-20241022' ;
}
}
2. Context Window Optimization
async function reviewFile (file : string , codebase : string return await claude.messages .create ({
model : 'claude-3-5-sonnet-20241022' ,
messages : [{
role : 'user' ,
content : `Codebase context:\n${codebase} \n\nReview:\n${file} `
}]
});
}
async function reviewFileOptimized (file : string , relatedFiles : string []const context = relatedFiles.join ('\n' );
return await claude.messages .create ({
model : 'claude-3-5-sonnet-20241022' ,
messages : [{
role : 'user' ,
content : `Related files:\n${context} \n\nReview:\n${file} `
}]
});
}
3. Caching Strategy class ResponseCache {
private cache = new Map ();
private ttl = 3600000 ;
async execute (
cacheKey : string ,
fn : () => Promise <{ result : T; cost : number }>
): Promise <{ result : T; cost : number ; cached : boolean }> {
const cached = this .cache .get (cacheKey);
if (cached && Date .now () - cached.timestamp < this .ttl ) {
console .log (`Cache hit: $${cached.cost.toFixed(4 )} saved` );
return { result : cached.response , cost : 0 , cached : true };
}
const { result, cost } = await fn ();
this .cache .set (cacheKey, {
response : result,
cost,
timestamp : Date .now ()
});
return { result, cost, cached : false };
}
getCacheStats (const entries = Array .from (this .cache .values ());
return {
entries : entries.length ,
totalSavings : entries.reduce ((sum, e ) => sum + e.cost , 0 ),
hitRate : 0
};
}
}
const cache = new ResponseCache ();
const { result, cost, cached } = await cache.execute (
`code-review-${fileHash} ` ,
async () => {
const response = await claude.messages .create (...);
return { result : response, cost : calculateCost (response.usage ) };
}
);
4. Batch Processing
async function reviewFiles (files : string []for (const file of files) {
await claude.messages .create ({
messages : [{ role : 'user' , content : `Review: ${file} ` }]
});
}
}
async function reviewFilesBatch (files : string []const batches = chunk (files, 10 );
for (const batch of batches) {
await claude.messages .create ({
messages : [{
role : 'user' ,
content : `Review these files:\n${batch.map((f, i) => `${i+1 } . ${f} ` ).join('\n' )} `
}]
});
}
}
Production Examples
Example 1: Plugin Marketplace Review
const budget = new BudgetEnforcer (10.00 );
const cache = new ResponseCache ();
const tracker = new CostTracker ();
async function reviewPlugins (const plugins = await getPlugins ();
const results = [];
for (const plugin of plugins) {
try {
await budget.executeWithBudget (async () => {
const { result, cost, cached } = await cache.execute (
`security-review-${plugin.id} ` ,
async () => {
const response = await claude.messages .create ({
model : 'claude-3-5-haiku-20241022' ,
max_tokens : 500 ,
messages : [{
role : 'user' ,
content : `Security review:\n${plugin.code} `
}]
});
const metrics = tracker.track (response.usage , response.model );
return { result : response, cost : metrics.totalCost };
}
);
results.push ({ plugin : plugin.name , review : result, cached });
return { result, cost };
});
} catch (error) {
console .error (`Budget exceeded at plugin ${plugin.name} ` );
break ;
}
}
return results;
}
Example 2: Cost Attribution by Team interface Team {
name : string ;
members : string [];
monthlyBudget : number ;
}
class TeamBudgetManager {
private teams = new Map ();
private teamSpend = new Map ();
addTeam (team : Team this .teams .set (team.name , team);
this .teamSpend .set (team.name , 0 );
}
async executeForTeam (
teamName : string ,
userId : string ,
fn : () => Promise <{ result : T; cost : number }>
): Promise {
const team = this .teams .get (teamName);
if (!team) throw new Error (`Unknown team: ${teamName} ` );
if (!team.members .includes (userId)) {
throw new Error (`User ${userId} not in team ${teamName} ` );
}
const spent = this .teamSpend .get (teamName) || 0 ;
if (spent >= team.monthlyBudget ) {
throw new Error (`Team ${teamName} budget exceeded` );
}
const { result, cost } = await fn ();
this .teamSpend .set (teamName, spent + cost);
return result;
}
getTeamReport (teamName : string const team = this .teams .get (teamName)!;
const spent = this .teamSpend .get (teamName) || 0 ;
return {
team : teamName,
members : team.members .length ,
budget : `$${team.monthlyBudget} ` ,
spent : `$${spent.toFixed(2 )} ` ,
remaining : `$${(team.monthlyBudget - spent).toFixed(2 )} ` ,
percentageUsed : `${((spent / team.monthlyBudget) * 100 ).toFixed(1 )} %` ,
daysRemaining : 30 - new Date ().getDate (),
projectedOverage : spent / new Date ().getDate () * 30 > team.monthlyBudget
};
}
}
const manager = new TeamBudgetManager ();
manager.addTeam ({
name : 'Engineering' ,
members : ['alice@example.com' , 'bob@example.com' ],
monthlyBudget : 500
});
manager.addTeam ({
name : 'QA' ,
members : ['charlie@example.com' ],
monthlyBudget : 100
});
await manager.executeForTeam ('Engineering' , 'alice@example.com' , async () => {
const result = await runTests ();
return { result, cost : 2.50 };
});
console .log (manager.getTeamReport ('Engineering' ));
ROI Analysis
Cost vs. Value Metrics interface WorkflowMetrics {
name : string ;
costPerRun : number ;
timesSaved : number ;
errorsPrevented : number ;
manualCost : number ;
}
function calculateROI (metrics : WorkflowMetrics number {
const timeSavingsValue = (metrics.timesSaved / 60 ) * metrics.manualCost ;
const errorCostSavings = metrics.errorsPrevented * 100 ;
const totalValue = timeSavingsValue + errorCostSavings;
const totalCost = metrics.costPerRun ;
return ((totalValue - totalCost) / totalCost) * 100 ;
}
const codeReviewMetrics : WorkflowMetrics = {
name : 'Automated Code Review' ,
costPerRun : 0.50 ,
timesSaved : 30 ,
errorsPrevented : 3 ,
manualCost : 100
};
const roi = calculateROI (codeReviewMetrics);
console .log (`ROI: ${roi.toFixed(0 )} %` );
Break-Even Analysis Workflow API Cost/Run Manual Cost/Run Runs to Break Even Code Review $0.50 $50 1 Test Generation $2.00 $200 1 Documentation $1.00 $80 1 Bug Triage $0.25 $25 1
Key Insight : Even "expensive" AI workflows pay for themselves in the first run.
Best Practices
DO ✅ const tracker = new CostTracker ();
const budget = new BudgetEnforcer (50 ); const model = task.isComplex ? 'sonnet' : 'haiku' ; const cache = new ResponseCache ();
DON'T ❌
Don't use Opus for everything
model : 'claude-3-opus-20240229'
Don't send full codebase every time
content : fs.readFileSync ('entire-repo.txt' )
await claude.messages .create ({...});
Don't run without budgets
while (true ) { await expensiveCall (); }
Tools & Resources
Analytics Daemon Monitor costs in real-time:
cd packages/analytics-daemon
pnpm start
Anthropic Dashboard
Plugins with Built-in Cost Optimization
performance-engineer - Automatic model selectioncost-optimizer - Budget trackingcache-manager - Response caching
Summary
Sonnet : $3/1M input, $15/1M output - Production standardHaiku : 73% cheaper - Use for simple tasksContext optimization : 85% cost savingsCaching : 30% cost savingsBudget enforcement : Prevents runaway costs
[ ] Implement CostTracker
[ ] Set daily budget limits
[ ] Use Haiku for simple tasks
[ ] Optimize context windows
[ ] Enable response caching
[ ] Monitor with analytics daemon
[ ] Calculate ROI for workflows
[ ] Set up team quotas
