You'd be surprised how much of a company you can decompose into its code and business systems. Agents have already cracked the first. In late 2025 and 2026, long-running background agents became the right form factor for real work, and code was the perfect fit: documented, versioned, and sitting in a repository waiting to be read.
Business systems are a totally different entity. They hold terabytes of company data, custom objects for things like bids and purchase orders, and years of logic gluing it all together. When companies change them, they hire a consulting firm and measure the project in months.
Therefore, for you to use AI here, you need a harness that's specific and can guarantee 100% accuracy and verifiability. Otherwise, you are simply not worth the risk.
We built Assemble's harness with that in mind, and we wanted to put it to the test. We took a production CRM with decades of data, based off of a customer's setup, and recreated it in Salesforce, starting with nothing but read-only access to the source organization and a new blank environment.
11 hours and 14 minutes later, with 64 parallel agents, it was done.
The agents were handed with:
- Field values: 3.4 million
- Rows of business data: 166,194
- Relationships between records: 403,008
- Archive: 8 TB across 100,000 files
Most of the complexity lived in two places: the size of the data, and the intertwined relationships between objects.
When building Assemble, our first instinct was to have one smart agent running the whole show. That works, but it's expensive, and it does the implementation sequentially (spoiler: the same job would take ~15x longer). Interestingly, a lot of the work in business systems splits naturally into modules that can be worked on in parallel: the data, the business logic and the files.
So in this run, the swarm organized itself into three layers.
At the top, a coordinator held the plan, kept everyone in step, and decided when work was actually done.
Below it, three specialists split the build. One loaded the data and checked every field, relationship and formula. One built the business controls: approvals, shipments and payments. One built the machinery for running the 8 TB data migration.
And then there were 60 agents, each owning a slice of the actual migration work. These agents didn't need to be smart. With the plan set and a supervisor watching, their job was simple, so they ran on our smallest, cheapest model. Each one copied its files to S3, checked them, and sent a receipt up the chain. Here's what one looks like:
That paid off midway through, when 32 of the 60 agents crashed on the same bug. Because every agent had been checkpointing its progress, none of them had to start over. Each picked up exactly where it stopped, and the coordinator reviewed every recovery before letting it back into the count.
Even after every automated test passed, the agents still clicked through the real interface the way a user would, and surfaced a few bugs the tests had missed. All were fixed before anything moved on.
Once every agent had turned in its receipts (100,000 files, exactly 8 TB), the results moved into Salesforce, and each file was attached to the business record it belonged to.
All of it took 11 hours, 14 minutes and 3.8 million execution requests, for under $1,000 in inference and cloud. The same project through a consulting firm means months of work and a bill with a lot more zeros.
Business systems have always moved slowly because the cost of breaking them is too high. Agents that build the system and verify every piece of it change that.
Originally published on X.
