Inside the Agent: How Salesforce Agentforce Works Under the Hood

The Atlas Reasoning Engine powers Agentforce by mimicking human thought processes. It delivers 33% better answer accuracy than traditional AI solutions. AI agents can now reason independently, make decisions, and handle complex business tasks in service, sales, marketing, and commerce. The platform comes with low-code tools and 40 pre-built connectors for enterprise systems, making powerful AI agents available to users without extensive coding knowledge. Let's take a closer look at Agentforce's inner workings, its architecture, agent memory, function-calling capabilities, and the intelligent systems behind it all.

Understanding the Core Architecture of Salesforce Agentforce

Image Source: Worxwide Consulting

Salesforce Agentforce brings a radical alteration to business interactions with AI systems. This AI system is different from traditional automation tools. It works as a complete agentic architecture that sees environments, makes decisions, and takes actions to achieve specific goals.

• What is Agentforce and how it is different from traditional bots
  Agentforce is different from conventional chatbots through its advanced reasoning capabilities and autonomous operation. Traditional chatbots use rigid, rule-based dialogs that only work with predefined scenarios and simple responses. Agentforce utilizes large language models (LLMs) to arrange natural conversations. It understands complex queries and makes intelligent decisions without extensive pre-programming.".
  Traditional bots need training on hundreds of utterances to understand natural language requests. This makes them time-consuming to implement. Agentforce understands intent natively and matches it to appropriate responses without extensive configuration. While chatbots handle simple, repetitive tasks through predefined scripts, Agentforce can reason through decisions. It grounds answers in trusted business data, including CRM data and external sources from Data Cloud.
  The main difference shows in their operational approach. Chatbots depend on pre-programmed scenarios that need human oversight. Agentforce operates with genuine autonomy within established guardrails.
• Agentforce Studio and Agent Builder overview
  Agentforce Studio is the central hub for agent customization. It provides tools to build, manage, and tailor digital assistants to specific requirements. Agent Builder works as a low-code platform within Agentforce Studio. The core team can customize out-of-the-box agents or create new ones for any role, industry, or use case.
  Agent Builder's interface has four main sections:

  • A left-hand sidebar for navigating agent settings
  • A left panel displaying the current setting page
  • A right-hand panel for initiating test conversations
  • A middle panel showing the test-drive output
  The interface makes shared development possible using existing tools like Flows, Prompts, Apex, and MuleSoft APIs without extensive coding knowledge. Agent Builder also offers a space to test agent responses. This ensures they work as intended before deployment.
• Role of topics, instructions, and actions in agent design
  Topics are the foundations of agent capabilities. They work like specialized departments with specific expertise and tools. They group user requests into specific categories. Each category has a defined scope and rules that control potential agent actions. Experts suggest limiting agents to 10-15 topics for the best results.
  Instructions guide how conversations flow within topics. They help select actions, establish conversation patterns, and provide vital business context. Clear, distinct topics prevent overlap and help the reasoning engine classify customer requests correctly.
  Actions are the tools agents use to interact with Salesforce and handle data. They come in several types:

  • Flow Actions (calling autolaunched Flows)
  • Apex Actions (invoking Apex classes)
  • Prompt Template Actions (executing prompt templates)
  • API Actions (connecting to external systems)
  Each topic should have 8-10 actions for best performance. An agent can only perform one action for each user utterance now. Action-chaining capabilities should arrive around Spring 2025.
  Topics, instructions, and actions work together as control levers. They engineer the prompts used by the Atlas Reasoning Engine to understand, decide, and act.

Inside the Atlas Reasoning Engine

Image Source: Salesforce Engineering Blog

The Atlas Reasoning Engine serves as the brain of Salesforce Agentforce. It gives agents their unique power to process information, make decisions, and act on their own. Atlas goes beyond standard LLM interactions by offering a sophisticated reasoning framework. Agents can adapt during conversations and learn from past interactions.

• Step-by-step reasoning flow from user input to action
  The reasoning process starts when users submit a query or when an event, data change, or API call triggers an agent. Atlas then begins a systematic decision process:

  1. Message reception - The engine gets the user input or system trigger
  2. Topic classification - Atlas matches the query with the most suitable topic
  3. Instruction and context assembly - The system adds relevant instructions, actions, and conversation history to the prompt
  4. LLM processing - The language model analyzes the constructed prompt
  5. Decision making - The LLM picks the next best action
  6. Validation - A grounding check makes sure the response follows instructions
  7. Response delivery - The user receives the final confirmed response

  This cognitive "flywheel" keeps running when needed. It gets more data or refines plans until the engine can achieve the user's goal accurately.
• Topic classification using topic name and description
  Atlas must first figure out which topic best matches the query's intent when a message arrives. The classification step reviews the topic name and classification description - not the instructions or actions linked to the topic.
  The engine uses similarity searching to find the best match through semantic understanding rather than keyword matching. The system defaults to an "off-topic" classification if no topic fits the user's query. This ensures controlled responses even for unexpected questions.
• Instruction injection and prompt construction
  Atlas builds a complete prompt after picking a topic. It combines several key elements:

  • The original user message
  • Topic-specific instructions that guide response behavior
  • Available actions for the selected topic
  • Conversation history (usually the last six turns)
  This combined prompt gives significant context. It helps the LLM understand what it can and should do within the selected topic's limits. The injection process puts these pieces together into a clear prompt structure that guides the LLM's reasoning.
• LLM decision-making and grounding validation
  Atlas sends the complete prompt to the language model for processing. The LLM then reviews all inputs (user message, instructions, potential actions) and chooses the best response strategy. This might include:

  • Answering directly from available knowledge
  • Running an action to get or change data
  • Asking for more details if needed
  • Telling users about its limitations for certain requests
  Atlas runs a vital grounding check before sending any response. This check makes sure the proposed response:

  • Follows the topic's instructions
  • Uses verified business data
  • Contains accurate information without making things up
  • Stays within set guardrails
  Atlas will try again if the grounding check fails. The system will tell users it can't help with specific requests after multiple failed attempts. This builds trust through honesty. This strong validation system sets Atlas apart from simpler LLM systems. It keeps responses accurate, appropriate, and in line with business goals.

How Agentforce Handles Actions and Function Calls

Image Source: LinkedIn

Salesforce Agentforce uses actions as executable components that turn reasoning into real-life results. These actions link user queries with Salesforce data and external systems to complete tasks on their own.

• Standard vs custom agent actions (Flow, Apex, API, Prompt)
  Agentforce's action system comes in two main categories to handle different business scenarios:
  Standard Actions come pre-configured and need no extra setup. Built-in actions help agents find records by name, query data, and summarize information without writing code.
  Custom Actions boost agent capabilities through four different methods:

  • Flow Actions: Run auto launched Salesforce Flows to manage complex business processes
  • Apex Actions: Use Apex code to handle sophisticated logic and integrations
  • Prompt Template Actions: Create dynamic responses with Prompt Builder templates
  • API Actions: Link to external systems through REST APIs
  Custom actions substantially set Agentforce apart from regular bots. Agents can complete transactions instead of just providing information. To name just one example, while standard actions might give a customer account summary, custom actions can update records, create proposals, or start approval processes.
• Action input instructions and execution flow
  Developers must give clear instructions that describe each action's purpose, required inputs, and expected outputs. These instructions help the Atlas Reasoning Engine decide the right time to trigger the action.
  The Atlas system follows a clear path at runtime after a user submits a query:

  1. The reasoning engine assesses the user request against available topics
  2. After picking a topic, it looks at available actions using the action instructions
  3. The engine picks the best action to address the user's intent
  4. It gathers required inputs from context or by asking the user
  5. The action runs with proper data access and permissions
  6. Results go back to the reasoning engine to show the user
  Action input instructions work like a contract between the reasoning engine and action implementation. They clearly define how and the right time to use actions.
• Function-calling orchestration using reasoning engine
  Agentforce's action system relies on its function-calling capability. This feature lets the LLM analyze natural language, understand intent, and create structured outputs with function names and arguments. The system can interact with external tools and real-life applications. The Atlas engine handles function calling through several steps:

  1. The LLM creates a structured function call based on what the user wants
  2. The orchestration layer catches this structured output
  3. The system runs the actual function call with proper security
  4. Results return to the context for more processing
  Agentforce keeps track of session IDs to connect interactions. Agents remember previous exchanges and keep context across multiple conversations. This session-based memory helps with complex workflows where actions build on previous results.

Agent Memory, Variables, and Conditional Filtering

Image Source: Architects | Salesforce

Memory and variable management are the foundations of intelligent agent behavior in Salesforce Agentforce. These elements let agents keep context during conversations and execute actions in a specific sequence.

• Context variables vs custom variables in Agentforce
  Agentforce uses two different types of structured memory to store and manage data during conversations:

  1. Context variables
  2. Custom variables
  Context variables work like memory slots. They automatically identify logged-in users, so customers don't need to repeat their information. These variables boost security by making sure users can only access their own data. They also enable customized responses by pulling user-specific information like account details without extra queries.
  Custom variables, on the other hand, act as flexible data containers without preset mappings. They store information that actions return and work as structured memory. Their values can be inputs or outputs for future actions.
• Session-based memory and variable persistence
  Agentforce keeps memory alive throughout a conversation session with a unique identifier. The memory stays intact whatever happens in later interactions. This ensures important information remains available no matter how long the conversation lasts.
  Memory persistence works through the session lifecycle:

  1. Original session creation with assigned memory ID
  2. Loading of entire memory when reusing the same ID
  3. Continuous updating of variables during conversation
  4. Session summary generation upon completion
  This method resembles how human memory works. It moves information between short-term and long-term storage based on how often it's used and how important it is.
• Conditional filters for topic/action gating
  Conditional filtering in Agentforce controls which topics and actions become available based on variable states. This feature boosts performance by:

  1. Taking out irrelevant topics based on conversation state, which cuts down "semantic noise" during classification
  2. Building security boundaries that block access to sensitive operations without proper authentication
  3. Making sure complex processes follow specific sequences
  Filters work differently from instructions. Instructions guide decisions within available options, while filters decide which options show up in the first place.
  Security-focused implementations usually use topic filters to protect sensitive operations. They often include conditions like "authenticationStatus = 'verified'". Action sequencing uses filters to ensure operations happen in the right order, with conditions like "orderNumber != null"

Prompt Engineering and Metadata in Agentforce

Image Source: Salesforce Developers

Prompt engineering is the foundation that powers Agentforce's intelligence. It gives developers precise control over how agents interpret and respond to user requests. Developers can fine-tune agent behavior without complex coding through well-crafted prompts and metadata configurations.

• Prompt templates vs agent prompts
  The Salesforce Agentforce ecosystem uses prompt templates and agent prompts for different purposes. Prompt Builder creates reusable prompt templates that blend CRM data through merge fields. These fields connect to record fields, flows, related lists, and Apex. Teams can use these templates as standalone generative AI components or blend them as actions within agents.
  Agent prompts work differently. They are instructions within topics that guide the Atlas Reasoning Engine's interpretation of user requests. These prompts shape the agent's personality and define its response patterns and decision-making parameters. Both types use LLMs, but prompt templates focus on specific data tasks like summarization or classification. Agent prompts control broader conversational behaviors.
• Metadata-driven topic and action configuration
  A resilient metadata architecture powers Agentforce's adaptability. Developers can access it through Salesforce's Metadata API and Tooling API. This structure lets teams program these key agent components:

  • GenAiFunction/GenAiFunctionDefinition: Actions available to agents
  • GenAiPlugin: Topics for agents and their instructions
  • GenAiPlanner/GenAiPlannerDefinition: The reasoning service that breaks down tasks and picks suitable actions
  • GenAiPromptTemplate: Storage for reusable prompt templates with generative capabilities
  Teams can version, deploy, and manage agent configurations across environments using standard Salesforce DevOps practices with this metadata approach. These components need API version 60 or higher since their introduction, so deployment tools must match this requirement.
• Role of Prompt Builder and Data Graphs
  Prompt Builder makes Agentforce more powerful by creating grounded, context-aware responses. It helps agents utilize generative AI for knowledge search, summarization, translation, and content creation. Teams can customize prompt templates to adjust their agent's personality, tone, and output format.
  Data Graphs add another layer of functionality by offering a detailed view of user data. Agents can access complete customer information when prompt templates reference Data Graphs. This includes related records from multiple objects in a single JSON structure. Agents can provide accurate, personalized responses without multiple database queries, which creates more relevant and contextual interactions.