We're sharing what we believe to be the first step towards a responsible, fully self-driving Salesforce teammate that can work inside your Salesforce organization with the same end-to-end ownership as a human professional.
Like a solutions architect, Assemble Agent reads business requirements from the knowledge base, inspects the relevant Salesforce org, and plans and implements the work using Computer Use and purpose-built connectors. It's built to act like a coworker: it reviews its own work, writes its tests, and iterates until the results pass validation.
We wanted to put our harness to the test. What better way than the same test Salesforce developers use to earn customer trust: Trailhead. It's how a developer proves their proficiency operating within the Salesforce ecosystem.
For each challenge, the agent had to read the requirements, inspect the org, decide what needed to change, implement the work, and revise its approach when Salesforce’s grader rejected the result.
Starting from a new Trailhead account, the agent reached All Star Ranger, the highest rank Salesforce publishes, with 629 badges, 371,300 points, 10 completed trails, and 30 Superbadges. For context, most Salesforce developers spend months working toward Ranger, which takes 100 badges and 50,000 points, and the average active Trailblazer sits around 200 badges.
Salesforce's Superbadges test real-world proficiency: each is a hands-on scenario that takes a human 1 to 3 hours. We focused Assemble on 30 Superbadges on Salesforce Trailhead, spanning flows, access control, authentication, dashboards, Apex, data configuration, and integrations. The agent cleared these challenges in roughly 6.4 hours of recorded execution time. Here is a side-by-side comparison:
This was our first test of a larger question: can an agent take responsibility for Salesforce work from an initial requirement all the way through implementation and validation?
Salesforce is more than a codebase
Coding agents are evaluated on the lines they write and the diffs they produce. But how do you evaluate a change to a living application? And more importantly, how do you undo it? A Salesforce org holds objects, permissions, automations, users, data, integrations, and years of accumulated business logic.
A single change can affect thousands of users. A flow built years ago may depend on the field you're about to edit. Two changes that look safe on their own can collide once they reach the same org.
To support this, we built version-control infrastructure around Salesforce’s APIs. Each agent starts from a defined org state with a scoped set of changes. Assemble records every query and mutation, verifies the result holistically, and maintains a deterministic path back to the previous state. We are moving from AI that can explain Salesforce toward AI that can make and verify changes inside Salesforce.
Turning requirements into working configuration
Across the 30 Superbadges, the agent configured access controls, authentication, flows, dashboards, data classification, and Apex integrations. It also had to inspect what already existed before deciding how to implement each change.
Choosing the right interface
The agent did not rely on one interface for every task.
For instance, Salesforce's Flow Builder can be difficulat to operate through browser automation, especially when a flow contains many nodes and configuration panels. In those cases, the agent used our Salesforce's connector to deploy metadata.
Working until the result passes
The agent did not pass every challenge on its first attempt. When a challenge failed, it inspected the org again, changed its implementation, and resubmitted the result.
By learning from its mistakes, the Assemble agent completed more than 2,500 Trailhead learning units, passing 93 percent on its first attempt. Its public profile now includes 629 badges, 371,300 points, 10 completed trails, and 30 Superbadges.
What comes next
Trailhead gives us structured requirements and deterministic grading. Real enterprise environments are harder. Requirements are incomplete, business logic is spread across tickets and documentation, and changes often extend into systems such as SAP, Oracle, NetSuite, and Workday.
That is the environment we are building Assemble for.
Proving this on Trailhead is an early step toward agents that can understand enterprise systems, execute changes, validate the result, and reverse the work when needed.
