Agentforce Engagement: the review workflow that decides what the agent sends

On August 24, 2026, Agentforce Lead Nurturing became Agentforce Engagement. Salesforce says the new name better describes the range of work the agent does with existing prospects, and that reading is fair. But the rename is the least interesting thing in the release notes.

The interesting change sits under it. Engagement Agents now run on Agent Script, the deterministic control layer the new Agentforce Builder is built on, and the release ships a review-workflow model that lets you auto-approve routine outreach while flagging complex or high-value records for a human before a single message leaves the org.

That review workflow is the whole build. An engagement agent that drafts a good email is table stakes. An engagement agent that knows which of tonight’s 400 scheduled sends it is allowed to send on its own, and which three a human has to see first, is the difference between a tool your revenue team trusts and one they switch off after the first bad send to a named account.

So decide the auto-send line as a rule, not as a sentence in the agent’s instructions. Write it where it runs deterministically every time, and keep the model out of the decision about whether a message is safe to send. Below is what changed, and how to build the gate so it holds.

What the rename actually brought with it

The name change landed on August 24. The capabilities landed around it, and they matter more.

Agentforce Engagement and its sibling, Agentforce Prospecting, now support scheduled autonomous runs. The agent wakes on a cadence you set, works a list, and prioritises contacts by recent engagement rather than by whatever order the report returned.

It can also do cross-ownership research, so it isn’t blind to activity on a record another rep owns. And every session it runs shows up in the Agent Activity tab, the audit surface you will live in during the first month.

Scheduled autonomous runs are the part to sit with. A nurture agent that only acts when a rep clicks is a copilot. A nurture agent that wakes at 6am, reads the list, drafts the outreach, and sends it is an autonomous actor touching your prospects without a human in the moment. The review workflow is the control that decides whether that autonomy is bounded or not.

Why Engagement runs on Agent Script now, and why that helps

The new Agentforce Builder is built on Agent Script, and Engagement agents inherit that. The point of Agent Script is control: you encode business rules and guardrails as script the runtime follows instead of hoping the model infers them from a prompt. For an outreach agent, that distinction is the safety model.

Consider the two ways to express “don’t send discount language to an account in an active renewal.” As an instruction, it is a sentence the model reads and mostly obeys, until a phrasing you didn’t anticipate slips through and the model decides the rule doesn’t apply this time.

As a script step, the same rule is a branch the runtime takes every time, with no interpretation. The human-in-the-loop literature has one durable finding: route the consequential decision through deterministic logic, not through the language model, because the model is the part that varies.

Engagement gives you the place to do that. You still write instructions for judgment, the tone of the email, which value prop fits this persona. You write script for policy, the conditions under which a draft is allowed to send without a human. Keep those two jobs separate and the agent gets predictable where it needs to be and flexible where it can afford to be.

Designing the review criteria: what auto-approves, and what waits

The release describes the model plainly: customized review workflows can automatically approve routine interactions while flagging complex or high-value records for manual review before communications are initiated. The design work is deciding what “routine” and “high-value” mean in your pipeline, because Salesforce cannot know that for you.

Start from consequence, not from volume. The question for each outreach is not “is this a common case” but “if this send is wrong, how bad is it, and can I take it back.”

An email to a cold inbound lead that misfires costs you a lead. An email that offers a renewal discount to an enterprise account whose deal desk is mid-negotiation costs you margin you cannot claw back. Those two belong on opposite sides of the gate even if both are common.

A workable first cut of the criteria that force human review:

• The account is named, strategic, or above a revenue threshold your sales leadership sets.
• The contact sits in an open opportunity past a certain stage, where a nurture email can cut across a live sales motion.
• The message contains pricing, discount, or commitment language, which is the category most likely to create an obligation.
• The account is in an industry or region with content rules you have to honour, so the copy needs a compliance eye.
• The agent’s own confidence in the classification is low, or it had to reach across ownership to assemble context.

Everything that clears all of those auto-sends. That is the routine tier, and it should be most of the volume, or the agent is not saving anyone time.

The trap is writing the criteria as prose in the agent’s instructions and calling it done. Put the load-bearing checks somewhere deterministic. A small invocable that the script calls, returning a routing decision, keeps the policy in one testable place:

public with sharing class EngagementReviewRouter {
    public enum Route { AUTO_SEND, HUMAN_REVIEW }

    public class Request {
        @InvocableVariable(required=true) public Id contactId;
        @InvocableVariable(required=true) public String draftBody;
        @InvocableVariable public Decimal classifierConfidence;
    }

    @InvocableMethod(label='Route engagement outreach for review')
    public static List<String> route(List<Request> requests) {
        List<String> out = new List<String>();
        for (Request r : requests) {
            out.add(decide(r).name());
        }
        return out;
    }

    private static Route decide(Request r) {
        Contact c = [
            SELECT Account.Is_Strategic__c, Account.AnnualRevenue,
                   (SELECT StageName FROM Opportunities__r
                    WHERE IsClosed = false ORDER BY Amount DESC LIMIT 1)
            FROM Contact WHERE Id = :r.contactId
        ];
        Boolean strategic = c.Account.Is_Strategic__c == true
            || c.Account.AnnualRevenue >= 5000000;
        Boolean liveDeal = !c.Opportunities__r.isEmpty();
        Boolean sensitiveCopy = containsPricingLanguage(r.draftBody);
        Boolean lowConfidence = r.classifierConfidence != null
            && r.classifierConfidence < 0.75;

        if (strategic || liveDeal || sensitiveCopy || lowConfidence) {
            return Route.HUMAN_REVIEW;
        }
        return Route.AUTO_SEND;
    }

    private static Boolean containsPricingLanguage(String body) {
        if (String.isBlank(body)) return false;
        String b = body.toLowerCase();
        for (String term : new List<String>{
            'discount', 'price', 'pricing', '% off', 'waive', 'credit'
        }) {
            if (b.contains(term)) return true;
        }
        return false;
    }
}

The router is deliberately dull, and the dullness is the value. You can read it, test it against real contacts, and change the threshold without touching the agent’s prompt.

The keyword scan for pricing language is a floor, not a ceiling. Treat it as the cheap first pass and let a human catch what it misses. When leadership moves the strategic-account bar, you edit one line and the whole fleet respects it.

The reviewer’s interface is the part teams underbuild

Every human-in-the-loop design lives or dies on the reviewer’s experience, and outreach review is where that shows up fast. If approving a flagged send means opening a record, reading the draft in a cramped field, and hunting for the context that made it get flagged, your reviewers will rubber-stamp the queue by Thursday and the gate becomes theatre.

The Agent Activity tab is where the runs surface, and it is worth building your review habit around it early. A flagged item needs to carry, in one view, the draft copy, the contact and account, why it was held, and the recent engagement the agent used to write it.

A reviewer who can see all of that decides in seconds. A reviewer who has to reconstruct it decides by reflex. That failure is the same one the approval-gate interface work warns about, and it applies whether the consequence is a database write or an email.

One rule keeps the queue meaningful: the human review has to happen before the communication is initiated, which is what the release specifies. A review that fires after the send is a log, not a gate. Confirm your workflow holds the message until approval, and test that it does, because an outreach agent that sends first and files for review second is worse than no agent at all.

Where you build it, and the seams to know

Two apps are in play, and mixing them up costs an afternoon. The agent itself, its script, instructions, and actions, is built in the Agentforce Builder inside the Agentforce Studio app.

Salesforce Go remains the place where you create and configure Engagement agents as a sales capability and point them at the audiences they work. Know which surface owns which setting before you start, or you will look for the review criteria in the wrong one.

Grounding is the other seam. An engagement agent that invents a product detail or a price in an email is a liability with your logo on it, and the fix is the same as for any customer-facing agent: ground it on data it cannot make up.

The Data Library pattern that keeps an inbound lead agent from inventing your pricing is exactly what an outbound one needs too. Do not let the model narrate specifics from memory.

The costs nobody puts on the first slide

Scheduled autonomous runs consume. An agent that wakes daily and works a list is doing real work on a cadence, and that work draws on your Agentforce entitlement the same way any agent action does.

Before you point it at a 50,000-contact audience, model the volume against your plan. The Flex Credit math is the reference, and the ROI conversation starts with the run cadence times the audience size, not with the demo.

The second cost is reputational and it does not show on any invoice. An autonomous agent sending email at volume is a deliverability and compliance surface. Your sending domain’s reputation, your unsubscribe handling, and the content rules of the regions you operate in are all now partly in the hands of a scheduled job. The review workflow is your control for the content risk. Your existing email infrastructure and consent model carry the rest, and neither of those got easier because the drafting is now automated.

What I would do first

Turn on the agent with the review threshold set aggressively low, so almost everything routes to a human, and watch the Agent Activity tab for a week. You are not measuring the agent yet. You are learning where its judgment is good enough to trust and where it is not, and you are calibrating what “routine” means with real sends in front of you.

Then raise the auto-send bar one criterion at a time, and only when the human reviews for that category have been boring for a week. An engagement agent earns autonomy the way a new rep does, by being right on the easy cases long enough that you stop checking. The review workflow is what lets you grant that autonomy in increments instead of all at once, and building it well is the difference between an agent that scales your team and one that speaks for it before it is ready.

Understanding the basics

Is Agentforce Engagement the same as Agentforce Lead Nurturing?

Yes. Salesforce renamed Agentforce Lead Nurturing to Agentforce Engagement, effective August 24, 2026, because the agent’s work extends beyond nurturing net-new leads to engaging existing prospects. The underlying capability is the same product line, now built on the Agent Script architecture, with added support for scheduled autonomous runs and a review-workflow model for human oversight.

What is the review workflow in Agentforce Engagement?

The review workflow is the mechanism that decides whether an outreach the agent drafts sends automatically or waits for a person. You define criteria that automatically approve routine interactions while flagging complex or high-value records for manual review before the communication is initiated. The design work is deciding what counts as routine versus high-value in your pipeline, and encoding those checks as deterministic logic rather than as instructions the model interprets.

Why does it matter that Engagement runs on Agent Script?

Agent Script lets you express business rules and guardrails as steps the runtime follows every time, instead of as prompt text the model may or may not honour. For an agent that sends messages to prospects on its own schedule, the decision about whether a message is safe to send belongs in that deterministic layer. It keeps the policy predictable while the model still handles the judgment work, like tone and message fit.

Where do I build and configure an Engagement agent?

The agent’s script, instructions, and actions are built in the Agentforce Builder within the Agentforce Studio app. Salesforce Go remains the primary place to create and configure Engagement agents as a sales capability and assign the audiences they work. Runs and their outcomes surface in the Agent Activity tab, which is where you review flagged sends and audit what the agent did autonomously.

---

The review criteria are a revenue-policy decision wearing a configuration screen, and they are easy to get wrong in a way you only discover after a bad send. Talk to us if you want the auto-send line designed against your actual pipeline, or see how our Agentforce delivery practice builds the guardrails before the agent goes autonomous.