Agentforce DX

Agentforce DX is Salesforce's developer experience for building, testing and deploying Agentforce AI agents with a professional software workflow, instead of assembling them only by hand from the graphical interface. It brings agent creation onto the same ground as the rest of Salesforce development: definitions treated as code, version control with Git, automated tests and deployment across environments.

In practice, Agentforce DX extends Salesforce DX (the platform's source- and metadata-driven development model) with agent-specific pieces: new commands in the Salesforce CLI to create, run and publish agents, a VS Code extension that lets you chat with the agent and debug it without leaving the editor, and a framework for writing behavior tests that check the agent responds as expected. It is the technical foundation of serious implementation work, part of what we cover in Salesforce for developers.

Unlike Agentforce Builder, the visual low-code console, Agentforce DX targets the professional developer who needs repeatability, code review and automation (CI/CD) for agents.

What problem it solves

When a company moves from a demo AI agent to one that lives in production and serves real customers, configuring it by hand from a screen stops being enough. You need to be able to version every change, have colleagues review it, test it before publishing it and move it from a test environment to production without rewriting anything. That is exactly the gap Agentforce DX fills: it brings to agents the software engineering practices the rest of Salesforce development already had.

How it works, piece by piece

• Salesforce CLI with agent commands: lets you generate, run and deploy agents from the terminal. The developer can invoke the agent, see how it reasons and publish it to an org or a sandbox with a single command, which makes it possible to automate it in CI/CD pipelines.
• VS Code extension: opens a view to chat with the agent, inspect its responses and debug its logic inside the editor, without going back and forth to the web interface.
• Agent as metadata (configuration as code): the agent's definition (its subagents, which Salesforce used to call topics, plus its instructions and actions) is treated as versionable source, so every adjustment is recorded in Git and can be audited.
• Testing framework: you write test cases that send an input to the agent and verify the expected result, to catch regressions before publishing. This builds on good practices in prompt engineering and guardrails.

Why it matters for the business

Without a workflow like this, every change to a customer-facing agent is an act of faith: you touch the configuration, cross your fingers and check whether something broke. With Agentforce DX, the team treats the agent as mission-critical software: there is history, review and testing. That lowers the risk of the agent hallucinating, giving inconsistent answers or breaking when it is updated, and it shortens the time between thinking up an improvement and publishing it safely.

A concrete example (Argentina / Latin America)

Consider a consumer goods distributor in Buenos Aires that runs a WhatsApp service agent for order inquiries. Its technical team works in a sandbox: it adjusts the agent's instructions so it better understands local expressions, writes a test that checks that "where's my order?" leads to the right order status lookup, and only when that test passes does it publish the change to production with a single command. The previous version stays saved in Git, so if something goes wrong the team can roll back in minutes. That controlled cycle is what makes an agent sustainable rather than a fragile experiment.

Common mistakes

• Treating the agent as content rather than code: skipping versioning and always editing in production leads to changes that cannot be reproduced and are hard to audit.
• Not writing tests: relying on manual testing means regressions only show up when a real customer gets a bad answer.
• Confusing the tools: Agentforce DX does not replace the visual Agentforce Builder; it complements it. Many teams prototype in the Builder and then industrialize with DX.

Agentforce DX vs Agentforce Builder

The two tools coexist: the Builder speeds up the initial build and exploration, while Agentforce DX brings the rigor needed to take the agent to production and maintain it over time. They are part of the same agent-building ecosystem that relies, underneath, on languages such as Apex and on the platform's reasoning engine.