What Does an Agentforce Developer Do? (and the Admin Version)

Hey friends,

If you’re a Salesforce developer, you’ve probably wondered where you fit now that agents are everywhere.

An Agentforce developer builds, tests and connects Salesforce AI agents with code and pro-code tools, such as Agent Script, Agentforce DX, Apex actions and the Agent API. The admin version of the job builds the same agents with clicks in Agentforce Builder and Prompt Builder.

Two quick terms first. An agent is an AI assistant that can reason and take actions in Salesforce. An action is one task the agent can run, like looking up a record.

What would I actually work on?

Salesforce’s developer career path says developers build custom apps and agents, use code to connect systems, and solve business problems.

For Agentforce, the Get Started with Agentforce APIs and SDKs page splits the work into three jobs: build agents, test agents, and use agents from other places. Here’s how I’d map the tools to those jobs.

Building. Agent Script is the language behind agents in Agentforce Builder. It mixes plain-language instructions with real logic, like if/else rules and variables. Agentforce DX gives you the same work in Salesforce CLI (the command-line tool) and VS Code. There’s also an Agentforce Python SDK (a code library) for creating and managing agents.

Testing. You have three options: Testing Center in the Salesforce screens (with CSV test files), Agentforce DX (YAML files), or the Testing API (XML files). Only the last two support custom evaluations.

Using agents from outside Salesforce. The Agent API lets you chat with an agent through a REST API, which is a standard web request. The Agentforce Mobile SDK adds agents to a mobile app.

One naming note: from April 2026, Salesforce calls agent topics subagents. Only the name changed.

What does an Apex action look like?

This is the task I’d expect most developers to start with: writing a custom action in Apex (Salesforce’s programming language). The InvocableMethod docs say these methods can be called from flows, REST, Apex and Agentforce agents.

Here’s Salesforce’s own sample, unchanged:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public with sharing class AccountQueryAction {
  @InvocableMethod(
    label='Get Account Names'
    description='Returns the list of account names corresponding to the specified account IDs.'
    category='Account'
  )
  public static List<String> getAccountNames(List<ID> ids) {
    List<Account> accounts = [
      SELECT Name
      FROM Account
      WHERE Id IN :ids
      WITH USER_MODE
    ];
    Map<ID, String> idToName = new Map<ID, String>();
    for (Account account : accounts) {
      idToName.put(account.Id, account.Name);
    }
    // put each name in the output at the same position as the id in the input
    List<String> accountNames = new List<String>();
    for (String id : ids) {
      accountNames.add(idToName.get(id));
    }
    return accountNames;
  }
}

Let’s read it in plain words.

Lines 2 to 6 are the annotation. The label and description are how people (and the agent) know what the action does. Salesforce recommends always giving a label, and I’d say the description matters just as much.

Line 7 is the method. It must be static and public or global, in an outer class, and only one method per class can have this annotation. It takes at most one input, and that input is a list.

Lines 8 to 13 query the Name of each account whose ID was passed in.

Lines 14 to 22 put each name in the same position as its ID, and line 23 returns the list. That’s not just tidy. The docs say outputs must match inputs in size and order.

One thing that catches people: if a flow calls your Apex, the running user needs access to that Apex class in their profile or permission set.

What’s the admin version of this job?

The admin career path says admins manage users, data and automation, and configure AI-powered workflows.

In Agentforce terms, the exam guide lists click-based work like building agents in Agent Builder, creating prompt templates in Prompt Builder, choosing subagents and actions, testing in Testing Center, and connecting agents to channels like email, voice and Slack.

(A prompt template is a saved set of instructions Salesforce sends to an AI model.)

Here’s how I see the two roles working together: the developer writes the Apex action, and the admin adds it to the agent in Builder and writes the instructions for when to use it.

Do I need to code to get certified?

No. The Agentforce Specialist exam guide says candidates aren’t expected to know the basics of Apex or Python.

So the certification works for both sides of the job. If you’re a developer, the code skills above are what set you apart at work, even though the exam doesn’t test them.

Next reads: building an Agentforce action with Apex, using a flow as an action, the Agent API, and the Agentforce Builder walkthrough. All my exam guides are on the certification study guides page.

Are you coming at this from the developer side or the admin side? Let me know!

Hope this helps!

Best,

Nick