I run a five-item audit: interactions, average tokens, documents for embeddings, expected concurrency and human-hours. I convert those inputs into inference, vector DB, storage, orchestration and staffing lines in a spreadsheet to produce a single monthly run-cost and a build-vs-buy threshold you can show the CFO.
- Inference, storage, connectors and ops staffing often equal or exceed the headline licence fee.
- A five-minute audit delivers the exact inputs you need: interactions, tokens, documents, concurrency and human-hours.
- A single-row spreadsheet with clear formulas produces a defensible monthly figure you can put in a budget.
- Build versus buy depends on steady monthly spend, not peak transactions; include staffing in the break-even.
- Vendor traps—egress, retained logs, retention rules—create surprise line items that kill ROI if you ignore them.
Signs this is happening in your business
- Support reads every onboarding ticket and copies fields between systems.
- You pay per-seat licences yet three people still perform manual handoffs each weekday.
- Engineering promises an internal fix that never ships because scope keeps expanding.
- Storage and monitoring bills creep up month to month with no owner for totals.
- You can't state tokens consumed by a single onboarding interaction.
- Timeouts and rate limits force staff to retry tasks manually during peaks.
- A vendor increases usage rates and the monthly invoice jumps with no owner ready.
- Embeddings are untracked while you have a pile of documents that must be searchable.
If several of these are true at the same time, the problem is usually the process rather than the people running it.
What this is costing you a year
(Team hours per week x hourly cost of employees x 52) = annual payroll loss
- People doing this work4
- Hours each per week6
- Hourly cost of employees$45
- Weeks52
The annual payroll cost of four people each spending six hours per week on the manual process.
Find the number before you spend anything
Run the formula above on your three most repetitive processes. If any of them clears a year of a salary, that is the one to bring to a call.
Estimate monthly run costs for AI agents with a short audit
I start with five inputs: interactions, average tokens per interaction, number of documents needing embeddings, expected concurrency, and human-in-loop hours. Those five numbers map directly to the vendor and ops lines that drive monthly bills—inference, vector storage and queries, document storage, orchestration, logs and staffing.
If you can answer these five items you stop treating the licence as the headline cost. The daily pattern of interactions and their length is what actually determines the invoice.
- Interactions per period: how often the agent is triggered
- Average tokens per interaction: text in and out the model processes
- Documents for embeddings: count, average size, retention windows
- Expected concurrency: simultaneous sessions in a short window
- Human-in-loop hours: weekly staff time for review and fixes
Audit checklist that produces the exact inputs you need
Run a 30–60 minute session with the process owner and a power user and capture each process as one row in a spreadsheet. Record counts and units so the sheet can multiply them by vendor rates and staffing costs to produce a monthly line item.
Do this once before buying, then validate the results in month one and update the same row with measured values.
- How often the process runs: per customer per month or total runs per month
- Average input and reply length: capture words or characters and convert to tokens
- Documents to index: document count and average size in KB
- Retention: hot retention window and cold archive rules
- Peak concurrency: highest parallel sessions in a 15-minute window
- Human-hours per week for review, escalation or corrections
- Connectors used: list external systems read or written to
- Logging level: full transcripts, error-only, or summaries
- Backup and compliance retention rules for data and transcripts
Convert audit inputs into monthly costs
Turn each audit input into a spreadsheet line: inference by model, embedding compute, vector storage and queries, document storage, orchestration and hosting, connectors, logs, backups and staffing. Use explicit formulas so each vendor charge maps to one audit input.
Sum those lines to get a single monthly run-cost you can show stakeholders and use for break-even analysis.
Inference cost: map tokens to monthly spend
Multiply monthly interactions by average tokens per interaction by the per-token price for your chosen model. Add a buffer for retries and long conversations and you have monthly inference spend in dollars.
Choosing a larger model raises per-token price and can dominate the bill; smaller models lower cost but may increase human review work.
- Formula: monthly interactions × avg tokens × per-token price = monthly inference
- Include a buffer for retries and long-form conversations (10–30% depending on error rates)
Embedding and vector DB cost: count stored vectors and queries
Embedding expense splits into compute to create vectors and the ongoing cost to store and query them. Count documents and average vector size for storage; estimate queries per interaction for query costs.
Treat embedding storage as a per-document monthly cost plus query consumption that scales with interactions; long retention turns one-off compute into recurring storage expense.
- Storage formula: number of documents × avg vector size × monthly storage rate
- Query formula: monthly interactions × queries per interaction × per-query price
Document storage and cold archives
Raw documents and transcripts require hot storage for active use and cold storage for long-term retention. Hot storage costs more per GB but avoids repeated recomputation of embeddings and reduces latency.
Decide retention rules up front: a short hot window with a cheaper cold archive often saves money while preserving compliance.
- Split storage into hot (fast access) and cold (archive) buckets
- Monthly cost = active GB × hot rate + archived GB × cold rate
Nobody owns the operational bill until someone owns the data and the invoice.
Orchestration, hosting and concurrency
Orchestration costs come from provisioning for peak concurrency and keeping connectors available. Estimate required capacity from peak concurrent sessions and average processing time to size hosting and scheduler costs.
Smoothing traffic or using small queues reduces peak capacity needs and the cost of reserved compute.
- Estimate capacity = peak concurrent sessions × average processing time
- Convert capacity to a monthly hosting bill using your cloud or platform rates
Logging, observability and retention costs
Detailed logs and full transcripts are useful but expensive to store and search. Define the minimum logging level required for safety and debugging, then estimate monthly GB of logs under that policy.
Reduce costs by truncating transcripts, exporting summaries, or keeping full logs only for escalations and a short retention window.
- Monthly logs = events per interaction × avg bytes per event × interactions per month
- Retention determines whether logs are charged as hot storage or archived
Connectors and integration costs
Each third-party connector—CRM, billing, storage—adds latency, egress and potential per-connector fees. Count connectors and estimate monthly transactions per connector to produce a connector line item.
Some connectors require ongoing maintenance; budget weekly engineer time for debugging and schema updates.
- Monthly connector cost = per-connector fee + transactions × per-transaction charge
- Include a small monthly line for debugging and schema updates
Support and maintenance staffing
Staffing is a recurring line many buyers miss. Estimate human review hours, ops on-call and a fractional automation lead for tuning. Multiply weekly hours by loaded hourly cost to produce the monthly staffing line.
For smaller volumes staffing can exceed inference costs and decide whether to build or buy.
- Include a fractional automation lead (10–30 hours/month) for tuning and vendor liaison
- Include daily review time for exceptions and weekly time for data hygiene
Identify your biggest operational bottleneck
Most owners already know which process is the problem. What they do not have is the annual figure attached to it. That is a 15-minute conversation, not a project.
Worked examples: small, medium and high usage with the spreadsheet math
I show three illustrative examples that apply the exact formulas to small, medium and high usage patterns. Replace the example unit prices with your vendor quotes and rerun the sheet to get accurate totals.
Each example multiplies the audit input by a rate per line and sums the rows to produce a monthly run-cost.
Example math — small usage (SaaS customer onboarding)
Scenario: 3,000 interactions per month, 1,200 tokens per interaction, 5,000 documents indexed and low concurrency. Use your vendor prices to update each line and the total will change accordingly.
Line items below are illustrative; swap in your quotes to produce real numbers.
- Inference: 3,000 × 1,200 tokens = 3,600,000 tokens. At $0.0002 per token = $720 / month.
- Embeddings compute (one-off): 5,000 vectors × $0.01 = $50 (amortise if desired).
- Embedding storage: 5,000 × 0.0005 GB × $0.02/GB = $0.05 / month.
- Document hot storage: 50 GB × $0.10/GB = $5 / month; cold archive 450 GB × $0.01/GB = $4.50 / month.
- Orchestration/hosting: small reserved capacity $120 / month.
- Logs: 10 GB × $0.10 = $1 / month.
- Connectors and maintenance: $200 / month.
- Staffing: 20 hours/week × $60 loaded = $4,800 / month.
- Total example monthly run-cost (small) = $6,900.55.
Automating a broken process speeds up failures and multiplies costs.
Example math — medium usage
Scenario: 30,000 interactions per month, 1,600 tokens average, 50,000 documents and moderate concurrency. The same formulas scale linearly with interactions and documents; staffing and storage grow faster.
Swap the illustrative unit prices for your vendor quotes to update totals.
- Inference: 30,000 × 1,600 = 48,000,000 tokens. At $0.0002 = $9,600 / month.
- Embeddings compute: 50,000 × $0.01 = $500 (amortised).
- Embedding storage and queries: estimate $300 / month.
- Document storage: 500 GB hot at $0.10 = $50; 5 TB cold at $0.01 = $51.20.
- Orchestration/hosting: $600 / month.
- Logs: 100 GB × $0.10 = $10 / month.
- Connectors and maintenance: $800 / month.
- Staffing: 60 hours/week × $60 = $15,600 / month.
- Total example monthly run-cost (medium) = $27,511.20.
Example math — high usage
Scenario: 300,000 interactions per month, 2,000 tokens each, 500,000 documents, high concurrency and reserved capacity. Costs concentrate in inference, vector queries and staffing, and you'll want volume discounts.
At this scale renegotiate per-token pricing and consider an internal build if monthly spend stabilises at a high level.
- Inference: 300,000 × 2,000 = 600,000,000 tokens. At $0.00015 (volume price) = $90,000 / month.
- Embeddings compute: 500,000 × $0.008 = $4,000 (amortise).
- Embedding storage and queries: estimate $3,500 / month.
- Document storage: 5 TB hot at $0.10 = $512; 50 TB cold at $0.01 = $512.
- Orchestration/hosting: reserved capacity $3,000 / month.
- Logs and observability: 1 TB × $0.10 = $102 / month, plus search fees $500.
- Connectors and maintenance: $2,500 / month.
- Staffing: 200 hours/week × $60 = $48,000 / month.
- Total example monthly run-cost (high) = $152,626 / month.
Sensitivity and break-even: when to build, hire, or buy
Build a conservative, expected and growth scenario in the sheet and include staffing in the break-even check. Compare annualised vendor run-cost to the annual loaded cost of an in-house automation lead plus maintenance to decide whether to build.
If vendor spend is steady and predictable and exceeds hiring costs, building becomes economical; if spend is volatile, prefer a hybrid or buy with fractional ops.
- Break-even: monthly vendor run-cost × 12 = annual vendor operating cost; compare to annual loaded hiring cost
- If vendor spend is volatile, buy the platform and hire fractional ops to reduce waste
- Sensitivity step: vary tokens per interaction by ±20% and staffing hours by ±25% to spot drivers
Where this fails in practice and the sequence that kills ROI
Projects fail when teams ignore operational lines: storage, logging, connectors and staffing. The predictable sequence I see is wide scope, uncontrolled usage, unclear retention, rising logs and storage, surprise invoices, emergency throttling and stalled features.
Finance notices a rising recurring bill, asks for a breakdown, ops has none, the vendor points to usage spikes and the fix is painful.
- Failure sequence: wide scope → unfettered usage → unclear retention → rising logs/storage → surprise invoice → emergency throttling → customer-impacting outages
- First to notice: finance for invoices, then support for degraded service, then product for rollback decisions
Vendor pricing traps and negotiation levers
Vendors hide costs in egress, retention, logging and per-query charges. Ask for clear unit prices and negotiated caps on lines that scale unpredictably—tokens, vector queries and storage—and insist on a CSV invoice with line items.
Use commitment discounts cautiously and avoid long locked contracts until you validate month-one usage.
- Watch for egress charges, per-query vector search fees and per-GB log retention fees
- Negotiate volume token discounts, capped monthly spend and lower retention charges
- Request a CSV invoice with line items so vendor charges map to your audit inputs
What to measure in month 1 and the downloadable monthly run-cost template
Measure interactions, avg tokens per interaction, queries per interaction, documents created or changed, peak concurrency and human review hours. Those six numbers validate the model and let you replace proxies with measured values.
Download the template, populate it with your audit inputs, then run month-one measurements against the same fields. If you want help I offer a focused cost audit—see How to work together.
- Month 1: total interactions, avg tokens in/out, vector queries, GB stored hot and cold, peak concurrency, human review hours
- Log values daily and aggregate to monthly totals for the template
- Use the template to produce a monthly run-cost and an annualised vendor spend for break-even checks
Next step: make the number you can show the CFO tomorrow
Do the five-minute audit, put the numbers into the template and produce a monthly run-cost you can print. If the figure surprises you, book a 30-minute cost audit and I will walk the sheet with you—see How to work together.
If you want implementation after the decision I offer build work at Build tech for you and advisory engagements at Services.
Where businesses waste the most time
- Re-keying customer dataTeam copies fields between systems, causing delay and errors.Add a direct connection so data flows automatically when an order arrives without replacing existing apps.A person still checks: A person spot-checks a daily exception report for failed transfers.
- Manual transcript storageSupport saves full transcripts in shared drives; searching is slow.Store summaries in the existing document system and archive full transcripts to a low-cost bucket.A person still checks: A reviewer inspects full transcripts only for escalations.
- Ad-hoc embeddingsDocuments get embedded on demand, creating duplicate work and cost.Add a scheduled job that updates embeddings for changed documents and keep a single index.A person still checks: An editor reviews the list of changed documents weekly.
How this compares with what you already run
| Operational area | The manual way | The automated way | Annual business impact |
|---|---|---|---|
| Onboarding tickets | Support copies fields manually | Agent handles routine steps; humans handle exceptions | Saves a full-time salary worth of hours |
| Document search | Staff search folders and share links | Embeddings return relevant passages instantly | Faster responses that accelerate revenue |
| Data re-keying | Team copies customer data across systems | Automated transfers at event time | Frees hundreds of hours per year |
| Error handling | Errors found late and escalated | Immediate flagging and human review of exceptions | Fewer escalations and reduced churn |
| Scaling capacity | Hire staff as volume rises | Increase platform parallelism | Predictable monthly cost instead of headcount jumps |
What the end-to-end workflow looks like
- Customer submits onboarding formA new onboarding request is created with customer data and documents.Automated: triggers the agent to begin processing
- Agent reads customer documentsThe agent retrieves indexed documents and builds context for the onboarding conversation.Automated: vector lookup provides relevant passages
- Agent runs the onboarding scriptThe agent asks or infers required fields and attempts to complete routine tasks.Automated: agent performs routine steps
- Human review of exceptionsAny missing or risky items are placed in an exceptions queue.Stays human
- System updates and confirmationsThe system writes confirmed data to CRM and triggers billing if ready.Automated: system connections push updates
- Logging and retentionTranscripts and logs are stored according to retention rules.Automated: summaries kept hot, full logs archived
- Weekly tuning and metrics reviewTeam reviews failed cases and tunes prompts or rules.Stays human
The metrics that tell you it worked
| Metric | What it tells you |
|---|---|
| Monthly interactions | Total agent-triggered sessions per month; it drives inference and query costs. |
| Average tokens per interaction | Average text in and out per session; multiply by interactions to get token consumption. |
| Exceptions per 1,000 interactions | Number of sessions requiring human review; it predicts staffing needs. |
| Documents indexed | Count of documents that require embeddings; it informs vector storage and compute. |
| Peak concurrent sessions | Maximum simultaneous sessions in a 15-minute window; it determines hosting capacity. |
| GB of logs per month | Total storage used by logs and transcripts; it maps directly to retention costs. |
| Human review hours per week | Staff hours spent on exceptions and tuning; it converts to a monthly staffing line. |
| Failed connector calls per month | Count of integration failures requiring retries; it predicts additional operational overhead. |
When this is the wrong move
- When monthly interactions are under a few thousand and staffing to maintain automation costs more than the vendor run-cost.
- When the process is poorly defined and will change weekly; automating a moving target wastes money.
- When you lack instrumentation to measure tokens, interactions or storage—improve visibility first.
- When regulatory rules force all data to remain on-premises and the vendor cannot meet that requirement.
- When the cost of errors exceeds the savings from automation and you cannot accept automated decisions.
The mistakes that cost the most
- Automating a broken processTeams replace human work with an agent before fixing the process; errors multiply, logs grow, staff triage increases and the project stalls.
- Ignoring retention and logsFull transcripts are retained indefinitely, invoices rise unnoticed, finance demands cuts and the team deletes data under pressure.
- Treating the licence as the only costBuyers budget the platform licence and miss ongoing inference, storage and staffing lines; after a year vendor spend can exceed a hire's cost and trigger audits.
Frequently asked questions
How accurate will my estimate be after the audit?
You get a defensible estimate suitable for budget decisions. The audit produces actual inputs—interactions, tokens, documents and human-hours—that you can measure in month one to validate and refine the model.
Can I reuse the template for multiple processes?
Yes. Put each process on its own row and sum the rows for the total monthly run-cost. Different processes have different tokens, document needs and staffing, so separate rows keep the math auditable.
Should I negotiate a flat cap with vendors?
Negotiate caps for lines that scale unpredictably—tokens, vector queries and log retention. A fixed cap prevents surprise invoices, but keep terms short until month-one behaviour proves stable.
When does hiring a part-time automation lead make sense?
When your monthly run-cost is steady and non-trivial and you need someone to cut waste, tune prompts and manage vendors. The lead should aim to reduce inference and storage waste within three months.
What if my team can't measure tokens or concurrency?
Start with proxies you can measure now: average message length in words, messages per session, daily peak sessions. Seed the spreadsheet with those proxies and add instrumentation immediately to replace proxies in month one.
Stop paying salary for robotic work
Bring your messiest process to a 15-minute audit and we will map where the hours actually go, live on screen. You leave with the number whether or not you work with me.