AI Spend Management: A 30-Day Implementation Guide

Getting visibility into AI spend feels like it should take months. It doesn't. If you're willing to accept 80% accuracy in week one and improve to 95%+ by week four, you can ship a working AI spend-management system in 30 days. This guide gives you week-by-week deliverables: what to build, who to involve, what decisions to make. By day 30, you'll have a centralized dashboard, cost allocated to business units, work-item-level attribution for your top agents, and the foundations of a monthly governance report for the board.

Week 1: Get visibility (Deliverable: One number—total monthly AI spend)

Goal: Centralize AI spend. You want one dashboard where your CFO can see "we spent $X on AI last month."

Day 1-2: Inventory your vendors. Make a list of every place you're spending money on AI inference. This includes:

• API subscriptions (OpenAI, Anthropic, Google, other model providers)
• Self-hosted inference (your own models running on cloud infrastructure)
• Vector databases (Pinecone, Weaviate, Milvus, others)
• Observability platforms (Datadog, New Relic, or custom logging infrastructure)
• Any custom AI infrastructure (fine-tuning services, VLLM instances, etc.)

Ask your CTO and head of AI for the complete list. Don't assume you know all the vendors. Shadow teams often have side contracts (a sales team might have a contract with Anthropic that finance doesn't know about). Get it all.

Day 2-3: Collect API keys and set up aggregation. For each API-based vendor (OpenAI, Anthropic, Google), create a service account. Connect it to your cost aggregation tool (Runrate, CloudZero, or a custom script that pulls from billing APIs). For self-hosted infrastructure, tag all inference-related resources in your cloud account (AWS, GCP, Azure) with a consistent tag like cost-center:ai-inference. For vector databases and observability, pull the last 30 days of billing history as a CSV. Manually aggregate them into a spreadsheet for now.

Day 4: Reconcile and validate. Your cost aggregation tool should now show API spend from OpenAI + Anthropic + Google. Your infrastructure tagging should show self-hosted inference cost. Your spreadsheet should show vector DB + observability. Add them together. This is your total monthly AI spend number. Call it $X. Sanity-check it: is it within 20% of what you expect? If not, you're missing vendors or misattributing cost. Dig until the gap is closed.

Day 5: Present to leadership. One-slide update to your CFO: "We spent approximately $X on AI last month. It breaks down as: API (40%), self-hosted inference (25%), vector DB (20%), observability (15%). We have visibility into 95% of this. By week 2, we'll allocate this cost to business units."

Week 2: Allocate to business units (Deliverable: Cost by team, cost by use case)

Goal: Connect the $X total spend to specific teams. Now the question is "who's burning budget?"

Day 8-9: Define allocation dimensions. You need two dimensions: team (sales, support, underwriting, etc.) and use case (lead scoring, support chatbot, claims processing, etc.). Some use cases span teams (a fine-tuning service might be shared). Design a simple taxonomy. Example:

• Sales: Lead scoring, qualification (OpenAI, fine-tuned)
• Support: Ticket escalation (Anthropic Claude)
• Claims: Claims processing (OpenAI + Pinecone)
• Operations: Contract review (self-hosted Llama)

Day 9-10: Tag cost sources by dimension. Go back to your aggregation tool. Tag every API call, every cloud resource, every vector DB by team and use case. This is tedious but necessary. If you have 100+ API keys, write a script to bulk-tag them. If you're using Runrate, this is a few clicks. If you're using CloudZero or a spreadsheet, you're doing it manually.

Day 11-12: Generate allocation report. Your cost aggregation tool should now show:

• Total AI spend: $X
• Spend by team: Sales $0.2X, Support $0.3X, Claims $0.4X, Ops $0.1X
• Spend by use case: (similar breakdown)

Review this with each team. It should answer "does your spend make sense?" If Sales says "we're only running lead scoring, we shouldn't be at $0.2X," you have a tagging problem or a rogue use case. Fix it.

Day 13: Governance decision. Decide who owns each budget. Sales owns the lead-scoring budget. Support owns the escalation agent budget. Claims owns the processor budget. They're accountable for living within it. This is where the budget discipline starts.

Week 3: Build work-item attribution (Deliverable: Cost per unit of work for your top 3 agents)

Goal: Move from "Sales spent $X" to "our lead-scoring agent costs $Y per lead scored."

Day 15-16: Define your work items. For each top use case, define the unit of work:

• Support escalation agent: unit = "ticket escalated to human" (not all tickets, just the ones the agent flagged as too complex)
• Claims processor: unit = "claim processed" (even if it goes to manual review later)
• Lead scoring: unit = "lead score generated and sent to CRM" (binary: scored or not)

This requires aligning with product and ops on the definition. A processed claim that gets rejected later still counts as "processed." A lead that gets scored as "low quality" and never contacted still counts as "scored." Be precise; get agreement.

Day 16-17: Instrument for attribution. Add logging to track when work items complete. Your support agent logs "escalation_decision_made" when it flags a ticket. Your claims processor logs "claim_processed" when it submits the result. Your lead scorer logs "score_submitted" when it writes to your CRM. These logs should include:

• Timestamp
• User/team ID
• Use case ID
• Work item ID (ticket ID, claim ID, lead ID)
• Success/failure flag

Pipe these logs into a data warehouse or a simple table in your cost aggregation tool.

Day 18-19: Calculate cost per unit. For each use case, aggregate:

• Total cost for the period (from week 1 aggregation)
• Total work items completed (from logging)
• Cost per unit = total cost / total work items

Example: Claims processor spent $44,000 last month. It processed 8,800 claims. Cost per claim: $5.00.

Day 20: Compare to baseline. What's the manual baseline? If you have human claims reviewers, calculate their cost per claim (total salary / claims reviewed). If the AI agent is cheaper, you have margin benefit. If it's more expensive, you have a problem. Example: Human reviewers cost $8 per claim (salary, benefits, overhead). AI agent costs $5. Savings: $3 per claim on volume. On 8,800 claims, that's $26,400/month in margin improvement. That's the conversation to take to leadership.

Week 4: Govern and report (Deliverable: Monthly cost governance dashboard + board report template)

Goal: Automate the reporting and set the stage for ongoing governance.

Day 22-24: Build the dashboard. Your cost aggregation tool should display:

• Total AI spend MTD vs. monthly target
• Cost per unit by agent (vs. SLO if you have one)
• Cost by team vs. budget
• Top cost anomalies (agents running hotter than usual)
• Headcount savings realized (AI spend offset against saved salary)

This dashboard should update daily. Invite your CFO, COO, and heads of product/engineering to review it weekly.

Day 24-26: Set initial SLOs. An SLO is a service-level objective for cost. Example: "Claims processor runs at $5.00 ± 10% per claim." That means the target is $5.00, and anything above $5.50 or below $4.50 triggers investigation. Set these for your top 3-5 agents. Don't set them too tight (you'll have false alarms). 10-15% variance is reasonable for month one.

Day 26-27: Draft the monthly board report. This is a one-pager for the board. It includes:

• Total AI spend (vs. budget, vs. prior month)
• Cost per unit for each agent (vs. target)
• Margin benefit (AI savings - AI cost)
• Any cost anomalies (agents running hot, new vendors, unexpected spikes)
• Headcount reallocation plan (if applicable)

Make this look sharp. Your board is asking "what's our AI ROI?" This report should answer that question in plain English, with numbers.

Day 28: Review with finance and ops. Walk through the dashboard and the board report with your CFO, controller, COO, and head of AI. Do the numbers make sense? Is there anything you're missing or misattributing? Lock in the process: who updates the dashboard? Who approves cost changes? Who escalates anomalies?

Day 29-30: Train the team and go live. Brief your finance team on the new dashboard. Show them how to read it. Show them the board report. Explain what an SLO is and why it matters. On day 30, publish the first version of the dashboard to your team and send the first monthly report to the board. It doesn't have to be perfect. It has to be real and updated.

What you've shipped by day 30

By end of week 1, you have centralized AI spend visibility: one number, total monthly AI cost.

By end of week 2, you have cost allocated to teams: who's spending, how much, and which use cases.

By end of week 3, you have work-item attribution: cost per ticket, per claim, per lead.

By end of week 4, you have automated reporting and governance: a live dashboard, SLOs for your top agents, a monthly board report, and the process to maintain it.

You're now at stage 3-4 of the 5-Stage AI Cost Maturity Curve: allocated and moving toward optimized. Most CFOs are still at stage 1-2. You're 6-12 months ahead.

What happens next (weeks 5-12)

• Weeks 5-7: Anomaly detection. Set up automated alerts when an agent's cost per unit drifts more than 20% from baseline. Investigate when the alert fires. (Is it a retry storm? A new prompt? A pricing change?)
• Weeks 8-10: Cross-agent benchmarking. Compare your cost per claim to known benchmarks (Klarna at $0.19/ticket, Sierra at $1.50/ticket, industry averages). Identify optimization opportunities.
• Weeks 11-12: Approval workflow. Build a process: new AI experiment requires estimated cost-per-unit impact; experiments exceeding $50k/month total cost need CFO sign-off. Lock down who can spin up new agents, change models, or adjust prompts.

Explore the full FinOps for AI framework in the pillar article.