The Agentforce Guide to Context Engineering

_{This guide supports the latest Agentforce Builder available through the App Launcher . Refer to the Legacy Guide if you maintain agents via Setup.}

AI agents are revolutionizing organizations by increasing efficiency, reducing manual effort, and creating a more sophisticated and adaptive workplace.

This guide explores the core elements of Agentforce, the Salesforce platform for building AI agents. Practitioners use context engineering to provide Agentforce agents with the specific information, actions, and instructions needed to achieve goals. We’ll examine how Agentforce Script uses hybrid reasoning to blend generative AI with deterministic control.

We know that developers build agents in many different environments. We support this flexibility to choose your preferred model and environment for the job.

Whether you build in Claude Code, Labs, Agentforce Studio, or elsewhere, it’s helpful to understand how Agentforce manages the logic and connections behind the scenes.

What we'll cover:

• II. Key Takeaways
• III. Agentforce Fundamentals
• IV. Agentforce Script
• V. Prompts vs. Agents
• VI. Context Engineering
• VII. How Agentforce Reasons
• VIII. Reliable Context
• IX. Best Practices
• X. Does Agentforce Need Data 360?
• XI. Conclusion
• XII. Learn More

• Hybrid reasoning drives Agentforce’s Reasoning Engine. This approach combines LLM flexibility with the deterministic reliability of Agentforce Script.
• Agentforce Script gives you full deterministic control over agent behavior, replacing overloaded system prompts with structured business logic.
• Data 360 provides an integral part of Agentforce. It powers indexing and chunking for retrieval augmented generation (RAG), Agent Analytics, and Digital Wallet.

An agent is a type of software that uses generative AI to make decisions about what to do next and how to do it. An agent can understand a question (often called an utterance), autonomously reason to determine what actions it needs to reach its goal, identify what data is needed, and then take action, with or without human intervention.

Key capabilities of AI agents

• Agents are dynamic, and can adapt to different situations, environments, and information.
• Agents can be autonomous (act without human intervention) or can be guided to involve a human in the loop.
• Agents are different from other generative AI tools because they can plan, reason, and act.

While agents use large language models (LLMs) to handle natural language and intent, Agentforce also uses Agentforce Script to follow specific business logic. This hybrid reasoning model makes agents more dynamic than traditional automation while remaining as reliable as hard-coded software.

Agentforce Studio

Agentforce Studio is our unified workspace for the entire agent lifecycle.

Agentforce Studio brings together every action you need to build, test, and manage agent behavior. Three key components of Agentforce Studio help you manage the agent development lifecycle:

• Agentforce Builder: Use the AI-native builder to draft rules in plain language. Use Agentforce Script, a language that expresses reliable agent behavior by unifying configuration, business logic, and instructions.
• Testing Center: Validate agent behaviors before you deploy
• Agentforce Observability: Monitor and analyze agent performance to see where to refine logic.

Agentforce Studio bridges the gap between technical and non-technical users. Katherine Mains of Conagra Brands describes this as “the 'Goldilocks Zone' of design; advanced enough for our architects, yet intuitive enough for our admins to dive right in.”

Agentforce is the framework that provides the predictability your business needs to move past simple FAQs and into high-value work. Hybrid reasoning and Agentforce Script blend control and creativity. Intelligent Context powers agents with the right data at the right time. Agentforce Studio provides a unified workspace to manage the entire system.

Data 360 provides a number of features that make Agentforce extensible. Here’s a quick look at these components:

Let’s take a closer look at Agentforce Script, the blueprint for an agent’s reasoning process.

Agentforce Script is our Agentforce-specific scripting language that serves as the text-based foundation for building and governing agents. It functions as a unified language that expresses the entire behavior of an agent. This single file brings together configuration, business logic, actions, and reasoning instructions. Rather than treating natural language and code as separate elements, practitioners use this blueprint to manage the entire agent architecture in one place.

In agentic actions that use only generative AI , users rely on lengthy natural language prompts, which can lead to inconsistent and unpredictable task outcomes. Agentforce Script changes this. Hybrid reasoning with Script blends natural language with deterministic, rule-based instructions.

Leaders see immediate results with this level of control. Scott Van Dusen, Partner & COO at Equitable Trust, notes that Agentforce Script is incredibly powerful. He finds the ability to manipulate flows and actions much more robust than LLM-only methods. "I’m having a lot more success controlling it," says Van Dusen.

Grant Roberson, the Agentforce admin at Datasite said Script is "light years better" than prompt-engineered agents.

"I used to have paragraphs of repetitive instructions everywhere to try and force behavior, ” Roberson said. “With Script, it’s easy to remove that noise and replace it with conditional logic that lets you trust your agents to do exactly as you want them to."

Script moves you away from prompt crafting toward scalable orchestration. Because it uses a structured, text-based format, your team can version, review, and govern agent behavior just like traditional code.

Agentforce Script organizes agent capabilities through declarative syntax. It treats instructions, actions, and subagents as modular components. This structure gives the Reasoning Engine a clear map of resources while setting boundaries to keep the agent within its intended scope. These scripts move workflows from probabilistic reasoning to guaranteed results by reducing LLM calls and preventing logic errors.

Architecture and Modularity

The following is a list of structural best practices organized by modular design principles to help you build a maintainable and predictable agent.

• Create small, separate scripts for specific tasks like identity checks. This makes the system easier to maintain because you can update a single script when business policies change without impacting other parts of the agent. You can also apply these common scripts across multiple subagents to ensure a consistent experience.
• Organize actions within the script based on the specific intent they serve. Give subagents and actions names that clearly describe their function since the Reasoning Engine uses these names to select the best path.
• Adopt a deterministic sandwich approach where code handles the beginning and end of every interaction. Use the AI’s natural voice for the middle portion to provide total control over conversation entry and resolution.

Data and Context Management

The following is a list of data management techniques organized by session handling to help you reduce latency and improve personalization.

• Define required data inputs at the start of a script block so the agent gathers context before it tries to take action. You should fetch all necessary data before the agent begins its main task to increase speed. Every LLM call adds time to the interaction, so using specific rules to gather facts upfront avoids extra calls.
• Store facts like a user’s name or status in session variables to manage data during a chat. These variables let you pass info between subagents, which prevents the agent from repeating questions. It also ensures the agent has the data it needs to use actions without extra user input.
• Insert variables directly into instructions as merge fields. This helps the agent provide personalized answers and follow specific logic based on the user's data.

Logic and Compliance Standards

The following is a list of configuration standards organized by execution logic to help you maintain strict compliance and reliability.

• Use instructions to influence conversation style while the script handles the actual business logic. This separation lets the LLM handle the language while the script manages data checks or mandatory sequences. This deterministic approach removes the guesswork often found in natural language prompts.
• Apply if-then logic to guide an agent through specific paths. For example, you can program the agent to check a customer's loyalty status before it offers a discount.
• Set explicit exit criteria to define exactly when a subagent should hand the conversation back to the main agent or close the session. Clear boundaries ensure the agent operates at peak efficiency.

Strategic Implementation

The following is a list of implementation guidelines organized by tool selection to help you choose the right automation path for your use case.

• Avoid designing agents to act like simple, linear chatbots . If a process is static and never changes, use a standard flow in Flow Builder instead of an AI agent. Reserve Agentforce Script for handling messy or unpredictable human input.
• Find prebuilt agent solutions and reusable scripts on the AgentExchange to save development time. This marketplace includes ready-to-use AI actions and third-party integrations to help you automate common business tasks quickly. Learn more about The AgentExchange Advantage in this e-book.

Before we continue, it’s important to note that agents aren’t the only generative AI tool available on the Agentforce 360 Platform. Prompt templates are another powerful tool for building applications that use generative AI. Prompt templates, built in Prompt Builder, allow you to define a set of structured, reusable instructions that guide a generative AI model to produce specific outputs. They can reference Salesforce data through predefined fields, data graphs, and contextual data retrieval augmented generation ( RAG) . Prompt templates are also highly secure – all prompts are routed through Salesforce’s trust layer — honoring permissions, masking sensitive data, and flagging toxic outputs.

Prompt templates are single-turn interactions with AI, and are an ideal fit for one-off tasks that don’t require memory or multi-step reasoning. For example, a prompt template is ideal when you need to reword a sentence or summarize a case, because ongoing context isn’t needed. When designing solutions with prompt templates it’s important to remember that they are stateless (they don’t retain memory between turns) and that they do not make decisions or take actions. Prompt templates generate a response based on the input and logic you provide at design time.

Prompt templates can be used on their own in an embedded AI solution, or you can add a prompt template to an agent via agent actions. Using a prompt template on its own is ideal when:

• Business context is well understood and stable
• The desired output follows a predictable format, though the response itself is not deterministic
• There is no need to evaluate different paths or take autonomous actions
• Ongoing context, or state, is not required
• Multi-step reasoning is not required

Prompt template use cases:

• Generating a structured record summary, like summarizing case notes
• Creating structured meeting notes
• Generating templated email responses
• Suggesting next best actions
• Identifying a sentiment analysis of a case

Keep in mind that while prompt templates can dynamically fill in data and generate responses based on the dynamic inputs that get rendered at run time, they cannot reason through options or take action.

Agents are software systems that autonomously decide what to do, in what order, and how to do it, based on evolving context. Agents go beyond a single prompt as they can plan, reason, call external actions (like API calls or database lookups), and react based on outcomes. They can choose different paths or responses depending on what they learn mid-process. Agents are best when:

• The environment or context can change dynamically
• Multiple decisions or branches are possible based on data
• AI needs to replace or assist human judgment in making a choice or taking action

AI agent use cases:

• Triaging and routing incoming support cases
• Resolving booking issues by checking external systems and policies
• Managing multi-step workflows with feedback loops
• Drafting a case response email based on the details of customer’s problem with possible solutions and relevant knowledge articles from your customer-facing website
• Scheduling an appointment based on service rep availability and customer preference
• Detecting events, such as software update issues, and proactively generating troubleshooting tasks or attempting remote resolution by triggering an action to invoke an API call

Knowing how the Reasoning Engine operates behind the scenes is key to successful agent implementation. In earlier days of AI agents, we practitioners talked a lot about prompt engineering: the art of "coaxing" an LLM to behave. Now, we’ve graduated to context engineering.

Context engineering is a more holistic practice, going well beyond just writing a good prompt. With Agentforce hybrid reasoning, you design a system that balances autonomous LLM reasoning with rules-based logic for deterministic control.

Context engineering is the successor to prompt engineering . It involves designing a system of subagents, instructions, rules, and actions to provide an agent with the exact information and boundaries it needs to be successful, rather than trying to craft the perfect words in an attempt to coax an LLM to give you exactly the right responses.

The Three Levers of Context Engineering

Practitioners use Agentforce Script as the unified language to express subagents, instructions, actions, and rules in a single language and file.

1. Subagents. These define specialized agents and their expertise.
2. Instructions. These provide guidance for conversation flow, tone, and intent.
3. Actions and Rules. These execute actions and enforce mandatory business logic.

Let’s take a closer look at subagents, instructions, and actions, three important pieces of metadata that you define each time you build an agent with Agentforce.

Subagents are the foundation of your agent’s capabilities, defining what it can do and the types of customer requests it can handle. Think of them as specialized departments with specific expertise, actions that lead to action, and instructions. When a customer sends a message, your agent first determines which “department” (subagent) should handle the request, then uses that subagent's tailored guidelines and tools to help the customer.

Instructions are the guidelines that direct how conversations are handled within a subagent, guiding action selection, setting conversation patterns, and providing business context. Clear and distinct subagents prevent overlap and ensure the Reasoning Engine correctly classifies customer requests. Instructions should be clear, specific, and actionable to guide the agent effectively.

Your agent uses actions to get information or perform tasks. When defining actions, it’s crucial to understand how the Reasoning Engine processes them. The engine reviews available actions based on their names, descriptions, and inputs, as well as the subagent instructions and conversation context. Agentforce comes with a number of standard agent actions, and you can create custom agent actions to further extend your implementation. Always check to see if a standard action can be used before creating a custom action. Design actions with reusability in mind, as they can be used across multiple subagents. Below is a list of the custom agent actions available and when you should use them.

The Reasoning Engine uses subagents, instructions, actions, and rules to get work done. Since Agentforce Script serves as the full definition of the agent, it eliminates the black box of probabilistic routing. In short, the Reasoning Engine will:

• Classify Subagent: The engine matches a customer message to the most appropriate subagent based on its name and description.
• Execute Scripted Logic: The engine executes the scripted instructions and rules dictated by the Script. This happens before the system evaluates non-deterministic instructions.
• Apply Actions: If a task requires external data or an update, the engine runs the necessary actions and collects the results.
• Grounding Check: Before sending a final response, the engine ensures the answer is based on accurate information from actions or instructions, and follows the guidelines provided in the Script and instructions.

Here’s a step-by-step breakdown of what happens inside the Reasoning Engine whenever an agent is invoked.

For an even deeper dive, see Agentforce Guide to Achieving Reliable Agent Behavior: A Framework for 6 Levels of Determinism

Practitioners must understand the distinction between filtering and instructions to build accurate agents. Filters control what the LLM sees and what it can do on each turn of a conversation, and they work at multiple levels. Filters can be applied to subagents, actions, and retrievers, giving practitioners fine-grained control over which subagents are available, what those subagents can do, and what content the model retrieves at each step.

Think of a bank's virtual assistant. When a customer asks about their mortgage, a subagent scoped to home lending kicks in. Its filter ensures the LLM only sees mortgage documents, not credit card data or investment records. But within that same conversation, the action that pulls the customer's current rate uses its own tighter filter, restricted to that customer's account. The customer gets a precise answer, and irrelevant data never enters the picture.

Filters can be set as static (preconfigured at setup) or dynamic (passed at runtime from conversation context or prompt inputs). With Enhanced Retriever Pre-Filters, practitioners can now apply up to 10 dynamic filters per retriever, combine them with AND/OR logic, and use LIKE operators for pattern matching. This reduces retrieval noise and keeps the context window focused on the most relevant content. In software development workflows, for example, practitioners can apply action-specific context filters to give an agent flexibility in interpreting user prompts while keeping it strict about the current state of the codebase.

Agentforce Script provides the highest level of deterministic control by encoding specific sequences and rules for the agent to follow. This approach prevents the prompt doom loop, where instructions become too long or confusing for the LLM to follow accurately.

While filters and Agentforce Script provide system-level control, practitioners must also provide a way to verify accuracy. Citations give users a clear audit trail for every response, connecting the internal context the agent used to the answer it surfaced.

The Reasoning Engine orchestrates these four components to resolve requests with a blend of flexibility and control. Consider a customer who said "I ordered a red sweater yesterday but I need to change the delivery address".

1. Subagent Classification. The engine analyzes the customer message and performs subagent classification. It matches the request to the "Change Order" subagent because the name and description align with the task.
2. Context Assembly. The engine performs context assembly to build the agent memory. It gathers the subagent instructions, script, and available actions.
3. Agentforce Script Execution. The engine executes the Agentforce Script to perform deterministic business logic. The script checks the order status of the red sweater. If the order remains in the warehouse, the script permits the agent to move forward with the change.
4. Instruction-Based Reasoning. The instructions guide the agent through the conversation. They define the tone and guide the agent to ask the customer for the new shipping address.
5. Action Application. The agent selects and runs the "Update Order Shipping" action. It passes the order ID and the new address to the system to complete the update.
6. Grounded Response. The agent delivers a final confirmation to the customer. It performs a grounding check and includes a citation to verify the source of the information.

Successful context engineering requires the seamless integration of subagents, instructions, script, and actions. These four elements work together to keep an agent within the boundaries of optimal relevance and accuracy. Subagents define specialized expertise. Instructions provide conversational guidance and tone. Agentforce Script adds a layer of deterministic control to enforce business rules. Actions allow the agent to execute actions and access real-time data. This combined strategy ensures your agent remains both helpful and highly reliable.

Successful context engineering requires knowing where to place your logic.

• Use Actions and Agentforce Script for control. Move critical business rules and multi-step workflows into Agentforce Script or actions. This includes complex calculations and mandatory sequencing.
• Use Instructions for behavior. Guide the conversation flow and define the response tone using instructions.

Best practices for writing effective instructions

• Define your terms. Do not assume the agent knows what industry terms mean. For example, define the difference between "Promo codes" for discounts and "Registration codes" for warranties.
• Be specific about sequences. If steps should happen in a certain order, state it clearly in one instruction block.
• Use consistent terminology. Refer to actions by their exact names and use the same terms throughout all instructions.
• Be intentional with absolutes. Words like "always" and "never" have a significant impact on how your agent interacts.
• Provide decision criteria. Help your agent choose between similar options. For example, instruct the agent to use the Email Reset action if the user has email access but use the Security Question action if they do not.

This is a question we hear from our customers often. The short answer, yes. Data 360 is an integral part of Agentforce because the Data 360 architecture is used for certain features in Agentforce like Agent Analytics and Digital Wallet. Data 360 infrastructure also powers indexing and unstructured data searches, as well as feedback logs and audit trails. Data 360 can also provide additional extensibility. Agentforce customers can also choose to enable features like Bring Your Own Lake (BYOL) and Bring Your Own Large Language Model (BYO-LLM) to use data and models built on platforms outside of Salesforce with agents built on Agentforce.

From accessing data from other data lakes through data federation, to using the hyperscale infrastructure for petabyte-scale data, utilizing Data 360's architecture with Agentforce ensures that customers experience better AI outcomes today. This powerful architecture also ensures long-term viability for successful agent adoption, no matter how big or complex the underlying datasets that power those agents may be.

Curious what specific Agentforce features are powered by Data 360? The following table details the Agentforce features Data 360 provisions by default, along with the optional features customers can enable to extend their implementation.

We’ve covered the key elements that make Agentforce work, including the Reasoning Engine, and how to use Script, subagents, instructions, and actions. Understanding these components is key to using Agentforce effectively. Use this guide to improve outcomes as you implement Agentforce. Check out the provided resources to learn more.

Find blogs, guides, demo videos, and more resources at Agentblazer.com and Agentforce.com

• Long-form guides:
  • Agentforce Guide to Achieving Reliable Agent Behavior: A Framework for 6 Levels of Determinism
  • The Guide to Operating an Agentic Enterprise
  • Agentforce and RAG: Best Practices for Better Agents
  • An Agentforce Guide to Context Engineering
    
    
• For CIOs:
  • A Practical Guide to Reliable AI Agents That Work
  • The Invisible Advantage - 8 key agentic enterprise design principles that have been tested and validated by named CIOs.

• Blog: Doomprompting Won’t Get You Predictable AI Agents, But a New Scripting Language Can
• Dev Blog: Control Agent Access and Decision-Making with Variables and Filters
  
  
• Trailhead: Agent Planning: Outline the Agent’s Work
  
  
• Help documentation:
  • Action Instructions
  • Subagent Instructions
  • Troubleshooting Agents