Agentforce 360 makes CRM the control plane for AI agents

Breaking: CRM is now the agent control plane

On October 13, 2025, Salesforce announced the general availability of Agentforce 360, a platform that turns CRM into a command center for building, governing, and scaling enterprise AI agents. In plain terms, the system that organizes customers and workflows can now supervise software employees that act on those workflows. It is the moment when a database of relationships becomes a traffic controller for machine labor. Salesforce announced Agentforce 360 GA. At launch, Reuters reported early adoption figures, a signal that this is not just another demo cycle.

Salesforce positions Agentforce 360 as a single, trusted system that connects humans, agents, and data. That framing matters. Many enterprises have stalled between pilot and production because tools live in silos, data is messy, and governance feels bolted on. By anchoring agents where business logic already lives, Salesforce is arguing that the control plane belongs inside CRM instead of a separate developer sandbox.

What actually launched

Think of Agentforce 360 as a kit with five pieces that snap together. Each piece matters on its own, but the compounding value shows up when they are used as a system.

Agentforce Builder

A conversational workspace for designing, testing, and deploying agents. You describe the job, and the system proposes topics, instructions, and actions. Builders can flip among a document-like editor, a low-code canvas, and a script view, then simulate real interactions with step-by-step traces. The core promise is faster iteration with the right guardrails.

Agent Script

A human-readable scripting format that blends if-then logic with model reasoning. Teams use it to specify guardrails, tools, handoffs, and deterministic steps while letting the model handle nuance, exceptions, and language. If you have ever tried to make a chatbot both helpful and safe, this is the missing gearbox. You can test and version Agent Script like code, which means policy and behavior travel together.

Agentforce Voice

A native voice layer for realistic, low-latency conversations that connect to contact center tools. Voice agents can transcribe, act, and hand off to a human in the Service Console, all while staying auditable. The value is not only faster answers but also clean traces that show what happened and why.

Slack-native orchestration

Slack becomes the shared room where humans and agents coordinate. Approvals, escalations, and partner agents can all live in channels, which keeps the execution loop visible and accountable. Work moves from summary to action inside the conversation where people already operate.

Multi-model choice

Out of the box, teams can pick leading models, route tasks based on strengths, and keep choices aligned with governance. For regulated industries, model choice and routing policy can be as important as features. The practical angle is simple: use the best fit for each step without rebuilding your stack.

From pilots to production across sales, service, and commerce

Most agent stories start with splashy demos and end with disclaimers. Agentforce 360 instead emphasizes how agents plug into revenue and support motions you already measure.

Sales: A visitor downloads a white paper. An agent qualifies the lead, drafts a personalized email, proposes a meeting time, and logs responses to the opportunity. If the buyer asks for pricing exceptions, Agent Script routes the case to a human and records the decision. This is the difference between a chat window and a system that knows the sales playbook.
Service: Voice agents answer common questions, check entitlements, schedule technicians, and escalate when necessary, all while producing a trace that supervisors can audit. The goal is not to replace representatives. The goal is to let them focus on edge cases with full context.
Commerce: Transactional surfaces connect to agents, including conversational checkout with controlled fulfillment. Agents do more than answer questions. They complete orders, update systems, and hand back a receipt.

If you have ever felt trapped in pilot purgatory, you know the seams that rip in production: brittle reasoning, no audit trail, and handoffs that drop state. Agent Script, an opinionated reasoning configuration, and Slack-native coordination exist to keep those seams stitched under load.

How Agentforce 360 works, in simple terms

Picture an airport. Customer 360 apps are the terminals where passengers arrive. Data 360 is air traffic control with radar on every plane. Slack is the concourse where ground crews talk. The agents are the aircraft that must taxi, take off, and land without colliding. The control plane needs three assurances: the flight plan is precise, the pilot can improvise safely, and the tower can see and record everything.

Precision: Agent Script defines required steps and guardrails, like a boarding checklist.
Improvisation: The model handles natural language, exceptions, and fuzzy requests, like a pilot adjusting to weather.
Visibility: Observability dashboards and traces show what happened and why, like a flight recorder you can read in real time.

The competitive stakes

The control plane is the new platform battleground. Microsoft is pushing multi-agent orchestration and model choice into its studio, complete with identity, compliance, and reach across Microsoft 365 and Teams. AWS is hardening runtimes with long-running executions, secure tool access, and OpenTelemetry compatible signals. ServiceNow is leaning into an AI control tower story with orchestration and governance across IT and operations.

Salesforce’s moat is different. It owns the customer graph and a massive installed base of workflows, and now it offers a model-agnostic agent layer that lives inside that context. If enterprises decide the safest agents are the ones built where the data already sits, CRM as the control plane is a durable bet.

For perspective across the ecosystem, see how governed agents are becoming shippable products in our analysis of AgentKit makes agents shippable, how orchestration shows up in dev workflows in Copilot’s coding agent hits GA, and how runtime choices extend to the network edge in Cloudflare’s Agents SDK at the edge.

A builder’s playbook you can run this quarter

The fastest way to make agents useful is to treat them like product lines, not experiments. Below is a concise playbook that teams can run inside Agentforce 360.

1) Design memory that compounds

Memory is not a single vector store. It is layered context you can reason about and control.

Session memory: What the user just asked and what the agent did. Store it in the trace and pass a compact summary forward.
Interaction memory: The last handful of conversations for a specific account, case, or opportunity. Maintain continuity without leaking across customers.
Institutional memory: The semantic layer that defines what things mean in your business. Think objects, picklists, policy docs, and troubleshooting flows. Keep this index versioned with owners and freshness dates.

Implementation steps:

Start with high-value tasks that require strict accuracy, such as quote approvals or warranty eligibility checks. Define the minimal schema an agent needs, then map it to your entities.
For unstructured content, ground agents in approved documents. Maintain a catalog of sources with owners and review cadences, and expire sources that fall out of compliance.
Give agents a short-term memory budget and force summarization. If a conversation exceeds limits, collapse it into bullet summaries that are signed by the agent for traceability.

2) Govern like you run payments

Treat every agent action like a transaction that could be audited. The goal is not to slow agents. The goal is to make their authority explicit.

Roles and scopes: Assign every agent a clear role, data scope, and allowed actions. Separate read, write, and execute permissions. A sales agent should not issue refunds. A support agent should not change pricing.
Guardrails in Agent Script: Encode preconditions and approvals directly into scripts. If a discount exceeds 15 percent, require a manager confirmation. Keep guards as code so they are versioned, reviewed, and tested.
Human-in-the-loop points: Identify the two or three policy cliffs in each flow, such as refunds, returns, or data exports. Insert confirmations that show the agent’s reasoning and the data it plans to use.
Slack as the control room: Run approvals where people already work. Use channels for high-sensitivity actions, make approvals explicit, and archive the thread ID in the case record.
Model choice policy: Document which models can be used for what, and why. For tasks that require long context or multimodal understanding, route accordingly. For conservative summarization or classification, route to models tuned for reliability. Keep the routing table in configuration, not in code.

3) Instrument for observability, not just logs

You cannot improve what you cannot see. Production agents need telemetry at three layers.

Outcome metrics: Deflection rate, resolution time, conversion lift, average handling time change, and dollar impact. Tie these to specific agents and scripts.
Quality and safety: Hallucination rate, tool-call error rate, policy violations, and escalation reasons. Track them per step in the reasoning trace so you can pinpoint brittle links.
Runtime signals: Latency by model and tool, token usage, timeouts, and queue backlogs. These are the warning lights that tell you to scale, cache, or switch models.

Make traces first-class objects that product managers can read. Tag every trace with an agent identity, script version, model, and data sources used. If you would not ship an unmonitored microservice, do not ship an unmonitored agent.

4) Reliability engineering for reasoning systems

Agents fail differently than services. Build for graceful degradation and predictable recovery.

Safe fallbacks: If a tool fails, fall back to a canned response or a human queue. Define fallbacks in Agent Script so they are tested and versioned.
Canary and shadow: Before changing a model or script, shadow the agent on live traffic and compare outcomes. Promote only when the delta is positive on quality and cost.
Adversarial tests: Include red-team prompts in unit tests. Try tricky pronouns, ambiguous references, and policy edge cases. Keep a test set per department.
Rate limit by risk: Allow high-frequency autonomous actions only for low-risk tasks. For high-risk actions, keep autonomy low and require human confirmation.

5) Data residency and provenance

If you sell in multiple regions or regulated industries, your agents must know which data cannot move. Keep a registry of sources with residency tags, and have scripts check residency before retrieval. Maintain provenance on outputs so any customer can ask what sources were used.

A practical 30-day launch plan

Use a simple cadence to get from idea to measurable impact without boiling the ocean.

Days 1 to 3: Pick the job to be done. Choose one flow with clear value and repetitive volume. Good starters are lead qualification, renewal outreach, or first-response triage.
Days 4 to 7: Define truth and boundaries. List the objects, fields, and documents the agent is allowed to use. Mark red lines for data and actions. Write the first pass of your routing policy.
Days 8 to 12: Script the happy path. Author an initial Agent Script with preconditions, tool calls, and two human-in-the-loop checkpoints. Add a fallback for each external dependency.
Days 13 to 16: Build the observability scaffold. Decide on metrics and dashboards. Tag traces with agent identity, script version, and model. Set alert thresholds for latency, error rate, and policy violations.
Days 17 to 21: Shadow and compare. Run the agent in shadow mode on real traffic. Compare outcomes against a human baseline. Capture failure modes and update the script.
Days 22 to 26: Canary safely. Ship to 10 percent of traffic with on-call coverage. Watch run cost, latency, and error patterns. If a failure repeats, pause, patch, and resume.
Days 27 to 30: Promote and document. Increase traffic to 50 percent, then 100 percent if metrics hold. Publish the playbook, the routing policy, and the rollback procedure.

Common pitfalls and how to avoid them

Unbounded memory. Letting conversations grow without summarization bloats cost and erodes reasoning. Enforce a memory budget and write explicit summarization steps.
Policy drift. If guardrails live in a wiki and not in Agent Script, behavior will drift. Treat policy as code so it is testable and reviewable.
Hidden coupling. Hard-coding model and tool choices inside logic makes upgrades painful. Keep routing in configuration and pass it as context.
Vanity metrics. Counting chats or messages tells you little about business value. Anchor on conversion lift, deflection rate, resolved tickets, or dollars saved.
Single-point failure. If a tool outage halts the agent, you did not design fallbacks. Add graceful degradation paths before go live.

Metrics that matter, with definitions

Deflection rate: Percentage of inquiries solved without human help. Track by intent, not just volume.
First contact resolution: Share of issues solved in the initial interaction. Ties directly to customer satisfaction.
Conversion lift: Relative improvement in conversion for agent-touched leads or carts compared to control.
AHT delta: Change in average handling time for assisted agents versus baseline.
Cost per resolved action: Total run cost divided by completed actions, segmented by agent and script version.

Make these visible to leaders weekly and to builders daily. The dashboard is your contract with the business.

Where this fits in your stack

Agentforce 360 is not a free-standing bot studio. It is a control plane that sits next to your objects, flows, and permissions. That is why it can enforce policy, why it can write back to the right records, and why it can show clean traces to auditors. If you already invest in governed agent patterns, the approach rhymes with our guidance in AgentKit makes agents shippable. If you are thinking about runtime placement, the edge trends we covered in Cloudflare’s Agents SDK at the edge will matter for low-latency use cases. And if your dev orgs are adopting multi-agent collaboration, the operational lessons in Copilot’s coding agent hits GA apply here as well.

What this means for teams right now

For sales leaders: Shift playbooks from reporting to execution. Start with one or two agent-led motions such as net-new lead qualification and renewals. Define guardrails in a script, connect to your data, and run a two-week canary. Success is not a nicer email. Success is more pipeline with the same headcount.
For support leaders: Put Voice on the most repetitive call reasons and measure deflection with auditability. The win is faster time to resolution and happier agents who handle the hard calls.
For commerce owners: Test conversational checkout on a limited catalog with strict policy checks, then tune for average order value and conversion. Keep a human confirmation choke point for refunds and returns.
For platform teams: Write a model routing policy and an agent identity standard. Document your observability schema and require it for every new agent.

The road ahead

Expect the platform chess match to continue. Microsoft will keep weaving orchestration, identity, and governance into the places people already work. AWS will keep hardening runtimes and neutral plumbing so any framework can plug in. ServiceNow will keep aiming to be the control tower for operational workflows. Salesforce will try to win by making the agent a native citizen of CRM, with Slack as the shared cockpit for humans and machines. None of these are mutually exclusive in a large enterprise, but the system that owns context will decide how fast agents earn trust.

The bottom line

Agentforce 360 marks a turning point. The control plane for agents is sliding into the systems that already hold your customers, workflows, and permissions. If you are a builder, treat agents like products, wire memory to your semantics, encode policy in Agent Script, and ship with traces you would proudly show to an auditor. If you do, those pilots finally become production.