When teams start using AI for internal workflows, costs can rise faster than expected. What looks cheap at first gets expensive once a prompt hits new edge cases, especially on a process that spans a lot of records and documents. The good news: there are reliable ways to cut unnecessary token use without cutting what the process actually does.
The scale of this is bigger than most teams realize. Ramp’s AI Index put the median company at $12 per employee per month on AI spend, with the top 1% already at $7,500 per employee per month. That’s not a rounding error anymore, and the gap between “using AI” and “using AI well” is showing up directly on the bill.
Source: Ramp AI Index (8/12/26), business spend data from Ramp. AI spend includes LLM subscriptions, coding agents, API, and GPU cloud spend. Chart via a16z.
Where token spend spikes
- Running the same context again and again. If your process sends the same instructions, reference documents, or background data with every call, you pay for it each time you use the prompt. Prompt caching fixes this directly.
- Using a bigger model than you need. Tasks like classification, extraction, and formatting often work just as well with a smaller, less expensive model. Save the frontier model for the step that actually needs judgment.
- Prompt retries with no limit. If a prompt keeps retrying after a failure without a set cap, or keeps checking its own work in a loop, it can burn through tokens fast with nothing to show for it. Every automated process needs a strict retry limit and a clear definition of when it’s finished.
The fix: skills with built-in safeguards
A skill is a focused, scoped set of instructions, routed to the right job and handling just one task. Using skills instead of one big general-purpose prompt lets you pick the right model for each step, use cheaper models for simple work, reuse information instead of resending it, and set a clear stopping point. That structure is also what lets you actually see how each task uses tokens, instead of guessing.
Rather than loading a large prompt that tries to do everything, load only the specific skill the task needs. Only the important instructions run, which keeps the process simple and keeps token use down.
Checklist before creating or downloading a skill
- Are you sending the same information more than once in a single run? If yes, you’re probably wasting tokens.
- Does each step use the model that fits the job, or is everything running on the same, possibly more expensive, model?
- Is there a clear endpoint, or could the process keep running in a loop?
- Do you know the cost of each run, or are you only seeing the total at the end of the month?
Skills load only when needed
Only the name and a short description of each skill stay in context at all times, and that costs just a few tokens each. The full instructions load only when a task actually needs them. That means you can have 50 skills available and pay for 50 short lines, not 50 long documents. Keeping most instructions out of context until needed is what lets you see exactly how each task affects your spend.
Give the model a path
Most wasted tokens don’t come from the instructions themselves. They come from searching, guessing, and redoing work. A well-scoped skill that says “read this file, then write to that path” can avoid ten unnecessary tool calls. In a long session, tool results, not instructions, are often the biggest single source of token use.
Skills can delegate to subagents
A skill can spawn an agent to do a search or a lookup, which keeps the messy intermediate steps out of your main context. You get a clean answer back instead of a raw data dump sitting in the conversation.
Good skills use progressive disclosure
Keep the skill’s main instructions short, and only link out to reference files for rare or special cases. The reference loads only when it’s actually needed, which keeps everyday runs cheap.
There’s a real trade-off here. Every skill description adds a permanent cost to your context, so 20 skills with long descriptions cost more than 5 with short, focused ones. Keep descriptions tight, review what you’re actually using on a regular basis, and delete what you don’t need. The rule underneath all of this: keep only what’s useful in context, so your spending stays visible instead of hidden.
Track spend per process, not per invoice
Instead of waiting for the bill to find out what AI cost you, track the cost of each process as it runs, the same way you’d track any other line item. Use your AI platform’s built-in usage dashboard, or log token counts straight from API responses. Our own Skills and Agents Run Tracker, along with tools like LangChain’s token trackers and OpenAI’s usage dashboards, can summarize token use per task so a cost spike gets caught early instead of showing up as a surprise.
Browse the skills catalog to see how existing skills are scoped and priced in practice, or read about what an agent is and does if you’re weighing whether a task needs one.