From Agentforce Prototype to Production: An Architect’s Readiness Checklist

Creating an Agentforce prototype can be quick. Creating an agent that can be trusted with real users, real customer data and real business processes requires a broader set of architecture decisions.

The difference is important. A prototype demonstrates that an agent can respond to a controlled prompt and complete a selected action. A production implementation must continue to perform when requests are ambiguous, data is incomplete, integrations are unavailable and users behave in unexpected ways.

Salesforce describes an Agent Development Lifecycle spanning ideation and design, development, testing and validation, deployment, and continuous monitoring and tuning. The following checklist translates that lifecycle into practical production-readiness questions for Salesforce architects and delivery teams.

1. Start with a bounded use case

A useful Agentforce use case has a clear user, goal and boundary.

Before implementation, document:

who can invoke the agent;
which outcomes it is expected to deliver;
which requests are explicitly outside its scope;
which records and systems it may access;
which actions it may perform;
when it must escalate to a person; and
how success, failure and business value will be measured.

The initial scope should favour a small number of high-value journeys over a long list of loosely related topics. A narrow agent is easier to instruct, secure, test and support. Additional capabilities can be introduced when evidence shows that the existing scope is reliable.

2. Establish trusted grounding data

An agent cannot compensate reliably for an unclear data model or poor-quality source data. If customer records are duplicated, status values are inconsistent or important fields are incomplete, the agent may confidently act on the wrong context.

For every response or action, identify the authoritative source. Consider whether the agent requires:

structured Salesforce records;
knowledge content;
Data 360 data;
information retrieved from an external system; or
a combination of these sources.

Then assess the data against the intended task. Completeness, accuracy, timeliness and identity resolution all matter. So do access controls: grounding must not expose information that the invoking user is not entitled to see.

Data quality should be monitored after launch rather than treated as a one-off migration activity. Production conversations often reveal missing knowledge, inconsistent classifications and weak ownership that were not visible during a prototype.

This is where an operational master data management capability can become part of the Agentforce architecture. clearMDM is a Salesforce-native Operational MDM solution developed by Audit9. It continuously cleanses, matches and merges customer data to maintain a trusted Golden Record, giving Agentforce a governed and authoritative customer view rather than leaving each agent implementation to resolve identity and data quality independently.

3. Design topics, instructions and actions as a contract

Topics define the work an agent can perform. Instructions guide its reasoning within that scope. Actions allow it to retrieve information or change the state of a business process.

These elements should form a clear contract:

topic classification determines whether the request belongs to the agent;
instructions state the rules and constraints;
actions provide specific, controlled capabilities; and
outputs make success or failure unambiguous.

Avoid relying on a long instruction to correct an action with an unclear interface. Action names, descriptions, inputs and outputs should be explicit enough for the reasoning engine to select and use them consistently.

The clearMDM Data Steward Agent provides a practical example. Its Agentforce capabilities are integrated with governed clearMDM matching and stewardship processes, supporting AI-assisted match scoring and duplicate review as well as automated acceptance or rejection within defined rules.

4. Enforce Least-Privilege Access and Layered Controls

An Agentforce agent operates within the Salesforce security model, but secure production design remains a shared responsibility. The agent should have only the permissions required for its defined use cases.

Review:

the agent user and assigned permission sets;
object, field and record-level access;
Apex, Flow and external-service permissions;
credentials and authentication used by integrations;
access to knowledge and grounding sources; and
logging of sensitive inputs and outputs.

Do not grant broad access simply to make a prototype work. Excess permissions increase the impact of an incorrect topic selection, a misunderstood request or a compromised integration.

Agentforce should be protected by more than one type of control. The agent’s instructions can explain what it should and should not do, but important rules should also be enforced by Salesforce. Validation rules, Flow decisions, Apex checks, API controls and approval processes provide predictable safeguards that do not rely on the agent interpreting an instruction correctly.

5. Make escalation a designed outcome

Human involvement is not necessarily an agent failure. In many processes it is the correct and safest outcome.

Define escalation conditions such as:

the request is outside scope;
required data is absent or contradictory;
identity or entitlement cannot be established;
an integration or action fails;
the user disputes the result;
the action exceeds a financial or operational threshold; or
policy requires human approval.

clearMDM can use its Data Steward Agent to provide reasoning and a second opinion on potential duplicate records while leaving the final decision with a human data steward. As confidence, rules and operational evidence mature, selected decisions can be automated.

Include a safe default for uncertainty. When the agent cannot establish that an action is permitted, it should stop or escalate rather than improvise.

6. Test behaviour, not only configuration

Traditional unit and integration tests remain necessary for Flow, Apex and APIs. They are not sufficient for an AI agent, because natural-language input and model reasoning introduce variation.

A representative Agentforce test set should include:

expected requests expressed in different ways;
ambiguous and incomplete requests;
requests that belong to similar topics;
out-of-scope questions;
missing, stale and conflicting data;
unauthorised requests;
action and integration failures;
attempts to bypass instructions;
multi-turn conversations; and
escalation and recovery scenarios.

Evaluate more than the final wording. Check topic selection, action selection, action sequence, grounding, instruction adherence, record changes and escalation behaviour.

Salesforce currently supports agent testing through the Agentforce Testing Center, Agentforce DX and the Testing API. Tests run in sandboxes and can consume requests and credits; they may also modify data. Test data and cleanup therefore need to be designed intentionally.

7. Plan deployment and rollback

Agentforce configuration should follow the same controlled delivery principles as other Salesforce metadata, while recognising that the agent also depends on data, knowledge, integrations and model-driven behaviour.

A release plan should identify:

all configuration and metadata dependencies;
required permission and credential changes;
grounding data and knowledge dependencies;
environment-specific endpoints;
activation order;
smoke tests;
business ownership and support arrangements; and
rollback or deactivation steps.

Consider a phased release to a limited audience or a small proportion of traffic. Start with lower-risk actions, observe real interactions and expand autonomy only when the evidence supports it.

8. Operate a continuous evaluation loop

Production launch is the beginning of agent evaluation, not the end.

Monitor technical, behavioural and business measures. Useful indicators may include:

sessions and adoption;
successful completion rate;
escalation and abandonment rates;
topic and action errors;
latency and integration failures;
quality or helpfulness scores;
customer or employee feedback;
agent consumption and cost; and
the business outcome defined for the use case.

Aggregate metrics reveal trends, while session-level traces help diagnose individual failures. Salesforce’s Agentforce Observability capabilities are designed around this combination, including session tracing, conversation clustering, quality measures, health monitoring and consumption analysis.

Establish ownership for reviewing this evidence. Changes to topics, instructions, actions and grounding should be versioned, tested and released through the same controlled process as the original implementation.

Also define incident thresholds. A sudden increase in action errors, unsafe outputs or escalations may require an alert, restricted functionality or immediate deactivation.

A practical production gate

An Agentforce implementation is ready for production when the delivery team can answer “yes” to the following:

Is the use case bounded and measurable?
Are the grounding sources trusted, current and appropriately secured?
Do topics, instructions and actions have clear contracts?
Does the agent operate with least privilege?
Are critical controls deterministic?
Are escalation paths intentional and tested?
Does a repeatable regression suite cover normal and adverse behaviour?
Can the solution be deployed, limited and rolled back safely?
Are quality, reliability, consumption and business outcomes observable?
Is there clear ownership for continuous improvement?

The objective is not to remove all uncertainty. That is unrealistic for any non-trivial production system and particularly for one that includes probabilistic reasoning. The objective is to constrain uncertainty, detect it and ensure that failures are safe and recoverable.

Agentforce can provide a flexible interaction and orchestration layer across Salesforce data and business processes. Its production value, however, depends on the architecture around the agent: trusted data, well-designed actions, layered security, repeatable testing and disciplined operations.

References

This article was developed with assistance from generative AI and reviewed and edited by Audit9.

Agentforce Grid

Agentforce Grid enables you to build structured workflows using AI agents. Each column builds upon the previous one, using either data from earlier steps or an AI-powered action to progress the workflow. Instead of working with isolated AI interactions, Grid enables you to build structured workflows where each step builds upon the output of the previous one.

Salesforce provides detailed product documentation, but in this post we'll explore what Agentforce Grid is, when to use it for testing, and how to configure your first grid.

Why use Agentforce Grid for testing?

Agentforce Grid provides an environment for experimenting with AI-powered workflows before incorporating them into production processes. Its spreadsheet-style interface makes it easy to test multiple scenarios, inspect the output of each step, and refine prompts without impacting existing automations.

For example, you can use Agentforce Grid to:

Validate prompts against real Salesforce data.
Compare AI responses across multiple records.
Test multi-step workflows where each action builds on the previous one.
Identify where prompts or agent actions need refining before deployment.
Estimate the Flex Credit consumption of a workflow.

By enabling rapid experimentation and iteration, Agentforce Grid helps you build more reliable AI solutions while reducing the risk of introducing untested workflows into production.

Activate Agentforce Grid

Before creating your first Agentforce Grid, you'll need to enable the required permissions.

Ensure Einstein is enabled in your Salesforce org.
Create a new permission set.
Add the Manage Agentforce Grids system permission to the permission set.
Assign the permission set to the users who will create or manage Agentforce Grids.

For more detail on these prerequisites, refer to the official Salesforce documentation.

Create an Agentforce Grid

To create an Agentforce Grid:

Open the App Launcher and search for Agentforce Grid.
Select Create Grid.
Enter a name and, optionally, a description for your grid.
Select Create.

After the grid has been created, you'll see the main design canvas, where you can begin adding columns and configuring your workflow.

Building your Agentforce Grid

On the right-hand side of the designer, you'll find five options for creating the first column of your grid:

Salesforce – Use data and actions from your Salesforce org.
Data Cloud – Access data stored in Salesforce Data Cloud.
AI – Add AI-powered prompts and reasoning to your workflow.
Agent – Invoke an Agentforce agent as part of the workflow.
Upload File – Import your own data to use within the grid.

Choose the option that best matches the starting point for your workflow. Each subsequent column can build upon the output of the previous one, allowing you to combine data retrieval, AI reasoning, and business actions into a single workflow.

If you're unsure where to begin, Agentforce can also assist with creating your grid by generating a starting workflow based on your requirements. For more information, refer to the Salesforce documentation on building Agentforce Grids.

Understanding Credit Cost

When creating a grid worksheet, you can see the 'Credit Cost'. This refers to the Usage Based Pricing model where actions performed by Agentforce consume Flex Credits for the actions configured within the grid.

Agentforce uses Salesforce's usage-based pricing model, where AI-powered actions consume Flex Credits. Monitoring the Credit Cost helps you understand the potential usage of your workflow before it is executed. For more information about Flex Credits and usage-based pricing, see the Salesforce documentation.

Final Thoughts

Agentforce Grid offers a practical way to design, test, and refine AI-powered workflows in Salesforce. By combining Salesforce data, Data Cloud, AI capabilities, and Agentforce agents within a single visual interface, it becomes much easier to experiment with ideas before incorporating them into production solutions.

Agentforce Testing Centre (Beta)

The Agentforce Testing Centre (Beta) offers new testing features that replace the legacy testing approach.

In this post, we’ll explore the latest enhancements to Agentforce Testing Center (Beta), including custom evaluation criteria, inline editing, AI output visibility, and new ways to monitor agent quality over time.

Note: Salesforce provides the following statement 'Note Agentforce Testing Center in Agentforce Studio is a pilot or beta service that is subject to the Beta Services Terms at Agreements - Salesforce.com or a written Unified Pilot Agreement if executed by Customer, and the Non-GA Credit Consumption, Non-GA Gen AI, and the Non-GA Open AI LLM Provider terms in the Product Terms Directory. Use of this pilot or beta service is at the Customer's sole discretion.'

The new features available are:

Define your own Evaluation Criteria.
Make changes to tests with inline editing.
View agent inputs and outputs
Assess the health of AI Agents
Clone Test Suites

Let's look at each one in turn, which you can access through the App Launcher and search for Agentforce studio. If there is not an option to select the Agentforce Studio, you will need to log a support case.

Define Evaluation Criteria

For Salesforce help regarding this feature, the following link provides further information.

In summary, you can now define your own evaluations which enables you to ensure your AI outputs reflect your brand, meet quality standards and convey the correct point of view.

Default Evaluations include:

Response Evaluation - Evaluates if the agent's response matches the desired response
Subagent Evaluation - Evaluates the agent's ability to select the correct subagent.
Actions Evaluation - Evaluates the agent's ability to select the correct actions.

Response Quality Evaluation:

Completeness - Evaluates if the response includes all necessary information.
Coherence - Evaluates if the response is easy to read and free of grammatical errors.
Conciseness - Evaluates if the response is short but accurate.
Latency - Measure the length of time, in milliseconds, it takes for the agent to generate a response.

You can also setup your own custom Evaluation. Here's how it works:

Create a new Test Suite.
Enter the Basic Information, Test Conditions and Test Data.
Within Evaluations, select the 'Add Custom' button.
Select the LLM Judge. (An LLM judge (or LLM-as-judge) is when one large language model (LLM) evaluates the outputs of another.)
Give the Evaluation a name and then click 'Next'.
On the next step you can select an existing evaluation prompt, or create a new one.
You can then set the threshold from 0 - 5. Any value greater than or equal to this threshold will be marked as PASS during testing.
Select Save.

Inline Editing

For Salesforce help regarding this feature, the following link provides further information.

Previously, if you wanted to make any edits to the test suites, you would need to download the csv file, edit and then re-upload. Now, you can make changes in real time using inline editing.

The following provides an example of how you can do this:

Navigate to Agentforce Studio (from App Launcher, search for Agentforce Studio).
Select a Test Suite.
Double click within a cell.
Make any amendments you want to make.
Click away from the cell. The changes will be saved.

Agentforce Testing Centre - Inline Editing

View AI Agent Inputs and Outputs

For Salesforce help regarding this feature, the following link provides further information.

One of the biggest challenges when testing AI agents is understanding how an output was generated. Agentforce Testing Center now provides visibility into both the agent inputs and outputs, making it easier to troubleshoot unexpected responses and validate behaviour.

The following provides an example of how to do this:

Navigate to Agentforce Studio (from App Launcher, search for Agentforce Studio).
Select a Test Suite.
Within a Test Case, select the 'Agent Response' column.
The Output Preview displays how the Agent comes up with the test result.

Assess the health of AI Agents

For Salesforce help regarding this feature, the following link provides further information.

You can compare the results of your tests over time, ensuring the AI agents are providing the same level of quality. This is a great way of ensuring the accuracy and quality of the tests being run. When a Test Suite is run, the Run History is provided by a link in a separate tab.

The following provides an example of how to do this:

Navigate to Agentforce Studio.
Select a Test Suite and then select to Run the test.
Once complete, select the Run History tab.

Clicking on the link provides a summary of the Tests executed, the pass and fails and the reasons for the results. These can be used to compare with future test runs.

Clone Test Suite

Within the Test Suite, you can select the dropdown, top right, and then clone the Test Suite.

Further Resources

The following provides links to further Salesforce resources that discuss how to create Test Cases and Test Suites in the Agentforce Testing Centre (Beta).

Final Thoughts

The latest enhancements to Agentforce Testing Center (Beta) provide Salesforce teams with more control, visibility, and flexibility when testing AI agents.

Features such as custom evaluation criteria, inline editing, and historical run comparisons make it significantly easier to validate AI behaviour and maintain response quality over time.

As Agentforce continues to evolve, these testing capabilities will become increasingly important for organisations looking to deploy reliable and scalable AI experiences within Salesforce.