How to cut your Agentforce bill: a Flex Credit optimization playbook

The first surprising Agentforce invoice usually arrives a couple of months after go-live, and the reaction is almost always the same: “we’re running one agent — why does it cost this?” Open Digital Wallet next to the bill and the answer is rarely the traffic. It’s the design. Two orgs can run what looks like the same service agent and pay wildly different amounts for the identical customer question, because on the Flex Credit meter you don’t pay for the agent — you pay for every action it takes, and a sloppy agent takes three actions to do a one-action job. Forever. At any volume.

That’s the good news hiding in the bad. Because Flex Credits price the actions an agent executes — not the conversation, not a seat — the bill is a direct function of choices you control: how many actions each request triggers, whether the reasoning engine loops, whether requests route to the right place, how much you stuff into each action. Most of those are tunable in a sprint, without touching a single use case. You don’t need to renegotiate your contract. You need a triage pass.

This is that pass. First where credit burn actually concentrates, then eight levers in rough order of impact — deflecting no-action chatter, cutting actions per request, taming the reasoning loop, fixing misrouting, right-sizing retrieval, matching the meter to the agent, debugging in sandbox, and the monitoring that keeps the savings from eroding. Run it once, then leave the last lever running permanently.

Where Agentforce credit consumption actually concentrates

Every billable event on the Flex meter is an action — a discrete function the agent performs on the platform: querying a record, running a Flow, calling an Apex invocable, executing a prompt template, updating data. The rate is flat and public: a pack of 100,000 Flex Credits lists at $500, a standard action consumes 20 credits (about $0.10), and a voice action consumes 30 (about $0.15). One fact that surprises teams: a custom Apex or Flow action bills the same 20 credits as a standard one — there’s no premium for building your own, so “custom vs standard” is a design decision, not a cost lever.

The whole bill, then, reduces to a single equation: actions executed × $0.10. Which means credit burn concentrates in exactly three places, and effective optimization starts by reading your own Digital Wallet breakdown rather than guessing:

• Action count per interaction. The dominant driver. Salesforce’s own pricing examples run 2–6 actions per interaction — an order-status check at 2 actions ($0.20), a case assist at 3 ($0.30). An agent that chains eight actions to do that same job costs 2–3x more on every single conversation.
• Reasoning overhead. The Atlas reasoning engine can call an action more than once while it works out what to do. Each call bills. Loops and retries are pure waste — credits spent reaching no new answer.
• What rides free, thrown away. Interactions that trigger no action at all — a greeting, a thank-you, an answer the agent can give from its instructions — cost nothing. Teams that route every “hi” through a Flow are paying $0.10 for a $0 event.

The eight levers below are ordered by the impact we typically see, but sequence them against your own top meters. Here’s the map:

Lever	What it moves	Why it matters	First thing to check
1. Deflect no-action interactions	Free vs $0.10 events	No action = no charge	Greetings/FAQ routed through Flows
2. Cut actions per interaction	Action count	Bill = actions × $0.10	Small reads/writes that could be one action
3. Tame the reasoning loop	Repeat/retry actions	Each loop call bills	Actions called twice in one turn
4. Stop the misrouting	Wasted actions	A misroute burns an action, resolves nothing	Overlapping topic/subagent descriptions
5. Right-size retrieval	Action count + token overflow	Bloated grounding splits one action into several	Top-K set high; whole articles retrieved
6. Match the meter to the agent	Flex vs Conversations	Crossover is ~20 actions	High-action agents on the wrong meter
7. Debug in sandbox, not prod	Where credits burn	Sandbox is discounted; loops are cheaper to find	QA cycles running against production
8. Monitor and guardrail	All of them	Catches drift and runaways early	Nobody owns the weekly review

Lever 1: make the agent do nothing, on purpose

The cheapest action is the one that never fires. Because an interaction that requires no action carries no charge, the first lever is simply to stop paying for work that isn’t work. Greetings, pleasantries, “are you a robot,” and — crucially — questions the agent can answer directly from its topic instructions rather than a retrieval or a Flow should resolve as plain responses, not trigger an action behind the scenes.

This sounds trivial until you price it at scale. An agent fielding 3,000 conversations a day that fires one unnecessary lookup on every opening turn is burning 3,000 actions daily — roughly $300 a day, ~$9,000 a month — to say hello. Audit the opening moves of your most common flows and make sure small talk and instruction-answerable questions stay on the free path. The design instinct that pays here is the same one behind good human-in-the-loop scoping: reserve the machinery for the moments that actually need it.

Lever 2: cut the actions per interaction

If the bill is actions × $0.10, the highest-leverage move is fewer actions per resolved request — and the biggest offender is the agent that does in five small steps what one well-built action could do in one. Three habits move this meter:

• Bulkify the reads and writes. An agent that reads the account, then the contact, then the last case, then the entitlement as four separate actions spent 80 credits assembling context that a single purpose-built action — one Apex invocable or one Flow returning the whole bundle — could deliver for 20. Design actions around the decision the agent needs to make, not around your object model.
• Return only what the model needs. A wide action that dumps an entire record forces the reasoning engine to work harder and can push the action past its processing ceiling (more on that in lever 5). Narrow the output to the fields the next step actually uses.
• Prefer one deterministic action over several probabilistic ones. Every action you hand the agent is a thing it might call, correctly or not. Fewer, sharper actions mean fewer chances to chain an extra call. This is where the Flow-versus-Apex-versus-Agentforce decision becomes a cost decision: consolidating three chatty actions into one deterministic Flow both cuts credits and makes the agent behave.

There’s no published discount for a well-built agent — but there’s a very real penalty for a badly built one. An agent averaging eight actions where three would do costs 2.6x more than it should, on every conversation, indefinitely.

Lever 3: tame the reasoning loop

The Atlas reasoning engine plans, calls an action, reads the result, and decides what to do next — and when instructions or action descriptions are vague, it can call the same action repeatedly inside one turn while it flails toward intent. Every one of those calls bills. A loop isn’t a bug that throws an error; it’s a quietly expensive success.

The fix is legibility, not fewer capabilities. Sharpen action descriptions so the engine knows exactly when each applies, tighten topic instructions so the plan is unambiguous, and — the underused step — watch what the agent actually did. The Plan Tracer in Agent Builder shows the step-by-step reasoning and the actions fired for a given request, which is where you spot the action that got called twice or the retry that resolved nothing. Treat an action count that’s higher than the task warrants as a defect to debug, exactly the way you’d treat an agent that keeps picking the wrong topic — because it usually has the same root cause.

Lever 4: stop the misrouting before it burns an action

A misrouted request is the worst kind of spend: it costs a full action and resolves nothing, so the customer re-asks and you pay again. Routing lives in how you wrote your topic and subagent classification descriptions — the Agent Router can only act on what you told it — so two subagents that describe overlapping jobs will trade requests back and forth, each handoff a billed event that moves the conversation nowhere.

The cure is design discipline covered in depth in designing subagents and classification descriptions: give each subagent a single, non-overlapping job; write classification descriptions that a stranger could route by; and add guardrails that stop the agent from firing actions on requests it shouldn’t be handling at all. Every request that reaches the right place on the first pass is an action you didn’t waste.

Lever 5: right-size retrieval and respect the action ceiling

Grounding is where two bills meet. Retrieval itself is an action on the Agentforce meter, and the underlying knowledge indexing and search run on Data 360’s separate credit pool — so bloated grounding costs you twice. It also carries a subtler trap: each action processes a bounded amount of content, and practitioners consistently report that an action carrying more than roughly 10,000 tokens is billed as multiple actions rather than one. I’d treat the exact multiplier as directional and verify it against the current Flex Credits rate card before you model it — but the direction is clear and matches how the engine works: stuff a whole knowledge article into one action’s context and you can silently turn a $0.10 event into $0.20 or $0.30.

So retrieval discipline is cost discipline:

• Tune top-K down. Retrieve the three most relevant chunks, not the ten most plausible. The right retriever configuration and result count is the single biggest lever on both answer quality and grounding cost.
• Chunk and structure the source. Long, unstructured articles are the top cause of oversized actions. Well-chunked content lets the right search index return the relevant paragraph, not the whole document.
• Trim the instructions too. Every word in the topic instructions and prompt template counts toward the action’s processing budget. Lean instructions keep actions under the ceiling and keep the agent focused.

One caveat, because it’s a common misconception: switching to a “cheaper” model does not directly lower your Flex Credit bill. The action price is flat at 20 credits regardless of which model reasons behind it. Model selection matters for cost only indirectly — a more verbose model can push actions over the token ceiling — or if you’re bringing your own LLM and paying that provider directly. Don’t reach for a model swap expecting a line-item discount.

Lever 6: put each agent on the meter it belongs on

Agentforce still offers two consumption meters, and they can’t coexist in one org: Flex Credits (per action) and the legacy Conversations meter ($2 flat per session, regardless of what the agent does). The crossover is clean arithmetic — at $0.10 per action, 20 actions per conversation is the break-even. Below it, Flex Credits are cheaper; above it, the flat conversation rate wins.

Most well-scoped service agents resolve in single-digit actions, which is why Flex Credits are cheaper for the majority of deployments. But the exceptions are real and worth catching: a heavy, multi-step agent — an outbound SDR that fires dozens of actions per sequence, or a deeply orchestrated back-office workflow — can cross the line, at which point the flat conversation meter is the cheaper home. This isn’t an optimization you apply blindly; it’s one you measure. Run the agent, read the average actions-per-conversation in Digital Wallet, and put it on the meter the telemetry supports. Just remember the meters don’t mix in a single org, so segment high-action and low-action agents accordingly.

Lever 7: burn your mistakes in sandbox, where they’re cheaper

Every lever above involves finding and fixing waste — loops, misroutes, oversized actions — and the finding is itself an iterative, credit-consuming process. Do it in production and you’re paying full freight to debug. Practitioner sources consistently report that Agentforce actions run at a discount in sandbox — on the order of 16 credits rather than 20 for a standard action, roughly 20% off — though it’s discounted, not free, so heavy QA cycles still cost something. Confirm the current sandbox rate against your rate card, then make it policy: adversarial testing, loop hunting, and topic tuning happen in a lower environment before the agent meets a customer.

This is where a real testing practice pays for itself twice — once in quality and once on the meter. Run your utterance batches and full-conversation simulations, diff the action counts before and after a change, and treat a change that raises the average action count as a regression to investigate, not just a behavior to accept.

Lever 8: monitor the meter, and guardrail the runaways

Everything above is a point-in-time fix. Consumption drifts — a new action gets wired in, a topic gets edited in a hurry, a knowledge article triples in length — so the durable savings come from watching the meter, not from one heroic cleanup. Two things make that stick:

Put Digital Wallet on a calendar. It’s the free instrument, and it’s granular: consumption cards with 7-, 30-, and 90-day windows, and Consumption Insights that drill down to the individual agent and action driving spend. The feature that makes it actionable is Usage Tagging — tag consumption by environment, agent, or feature so a spike has a name attached instead of being an anonymous number. Fifteen minutes, weekly, same owner: which agent moved most versus last week, and which action drove it? Spikes almost always have a mundane, named cause.

Guardrail the agents that can run away from you. The most dangerous credit event isn’t a busy day — it’s a broken agent looping. An event-triggered agent that fires on every record change, or a reasoning loop that never converges, can burn credits at machine speed with nobody watching. A broken agent doing 100 needless actions across a few thousand daily interactions is a five-figure surprise before anyone notices. Set consumption alerts at staged thresholds so an overage becomes a scheduled conversation rather than an invoice, scope triggered agents tightly, and — for anything customer-facing and autonomous — build the observability to see it failing quietly. Governance here is the same posture that keeps an agent fleet from turning into shadow IT: owners, scopes, and a retirement plan.

The bill is a design review

A sprint spent on this checklist tends to end in the same realization the Data 360 version does: the levers weren’t secrets, they were defaults nobody revisited. Actions where a bulkier action would do. Retrieval pulling ten chunks where three suffice. A reasoning loop nobody read the trace for. A greeting routed through a Flow. Consumption pricing punishes inattention far more than it punishes ambition — and it does it monthly.

That reframes what the invoice is for. A per-seat license tells you nothing about the quality of your build. A consumption bill is an itemized critique of it: every over-eager action, every sloppy topic, every un-chunked article shows up as a number with your name on it. And the reframe cuts the happy way too — the teams that treat the meter as a design constraint end up with agents that are simultaneously cheaper and better, because low action counts and good answers are symptoms of the same discipline: narrow topics, deterministic actions, and grounding that resolves in one clean retrieval instead of three.

So run the sequence. Deflect the free stuff, cut and bulkify the actions, trace the loops, fix the routing, right-size retrieval, put each agent on the right meter, debug in sandbox, and watch the wallet. If you want to pressure-test whether the savings justify the effort — or model a new agent before you build it — our Agentforce ROI calculator runs the same action-and-cost math interactively, and tuning agents to be cheap and good against real transcripts is a normal week for our Agentforce practice.

Understanding the basics

How are Agentforce Flex Credits consumed?

Flex Credits meter the individual actions an agent executes — querying a record, running a Flow, calling Apex, executing a prompt, updating data. A standard action consumes 20 credits (about $0.10 at the list price of $500 per 100,000 credits) and a voice action consumes 30 (about $0.15); custom actions bill the same 20 as standard ones. Interactions that trigger no action at all — a greeting, or an answer the agent gives straight from its instructions — cost nothing. Your whole Flex bill is essentially the number of actions executed times the per-action rate, which is why cutting actions per interaction is the highest-leverage cost lever.

How do I reduce my Agentforce bill?

Work the levers in order of impact: keep no-action interactions (greetings, instruction-answerable questions) off the paid path; consolidate several small reads and writes into fewer bulkified actions; use Plan Tracer to find and fix reasoning loops that call an action repeatedly; tighten topic and subagent descriptions so requests stop getting misrouted; tune retrieval down to the few chunks you need so grounding stays cheap and actions stay under their processing ceiling; put high-action agents on the conversation meter and low-action agents on Flex Credits; debug in the discounted sandbox rather than production; and monitor Digital Wallet weekly with Usage Tagging and threshold alerts. Most orgs find their spend concentrated in action count, so start there.

Does using a cheaper model lower Flex Credit costs?

Not directly. A standard action costs 20 credits regardless of which foundation model reasons behind it, so swapping to a lighter model doesn’t produce a per-action discount. Model choice affects cost only indirectly — a more verbose model can push an action’s content past its processing ceiling and get it billed as multiple actions — or when you bring your own LLM and pay that provider’s token costs separately. Optimize model selection for capability, latency, and quality; optimize the Flex bill with the action-and-retrieval levers instead.

What is Digital Wallet in Agentforce?

Digital Wallet is Salesforce’s free consumption-monitoring layer for metered products, including Agentforce and Data 360. Its consumption cards show near-real-time credit usage over 7-, 30-, and 90-day windows, Consumption Insights drills down to the individual agent and action driving spend, and Usage Tagging lets you attribute consumption by environment, agent, or feature. Combined with staged threshold alerts, it’s the primary tool for catching consumption drift — a new action, a longer knowledge article, a looping agent — before it becomes a surprising invoice.

---

Looking at an Agentforce bill that outgrew its forecast, or want to build the agent cheap from the start? Talk to us — right-sizing the action count and the grounding so an agent is both affordable and good is exactly the tuning we do against real transcripts.