Agentforce
Agentforce is Salesforce's platform for building, deploying, and managing AI agents that take action on the platform's data and processes.
Definition
Agentforce is Salesforce's platform for building, deploying, and managing AI agents that take action on the platform's data and processes. Launched in 2024 and rapidly evolving, it is the centerpiece of Salesforce's AI strategy: not just generative chatbots that answer questions, but autonomous agents that can read records, run Apex, send emails, create Cases, update Opportunities, and chain multi-step actions. Salesforce positions Agentforce as the third wave of platform automation after declarative tools (Flow) and code (Apex).
An Agentforce agent has three pieces: topics (the categories of questions or jobs it handles), actions (the things it can do, like Apex methods, Flow invocations, REST calls, or other agents), and a backing large language model that decides which actions to invoke based on the user's input and conversation context. Agents run in conversational interfaces (Slack, Salesforce Mobile, Experience Cloud sites, embedded chat) and in headless contexts triggered by events. The Atlas Reasoning Engine routes user requests to the right topic and chooses the right action. Agentforce is licensed separately and consumes credits per interaction.
How Agentforce changes what AI does inside Salesforce
Agents versus chatbots versus copilots
Three related concepts. A chatbot answers questions in a conversational interface. A copilot drafts content (email replies, summaries) for a human to review. An agent takes action: it reads Salesforce data, decides what to do, and executes the work. Agentforce is the agent layer. The agent can also chat and draft like a copilot, but the differentiator is autonomous action: an Agentforce agent can create the Case, send the email, update the Opportunity stage, and route the work, not just suggest what a human should do.
Topics: the categorical mental model
Each Agentforce agent organizes its capabilities into topics. A Service Agent might have topics for Order Status, Returns, Subscription Management, Billing Inquiries. A Sales Agent might have topics for Lead Qualification, Quote Generation, Pipeline Forecast Summary. Each topic has a description that explains when it applies, instructions that guide behavior, and a set of actions available within it. The Atlas Reasoning Engine reads the user input and decides which topic to engage based on the topic descriptions; topic design is the most consequential agent configuration choice.
Actions: how agents interact with Salesforce and beyond
Actions are what agents can actually do. Five action types. Apex actions invoke @InvocableMethod Apex code, the right pattern for complex Salesforce-side logic. Flow actions invoke autolaunched Flows for declarative business logic. Prompt Template actions generate text from grounded data. API actions call external systems through Named Credentials. Other Agents become callable actions, supporting agent composition for complex workflows. Each action has input parameters, output values, and a description that the reasoning engine uses to decide when to invoke it.
Grounding: making agents answer with real data
Generative AI without grounding hallucinates. Agentforce grounds agent responses by injecting real Salesforce data into the LLM prompt: record fields, related records, Knowledge articles, Data Cloud objects, and any other queryable source. The agent reads what the user asks, fetches relevant data through SOQL or Data Cloud queries, and includes that data in the prompt before the LLM generates its response. Strong grounding is the differentiator between an agent that gives accurate, current answers and one that confidently states fiction.
The Atlas Reasoning Engine and prompt orchestration
Atlas is the orchestration layer that converts user input into agent actions. It picks the right topic, decides which actions to invoke, manages the conversation state, and synthesizes the final response. Atlas runs across multiple LLM calls per user turn: classify the topic, decide actions, gather grounding data, generate the response, validate against safety filters. This multi-step process is why Agentforce conversations cost more compute credits than simple chatbot exchanges, but it is also why the responses are dramatically more useful.
Channels: where agents appear
Agentforce agents surface across multiple channels. Slack via the Agentforce in Slack integration. Salesforce Mobile and desktop via the Einstein Copilot panel. Experience Cloud sites via embedded chat components. WhatsApp, SMS, and other messaging channels via Service Cloud Messaging integration. API endpoints for headless integration. Each channel needs configuration but the agent definition is shared; one agent definition serves multiple front-ends.
Licensing, credits, and operational considerations
Agentforce is licensed separately from base Salesforce, with consumption-based pricing measured in Einstein Credits. Each agent interaction consumes credits proportional to the LLM tokens used, the grounding data fetched, and the actions invoked. Monitor consumption via Setup > Agent Studio > Usage. Plan budget around expected conversation volume. Audit Trail logs every agent action, which is important both for debugging and for compliance review of what autonomous agents actually did.
How to build an Agentforce agent
Building an Agentforce agent is iterative. Define the agent purpose, map topics, configure actions, ground with data, test against realistic conversations, and refine the topic and action descriptions until the agent picks the right path consistently. The work is more like prompt engineering than traditional Salesforce configuration; expect significant iteration time.
- Define the agent purpose and audience
What is the agent for, who will use it, what kinds of conversations should it handle, what is out of scope. A clear scope helps you decide topic boundaries and avoid agents that try to do everything badly.
- Open Agent Studio and create the agent
Setup > Agent Studio > New Agent. Provide a name, description, and instructions. Pick the agent type (Service, Sales, Custom). Save and proceed to topic definition.
- Define topics with clear descriptions
For each major job the agent does, create a topic. Write a description that explains when this topic applies. The reasoning engine uses topic descriptions to route user input, so be specific about scope.
- Add actions to each topic
For each topic, add the actions the agent can invoke: Apex methods, Flows, Prompt Templates, API calls, sub-agents. Configure input parameters and write description text that explains when to invoke the action.
- Ground the agent with Salesforce data
Configure grounding rules so the agent reads relevant data before responding. Common patterns: ground on the current record (the user is viewing an Opportunity), ground on related records, ground on Knowledge articles, ground on Data Cloud objects.
- Test the agent in the Conversation Playground
Agent Studio includes a playground for testing. Type realistic user inputs, observe which topic the engine picks, which actions fire, and how the response reads. Iterate on topic descriptions until routing matches expectation.
- Configure the channels the agent surfaces in
Embed the agent in Slack, Experience Cloud, Salesforce Mobile, or other channels. Each channel has its own configuration but they share the agent definition.
- Monitor usage, accuracy, and credit consumption
Agent Studio > Usage shows interaction counts, credit consumption, and conversation logs. Review failed or low-quality conversations and refine the agent definition. Plan for ongoing tuning; agents are not "deploy and forget" artifacts.
Categorical mental model of agent jobs. Topic descriptions drive the reasoning engine''s routing decisions.
What the agent can do. Each action has a description that guides when the engine invokes it.
Salesforce records, Knowledge, Data Cloud objects, and other data the agent reads before responding to keep answers accurate.
- Agent quality depends heavily on topic and action descriptions. Vague descriptions produce inconsistent routing; clear descriptions produce reliable behavior. Plan multiple iteration cycles on the descriptions.
- Ungrounded responses hallucinate. The LLM confidently states facts that are not in your data unless you ground the conversation. Always configure grounding for any agent answering data-specific questions.
- Einstein Credits consume per interaction. High-volume agent deployments produce significant credit consumption. Monitor usage and set budget alerts to avoid surprise overage charges.
- Agents can take action autonomously. Audit Trail logs everything, but unintended actions are harder to roll back than human-driven mistakes. Constrain agent action scope carefully during initial deployment.
- Salesforce''s AI features evolve rapidly. Agentforce is a fast-moving platform with frequent capability changes. Plan for iteration; documented best practices today may be outdated in 6 months.
Trust & references
Cross-checked against the following references.
- Agentforce Product PageSalesforce
- Agentforce OverviewSalesforce Help
Straight from the source - Salesforce's reference material on Agentforce.
- Agent Studio DocumentationSalesforce Help
- Agent TopicsSalesforce Help
- Agent ActionsSalesforce Help
About the Author
Dipojjal Chakrabarti is a B2C Solution Architect with 29 Salesforce certifications and over 13 years in the Salesforce ecosystem. He runs salesforcedictionary.com to help admins, developers, architects, and cert/interview candidates sharpen their fundamentals. More about Dipojjal.
Test your knowledge
Q1. What engine powers Agentforce agents?
Q2. What makes Agentforce agents 'autonomous' compared to a traditional chatbot?
Q3. Which Salesforce component ensures masking, audit logging, and toxicity detection for Agentforce interactions?
Discussion
Loading discussion…