Agentforce Builder Guide: Build Production-Ready Agents Without Code (Spring '26)

Spring '26 rewrote how Salesforce admins build AI agents. The new Agentforce Builder isn't a wizard. It's a full development environment with a low-code canvas, a pro-code script editor, an embedded AI assistant, and a test console, all in one workspace inside Setup.

If you've been waiting for the tooling to catch up to the ambition, it has. Here's how to use it.

---

What's New in Agentforce Builder (Spring '26)

The previous agent creation flow required navigating across multiple Setup pages. The new Builder consolidates everything: describe your agent, configure its behavior, test it, and deploy — without leaving a single screen.

Four components you'll use in every build:

1. Explorer panel — left sidebar showing all agent elements: topics, actions, variables, subagents
2. Canvas view — low-code visual editor; Agent Script rendered as structured, collapsible blocks
3. Script view — pro-code editor with syntax highlighting, autocomplete, and validation
4. Agentforce Assistant — AI chat panel; describe what you want and it writes the Agent Script for you

The two views are live-synced. Edit in Canvas and the Script updates. Edit Script and Canvas refreshes. You can switch at any point without losing work.

---

Step 1: Open Agentforce Builder in Setup

Navigate to Setup → Agentforce Agents and click New Agent, or open an existing agent to edit it.

You'll land in the Builder workspace. The Explorer panel on the left shows your agent's current configuration. The main canvas is blank until you add your first topic.

---

Step 2: Define Your Agent's Role

Before configuring behavior, define what your agent is for. The Agentforce Assistant in the top panel accepts plain English:

"Create a service agent that handles order status inquiries, return requests, and account password resets."

The assistant generates:

• An agent name and description
• Three initial topics mapped to your stated use cases
• Default action stubs for each topic

The agent description matters beyond setup. When you add this agent as a specialist under a multi-agent orchestrator later, the orchestrator routes work by reading this description. Write it as a routing signal, not a branding statement: what this agent handles, specifically.

---

Step 3: Configure Topics and Actions in Canvas View

Each topic represents a category of intent the agent handles. In Canvas view, topics appear as blocks. Click a block to expand it and configure:

• Trigger conditions — what user inputs activate this topic
• Actions — what the agent does when the topic is active
• Handoff rules — when to escalate to a human

Adding resources in Canvas:

• Type / to insert expressions (conditional logic, loops, variable assignments)
• Type @ to reference resources: actions, subagents, Knowledge Libraries, variables

For an order status topic, a typical action stack looks like:

1. @GetOrderStatus (Flow or Apex action that queries Order records)
2. Conditional: if status is "Cancelled," offer return initiation
3. Conditional: if agent confidence is low, escalate to human queue

Canvas translates this into Agent Script automatically. You don't need to know the syntax.

---

Step 4: Use Inline Actions for Pre-Processing

Inline Actions run before the LLM starts reasoning. This is where you set up context the agent needs before it can answer anything useful.

Common Inline Action uses:

• Load customer context — query the Contact and Case records for the authenticated user so the agent opens with full history
• Set variables — capture session data (channel, language preference, entitlement tier) before the conversation loop starts
• Run required checks — verify the user is authenticated or that the account is in good standing before the agent offers account-sensitive actions

Without Inline Actions, the agent starts reasoning from scratch on every turn. With them, it starts informed.

To add an Inline Action: in Canvas view, click + Add Inline Action at the top of any topic block. Select a Flow, Apex action, or Data Action from your org.

---

Step 5: Ground Your Agent in Knowledge

Connect a Knowledge Data Library to give your agent access to your support documentation, product guides, and PDFs without retraining any model.

In Builder: Explorer → Knowledge → Add Library → select the Data Space containing your knowledge content.

The agent uses Retrieval Augmented Generation (RAG) to search your library in real time when a user's question doesn't match a configured action. Instead of guessing from training data, it retrieves the closest-matching article and cites it in the response.

What to put in your Knowledge Library:

• Product FAQs and troubleshooting guides
• Return/refund policy documents
• Onboarding materials and setup guides
• Anything your human agents currently search manually

Keep articles under 1,500 words and write them in plain language. The RAG retrieval quality degrades on dense, jargon-heavy documents because the semantic search can't match user intent to technical language effectively.

---

Step 6: Switch to Script View for Precision Control

Canvas is fast. Script view is precise. Switch when you need:

• Complex conditional branches that don't render cleanly in Canvas blocks
• Exact control over what the LLM sees in its context window
• Reusable logic blocks you want to copy between agents

Click Canvas in the upper right of the Explorer panel and select Script to switch views.

Agent Script reads like structured prose. The example below is illustrative of the pattern — for exact syntax, see the official Agent Script developer reference:

topic OrderStatus
  description: "Handles order status inquiries for authenticated customers"
  
  inline:
    action GetCustomerContext
    
  on user asks about order status:
    action GetOrderStatus with orderId: @session.orderId
    if @result.status == "Cancelled":
      offer ReturnInitiation
    else:
      respond with @result.statusMessage

Autocomplete suggests available actions, variables, and resource names as you type. The validator flags errors inline — wrong action names, missing required parameters, unreachable branches.

---

Step 7: Test Before You Deploy

The Builder includes a built-in test console. Click Test in the top bar to open a conversation simulator.

Test the following before any deployment:

1. Happy path — typical user question, expected action, expected response
2. Edge cases — ambiguous intent, missing required data, authenticated vs. unauthenticated user
3. Escalation — confirm the handoff to a human queue triggers correctly
4. Knowledge fallback — ask something not covered by your actions; confirm the agent retrieves from the Knowledge Library rather than hallucinating

The test console shows a trace panel alongside the conversation: which topic fired, which action ran, what data was retrieved, what the LLM received. This is your primary debugging tool.

---

Step 8: Deploy to a Channel

When testing passes, deploy the agent to a channel. From Explorer, click Channels → Add Channel and select:

• Messaging (SMS, WhatsApp, Messaging for Web)
• Voice (Agentforce Voice for phone interactions)
• Slack (internal-facing agents)
• Experience Cloud (customer portal or self-service site)

Each channel has its own configuration: session timeout, authentication requirements, and escalation routing. Configure these per channel, not in the agent itself — the agent behavior stays consistent across channels; the channel settings control the deployment context.

---

What Separates a Good Agent from a Demo Agent

Builder makes it easy to get something running. Getting it production-ready takes a few more decisions:

Write descriptions as routing signals. Your agent's description (and each topic's description) isn't marketing copy — it's the text the orchestrator reads to decide where to route work. "Handles order status, returns, and account resets for authenticated retail customers" outperforms "Your helpful service agent."

Use Inline Actions to front-load context. Agents that start conversations knowing the customer's account status, open cases, and order history outperform agents that ask for all that information mid-conversation. Customer satisfaction correlates directly with how few clarifying questions the agent has to ask.

Keep Knowledge Libraries current. A RAG-powered agent is only as accurate as its most recent documents. If your return policy changed last month and the Knowledge Library hasn't been updated, the agent will cite the old policy confidently.

For a deeper look at how the underlying reasoning loop works, see How the Atlas Reasoning Engine Powers Agentforce. Understanding the reasoning loop makes the Inline Action and Knowledge Library decisions above clearer.

And if you want to see what the platform looks like in a specific service deployment, the Agentforce Contact Center guide covers the channel configuration and escalation design for a production service implementation.

---

Quick Reference: Agentforce Builder Spring '26

Spring '26 made building agents the easy part. The hard part — clean data, well-scoped use cases, tested escalation paths — remains on you. But the tooling no longer gets in the way.