Agent Broker Hits GA, June 2026 | Salesforce Dictionary

Salesforce is moving Agent Broker to general availability this month. The beta opened in April. As of June 2026 the orchestration brain that ties every Agentforce, Bedrock, and Foundry agent in your estate to a single control plane is production software, and it ships with three things the beta did not have: the visual authoring canvas, the Agent Script language out of preview, and support for Salesforce-hosted models inside the broker itself.

If you read our Agent Fabric expansion writeup from May, this is the other shoe. That drop promoted AI Gateway, MCP Bridge, and Trusted Agent Identity to GA and left Agent Broker in beta. The control plane was lit, but the part that actually decides which agent runs next was still a preview feature. That gap closes this month. Here is what changed, what Guided Determinism really means for the way you build, and the work it puts on your plate.

What Agent Broker actually does

Strip away the marketing and Agent Broker is a router with a memory. When a request comes in, it decides which agent or sub-agent handles it, hands off the conversation with shared context, and enforces hard rules at every boundary. It sits above the individual agents, not inside them. An Agentforce service agent, a Bedrock-hosted pricing agent, and a Foundry-hosted document agent can all be coordinated by the same broker without any of them knowing the others exist.

That coordination is the part teams kept getting wrong on their own. Wire three autonomous agents together and let them call each other freely, and you get loops, contradictory actions, and a refund issued twice because two agents both thought they owned the step. Agent Broker exists so you stop hand-rolling that orchestration in Apex and Flow and start declaring it.

The GA release adds the visual authoring canvas, so you can lay out the agents, the handoffs, and the guardrails as a diagram instead of a wall of configuration. It adds Salesforce-model support, meaning the broker can route to Atlas and other first-party models directly rather than only brokering external ones. And it promotes Agent Script, the language underneath the canvas, to a supported authoring surface.

Guided Determinism, said plainly

Salesforce has a name for the architecture now: Guided Determinism. The phrase is doing real work, so it is worth being precise about what it claims.

Fully autonomous multi-agent orchestration does not hold up in production. Salesforce is conceding that publicly. The fix is not to abandon the language model. The fix is to put it inside fences. You define the fixed handoff rules, the escalation paths, and the points where an action must execute exactly the same way every time. The model reasons freely in the space between those fences. As Salesforce's engineering team frames it, the deterministic layer sits on the outside and the probabilistic intelligence operates within it.

A concrete example. A customer asks to return an order. The broker routes to the returns sub-agent. The model reads the message, checks the order, and decides whether the customer qualifies. That part is probabilistic, and it should be, because phrasing varies and edge cases are endless. But the refund itself is a fixed transition: if the amount exceeds the threshold, hand off to a human approval step, every time, no exceptions, no model discretion. The reasoning is soft. The handoff is hard.

This is the right call. The industry spent a year pretending agents could be trusted to orchestrate themselves, and production reality kept disagreeing. Robert Kramer of KramerERP put the obvious quiet part on record in InfoWorld: pure autonomous agents do not work in production because enterprises need predictable outcomes. Agent Broker is Salesforce building a product around that admission.

Agent Script is the part developers should read first

The canvas is the friendly face. Agent Script is the substance. It is a structured definition language for agents, with sub-agents, variables, conditional expressions, guardrails, and transitions. If you have written Flow, the mental model is close, but Agent Script is built for the agentic case where part of the runtime is a language model you do not fully control.

A few concepts matter the most.

Sub-agents are the modular pieces you transition between. These were called topics earlier. You can move between them deterministically with a rule, or let the model decide the switch through a tool call. You choose which, per transition, which is exactly the lever Guided Determinism hands you.

Variables store the agent's state. The documentation is blunt about why: store state in variables rather than relying on the model's context memory. If a critical fact lives in a variable, it survives. If it lives only in the prompt history, it can drift or fall out of the window. Treat variables as the source of truth and the model as a consumer of them.

Conditional expressions branch execution on variable values. Standard if/else logic, accessed through / shortcuts in the canvas, so the deterministic skeleton of a workflow is real code you can read and test, not an instruction you hope the model honors.

Reasoning instructions mark the zones where the model is free to decide versus the zones where the agent must execute deterministically. This is Guided Determinism expressed in syntax. You are drawing the fences in the script.

Salesforce supports three ways to author the same thing: natural-language chat with Agentforce Builder, the canvas with expandable blocks, and direct script editing with syntax highlighting and validation. The three stay in sync. You can prototype in chat, refine on the canvas, and drop into the script when you need precision.

The builder gap nobody is naming on the slides

Here is the uncomfortable part. Agent Script is a language. Variables, conditionals, state management, transitions, guardrails: that is software engineering, dressed in a canvas. The admins and Flow builders who carried the last decade of Salesforce work were not hired for that, and most were never trained for it.

Vernon Keenan flagged this at TDX 2026 and called it the builder gap. The platform's center of gravity is sliding toward pro-code agentic development that assumes engineering depth, while the low-code builder who owns the org today watches the new surface area land just out of reach. Agent Broker GA does not close that gap. It widens it, because the canvas looks approachable and the model underneath it is not.

If you run a Salesforce practice, do not let the demo fool your staffing plan. Someone on the team needs to read Agent Script as code, reason about state, and test the deterministic paths. The canvas lowers the barrier to drawing a workflow. It does not lower the barrier to building one that holds up under a security review.

The lock-in question is real, and worth asking now

Agent Broker is a control plane. Control planes are sticky by design, and that is the point of buying one. It is also the risk.

Scott Bickley made the case directly in InfoWorld: once your agent control plane runs on Agent Fabric, switching costs climb. Every agent you register, every orchestration rule you encode, every governance policy you define makes the broker harder to leave. The value and the lock-in grow on the same curve.

That does not make Agent Broker a bad bet. For most Salesforce-centric shops it is the obvious one, because the alternative is hand-building orchestration that the platform now ships and supports. But ask the portability questions before you encode a hundred workflows, not after. Can your Agent Script definitions move? What does an exit look like if Salesforce changes the pricing on brokered model calls? Where does the orchestration logic live if you ever need it outside Salesforce? The Futurum analysis makes the same point from the enforcement side: the multi-vendor story is strong on discovery and still has to prove that guardrails enforce identically across Agentforce, Bedrock, and Foundry agents. Discovery is shipping. Enforcement parity is the claim to watch.

How this lines up with Summer '26

The timing is not an accident. The Summer '26 release is available June 15, and its headline is multi-agent orchestration moving from experiment to scaled impact. Agent Broker GA is the plumbing that claim rests on. Multi-agent orchestration, a single point of contact with shared context across channels, the new Customer Engagement Agent qualifying buyers around the clock: none of it is safe to run in production without the deterministic guardrails Agent Broker provides.

So treat Agent Broker GA and Summer '26 as one move. The release gives you the agents. The broker gives you the rules that keep them from stepping on each other. Shipping the second one first, even by a couple of weeks, is the correct order.

What to do this week

Spin up a sandbox and open Agentforce Builder. Build one small brokered workflow end to end: two sub-agents, one deterministic handoff, one model-decided transition, and one hard escalation rule that fires when a value crosses a threshold. Watch how Agent Script captures all four. That single exercise will teach you more about Guided Determinism than any deck.

Then have the person who will actually own this read the Agent Script guide and write a real definition by hand, not from the canvas. If that person does not exist on your team yet, you found the staffing gap before it found you. Better this week, in a sandbox, than the week a brokered refund path fails its first audit.

About the Author

Dipojjal Chakrabarti is a B2C Solution Architect with 29 Salesforce certifications and over 13 years in the Salesforce ecosystem. He runs salesforcedictionary.com to help admins, developers, architects, and cert/interview candidates sharpen their fundamentals. More about Dipojjal.