Collections with Agentforce

Accounts receivable is where good revenue quietly turns into bad debt, and it’s almost always because collections runs on a blunt instrument: an aging report, a fixed dunning cadence, and a team that treats a temporarily-glitched reliable payer the same as a genuinely at-risk account. Everyone gets the same three emails on the same schedule. The result is days-sales-outstanding that’s higher than it should be and customer relationships that get strained by dunning that had no business being aggressive.

Collections with Agentforce, generally available in the Summer ‘26 release, is Salesforce’s move to make that process discriminating instead of uniform. It uses predictive AI to score every open invoice, recommends a risk-based dunning plan per account, and lets you adapt the whole approach by customer tier — so your specialists spend their time on the accounts that actually need a call and stop chasing the ones that were always going to pay. This is one of the clearer examples of an agent doing real enterprise automation rather than answering questions, and it’s worth understanding how it actually sits on the platform before you assume it’s plug-and-play.

The problem it’s actually solving

Traditional collections fails in two specific ways, and Collections with Agentforce targets both.

The first is undifferentiated risk. A standard aging bucket says an invoice is 30 days past due. It doesn’t say why, or whether it matters. A customer whose external credit score looks healthy but whose internal payment speed is quietly decelerating is a real risk that an aging report renders invisible. A reliable payer who missed one invoice because of a technical glitch looks identical to a serial late-payer at the same day count. Sorting by days-past-due puts your best specialists on the wrong accounts.

The second is one-size-fits-all outreach. Fixed dunning sends the same email sequence to your largest strategic account and your smallest transactional one. That’s how you damage a relationship worth six figures to recover an invoice worth four — the outreach was tuned for no one in particular, so it was wrong for the accounts that mattered most.

Collections with Agentforce attacks both by scoring first and prescribing second.

How the scoring works

The agent scores invoices using predictive AI over payment history and account data — not just the external credit signals a finance team might buy in, but the internal behavioral signal that’s usually the more predictive one: how this specific customer has actually paid you over time. That’s the piece that catches the account whose third-party score is fine but whose payment velocity against you is slowing.

Two outputs matter from the scoring:

Level of attention. Each account gets a score that decides how much effort it warrants from the start, so the queue is prioritized by genuine risk rather than raw age.
Willingness-to-pay signal. Rather than a flat “days late,” the scoring separates accounts by likelihood and intent to pay, so an at-risk account and a reliable-payer-with-a-glitch don’t land in the same pile.

None of this is useful if the underlying data is thin, which is the first hard truth of any AI-on-finance project: the score is only as good as the payment history and account data feeding it. If your billing records are incomplete or your account data is a mess, the model will confidently mis-score. Getting the data foundation right for AI is not optional here — it’s the precondition. An unreliable score doesn’t just fail to help; it actively points your team at the wrong accounts with false confidence.

From score to action: the dunning plan

Scoring is the interesting half; the automation is the useful half. Based on the score, Agentforce recommends the optimal risk-based dunning plan — and “plan” here is concrete, not vague. A recommended plan spells out:

Outreach cadence — how often to reach out, tuned to the risk rather than a fixed weekly beat.
Escalation timing — when to move from a gentle reminder to a firmer one.
Actions like fees or service holds — the consequential steps, recommended at the point in the sequence where they’re warranted.

On top of that, teams define dynamic rules by customer tier, so a high-value account automatically gets a more measured, relationship-preserving approach while a transactional account gets a more direct one. The tiering is where finance keeps control of the strategy: the agent proposes the plan, but the guardrails for how aggressive it’s allowed to be per tier are yours to set.

Conceptually, a per-tier policy looks like this — a shape, not a screenshot:

# Illustrative dunning policy shaped by risk score + tier
tiers:
  strategic:            # high-value accounts: protect the relationship
    max_channel: email  # never auto-escalate to a call/hold without review
    fee_actions: manual_approval
    cadence: measured
  standard:
    max_channel: sms
    fee_actions: auto_after_escalation
    cadence: standard
  transactional:        # low-touch: let the sequence run
    max_channel: call
    fee_actions: auto
    cadence: direct

The agent scores the invoice, the tier rules bound what it’s allowed to recommend, and the dunning plan comes out the other side matched to both risk and relationship value.

Where it sits on the real object model

This is the part that decides whether it’s a weekend enablement or a project. Collections with Agentforce isn’t a standalone product — it’s an AI layer on top of Revenue Cloud Billing, and it operates on that product’s existing dunning and collections model. If you’re evaluating it, know the pieces it’s built on:

CollectionPlan — the Revenue Cloud Billing object (available in API version 64.0 and later) that carries the total invoice balance and the collections state for an account. This is the record the agent’s scoring and the dunning process both hang off of.
Dunning plans and dunning activities — the configuration that defines the collection cadence: the sequence of activities (reminders, escalations, and the actions the plan can take), which is exactly what the agent’s recommendation shapes per account.
The collections queue — accounts move into a collections state and generate the outreach and tasks defined by their dunning plan; Collections with Agentforce decides which plan and how aggressive rather than replacing the plan machinery itself.

Two things follow from that. First, the terminology in an older org may differ — the legacy Salesforce Billing managed package modeled dunning around its own objects, and Revenue Cloud Billing is the current native lineage — so confirm which billing product your org actually runs before mapping fields. Second, the practical implication: Collections with Agentforce assumes you’re running Revenue Cloud Billing. The agent makes the dunning process smart — scoring, prescribing, tiering — but it’s smartening a process that already has to exist in your org. If your billing and collections aren’t on Revenue Cloud, adopting this is a Revenue Cloud Billing project first and an Agentforce project second. Salesforce did ease the Billing side in the same release — Summer ‘26 added a guided setup wizard that consolidates usage-based product setup (usage resources, rate cards, rate card entries, and related objects) into a single screen — but “easier” is not “already done.”

The human-in-the-loop line you have to draw

Here’s the judgment call, and it’s the same one that governs every agent that can take a consequential action. Scoring an invoice is safe. Sending a polite reminder email is safe. Placing a service hold or charging a late fee is not something you let an agent do unsupervised — those actions touch revenue, contracts, and the customer relationship, and a mis-scored account that gets a wrongful service hold is a support escalation and possibly a churn event.

So the right configuration mirrors the tiered policy above: let the agent run the low-consequence outreach autonomously, and require human approval for the actions with teeth — fees, holds, anything that changes the customer’s service or balance. This is precisely the human-in-the-loop approval gate pattern, applied to money. Design the gate before you turn the agent on, not after the first wrongful hold. The dynamic-rules-by-tier mechanism is where you encode it: manual_approval on fee_actions for your strategic tier is not a nice-to-have, it’s the control that keeps an autonomous collections agent from damaging your most important accounts.

The teams that will get this right are the ones that treat the agent as a recommendation engine with a governed action surface, not an autonomous debt collector. The score and the plan can be automated aggressively. The consequential actions get a gate whose strictness scales with the account’s value.

What to actually do

If you’re already on Revenue Cloud Billing, Collections with Agentforce is a genuine upgrade to a process you’re running by hand — start by auditing the payment history and account data feeding it, because the scoring lives or dies on that. Define your customer tiers explicitly and set the dynamic rules so high-value accounts get a measured approach and consequential actions (fees, service holds) require human approval. Let the agent score and prescribe across the whole book, but pilot the autonomous outreach on a low-risk tier first and measure whether DSO actually moves before you widen it. If you’re not on Revenue Cloud Billing, be honest that this is a billing-platform project with an AI payoff at the end, not a switch you flip.

The broader pattern is worth naming: this is what agentic automation looks like when it’s aimed at a back-office process instead of a customer-facing one. No chat window, no “how can I help” — just a scoring model, a recommendation, and a governed set of actions that recover cash faster while protecting the relationships that matter. It’s the same discipline as agentic commerce and every other production agent: automate the reasoning, govern the actions, and get the data right first. For finance-heavy orgs, especially in financial services, that’s a template worth learning.

Understanding the basics

What is Collections with Agentforce?

It’s a Summer ‘26 GA capability in Salesforce Revenue Cloud that uses predictive AI to score open invoices based on payment history and account data, recommend a risk-based dunning plan (outreach cadence, escalation timing, and actions like fees or service holds), and adapt the approach by customer tier. It sits on Revenue Cloud Billing’s existing dunning and collections object model rather than being a standalone product.

Do I need Revenue Cloud Billing to use it?

Yes. Collections with Agentforce is an AI layer over Revenue Cloud Billing’s dunning and collections framework — built on the CollectionPlan object (API version 64.0 and later) and the dunning plans and activities that define collection cadence. It makes an existing collections process smarter; it doesn’t replace the need for that process to be set up in Revenue Cloud Billing first.

How does the invoice scoring work?

It applies predictive AI to internal payment behavior and account data — crucially including how a specific customer has actually paid you over time, not just external credit signals. That catches accounts whose external score looks healthy but whose payment velocity is slowing, and separates genuinely at-risk accounts from reliable payers who simply had a one-off glitch. The scores are only as good as the payment and account data behind them.

Should the agent place service holds and charge fees on its own?

No — those are consequential actions that touch revenue and the customer relationship, and a mis-scored account getting a wrongful hold is a real incident. Let the agent automate scoring and low-consequence outreach, but gate fees, service holds, and anything that changes a customer’s service or balance behind human approval, with the strictness scaled to the account’s value using the dynamic rules by tier.

Weighing Collections with Agentforce and want an honest read on whether your billing data and Revenue Cloud setup can carry it — and where to draw the human-approval line? Talk to us — designing governed, data-grounded automation for back-office finance processes is exactly the work we do.

Collections with Agentforce: predictive invoice scoring and risk-based dunning, explained