It’s week ten of the quarter. An account executive has six deals that went quiet in August, so she asks her Agentforce agent for help. The agent does exactly what it was built to do: it drafts six follow-up emails, logs the activities and closes the session. Ten days later two prospects have replied, one email has bounced, and the agent has no idea any of it happened.

Nothing broke there. That’s simply how nearly every enterprise agent has worked for the past two years, on any platform. A request arrives, the agent reasons, acts and responds, and the context goes away with the chat window.

For a lot of work, that model is perfect. Resetting a password or summarizing a case is a sprint, and sprints should end quickly. The work that moves revenue is usually shaped differently. Rescuing a stalled deal is a campaign. So is rebuilding a field service schedule after a technician calls out sick on launch day.

Salesforce’s answer is the long-horizon runtime, a new layer under Agentforce built to keep one goal alive for days, weeks or even months. Hunter, the outbound sales agent, is the first agent to run on it. It’s in pilot today, with general availability targeted for November 2026.

For architects, the more useful question is what changes in your org once an agent stops forgetting.

Salesforce describes the runtime with three attributes. Each one fixes a specific way session agents fall over on long jobs, which is why they’re worth taking one at a time.

If you’ve worked with workflow engines, durable execution will feel familiar. Long-running orchestrations survive restarts for the same reason: the state of the plan lives outside any single run, so a failure turns into a resume point. The new part is pairing that durability with an LLM planner that can rewrite the remaining steps when the situation changes.

These agents also show up wherever people already work. Salesforce lists Agentforce Coworker, Slack and third-party apps as surfaces, which means a seller can check on a two-week plan from the same place they check on everything else.

Salesforce’s own walkthrough uses a scenario every sales leader knows: an account executive close to quarter-end with a handful of at-risk deals. Here’s the flow, with the design detail that matters at each stage.

Step five is the one I keep coming back to. A session agent hitting that bounce would retry, fail quietly or hand the error back to the user. Hunter treats it as new information, proposes a change and waits for a person to agree. That’s the behavior you’d want from a sharp junior rep, and it’s what makes a weeks-long agent safe to run.

This is where architects earn their keep. A session agent’s mistakes stay inside one conversation. A long-horizon agent’s decisions compound over weeks, so a few choices that used to be optional now carry real weight.

What Decision 3 Looks Like in Apex

The invocable action below creates a follow-up task. The agent passes a step key that stays the same across resumes (the opportunity ID plus the plan step name works well), and the action returns the existing task instead of inserting a duplicate.

APEXpublic with sharing class CreateFollowUpTask {
    public class Request {
        @InvocableVariable(required=true) public Id opportunityId;
        @InvocableVariable(required=true) public String stepKey; // stable across resumes
        @InvocableVariable public String subject;
    }

    @InvocableMethod(label='Create Follow-Up Task (Idempotent)')
    public static List<Id> run(List<Request> requests) {
        Set<String> keys = new Set<String>();
        for (Request r : requests) { keys.add(r.stepKey); }

        // A resumed step finds the task it already created
        Map<String, Id> byKey = new Map<String, Id>();
        for (Task t : [SELECT Id, Agent_Step_Key__c FROM Task WHERE Agent_Step_Key__c IN :keys]) {
            byKey.put(t.Agent_Step_Key__c, t.Id);
        }

        Map<String, Task> toInsert = new Map<String, Task>();
        for (Request r : requests) {
            if (!byKey.containsKey(r.stepKey) && !toInsert.containsKey(r.stepKey)) {
                toInsert.put(r.stepKey, new Task(WhatId = r.opportunityId, Subject = r.subject,
                    Agent_Step_Key__c = r.stepKey, ActivityDate = Date.today().addDays(2)));
            }
        }
        if (!toInsert.isEmpty()) { insert toInsert.values(); }
        for (Task t : toInsert.values()) { byKey.put(t.Agent_Step_Key__c, t.Id); }

        List<Id> results = new List<Id>();
        for (Request r : requests) { results.add(byKey.get(r.stepKey)); }
        return results;
    }
}

Agent_Step_Key__c is a plain text field on Activity. It’s twenty minutes of work, and it removes a whole class of “why did the customer get two emails?” tickets before they exist.

Where to Draw the Autonomy Line

The runtime handles memory, persistence and steering. Your business rules are still yours to write. None of the work below is new to anyone who has shipped a serious integration, but each item matters more when an agent keeps working for weeks on your behalf.

Hunter is the first agent on the runtime, not the last. Salesforce plans to move more agents onto it and eventually let customers build their own long-horizon agents with Agent Script.

Salesforce’s field service example shows where this heads. Picture a CPG dispatcher on product launch day when the rep covering a major account calls in sick. Finding a replacement by hand means juggling who’s on shift, who’s nearby and who knows the store. A long-horizon agent tracking that goal would surface a recommended swap, and the dispatcher’s only job is yes or no.

Pair the runtime with Agent Optimizer, which reaches GA in October. It works through large volumes of production sessions, groups the failures that repeat, and puts the costliest ones at the top of the list. For agents that work across weeks, that feedback loop is how a pilot grows into a program.

Most Agentforce roadmaps still list use cases as questions an agent can answer. Starting now, a better list is goals an agent can own. If you had an agent that remembered everything for six weeks, which goal would you hand it first?