Agentforce 360 makes Slack the command line for enterprise AI

Breaking: Slack becomes the place where agents get real work done

Salesforce just flipped a switch on how enterprise artificial intelligence shows up at work. Agentforce 360 connects the building, governance, and deployment of agents to the same place where most information workers already live each day: Slack. The pitch is stark and simple. Treat Slack like a command line for the enterprise. Type what you want, mention who or what should help, and agents with the right permissions do the rest against governed data in Customer 360. The platform is now broadly available, per Salesforce's Agentforce 360 announcement.

If that framing sounds bold, it is meant to be. Chat interfaces have promised to help before, but they usually stopped at a draft or a suggestion. Agentforce 360 is built to execute. It is designed to route requests across people, processes, and systems, then complete tasks the way a seasoned colleague would, only faster and at all hours.

The big consolidation: build, govern, and deploy in one loop

The old way of enterprise automation scattered responsibilities across tools. You designed the flow in one product, wired data in another, set policies in a third, and surfaced the result in yet another interface. Agentforce 360 compresses that sprawl into a single loop.

Build where you work. Teams sketch and refine agents in a conversational workspace and push them live to Slack channels and canvases. The same environment supports low code for speed and pro code for precision.
Govern by default. Identity, roles, data access, and audit trails are defined once in Customer 360, then inherited by every agent and action.
Deploy without ceremony. Launch to a Slack channel, a service console, or a website widget with the same permission model, logging, and guardrails.

Think of it like moving from a kitchen with ingredients stored in four different houses to a kitchen where the pantry, stove, and sink are in one room. Time to value comes from proximity.

Agentforce Builder: the drafting table, lab bench, and launchpad

Agentforce Builder brings drafting, testing, and deployment together in one place. For capabilities and packaging, see the Agentforce product page. You start by describing the outcome you want in plain language. The system scaffolds a first pass: which data the agent needs, which actions it might call, and what a good conversation should look like. From there you can refine in three synchronized views.

Document view for writers. Edit instructions like a living playbook. This suits product managers and subject matter experts who think in words and examples.
Canvas view for low code. Drag topics, actions, and data sources into a visual flow. This is where you line up steps that must always run, such as identity checks or policy lookups.
Script view for pro code. When you need sharp control, Agent Script exposes a text-based definition of the agent that developers can version, review, and test like any other code.

Builder includes a testing center that spins up synthetic conversations, generates edge cases, and checks outcomes against guardrails. You can set expectations like “never reveal the raw policy table,” “always log calls touching customer payment data,” or “escalate to a human when sentiment crosses a threshold.” Because testing sits next to the draft, the build and test loop collapses into minutes. Teams that today file tickets and wait days for a staging deploy can iterate in a single working session.

Agent Script and hybrid reasoning: rails plus a steering wheel

Enterprises want the flexibility of large language models, and the predictability of workflows that never skip steps. Agent Script combines the two into hybrid reasoning.

Deterministic rails. You define steps that must always run in sequence. For example, validate identity, check entitlements, compute refund eligibility, log the action.
Model-driven steering. In between those steps, the agent uses a large language model to interpret messy human requests, choose the next best action, or draft the response in an appropriate tone.

A simple metaphor helps. Rails keep the train on track through the stations that matter. The steering wheel handles the turns you cannot preprogram, like interpreting a vague request or resolving a conflict between two data sources. This pairing lets a retail agent process a return with zero surprises while still understanding that “wrong size, found receipt later” should trigger a goodwill extension.

Now apply that pattern across departments.

Sales: A rep asks in Slack, “Summarize my last five customer calls and prep a renewal plan.” Rails pull transcripts, compute health scores, and check discount policy. The steering wheel writes a tailored plan and flags missing approvals.
Service: A technician says, “Schedule a field visit for this serial number, avoid Tuesdays, coordinate with facilities.” Rails handle entitlement and logistics. The steering wheel confirms constraints and negotiates a slot directly in the channel.
Finance: A controller requests, “Draft the close checklist, surface unusual variances over 3 percent, and alert the regional leads.” Rails run queries and populate templates. The steering wheel explains anomalies and asks clarifying questions before posting to the team.

Agent Script’s explicit structure also unlocks code review and change management. You can treat an agent like a software artifact: version it, test it, and roll it back. That is the baseline enterprises have been waiting for. For deeper context, see how test-time compute is rewriting agents.

Agentforce Voice: when talk becomes the shortest path

Not all work starts in a chat thread. Many high-value moments still happen on the phone or through a microphone. Agentforce Voice brings the same agents to spoken conversations that flow across phone, web, and mobile.

This matters for two reasons.

Speed of intent. Speaking a request is often the fastest way to express context, urgency, and constraints. “I just got the invoice. The amount is wrong, and the deadline is today.”
Emotional bandwidth. Tone and pacing carry signals that text cannot. Agents that pick up those cues can escalate sooner or slow down for a customer who sounds lost.

A voice session can trigger the same rails and steering patterns. Confirm identity, pull the account, compute options, and initiate the resolution. Then post the transcript, outcome, and next steps back into Slack where the team can inspect, coach, or continue the thread.

Why Slack is the right command line

Slack has three properties that make it ideal for the agent era.

It is the shared cockpit. Most modern teams already gather in Slack to decide, ask, and share. Agents that enter that space gain context from the surrounding conversation and reduce app switching.
It is permission aware. Slack knows who you are, who you work with, and which channels you can see. Agents can inherit that identity, which reduces the risk of overexposure and the friction of repeated logins.
It is composable. Channels, canvases, and workflows are containers where agents can post results, collect approvals, and trigger follow-on actions. The channel becomes both chat history and change log.

Treating Slack like a command line does not mean everyone learns syntax. It means the simplest instruction wins. “@RenewalAgent draft options for Acme by Friday, keep the discount under five percent, and tag legal.” The agent runs, posts a plan, and gathers the right people without spinning up a meeting. For the interop picture, see how the MCP standard for agents is becoming the layer between tools.

Governance without the whiplash

AI experiments often stall when pilots meet the enterprise risk committee. Agentforce 360 bakes governance into the fabric.

Data 360 context. Agents sit on top of unified customer data, not just a folder of documents. That means fewer hallucinations, fewer mismatched accounts, and a trail that links every action to an entity and owner.
Identity and policy. Roles, permissions, and data residency are inherited from the systems teams already manage. If a new agent needs access to invoices, it goes through the same approval and logging as any other system.
Testing and telemetry. The testing center lets owners evaluate prompt injection resistance, confidential data handling, and performance. Telemetry shows what agents tried, what they did, and where they struggled. That feedback loop informs both safety and product improvement.

This is the shift from “model safety” to “system safety.” Models are necessary, but the bigger wins come from knowing which actions are allowed, which are reversible, and which should always require a second human glance.

Real-world patterns that are ready now

Four agent patterns are already viable for many organizations.

Intake triage in Slack. Route inbound requests in shared channels. An agent tags the right owner, collects missing details, and proposes a response that a human can accept with one click. The goal is not to bypass people, but to remove idle time.
Back-office errands. The long tail of requests to sales operations, finance, human resources, and information technology are perfect for rails plus steering. Renew a badge, reissue an invoice, unlock a report, or set up a contractor. Each has a checklist, exceptions, and an audit trail.
High-velocity service deflection with a human in the loop. Use Agentforce Voice for first contact, then switch to a Slack thread where the same agent posts the transcript and recommended steps. Humans can intervene, and the agent learns from corrections that are reviewed in testing.
Sales hygiene and insight. The least glamorous but highest return work in sales is hygiene. Logging notes, updating fields, and chasing approvals. Let agents do it when the conversation is still fresh, not Friday night.

Critically, each pattern works across multiple departments, which echoes a core design choice in Agentforce 360. Agents are not separate bots for each product. They are governed actors that can collaborate with each other and with people in one place.

How this stacks up against operating system Copilot and Google Workspace

Three models for the next year are emerging.

Slack-first workplace. Agents meet people where collaboration already happens. Advantages include shared context, faster approvals, and uniform governance through Customer 360. The risk is dependency on Slack adoption. If critical teams are not in Slack, value is patchy.
Operating system Copilot. The operating system approach integrates agents into Windows and system menus. It is always present, which is ideal for individual productivity, screenshots, and file access. The risk is fragmentation when work lives in team hubs like Slack or when permissions differ between desktop and cloud systems.
Google Workspace centric. Workspace agents live in Docs, Sheets, and Gmail. They excel in content creation and document-centric workflows. The risk is the extra steps required to connect actions to governed systems and to reach the cross-functional teams that coordinate in Slack.

Also compare this shift to OpenAI's agent platform moment.

The next 12 months: what to expect and how to prepare

Here is a grounded forecast for the next year of enterprise experience design.

Agents will have names, owners, and budgets. Expect a service catalog inside Slack listing agents, capabilities, uptime, monthly cost, and the human owner who approves changes. Finance will ask for this because agent minutes look like cloud minutes.
Teams will design playbooks before models. The durable advantage will be clear instructions and rails, not just model choice. Companies will invest in Agent Script expertise the way they once invested in integration platforms.
Voice will move from novelty to normal. Contact centers will blend Agentforce Voice with Slack backstops, so every call becomes a thread with searchable context and a next action. Leaders will measure containment rates and customer effort score, not just average handle time.
Marketplace momentum. As agents become units of work, a marketplace inside Slack will grow around ready-made actions and topic templates. Buyers will prefer bundles that include both rails and steering, because no one wants to stitch ten separate skills into one reliable agent.

To get ready, take three steps that do not require a moonshot.

Pick one painful process where information hops across teams in Slack. Map it with the people who do the work. Define rails and write down the few sentences an expert uses to handle edge cases. That is your first agent.
Stand up a testing habit. Before you build a second agent, create a small suite of tests that check guardrails, required steps, and success criteria. Keep the suite short, but run it on every change. Treat this like seatbelts, not optional accessories.
Publish a one-page governance charter. In plain language, state which systems agents can touch, who approves access, what gets logged, and how rollbacks work. Share it in a pinned Slack canvas so everyone can find it. Update it monthly.

What could still go wrong and how to handle it

Context bloat. Agents that read too much context slow down and cost more. Use Data 360 and telemetry to trim what an agent loads by default. Keep the rest available on demand.
Shadow agents. If teams build agents in isolation, you will get duplicated effort and hidden risk. Create a lightweight review of Agent Script changes and require owners for every deployed agent.
Overtrust in drafts. Even the best hybrid reasoning will get tone, policy, or math wrong sometimes. Use rails for the decisions that must be correct. Let the steering wheel handle suggestions that a human can review.

These are normal growing pains. The advantage goes to teams that learn visibly, write playbooks, and keep humans in the loop where the cost of error is real.

The competitive question every leader should ask

If your competitors could grant every employee a trusted operator inside Slack by January, what would they automate first that you still do by hand? It is a useful lens because it forces specificity. Pick one customer journey or one back-office process and attack the idle time between steps.

Agents do not replace teams. They remove the waiting and the rework. When work becomes a conversation with a reliable finisher on the other end, you can move at the speed of your best people on their best day.

The bottom line

Agentforce 360 reframes the enterprise interface around where people already talk, decide, and coordinate. Slack becomes the command line. Customer 360 becomes the operating system of record. Builder, Agent Script, hybrid reasoning, and Voice turn ideas into governed execution. The shift is not about chat for its own sake. It is about placing trusted action within one keystroke of the conversation that needs it. The next year will reward teams that start small, test relentlessly, and treat agents as products with owners, budgets, and roadmaps. The sooner you do that, the faster your organization’s conversations will turn into outcomes.