Quick Answer: What Is Salesforce Agentforce Customization?
Salesforce Agentforce customization is the process of adapting an Agentforce agent to an organization's specific business processes, data, instructions, workflows, actions, integrations, security requirements, and user experience.
Organizations can customize Agentforce using subagents, actions, instructions, variables, data sources, prompts, workflows, and Agent Script. Salesforce's current Agentforce Builder supports both low-code configuration through Canvas and more advanced control through Script view.
Customization matters because an enterprise AI agent should not simply answer questions. It needs to understand what it is allowed to do, which data it can access, which actions it can execute, when it should escalate to a person, and how its behavior should fit existing business processes.
Why Agentforce Customization Matters
An out-of-the-box AI agent can provide a starting point, but enterprise organizations rarely operate with completely standard processes.
A sales organization may have a custom qualification process.
A service team may use a specific escalation workflow.
A financial services organization may need additional approval before an action can be completed.
A manufacturing company may need an agent to retrieve information from an ERP system before recommending the next step.
This is where customization becomes important.
Instead of asking:
"How do we make Agentforce answer more questions?"
enterprise teams should ask:
"How do we make Agentforce operate correctly within our business?"
That difference changes the entire implementation approach.
Salesforce's Agentforce Builder allows teams to modify agent settings, subagents, actions, variables, data sources, instructions, and other assets. Organizations can also test agents in Preview mode and inspect how subagents, actions, instructions, and reasoning contributed to responses.
What Can You Customize in Agentforce?
Agentforce customization can be divided into several major areas:
| Customization Area | What You Control |
|---|---|
| Agent instructions | Overall behavior and boundaries |
| Subagents | Specialized business responsibilities |
| Actions | What the agent can actually execute |
| Prompts | How specific tasks are handled |
| Variables | Information passed between processes |
| Data | What business context the agent can access |
| Workflows | Deterministic business processes |
| Integrations | External systems and APIs |
| Security | Permissions, access and guardrails |
| User experience | Tone, messages and interaction patterns |
| Agent Script | More predictable, programmatic behavior |
| Testing | How the agent is validated before deployment |
| Observability | How production behavior is monitored |
Salesforce's current Builder supports customization through both a natural-language Canvas experience and Script view. Changes made in Canvas and Script remain synchronized.
1. Customize Agent-Level Instructions
Agent-level instructions establish the overall behavior of the agent.
They answer questions such as:
- What is the agent responsible for?
- What should it never do?
- What tone should it use?
- When should it ask for additional information?
- When should it escalate?
- Which business policies should it follow?
- How should it handle uncertainty?
- What should happen when no relevant information is available?
For example, a customer service agent could have instructions such as:
- Confirm the customer's identity before accessing account-specific information.
- Never promise a refund without checking eligibility.
- Use approved knowledge sources when answering policy questions.
- Escalate complaints involving legal or regulatory issues.
- Do not disclose internal system information.
The objective is not to create an enormous instruction document.
The objective is to establish clear operating boundaries.
Good Agent Instructions
Good instructions are:
- Specific
- Relevant
- Testable
- Business-oriented
- Consistent
- Easy to maintain
Poor Agent Instructions
Avoid instructions such as:
"Always be helpful and give the best answer."
That provides very little operational guidance.
Instead:
"If the requested refund exceeds the configured approval threshold, do not complete the refund. Explain that approval is required and route the case to the appropriate service queue."
The second instruction defines observable behavior.
2. Customize Subagents
One of the most important concepts in modern Agentforce customization is the subagent.
Salesforce changed the terminology from "topics" to "subagents" beginning in April 2026. The functionality remains the same.
A subagent represents a specialized responsibility within the broader agent.
For example, a customer service agent could contain:
- Order Management subagent
- Returns subagent
- Billing subagent
- Product Information subagent
- Technical Support subagent
- Escalation subagent
Each subagent can have its own instructions and actions.
This creates a more structured architecture than trying to put every possible business process into one large set of instructions.
Standard vs Custom Subagents
Organizations can customize existing standard subagents or create their own.
Salesforce supports creating custom subagents from the asset library or directly within Agentforce Builder. A subagent created in the asset library can be reused across agents and versions, while one created within a specific agent can remain scoped to that agent.
When to Create a Custom Subagent
Create one when a business responsibility has:
- Distinct instructions
- Distinct actions
- Different data requirements
- Different escalation rules
- A clear business purpose
- Potential reuse across multiple agents
3. Customize Agentforce Actions
An agent becomes significantly more useful when it can take action rather than simply generate text.
Examples include:
- Create a Salesforce case
- Update an opportunity
- Retrieve an order
- Create a task
- Schedule an appointment
- Update a customer record
- Generate a quote
- Trigger an approval
- Query external data
- Send an approved communication
- Start an automation
Salesforce allows custom Agentforce actions to be built on existing platform capabilities, including:
- Apex
- Autolaunched Flows
- Prompt templates
- External services
- MuleSoft APIs
These underlying capabilities become the reference actions that Agentforce can invoke.
4. Flow-Based Agentforce Customization
Salesforce Flow is particularly useful when an action needs deterministic business logic.
For example:
User:
"Cancel my order."
Agentforce can determine that the request belongs to the order management subagent.
The subagent can invoke an action.
That action can trigger a Flow.
The Flow can:
- Retrieve the order.
- Check its status.
- Check cancellation eligibility.
- Determine whether approval is required.
- Update the record if permitted.
- Return the result to Agentforce.
This creates a useful separation:
Agentforce handles intent and conversation.
Flow handles deterministic business logic.
That architecture is often preferable to allowing an LLM to independently determine every business rule.
5. Apex-Based Agentforce Customization
Apex becomes useful when business logic is too complex for standard configuration or Flow.
Examples include:
- Complex calculations
- Custom validation
- Advanced Salesforce queries
- Specialized data processing
- Custom integrations
- Complex transactional logic
Salesforce supports custom actions built on Apex functionality, including invocable and REST-based Apex implementations.
For example:
Agent Request
"Find all enterprise customers with an open opportunity above $500,000 that has not been updated in 30 days."
The agent can invoke a custom action that executes controlled Apex logic and returns structured results.
The important principle is:
Do not use an LLM for deterministic computation when conventional application logic can perform it more reliably.
6. Customize Prompts
Prompts remain an important part of Agentforce customization.
They are particularly useful for tasks involving:
- Content generation
- Summarization
- Personalization
- Classification
- Drafting
- Recommendations
- Context transformation
For example, a sales agent could use a prompt to create an account briefing from:
- Account information
- Recent opportunities
- Open cases
- Previous interactions
- Customer communications
- Relevant external information
A service agent could use a prompt to draft a response based on:
- Customer issue
- Case history
- Knowledge articles
- Product information
- Company communication guidelines
Salesforce also supports prompt templates as reference actions within Agentforce.
7. Customize Agentforce with Agent Script
For organizations that require greater control, Agentforce supports Agent Script.
Salesforce describes Agent Script as a way to build predictable, context-aware workflows that do not rely solely on LLM interpretation.
This distinction is important.
A fully conversational approach can be flexible, but enterprise workflows often need deterministic behavior.
For example:
IF customer identity is not verified
request verification
ELSE
retrieve account
END IF
Or:
IF refund amount <= configured threshold
process refund
ELSE
request human approval
END IF
Agent Script can help introduce this type of control.
8. Customize Agentforce Variables
Variables allow information to move between different parts of an agent workflow.
Examples include:
- Customer ID
- Case ID
- Order ID
- Product ID
- Opportunity ID
- Language
- Customer segment
- Approval status
- Authentication status
- Requested action
- Conversation context
Variables become especially useful when an agent performs multi-step tasks.
For example:
Customer ID → Retrieve Account → Retrieve Orders → Identify Order → Check Eligibility → Execute Action
Without structured information passing between steps, complex workflows can become difficult to manage.
9. Customize Agentforce Data Access
Agent quality depends heavily on the information available to it.
Organizations can customize which data sources the agent uses and how that information contributes to responses.
Depending on the architecture, this can involve:
- Salesforce records
- Knowledge
- Data 360
- Structured business data
- Unstructured content
- Search indexes
- Retrievers
- External systems
Agentforce Builder includes tools for managing data sources, libraries, retrievers and search indexes.
For enterprise implementations, the question should not simply be:
"Can the agent access this data?"
Instead ask:
"Should this agent access this data, under which conditions, and for which actions?"
That distinction is critical for security and governance.
10. Customize Agentforce Integrations
Many enterprise agents cannot operate effectively using Salesforce data alone.
They may need information from:
- SAP
- Microsoft Dynamics 365
- NetSuite
- ERP platforms
- HR systems
- Payment platforms
- Logistics systems
- Data warehouses
- Custom applications
- External APIs
Agentforce can connect to existing Salesforce assets and integration technologies including Flow, Apex and MuleSoft APIs.
For example:
Customer asks
"Where is my shipment?"
Agentforce could:
- Identify the customer.
- Retrieve the relevant order.
- Call a logistics API.
- Retrieve shipment status.
- Translate the response into a customer-friendly answer.
The agent becomes an orchestration layer rather than another isolated application.
11. Customize the User Experience
Customization is not limited to backend functionality.
Organizations can also customize the user experience.
This can include:
- Agent name
- Description
- Welcome messages
- Error messages
- Supported languages
- Communication style
- Escalation messaging
- Channel-specific behavior
Salesforce's Agentforce Builder allows these agent settings to be configured as part of the agent definition.
For enterprise deployments, the experience should feel like an extension of the existing organization rather than a disconnected AI tool.
12. Customize Agentforce Guardrails
More capability means more responsibility.
An agent that can update records, issue refunds or trigger external APIs needs stronger controls than an agent that only answers FAQs.
Guardrails should define:
- What the agent can do
- What it cannot do
- What requires confirmation
- What requires human approval
- What data it can access
- Which actions are restricted
- When conversations should be escalated
A useful model is:
Low Risk
Read customer information.
Medium Risk
Create a case or update non-critical information.
High Risk
Issue refunds, change financial information or execute contractual actions.
The higher the business impact, the stronger the control framework should be.
13. Customize Human Escalation
A good enterprise agent should know when not to act.
Define escalation conditions such as:
- Customer explicitly requests a human
- Agent cannot confidently resolve the issue
- Required information is unavailable
- Policy exception is requested
- Transaction exceeds an approval threshold
- Legal or regulatory concerns are detected
- Customer sentiment indicates serious dissatisfaction
- High-risk action requires approval
The objective is not to eliminate human involvement.
The objective is to ensure humans handle the situations where human judgment creates the most value.
14. Agentforce Customization by Business Function
The customization strategy should change depending on the business function.
Sales
Customize around:
- Lead qualification
- Account research
- Opportunity management
- Sales coaching
- Pipeline updates
- Quote generation
- Follow-up tasks
Example:
Subagent: Opportunity Management
Actions:
- Retrieve opportunity
- Update stage
- Create task
- Generate opportunity summary
Customer Service
Customize around:
- Case classification
- Knowledge retrieval
- Troubleshooting
- Returns
- Order status
- Escalation
- Case summaries
Example:
Subagent: Returns Management
Actions:
- Retrieve order
- Validate eligibility
- Create return
- Generate return instructions
- Escalate exceptions
Marketing
Customize around:
- Audience segmentation
- Campaign creation
- Personalization
- Journey orchestration
- Campaign analysis
- Lead nurturing
Example:
Subagent: Campaign Optimization
Actions:
- Retrieve campaign performance
- Identify underperforming segments
- Generate optimization recommendations
- Create approved campaign changes
Operations
Customize around:
- Approvals
- Process automation
- Record updates
- Exception handling
- Internal requests
Example:
Subagent: Approval Management
Actions:
- Check approval status
- Retrieve policy
- Submit request
- Notify approver
- Update workflow
Agentforce Customization Example
Consider a manufacturing company using Salesforce.
The company wants an AI agent that helps sales representatives answer questions about customer accounts and open orders.
A basic agent might simply retrieve Salesforce records.
A customized agent can do much more.
Step 1: Define the Agent
Purpose:
Help sales representatives research customers and manage account-related tasks.
Step 2: Create Subagents
- Account Research
- Order Management
- Opportunity Management
- Customer Support
Step 3: Add Actions
- Retrieve account
- Retrieve opportunities
- Retrieve orders
- Query ERP
- Create follow-up task
- Create support case
Step 4: Add Business Rules
For example:
Do not modify an opportunity above the approval threshold without confirmation.
Step 5: Add Integration
Connect to the ERP system for order information.
Step 6: Add Data Context
Use Salesforce records, knowledge and relevant customer data.
Step 7: Add Escalation
Escalate financial exceptions to an authorized employee.
Step 8: Test
Test scenarios such as:
- Normal request
- Missing customer
- Multiple matching customers
- Unauthorized action
- Integration failure
- High-value transaction
- Customer asks for human assistance
This is what separates a basic AI assistant from an enterprise agent.
Agentforce Customization Architecture
A practical architecture can look like this:
USER
|
v
+---------------+
| Agentforce |
| Agent |
+---------------+
|
+-------+-------+
| |
v v
Subagent A Subagent B
Sales Research Order Mgmt
| |
+-------+-------+
|
Agent Actions
|
+-------------+-------------+
| | |
Flow Apex Prompt
| | Template
+-------------+-------------+
|
Integration Layer
|
+-----------+-----------+
| |
Salesforce External
Data Systems
|
ERP / APIs
This architecture allows the conversational layer, business logic, data and integrations to remain logically separated.
Low-Code vs Pro-Code Agentforce Customization
Not every Agentforce project needs the same development approach.
| Requirement | Recommended Approach |
|---|---|
| Basic instructions | Agentforce Builder |
| Standard subagents | Agentforce Builder |
| Standard actions | Agentforce Builder |
| Simple automation | Flow |
| Complex business logic | Apex |
| Prompt-based generation | Prompt Builder |
| External APIs | MuleSoft / APIs |
| Predictable workflows | Agent Script |
| Advanced development | Agentforce DX |
| Enterprise testing | Builder + Testing tools |
| Production monitoring | Agentforce observability |
Salesforce's current Builder supports Canvas for low-code configuration and Script view for more advanced control.
Agentforce Customization Best Practices
1. Start With the Business Process
Do not begin by asking:
"What can Agentforce do?"
Start with:
"Which process are we trying to improve?"
2. Keep Subagents Focused
A subagent should have a clear responsibility.
Avoid creating one enormous subagent containing every business process.
3. Use Deterministic Logic Where Appropriate
Use Flow, Apex or Agent Script for rules that must behave predictably.
Do not ask an LLM to make decisions that can be expressed as clear business rules.
4. Keep Actions Small and Purpose-Driven
Instead of creating one action that performs ten unrelated operations, create focused actions.
This makes:
- Testing easier
- Permissions easier
- Troubleshooting easier
- Governance easier
- Reuse easier
5. Design for Failure
Ask:
- What happens if the API fails?
- What happens if data is missing?
- What happens if two records match?
- What happens if the user lacks permission?
- What happens if the agent is uncertain?
A production agent needs answers to these questions before launch.
6. Build Human Escalation Into the Design
Do not add escalation as an afterthought.
Define it during architecture and workflow design.
7. Test Real Scenarios
Salesforce's Agentforce Builder provides Preview and testing capabilities, allowing teams to evaluate how agents behave and inspect the underlying interaction details.
Test:
- Normal requests
- Ambiguous requests
- Unexpected inputs
- Unauthorized requests
- Missing information
- Integration failures
- High-risk actions
- Escalation scenarios
8. Monitor After Deployment
Customization does not end when the agent goes live.
Agent behavior should be continuously reviewed.
Salesforce's Agentforce Studio includes observability and analytics capabilities for monitoring interactions and identifying issues such as unresolved conversations and knowledge gaps.
Common Agentforce Customization Mistakes
Mistake 1: Treating Agentforce Like a Chatbot
Enterprise agents need access to business processes and actions, not just conversation.
Mistake 2: Overloading Instructions
Long instructions do not automatically create better agents.
Use focused instructions and structured workflows.
Mistake 3: Giving Agents Too Much Access
More access does not mean more capability.
Use the minimum data and action permissions required.
Mistake 4: Making Everything AI-Driven
Some processes should remain deterministic.
Mistake 5: Ignoring Existing Automation
Before building a new AI workflow, review existing Salesforce Flows, Apex, integrations and approval processes.
The agent may be able to orchestrate them instead of replacing them.
Mistake 6: Skipping Production Monitoring
An agent can perform well during a demo and still struggle with real customer conversations.
Mistake 7: Customizing Before Defining the Outcome
Do not customize features simply because they are available.
Start with a measurable business outcome.
Agentforce Customization Checklist
Before deploying a customized Agentforce agent, verify:
Business Design
- Business objective defined
- Target users identified
- Supported use cases documented
- Out-of-scope scenarios defined
Agent Design
- Agent instructions defined
- Subagents mapped
- Actions identified
- Variables defined
- Data sources identified
Automation
- Existing Flows reviewed
- Existing Apex reviewed
- Existing integrations reviewed
- Deterministic logic identified
Security
- User permissions reviewed
- Data access reviewed
- Action permissions reviewed
- Sensitive operations identified
- Human approval requirements defined
Testing
- Happy paths tested
- Edge cases tested
- Failure scenarios tested
- Unauthorized scenarios tested
- Escalation scenarios tested
Production
- Monitoring configured
- KPIs defined
- Feedback process established
- Optimization process established
- Version management defined
How MoreYeahs Can Support Agentforce Customization
Agentforce customization often sits between CRM configuration, automation, integration, data and AI.
That means the implementation team needs to understand more than just the Agentforce interface.
MoreYeahs' Salesforce services include custom object and workflow design, data migration and validation, integrations, feature development, enhancements, org health monitoring and managed services.
Its Salesforce delivery approach is structured around:
Discovery → Configuration → Integration → Training → Optimisation
This is relevant for Agentforce projects because customization should be tied to the underlying Salesforce architecture rather than treated as an isolated AI layer.
For organizations already running Salesforce, the practical starting point is often an assessment of:
- Existing CRM configuration
- Automation
- Data quality
- Integrations
- User permissions
- Existing AI capabilities
- Candidate agent use cases
- Governance requirements
From there, the team can identify which processes are suitable for agent-based automation and which should remain deterministic.
Final Takeaway
The most effective Agentforce implementations do not treat customization as simply changing prompts.
Enterprise customization is about connecting an AI agent to the right business responsibilities, data, actions, workflows, integrations and controls.
A strong architecture typically follows:
Business Process → Agent → Subagent → Instructions → Action → Deterministic Logic → Data → Integration → Human Escalation → Monitoring
Salesforce provides the building blocks through Agentforce Builder, Flow, Apex, prompt templates, integrations and Agent Script.
The real implementation challenge is deciding how those building blocks should work together for a specific enterprise.
That is where Agentforce customization moves from configuration to architecture.
