Flow or Agentforce? How Salesforce itself decides
Every company that turns on Agentforce falls into the same temptation: turning every automation into an agent. Update a field when an opportunity changes stage? "Let's put an agent on it." Create a task when a case is closed? "Agent for that too."
Salesforce has an official answer for this, and it's more conservative than the marketing makes it seem. It's in the Architecture Center decision guide, Determining Agentic and Traditional Workflow Automation, written by the Well-Architected team. Using an agent to execute a path that already fits in rules is, in the guide's words, an anti-pattern.
In this post, you'll see the criterion Salesforce uses, how it translates into everyday cases, and why it matters if you're studying for the Platform Administrator exam.
What is the question that decides between Flow and Agentforce?
The guide's first question is: can the execution path be fully defined at design time? If every branch and every outcome can be written as a rule before the automation runs, the starting point is traditional automation: Flow or Apex. The agent comes in when the path doesn't fit in rules, because it depends on interpreting an intent, free text, or context that only shows up at runtime.
The guide calls this criterion Orchestration Density and measures three things, in this order:
- Execution path: can you specify all of it at design time, only part of it, or none of it?
- Goal complexity: is it a single task with a predictable outcome, or several goals competing with each other?
- Modality mix: is the input only structured CRM fields, or also email, transcripts, voice?
The order matters. If the path is fully specifiable, the analysis pretty much stops there: start with Flow.
Why is using an agent where a rule fits a mistake?
Because you trade predictability for nothing. The guide says that orchestrating a deterministic path with an agent, with no need for reasoning at all, leads to two problems it names: agent sprawl (agents multiplying without governance) and agent slop (unnecessary, low-quality AI output). The return on investment drops.
The guide also lists the practical costs:
- Latency. A synchronous Record-Triggered Flow runs inside the transaction and finishes in milliseconds. The agent's time depends on reasoning, and the guide itself says it isn't suited to processing records at high volume when latency matters.
- Cost. Agent reasoning has a price, and it needs to be justified by the value of the outcome.
- Auditing. Flow leaves a complete trail in Flow Trigger Explorer. The agent leaves reasoning logs, which give transparency but take experience to interpret.
For tasks with compliance requirements, the guide is direct: traditional automation, because the static path guarantees a repeatable outcome.
In practice: what goes to Flow and what goes to the agent?
The table below sums up the cases the guide brings, translated into situations an Admin runs into:
| Situation | Recommended tool | Why |
|---|---|---|
| Update a field when a record changes | Record-Triggered Flow | Structured data, fixed rule, predictable outcome |
| Schedule an action for X days after an event | Flow with Scheduled Path | Flow reschedules and cancels on its own if the data changes |
| Rollback, savepoint, bulk processing with fine-grained control | Apex | Transaction control that Flow doesn't have |
| Rule-based process, but with one step that needs to summarize text | Flow + Prompt Template | Flow orchestrates; AI comes in only at the step that needs it |
| Customer writes in natural language and the request needs to be interpreted | Agentforce | The input isn't structured and resolution requires conversation |
| Long process with competing goals (e.g., an insurance claim with fraud, policy, and satisfaction) | Hybrid: agent + Flow/Apex | AI plans; Flow and Apex guarantee transaction integrity |
Look at the fourth row. The answer isn't "Flow or Agentforce". Often it's Flow with AI inside: the process stays deterministic and AI is called only at the node that needs reasoning. The guide recommends starting exactly like this, embedding an agent only at the points where there's reasoning, instead of handing the whole process over to it.
What changes when the agent is the right choice?
Even when the agent comes in, the guide asks for restraint. Three recommendations that apply if you're going to configure one:
- Don't overload the agent with subagents or instructions. The guide talks about subagents "previously topics". An agent that runs inside an automation can be lean, because it isn't the only interface.
- Avoid repeated actions. Having more than one action that does the same thing hurts the agent's ability to pick the right tool.
- Define the goal as an observable outcome, not as a procedure. A vague goal leads to drift.
And for irreversible actions, like a financial transaction or a regulatory submission, the guide asks for an explicit human approval point.
Why does this matter for the Platform Administrator exam?
The Platform Administrator exam has two domains that meet here: Automation, weighted at 15%, and Agentforce, at 8%. The first covers when to use each automation tool. The second covers Agentforce capabilities, use cases, and when to use AI. The question "does this need an agent?" is exactly the bridge between the two.
Two notes so you don't trip up:
- The exam uses the old names. The exam is aligned with Summer '25 and talks about topic and Agent Builder. The current product calls them subagent and Agentforce Builder, as the architecture guide itself already does. It's the same concept. On the exam, recognize the old name.
- The exam doesn't cover the architecture guide. Terms like Orchestration Density, Agent Script, and Agentforce Grid belong to architecture, not Admin. What's worth taking away is the reasoning: a fixed rule with structured data goes to Flow; intent in free text goes to an agent. Scenario questions tend to reward whoever doesn't pick the newest tool just because it's new.
Where Well-Architected fits in
The decision guide is part of the Salesforce Well-Architected Framework, which was reorganized into five pillars: Trust, Reliability, Operational Excellence, Resource and Cost Optimization, and Fairness. Each pillar now has a variant for agent-based solutions, the Agentic Enterprise lens.
The framework's central idea connects with everything above: the important decisions are trade-offs between pillars. More autonomy for the agent brings efficiency, but increases the risk of unfair or opaque decisions. More auditing brings trust, but consumes resources. The framework doesn't give a single answer. It helps you make the trade-off on purpose, instead of discovering it in production.
Conclusion
Salesforce isn't telling you to swap Flow for agents. It's saying the opposite: start with the simplest automation that solves the problem, put AI only where there's real reasoning, and treat the agent as a piece of an architecture, not as a replacement for it.
If you're studying for Platform Administrator, that's good news. Flow fundamentals are still the foundation, and understanding when not to use an agent is worth as much as knowing how to configure one.
If you want to practice both domains, the Platform Administrator course has Automation and Agentforce trails, including the lesson on what protects data when an agent acts on behalf of the user.
→ Check out the Platform Administrator course
Frequently Asked Questions
Will Agentforce replace Flow?
No, according to Salesforce's own architecture guide. For work with fixed rules and structured data, Flow is still the recommended choice, because it's predictable, fast, and auditable. Agentforce comes in when the path can't be defined in advance.
Can I call AI from inside a Flow?
Yes, and the guide recommends this pattern when the process is rule-based but one step needs AI, like summarizing text. Flow keeps orchestrating, and AI is called as an action, for example with a Prompt Template.
Does the Platform Administrator exam cover Agentforce?
It does. The Agentforce domain is worth 8% of the exam and includes capabilities, use cases, security, and maintenance of prompts and instructions. The exam is aligned with Summer '25 and uses the names "topic" and "Agent Builder".
What is Orchestration Density?
It's the criterion in Salesforce's decision guide for measuring the complexity of an AI automation. It evaluates the execution path, goal complexity, and the mix of input types. Low density points to Flow or Apex; high density, to an agent or a hybrid solution.
