What Salesforce's New AgentScript Language Means for Your Agentforce Build

If you've taken an Agentforce build past the demo stage, you've probably hit the same wall every admin and architect hits: the agent works beautifully in a controlled test, then does something unexpected the first time a real customer asks something you didn't script for. That gap between "looks great in the sandbox" and "safe to run against production data and real payments" has been the single biggest blocker to Agentforce adoption at scale.

Salesforce's answer, open-sourced in April 2026, is AgentScript — and it's worth understanding properly before your next Agentforce build, not after an incident review.

What AgentScript actually is

AgentScript is a single-file, declarative language for defining agent behaviour. Salesforce describes it as the control plane for the decisions an agent makes on the way to completing a task — you use it to pin the load-bearing logic that has to be deterministic (payment approvals, refund thresholds, escalation rules, anything with real business or compliance consequence) while leaving the LLM free to reason through everything else, in the same file. The public repo is open for anyone to inspect the schema directly rather than take Salesforce's word for how it works.

It runs alongside Agent Graph, the graph-based runtime behind Agentforce's Atlas Reasoning Engine. Salesforce's engineering team frames this as "guided determinism" — hybrid reasoning that combines LLM flexibility with a graph runtime you can inspect and constrain, rather than a black box you can only prompt and hope.

Why this matters more than another autonomy headline

The number everyone quotes is Agentforce's growth — past $500M ARR, up 330% year-over-year. What's more relevant to your build is why Salesforce shipped a whole scripting language for control at the same time, instead of just marketing more autonomy.

The honest answer, per Salesforce's own Agent Fabric announcement, is that autonomous agents without explicit control points don't hold up in real enterprise environments — especially anywhere near money, refunds, or regulated data. AgentScript is a direct response to that failure mode, not a nice-to-have feature.

What changes in how you build

• Execution topology is known before any conversation starts. Because the deterministic paths are declared upfront, you can lint and validate them without a single LLM call — a real shift from testing agent behaviour purely through live conversation transcripts.
• You pin per decision, not per agent. AgentScript doesn't force an all-or-nothing choice between "fully autonomous" and "fully scripted." You mark the specific decisions that must be deterministic and let the model reason through the rest in the same file — no tool-switching between a flow builder and a prompt.
• It extends to Agent Broker. AgentScript now brings guided determinism to Agent Broker as well, letting you define fixed handoff rules between agents while the LLM handles the reasoning in between — relevant if your build spans multiple agents rather than a single bot.

A practical starting checklist

• List every decision in your current or planned Agentforce flow that touches payments, refunds, data deletion, or an external system with real-world consequences — these are your AgentScript candidates.
• For each one, ask whether it's currently handled by prompt instructions alone. If the answer is yes, that's the gap AgentScript exists to close before you scale usage.
• Test the deterministic paths independently of the LLM — if you can't validate a decision without calling the model, it probably shouldn't have been left to the model in the first place.
• Revisit this list before every material expansion of an agent's scope, not just at initial launch — scope creep is exactly how undocumented autonomy re-enters a build that started out well governed.

Where this fits for your org

Whether you're building Agentforce in-house or with a partner, the standard worth holding it to is the same: can you point to which decisions are pinned as deterministic, and which are left to the model? If a build (yours or a vendor's) can't answer that clearly, AgentScript is the tool built specifically to close that gap — and it's a far easier conversation to have before go-live than after an incident review.

TechForce is a Salesforce Summit Partner with Agentforce delivery experience across Australia and India. If you're working through a governed-AI build and want a second set of eyes, get in touch.