Agent Script for Developers: Coding Agentforce Agents Like Real Software

Building an agent by clicking through Agentforce Builder works fine until your logic gets specific — "offer free shipping only if the order total is over $100 AND the customer is a loyalty member AND it's not already on backorder." At that point, natural-language instructions to an LLM start to feel like duct tape. Agent Script is Salesforce's answer: a real, readable scripting language purpose-built for agents.

TL;DR: Agent Script is a declarative, human-readable language for defining Agentforce agents — their subagents (formerly called topics), instructions, variables, and actions — as code instead of only as clicks. It blends natural-language reasoning instructions with deterministic if/else logic, lives in a .agent file inside your Salesforce DX project, and is fully supported in VS Code with syntax highlighting and validation. If you've ever wished you could put an agent under version control, this is how.

Why Developers Should Care

Agentforce Builder's canvas view is genuinely good for admins — natural language in, working agent out. But every agent eventually needs the same things any serious codebase needs: predictable branching logic, reusable structure, code review, and a diff you can actually read. Agent Script gives you all of that because, under the hood, every agent you build in Agentforce — whether through chat, canvas, or script — is Agent Script. The Script view just lets you work with it directly instead of through a UI abstraction.

That matters for a very practical reason: it puts agent definitions in your Salesforce DX project, next to your Apex and LWC, where they can be versioned, code-reviewed, and deployed the same way as everything else you ship.

The Building Blocks of a Script File

An Agent Script file is organized into a small number of named blocks. Once you recognize them, most scripts read top to bottom without much translation:

Block	What it holds
config	Core agent settings — developer_name, agent_label, description, agent_type, and which Salesforce user the agent runs as.
system	Agent-wide instructions and required messages like welcome and error.
variables	Named state the agent tracks across a conversation, referenced anywhere as @variables.<name>.
subagent	A self-contained unit of behavior — its own description, instructions, and available actions. This is where most of the actual logic lives.
start_agent	The entry point every conversation begins at; decides which subagent should handle the user's request.
connected_subagent	A reference to a different Agentforce agent in your org, so one agent can delegate work to another.

If "subagent" sounds like a rename, it is — Salesforce renamed topics to subagents in April 2026 with no functional change, so don't be surprised if you see both terms depending on which doc or org version you're looking at.

A Worked Example: Order Status, in Script

Let's script a small piece of the same order-status scenario from our last post — but this time controlling when the agent should hand off to a human instead of just answering.

config:
  developer_name: "Order_Support_Agent"
  agent_label: "Order Support Agent"
  agent_type: "AgentforceServiceAgent"
  default_agent_user: "order_support_agent_user@yourorg.com"
  description: "Helps customers check order status and escalates delayed orders to a human agent."

system:
  welcome: "Hi! I can help you check on an order — what's your order number?"
  error: "Something went wrong on my end. Let me connect you with a teammate."

variables:
  order_status: string
  days_delayed: number

subagent order_lookup:
  description: "Looks up an order's status and delivery estimate when the customer provides an order number."

  reasoning:
    instructions:
      "Ask for the order number if it hasn't been provided ->
       If @variables.days_delayed > 3 | Apologize for the delay before sharing status details.
       Otherwise | Share the order status plainly and offer to help with anything else."
    actions:
      - get_order_status
      - transition_to_escalation

  actions:
    get_order_status:
      description: "Calls Apex to retrieve status, delivery estimate, and delay in days for an order number."
      target: apex://OrderStatusAction

subagent escalation:
  description: "Hands off to a human agent when a delay is significant or the customer asks for a person."
  reasoning:
    instructions:
      "If @variables.days_delayed > 7 | Explain that a specialist will follow up and transition immediately.
       Otherwise | Ask one clarifying question before deciding whether to escalate."

A few things worth noticing:

• The line with -> inside reasoning.instructions is where Agent Script earns its keep. Everything before it can be plain natural language; everything after can be a hard conditional evaluated against a real variable — not something the LLM has to infer from conversation history.
• get_order_status here points at apex://OrderStatusAction — the exact custom Apex action with @InvocableMethod we built in the previous post. Agent Script doesn't replace Apex actions; it's the orchestration layer that decides when and whether to call them.
• Variables like days_delayed give the agent reliable memory instead of leaning on the LLM to remember and recompute values mid-conversation.

Three Ways to Write It (All Produce the Same Thing)

Salesforce is intentionally flexible about how you author a script:

1. Chat with Agentforce and describe what you want ("if the order's more than a week late, hand it straight to a human") — Agentforce converts that into subagents, actions, and instructions for you.
2. Canvas view — a visual, block-based editor where / inserts logic patterns like if/else and @ inserts references to subagents, actions, or variables.
3. Script view — write and edit the raw .agent file directly, with the same syntax highlighting and autocomplete you'd expect from any language extension in VS Code.

All three are the same underlying artifact. You can start in canvas view and drop into script view the moment the logic gets too specific for clicking — and back again.

Working in VS Code with Agentforce DX

If you'd rather live in your editor than in Setup, Agentforce DX brings the whole workflow local:

1. Generate or retrieve an authoring bundle for your agent into your DX project — it lands at force-app/main/default/aiAuthoringBundles/<Agent_API_Name>/<Agent_API_Name>.agent.
2. Edit the .agent file directly, or open the Agentforce Vibes panel to describe changes in natural language and let it edit the script for you.
3. Validate the file before you publish — VS Code's AFDX: Validate This Agent command (or the equivalent CLI command) checks that the script compiles and flags syntax errors with their exact location.
4. Preview the agent from the script file itself to test behavior before publishing it back to your org.

One habit worth building early: validate often, not just before a deploy. Agent Script errors are usually small — a missing colon, a typo in a block name — and they're far easier to fix one at a time than after you've written fifty lines on top of a broken block.

Where This Fits with What You Already Know

If you've spent time in Flow, a lot of this will feel familiar wearing different clothes: subagents are a bit like Flow's screen-by-screen structure, reasoning instructions are your decision logic, and actions are the same invocable Apex, Flow, and prompt-template building blocks Agentforce already supports. The real shift is that it's all expressed as one readable, versionable file instead of a set of linked records you navigate by clicking.

The Bottom Line

Agent Script doesn't replace Agentforce Builder — it's what Agentforce Builder is writing on your behalf every time you build an agent through chat or canvas. Once your agent's logic outgrows what feels safe to leave entirely to LLM interpretation, dropping into Script view (or straight into VS Code with Agentforce DX) gives you the same rigor you already expect from Apex: version control, code review, and behavior you can actually predict.

Have you tried writing Agent Script directly, or are you still building through canvas view? Let me know how it's going in the comments below.

Agentforce for Developers: Building Your First Custom Action with Apex

Everyone's talking about Agentforce from the admin side — click-based agent setup, prompt templates, topics and instructions. But if you're an Apex developer, the real question is different: how do I plug my own logic into an agent so it can actually do something in my org, not just talk about it?

TL;DR: Agentforce agents don't just answer questions — they take action by calling "actions" under the hood. The fastest way to give an agent real capability is an Apex class with an @InvocableMethod. Write the method, add a couple of annotations Agentforce reads to understand what your code does, deploy it, wire it up in Agentforce Builder, and your agent can now query, update, or trigger anything Apex can reach.

Why This Matters for Developers Right Now

Admins can build a lot with Agentforce out of the box — Flow actions, prompt templates, standard actions for common objects. But the moment a business process needs custom validation, a call to an external system, or logic too complex for a Flow, the agent needs your code. That's the developer's entry point into Agentforce, and it's honestly one of the most in-demand skills in the ecosystem right now — most teams have admins who can configure an agent, but far fewer have developers who know how to extend one safely.

The good news: if you already know how to write an invocable Apex method for Flow, you're 80% of the way there. Agentforce reuses the same annotation.

How an Agent Actually Calls Your Code

It helps to think of an agent as a planner, not a black box. When a user asks it something, the agent:

1. Reads the instructions and topics it's been configured with.
2. Decides which action (or actions) can help complete the request.
3. Calls that action with whatever inputs it can infer from the conversation.
4. Reads the output and decides what to say or do next.

An "action" can be a Flow, a prompt template, a REST-exposed Apex method, or — what we're building today — an Apex class annotated with @InvocableMethod. The annotation is what makes your class show up as a selectable action inside Agentforce Builder.

What We're Building

A support agent for a fictional subscription business needs to answer: "What's the status of order 00012345?" Instead of guessing, it should call real Apex that queries the actual record. Here's the class:

public with sharing class OrderStatusAction {

    @InvocableMethod(
        label='Get Order Status'
        description='Returns the current status, expected delivery date, and total for a given order number.'
    )
    public static List<OrderStatusResult> getOrderStatus(List<OrderStatusRequest> requests) {
        List<OrderStatusResult> results = new List<OrderStatusResult>();

        for (OrderStatusRequest req : requests) {
            OrderStatusResult result = new OrderStatusResult();

            Order__c ord = [
                SELECT Status__c, Expected_Delivery__c, Total_Amount__c
                FROM Order__c
                WHERE Order_Number__c = :req.orderNumber
                WITH USER_MODE
                LIMIT 1
            ];

            result.status = ord.Status__c;
            result.expectedDelivery = ord.Expected_Delivery__c;
            result.totalAmount = ord.Total_Amount__c;
            results.add(result);
        }

        return results;
    }

    public class OrderStatusRequest {
        @InvocableVariable(label='Order Number' description='The order number the customer
 is asking about, e.g. 00012345.' required=true)
        public String orderNumber;
    }

    public class OrderStatusResult {
        @InvocableVariable(label='Status' description='Current fulfillment status of the order.')
        public String status;

        @InvocableVariable(label='Expected Delivery' description='The date the order is expected to arrive.')
        public Date expectedDelivery;

        @InvocableVariable(label='Total Amount' description='The total charged for this order.')
        public Decimal totalAmount;
    }
}

A few details that matter more here than in ordinary Apex:

• The description on @InvocableMethod and every @InvocableVariable isn't a comment — it's instructions the agent reads at run time to decide when to call this action and how to fill in its inputs. Vague descriptions produce agents that call the wrong action or leave inputs blank.
• WITH USER_MODE enforces the running user's field- and object-level security, which matters even more with an agent in the loop, since you don't want it surfacing data the requesting user couldn't normally see.
• Keep request/response wrapper classes flat and simple. Agents reason better over a handful of clearly-labeled fields than a deeply nested structure.

Wiring the Action into Agentforce Builder

Once the class is deployed:

1. From Setup, open Agentforce Studio (or Agent Studio, depending on your org's release) and open the agent you want to extend, then start a new version.
2. Under Actions, choose New Action, then set the reference type to Apex and the category to Invocable Method.
3. Select OrderStatusAction from the list — Agentforce Builder will pre-fill the action's name, description, inputs, and outputs directly from your annotations.
4. Check Show in conversation on any output field you want the agent to surface directly in its reply (for example, status), rather than just reasoning over silently.
5. Save, commit the version, and activate it.

Testing Before You Ship It

Don't skip this step. Agentforce Builder has a Preview / Live Test Mode pane where you can chat with the draft agent before it goes live. Ask it the exact question a real user would ask — "Where's my order 00012345?" — and confirm two things:

• It actually selects your action instead of hallucinating an answer.
• The output it reads back matches what your Apex actually returned.

If it doesn't call the action reliably, the fix is almost always a clearer description, not more code. Agents lean heavily on that text to route correctly.

Permission Set Gotcha

This trips up a lot of developers coming from a pure-Apex background: an agent runs with the permissions of whatever user or agent user is assigned, not with elevated access. If the Apex class, the custom object, or the specific fields in OrderStatusAction aren't granted through a permission set assigned to that user, the action will silently fail to appear as usable — even though it's deployed and wired up correctly in Builder. If your action isn't behaving, check permissions before you touch the code.

From One Action to a Real Agent Skill

A single action is a good first step, but the pattern scales:

• Chain actions together — one action to look up the order, another to check refund eligibility, another to actually issue the refund — and let the agent sequence them based on the conversation.
• Use External Objects with Prompt Builder to ground the agent's generated responses in live data from systems outside Salesforce, instead of custom Apex callouts for every case.
• Log agent actions back to Data Cloud so you can monitor which actions get called, how often they succeed, and where agents get stuck — treat it like observability for a new kind of user.

The Bottom Line

If you can write an invocable Apex method for a Flow, you already have the core skill Agentforce needs from a developer. The shift isn't really technical — it's about writing your method and field descriptions for an AI reader instead of a human one, and being deliberate about what the agent is and isn't allowed to touch. Start with one well-scoped action, test it in Live Test Mode until it behaves predictably, and expand from there.

Have you built a custom Agentforce action yet? Share what it does — or where it broke — in the comments below.