With Agentforce, enterprises can now unlock new paradigms for automated work that can’t easily be reduced to rules. These new capabilities include resolving customer intent from unstructured conversations, coordinating multi-party processes across systems, and responding to operational conditions in real time. Agentic workflows use automation designed to reason toward outcomes rather than execute predefined steps. Meeting this demand requires a platform that operates across the full spectrum of automation complexity, and a framework showing where each capability fits.

Agentforce combines the Einstein Trust Layer, Reasoning Engine, Agent Script, Flow, Apex, and Data 360 into a single, unified platform. This combination handles everything from simple record trigger automation to complex multi-agent orchestration across voice, vision, documents, and real-time telemetry. MuleSoft extends this platform with the MuleSoft fabric, governance, and cross-system orchestration needed to connect agentic workflows across an enterprise. Agentforce Operations (previously Agentforce Supply Chain) applies these capabilities to the specific demands of operational and manufacturing processes.

This document introduces the Orchestration Density framework and guidelines for making informed decisions across this product landscape. The framework provides architects with a repeatable approach to select the right tools and patterns using density levels for intelligent automation use cases on the Salesforce Platform.

Agentforce represents a fundamental shift in how work gets done on the Salesforce Platform, from rules-based automation to reasoning-based workflows. To unlock its potential, architects must make deliberate, informed decisions about where agents fit, how they are composed, and what they orchestrate. The following principles provide a repeatable guideline for agentic decisions.

• Use the right tool for the right task. Use orchestration density based on execution path, modality mix, and goal complexity to determine the best fit solution.

  • Use Traditional Automation with Flows and Apex for rule-based deterministic work, where the outcome can be entirely scoped and defined by a set of rules. Traditional automation results in a static execution path, which guarantees predictable and repeatable outcomes and is crucial for auditability. Choose traditional automation for tasks that demand strict compliance and legal adherence.

  • Use Agentforce Grid for bulk inference use cases with low to medium orchestration complexity. This pattern uses single-turn generative reasoning to classify, score, or summarize data across a high volume of CRM records, ensuring high-throughput execution with immediate auditability.

  • Use Agentforce with Agent Script for tasks that have open-ended goals where the desired outcome is known, but the exact execution path can’t be specified at design time. Apply this pattern to requirements that require reasoning via guided determinism, to ensure predictable and traceable outcomes.

  • Use Agentforce Operations to streamline and automate collaborative business processes with AI-enabled management for supply chain workflows.

• Avoid applying agentic workflows to low-orchestration-density use cases. Evaluate tradeoffs between traditional and agentic automation for functional and non-functional requirements. Traditional automation can offer the scale, reliability, and performance required for your use case.

• Adopt an Agent Automation Hybrid approach, which combines Agentforce and traditional automation with Flows and Apex, when this synergy offers greater value than using either agentic or traditional automation in isolation.

The Salesforce sObject is traditionally the primary entry point for record automation. The system executes logic based on rules, beginning immediately after a Data Manipulation Language (DML) event such as insert, update, or delete. To decide between tools for efficient record-triggered automation, we introduced Automation Density as a means to measure the complexity of the system, considering automation quantity, record volume, and dependency sprawl. Traditional automation is limited by the extensive pre-work required to bring data into a structured, schema-compliant, and rules-based construct.

Agentic automation upgrades traditional automation using user intent or unstructured data as the input where reasoning can be applied to reach a desired outcome. Architects must decide when to leverage probabilistic reasoning for multi-modal unstructured data and when to enforce guided, deterministic workflows to mitigate the risk of unpredictable outcomes.

When the requirement shifts from executing rules-based steps to reasoning toward outcomes, architects need a standardized framework to evaluate the reasoning depth and goal complexity of the proposed solution.

Orchestration density is the measure of complexity within an agentic workflow. Three factors determine orchestration density: execution path, goal complexity and modality mix. While automation density measures the physical complexity of the system’s rules and volume, orchestration density measures the reasoning complexity of the agent's path toward a goal. Use the composite orchestration density to evaluate your design requirements and map to the architectural standard.

• Execution Path: The degree to which workflow can be fully scoped and specified at design time. A fully specified workflow means the workflow defines every branch and outcome resulting in a predetermined execution path. A non-specifiable workflow has a path that can emerge during runtime through reasoning against contextual data and instructions.
• Goal Complexity: The number of distinct outcomes, decision points, and path variations that the workflow must resolve at runtime. A low-complexity workflow handles a single contained task with a predetermined outcome, while a high-complexity goal spans multiple stages with competing or conflicting goals with edge cases that can’t be anticipated at design time.
• Modality Mix: The range of input types a workflow must process, and the output forms it must produce. A low modality mix reads standard CRM fields and produces record updates. A medium modality consumes a mix of structured CRM fields and static, unstructured data, like email bodies or case transcripts, to produce record updates. A high modality mix consumes dynamic, real-time streams, like live audio or telemetry, and produces multi-modal outputs across multiple external systems.

Determining the appropriate orchestration density level requires sequentially evaluating the execution path, goal complexity, and modality mix. Inspect the execution path first. If a path is fully specifiable, begin with traditional automation. Using an Agentic solution just to orchestrate and execute a deterministic path without any reasoning requirement is an anti-pattern. It leads to agent sprawl (excessive, unmanaged AI agent proliferation) and agent slop (low-quality, unnecessary AI-generated output), resulting in poor value returns.

For partial or non-specifiable paths, continue evaluating goal complexity. If the goal complexity is well-defined but certain nodes along the path need probabilistic evaluations, consider calling agents from Flow or Apex to meet the specific localized need. Instead, if the steps in the execution path need one or more AI-driven requirements across a large set of records, consider Agentforce Grid. Grid supports multi-step, sheet-based workflows through multiple AI or agent columns. It is best suited for bulk, row-oriented execution. This approach ensures that the workflow remains highly performant and auditable, invoking probabilistic reasoning only where the path cannot be predefined.

As goal complexity increases with competing dimensions (for example, determining an insurance claim payout along with fraud detection, compliance with policies, and customer satisfaction) and non-specifiable execution paths, consider Agentforce with Agent Script for guided determinism in your automation. For cross-enterprise use cases that involve Salesforce and third-party systems, use MuleSoft Fabric and Agent Broker.

Finally, evaluate the modality mix to identify the necessary technical capabilities, such as multi-modal connection or specialized integration. Modality mix functions as a capability selector, not a density calculator. It helps determine the infrastructure required to handle the input and output shape of the solution, without altering its fundamental orchestration logic.

Use this matrix to determine the architectural standard for your agentic automation. Balance traditional and agentic automation by selecting the approach that solves your automation problem.

• Traditional Automation (Low orchestration density): Use traditional automation when the process is triggered by a record change, the data is structured, logic is rule-based and pre-determined, and the outcome must be predictable (for example, standard price calculations or auto-task creation).
• Agentforce Grid (Low to medium orchestration density): Use Agentforce Grid when bulk AI tasks across existing records must be processed (for example, summarize the last 50 cases for every Account in this list, calculate the sentiment score and persist the score in the case field).
• Hybrid Orchestration (High-Order Augmented Automation): Use hybrid orchestration when automating a complex end-to-end business process (for example, claims processing or onboarding) that requires the planning capabilities of AI but the transaction integrity of Flow and Apex.
• Agentforce Agent Script (High Intent Complexity): Use Agent Script when the entry point is unstructured (for example, chat, email, and voice) and the resolution requires a conversation or the ability to handle ambiguous user requests.

This table provides general best-fit recommendations for various use cases.

Latency

Synchronous record-triggered flows execute within the platform transaction and complete in milliseconds. Agentforce inference time is dependent on the Atlas Reasoning Engine and scales with reasoning depth and modality complexity. Agentforce is unsuitable for high-volume, synchronous record processing where latency is a primary constraint.

Cost

The reasoning cost of an agentic workflow must be justified against the business value of the outcome. For high-volume, low-orchestration density tasks where a deterministic path exists, traditional automation or Agentforce Grid might be more economical than an end-to-end agentic workflow. Ensure the design accommodates the right retry pattern with explicit max-retry limits and breakers. This guardrail limits the compounding cost-overrun risk associated with bulk processing.

Governor Limits

Evaluate high-volume agentic workflows against daily platform limits for asynchronous execution. Agentforce Grid batch operations follow standard platform transaction limits. For automation involving Salesforce Objects, consider the total daily number of DML operations, as Salesforce enforces both shared resource management in a multitenant environment, and governor limits to prevent runaway automations from monopolizing shared resources.

Auditability and Compliance

Traditional automation produces fully auditable execution trails through Flow Trigger Explorer and Apex logs. Agentforce-based end-to-end or hybrid patterns produce reasoning logs that provide transparency into agent decision making, but they require expertise to interpret. Guided determinism via Agent Script is the recommended pattern for regulated industries where full execution auditability is a compliance requirement.

Escalation

Agentic workflows operating at high density should incorporate explicit human approval or escalation gates for actions with irreversible consequences, such as financial transactions, regulatory submissions, or supplier commitments. Agent Script conditional controls provide the mechanism for enforcing these gates deterministically within an otherwise agentic workflow.

Prioritize simplicity in your orchestration design. Start at the minimal orchestration level that can achieve the goal, validate it under real load, and iterate. Every additional agent, handoff or dependency in your chain introduces a new surface that can produce inconsistent behavior.

In your specifiable execution path, at nodes where reasoning is required, begin embedding an agent. Follow the best practices for building Agents in Agentforce. Avoid packing numerous subagents (previously “topics”) and never bloat instructions. Agents deployed in automation use cases can afford to be lean, as they are not the only interface. Choose the right primitive for chaining. An orchestration (delegation) pattern has tighter control over the execution sequence and can delegate sub-tasks to specialists. Avoid choreographed (handoff) patterns. If you must implement a handoff design, provide the receiving agent with the goal, context and state so that it can optimize globally rather than local objectives.

Avoid actions or tools sprawl. Actions are where agent reasoning is realized, and their design determines whether they produce reliable outcomes or failures. Every action must return a structured, observable response that the AI agent can use to plan the next turn of the conversation.

Having more than one action (and different output constructs) to do the same task degrades the agent’s ability to reason or pick the right tool for the job. It may cause the agent to miss nuances. Overlapping action definitions risks wrong classification. Make sure your action library is audited, versioned and conforms to Subagent (previously Topic) scope.

Define observable goals. Define the goal as an observable outcome, not just a procedure. A vague goal invites agent drift. Augment with a specifiable execution path. Use Agent Graph with hybrid reasoning to model the goal as a graph node with explicit state. The runtime tracks the agent’s current position in the workflow and restores it after tangential inputs; it won’t lose the goal when it receives additional information in the context window.

Test and evaluate. Implement a robust testing and evaluation framework to validate the reasoning of probabilistic nodes and the output of agentic automations. Verify execution paths against an expected result path to ensure that the model arrives at the correct outcome. Prevent silent failures where an agent falsely reports success, or enters into an infinite or non-recoverable loop by asserting the results at execution steps. Use session tracing to inspect turn-by-turn interactions, reasoning engine executions, actions, prompt and gateway inputs/outputs, error messages, and final responses.

About the Author

Arvind Palaniswamy is a Software Engineering Architect at the Office of the Chief Architect, Well-Architected Team. He likes to frame complex systems in their simplest forms using first principles. He understands engineering, operations, and business through decades of experience and MS/MBA(Kellogg) education.