12.3 Agentforce Automation for App Builders
Key Takeaways
An Agentforce agent is assembled from topics (what it may handle), instructions (natural-language guidance for the underlying LLM), and actions (concrete steps within a topic).
Actions can be built from flows, prompt templates, Apex, and APIs — existing declarative work becomes agent-callable.
Agent Builder is where admins and developers create the agent's jobs to be done, instructions, actions, and guardrails, with natural-language assistance.
The Einstein Trust Layer is part of the Agentforce platform architecture; this does not eliminate Agentforce licensing, usage charges, or separate integration requirements.
Deterministic record operations belong in a record-triggered flow; an agent can call an autolaunched flow action, whose record changes can trigger record-triggered automation.
Agentforce Automation for App Builders
The SU '26 blueprint added a Business Logic objective that surprises candidates who prepared from older materials: describe the capabilities and use cases for using Agentforce to automate business processes. Agentforce is Salesforce's platform for building and running autonomous agents, and the good news for app builders is that its core concepts are declarative.
An Agentforce agent is assembled from three kinds of parts: topics, instructions, and actions.
| Building Block | What It Defines | Example |
|---|---|---|
| Topic | What the agent is allowed to handle — its scope | Case Resolution, Order Status |
| Instructions | Natural-language guidelines that tell the underlying LLM how to reason and behave | Always verify account standing before issuing a credit |
| Action | A concrete step the agent can take within a topic | Query records, send an email, update fields, trigger a Flow, call an external API, escalate to a human |
Topics set the boundaries. Topic classification and instructions help keep the agent on task, but they are not an authorization guarantee. Enforce sensitive operations through action permissions and deterministic policy checks. Instructions steer the reasoning: they are written in natural language, and they encode tone, policy, and guardrails. Actions do the work — every change an agent makes to data or the outside world happens through an action.
Consider a Case Resolution agent. Its actions might include querying an order record, drafting an email reply for approval, updating case fields, triggering a fulfilment flow, calling a carrier's tracking API, and escalating to a human agent when confidence drops. Nothing in that list requires an app builder to write code — each action wraps an existing flow, prompt template, Apex class, or API integration.
Actions Are Built From Things You Already Know
Actions can be built from flows, prompt templates, Apex, and APIs. That single sentence is the exam's favorite Agentforce fact: existing declarative work — a refund flow, a case-summary prompt — becomes agent-callable. The automation you can already build in Flow Builder is the same raw material agents consume.
Permissions, Deterministic Checks, and Testing
An action is executable behavior, so review the agent's effective user, action access, Flow execution context, object permissions, and sharing. A system-context flow does not become user-secured merely because an agent calls it. Give the action only the required inputs and outputs; do not return an entire record containing unrelated confidential fields.
Suppose a refund policy caps automatic credits at 100 units of currency and requires human approval above that amount. Put that comparison in Flow or Apex before issuing the credit. The prompt can explain the policy, but an instruction such as “never exceed 100” is not a substitute for the check. Verify 99.99, 100, and 100.01; missing or negative amounts; an unauthorized customer; and a repeated action request. Keep an idempotency key or equivalent record-based protection so a retry cannot issue a second credit.
Test the conversational and deterministic layers separately, then together. Evaluate out-of-topic requests, missing identifiers, failed callouts, and escalation to a human. Review the installed agent's licensing and Trust Layer data-handling documentation instead of assuming that every prompt remains wholly inside the org or that platform trust features prove compliance.
Official Source Check
Checked October 19, 2026: Agentforce overview and architecture.
Agent Builder and the Einstein Trust Layer
Agent Builder is where admins and developers create the agent's jobs to be done, its instructions, its actions, and its guardrails — and it is natural-language assisted: you describe what the agent should handle and refine from there. Teams typically iterate: draft the job to be done, generate a starting topic and instruction set, swap in proven actions, then refine instructions against real conversations — all inside Agent Builder. An app builder scopes topics, drafts instructions, and configures actions declaratively; where an action needs code, a developer supplies the Apex, but the app builder does not write it.
The Einstein Trust Layer is built into Agentforce on the Salesforce Platform — it is not a separately licensed add-on bolted on afterward.
Flow versus Agentforce: Choosing the Right Tool
The exam tests the boundary between deterministic automation and agentic automation:
| Consideration | Traditional Flow Automation | Agentforce Agent |
|---|---|---|
| Trigger | Fixed: record change, schedule, or event | Conversational entry within its topics |
| Determinism | Same inputs, same path, every run | LLM reasons within guardrails; path flexes |
| Interaction model | Headless or guided screens | Multi-turn natural-language conversation |
| Input shape | Structured fields and records | Unstructured language plus record context |
| Best fit | Fixed record operations in strict order | Ambiguity and multi-step reasoning over messy input |
| Built in | Flow Builder | Agent Builder |
Important
A record-triggered flow remains the right tool for deterministic saves. An agent can call a supported autolaunched flow action, whose saves can in turn start record-triggered flows — the agent handles the messy conversational front end, while the flow guarantees the record operation.
Putting Them Together: A Worked Scenario
Consider an expense reimbursement assistant. Employees describe an expense in chat — receipts photographed, amounts garbled, categories implied. The requirements are conversational entry, ambiguity, and multi-step reasoning over unstructured input: an agent fits the front end.
Behind the conversation, the agent calls a flow action that creates the Expense record, applies validation, and notifies the manager — fixed record operations in strict order, exactly what a flow guarantees. Edge cases the agent cannot resolve escalate to a human action. And when expense policy changes quarterly, the team updates instructions for conversational guidance and also updates/test-enforces any policy thresholds in the action implementation — the payoff for keeping policy in natural language. No part of the deterministic save moved into the agent, and no part of the conversation moved into the flow. That division of labor — agent for language, flow for records — is the pattern the exam rewards.
Best Practices & Common Exam Traps
- Fixed record operations in strict order mean Flow; ambiguity and unstructured input mean an agent. Most wrong answers on this objective swap the two.
- An agent calling a flow does not replace the flow. The flow remains the deterministic engine; the agent orchestrates conversationally.
- App builders scope and configure actions declaratively — writing Apex is a developer's task.
- Actions come from flows, prompt templates, Apex, and APIs — common supported action implementation sources.
- The Einstein Trust Layer is built into Agentforce on the Salesforce Platform, not purchased separately.
Universal Containers wants automation that, whenever an Opportunity is marked Closed Won, creates a renewal Opportunity dated twelve months out and posts a notification to the owner — always in that order, with no user interaction. Which tool should the app builder recommend?
An Agentforce agent with an Order Management topic, so the model can reason about each closed opportunity
A record-triggered flow on Opportunity that creates the renewal record and posts the notification in a fixed order
A screen flow the sales rep runs manually from the Opportunity record page after closing the deal
A scheduled flow that scans nightly for opportunities closed that day and processes them in batches, because record-triggered automation cannot create records
A new app builder is asked to explain how an Agentforce agent is assembled. Which description is accurate?
An agent is a single prompt; topics and actions are optional refinements the model invents at runtime as needed
Actions define what the agent may handle, while topics execute the record operations in a strict, fixed order that never varies, with guardrails enforceable only through Apex triggers fired after each conversational turn
Instructions are compiled rules that enforce guardrails, and actions are limited to flows and prompt templates
Topics define what the agent may handle, instructions give the model natural-language guidance, and actions run steps such as querying records, updating fields, or escalating
During an Agentforce pilot, the legal team asks how prompts and responses are protected, and whether the trust layer must be procured separately before go-live. What should the app builder tell them?
The Einstein Trust Layer is built into Agentforce on the Salesforce Platform, with no separate procurement required
The trust layer is an add-on subscription that must be purchased per agent before activation in Agent Builder
Trust protections apply only to agents built entirely from AgentExchange listings, not to custom actions
Agentforce routes every prompt through an external third-party gateway that each org must contract, provision, and pay for separately before any agent can be activated
Sections you finish are checked off in the contents.