Agentforce Builder: How to Build AI Agents in Salesforce

If you've been keeping an eye on Salesforce lately, you've probably noticed the word "Agentforce" showing up everywhere. And honestly? It's not just hype this time. The new Agentforce Builder, which went generally available in February 2026, is a genuinely different way to create AI agents inside Salesforce - and it's way more accessible than you might think.

I've spent the last few weeks getting my hands dirty with it, and I want to walk you through what it actually looks like to build agents with this tool. Whether you're an admin who's never written a line of Apex or a developer who lives in VS Code, there's something here for you.

What Is Agentforce Builder, Exactly?

Before we get into the how, let's make sure we're clear on the what. Agentforce Builder is Salesforce's unified workspace for creating, testing, and deploying AI agents. Think of it as the control center where you define what your agent does, what data it can access, and how it reasons through problems.

The old way of setting up agents felt scattered - you'd configure topics in one place, add actions somewhere else, then jump over to test things in yet another screen. Agentforce Builder collapses all of that into a single interface. You can start with a conversational AI assistant that helps you scaffold your agent, then switch to a visual canvas for fine-tuning, or drop into a script view if you want full control.

It's built on top of the Atlas Reasoning Engine, which is the brain behind how Agentforce agents think. Atlas doesn't just match keywords to responses. It analyzes what a user actually wants, figures out what data it needs, and executes multi-step actions to get the job done. If you want to understand more about how Atlas and other Agentforce terms work, salesforcedictionary.com is a solid resource for looking up Salesforce-specific terminology.

Three Ways to Build: Pick Your Style

One of the smartest things Salesforce did with Agentforce Builder is giving you three different ways to work, all within the same tool.

Canvas View

This is the default when you create a new agent. Canvas view turns your agent's logic into visual blocks that you can read at a glance. If-then conditions, data lookups, action steps - they all show up as expandable cards. You don't need to understand scripting to use Canvas view. It's really built for admins and business analysts who want to assemble logic patterns quickly.

You can drag things around, expand blocks to see what's underneath, and use quick-action shortcuts to add new steps without typing much. For straightforward agents - think a service bot that handles password resets or order status checks - Canvas view gets you there fast.

Script View

For those of you who want more precision, Script view gives you access to Agent Script, a new high-level scripting language designed specifically for defining agent behavior. Agent Script lets you combine deterministic logic (do exactly this when X happens) with natural language prompts (use your best judgment to respond to the customer).

This hybrid approach is pretty powerful. You get the reliability of hard-coded business rules where you need them, plus the flexibility of LLM reasoning where it makes sense. For example, you might script a strict escalation path for billing disputes but let the agent freestyle a bit when answering general product questions.

AI-Assisted Building

Here's where it gets interesting. You can literally have a conversation with the Builder's AI assistant to scaffold your agent. Describe what you want in plain English - "I need an agent that helps customers track their shipments and handles return requests" - and it generates the initial structure for you. Topics, instructions, suggested actions, the works.

From there, you refine. It's not going to build a production-ready agent from a single sentence, but it gives you a massive head start. I've found it especially useful when I'm prototyping ideas quickly.

Setting Up Your First Agent: A Practical Walkthrough

Let's get concrete. Here's what the process actually looks like when you sit down to build an agent.

Step 1: Open Agentforce Builder. Navigate to Setup, search for "Agents," and click New Agent. You'll land in Canvas view by default.

Step 2: Define your agent's role. Give it a name and a description of what it does. Be specific here - this description helps the Atlas Reasoning Engine understand your agent's purpose, which directly affects how well it performs.

Step 3: Create Topics. Topics are the foundation. Each topic represents a category of requests your agent can handle. A service agent might have topics like "Order Status," "Returns," and "Account Changes." For each topic, you write natural language instructions that tell the agent how to handle requests in that category.

Step 4: Add Actions. Actions are the things your agent can actually do - run a Flow, call an Apex class, query a record, send an email. You map actions to topics so the agent knows what tools it has available for each type of request.

Step 5: Connect Knowledge. This is new in the Spring '26 release. Agents can now pull from assigned Data Libraries, so they're not just working with record data - they can reference your knowledge base articles, documentation, and other unstructured content.

Step 6: Test with Previews. This is the part I love. The Preview feature lets you simulate conversations using mock data, so your org stays clean. You can see exactly what the agent is thinking at each step - what data it pulled, which topic it matched, why it chose a particular action. That transparency makes debugging so much easier.

If any of these terms are unfamiliar, the Salesforce Dictionary breaks down concepts like Topics, Actions, Flows, and more in plain language.

What Makes Agent Script Different

I want to spend a minute on Agent Script because it's genuinely new and worth understanding. It's not Apex. It's not a Flow. It's its own thing - a lightweight scripting language designed to sit between low-code and pro-code.

Agent Script supports conditional logic, loops, variable assignment, and natural language instruction blocks. You can write something like:

IF customer.tier == "Enterprise" THEN
  INSTRUCT "Prioritize this request. Use a warm, consultative tone."
  EXECUTE escalation_flow
ELSE
  INSTRUCT "Handle this request with standard support procedures."
  EXECUTE standard_support_flow
END

The INSTRUCT blocks are where the LLM does its thing - it takes your natural language guidance and applies it to the conversation. The EXECUTE blocks fire off your deterministic business logic. Mixing the two gives you agents that are both predictable and adaptable, which is exactly what enterprises need.

Tips From the Trenches

After building a handful of agents over the past few weeks, here are some things I wish I'd known from day one.

Start narrow, then expand. Don't try to build a do-everything agent right away. Start with one topic, get it working well, then add more. Agents that try to handle too many unrelated things tend to get confused about which topic to match.

Write instructions like you're onboarding a new hire. The natural language instructions you give your agent matter a lot. Be explicit about tone, escalation criteria, and what the agent should NOT do. Vague instructions lead to vague behavior.

Use Previews heavily. Don't just test the happy path. Throw weird, off-topic questions at your agent. See how it handles ambiguity. The Preview's reasoning summary is your best friend for understanding why the agent did what it did.

Pay attention to guardrails. Agentforce includes the Einstein Trust Layer, which handles things like data masking and toxicity detection. Make sure you understand what's on by default and what you might need to configure for your specific use case.

Keep an eye on connected apps migration. If you're working with external integrations, note that Spring '26 is phasing out connected apps in favor of External Client Apps. Plan your migration now rather than scrambling later.

Where This Is All Heading

Salesforce isn't slowing down with Agentforce. The Spring '26 release also introduced Agentforce for Setup (in beta), which essentially puts an AI agent inside the Setup menu itself to help admins configure their orgs. There's also Agentforce Voice for industries like financial services, and an emerging Agent Marketplace on AppExchange where you'll be able to grab pre-built agents for common use cases.

The direction is clear: Salesforce wants every org running multiple specialized agents that handle different parts of the business. And with the Builder making it this accessible, that future is a lot closer than most people realize.

If you're just getting started, I'd recommend hitting up Trailhead - there are already solid modules on Agentforce Builder basics. And for quick lookups on Salesforce terms and concepts, salesforcedictionary.com is always a handy bookmark.

What are you planning to build with Agentforce Builder? Drop a comment below - I'm curious what use cases people are tackling first.