Build one product with several workers

Build a small Node.js package named "units" in this Workspace with 3 workers, one per module. Use only Node.js built-ins and no npm dependencies.

Start 3 workers at the same time:
1. Worker "length": write src/length.js, which exports convertLength(value, from, to) for the units m, km, cm, mm, in, ft, mi, and test/length.test.js with node:test. An unknown unit throws a RangeError. Run `node --test test/length.test.js` before you finish.
2. Worker "mass": write src/mass.js, which exports convertMass(value, from, to) for the units g, kg, mg, lb, oz, and test/mass.test.js with node:test. An unknown unit throws a RangeError. Run `node --test test/mass.test.js` before you finish.
3. Worker "temperature": write src/temperature.js, which exports convertTemperature(value, from, to) for the units C, F, K, and test/temperature.test.js with node:test. An unknown unit throws a RangeError, and a result below absolute zero throws a RangeError. Run `node --test test/temperature.test.js` before you finish.

Each worker changes only its own two files. You write package.json (name "units", "type": "module", test script "node --test test/length.test.js test/mass.test.js test/temperature.test.js"), src/index.js (re-exports the three functions) and README.md (one usage example per function) yourself.

When all three workers' changes are in the Workspace files, run `npm test` on the combined files and fix anything that fails. Reply with the list of files, which worker wrote each one, and the test output.

Why is the prompt shaped this way?

Each worker changes only its own two files. Plori merges the changes of a finished worker automatically when they have no conflict with the Workspace files. When two workers change the same lines, the changes have a conflict, and the manager must resolve it. A split by file prevents conflicts.

The manager writes the shared files: package.json, src/index.js and README.md. These files refer to all three modules. When one agent owns them, no two workers edit the same file.

Each worker runs its own test file before it finishes. That test shows that one module works. The test on the combined files shows that the parts work together, so the prompt tells the manager to run npm test after all three changes are in the Workspace files. The merge checks only that the changes do not overlap. It does not run or test the code.

The test script lists the three test files. Node.js 22 does not accept a directory as the argument of node --test, so the script node --test test/ fails on Node.js 22.

Where did the run start, and what needed approval?

The recorded run started from the plori CLI, signed in with an API key on the owner's account. The commands were plori workspace create and plori workspace run with the prompt. The CLI sends the prompt to the same Workspace manager as the web app. This guide has no run from the web app or from an MCP client.

No action needed approval in the recorded run, and no worker asked a question.

What did the real run prove?

On 18 October 2026, the prompt above ran in a new Workspace. In its first turn, the manager started the three workers and replied "Waiting for Workspace workers: mass, temperature, length." The three workers then ran at the same time. Plori merged the changes of each worker when it finished, and each merge started a new manager turn. After the third merge, the manager ran npm test on the combined files.

Time (UTC)	Event
14:55:02	The owner sent the prompt
14:55:33	The manager started 3 workers and ended its first turn
14:56:22	Worker temperature finished, after 10 model rounds
14:56:24	The changes of temperature merged into the Workspace files
14:56:40	Worker mass finished, after 19 model rounds
14:56:42	The changes of mass merged
14:56:46	Worker length finished, after 13 model rounds
14:57:04	The changes of length merged
14:57:04 to 14:57:25	The manager ran npm test: 89 tests passed, 0 failed

All three merges were clean. No merge had a conflict, no worker asked a question, and no action waited for approval. Each worker changed only its own two files:

Files	Written by
package.json, src/index.js, README.md	The manager
src/length.js, test/length.test.js	Worker length
src/mass.js, test/mass.test.js	Worker mass
src/temperature.js, test/temperature.test.js	Worker temperature

The manager also checked the re-exports in src/index.js and some sample conversions: 1 km is 1000 m, 1 lb is 453.59237 g, 100 C is 212 F, and 0 C is 273.15 K. It checked that an unknown unit and a conversion of -300 C to K throw a RangeError. Its last reply began with "All three workers landed, and the combined suite passes on the root with no fixes needed." The reply listed the nine files with the agent that wrote each one, and it added two notes. src/mass.js also exports two constants that the prompt did not ask for. The temperature tests compare a round trip from F to F with a tolerance of 1e-9.

We downloaded the nine files and ran npm test on another computer with Node.js 22.22.2. The result was the same: 89 tests passed and 0 failed. The Workspace runs Node.js 20.19.2.

The cost of the job, from the cost read of the Workspace:

Item	Cost
Manager, 4 turns	$0.028
Worker temperature	$0.016
Worker mass	$0.023
Worker length	$0.023
Total	$0.090

Of the total, run time was $0.051 and model usage was $0.039. The tools cost $0.

The run shows that one prompt can start three workers on one product and that Plori can merge their changes with no help from the manager. The combined files passed their tests with no fix. The run does not show a conflict, because each worker had its own files.

How many attempts did it take?

The recorded run is the fourth run of this job. All four ran on 18 October 2026:

1. A first run with 2 workers. The workers length and mass tested the split. The changes of both workers merged automatically, and 10 tests passed. Plori keeps some of its own files in the Workspace. A node --test command with no file found those files and failed. We filed this as a Plori defect. The manager then ran the tests from the test folder. Cost: $0.074.
2. The first run with 3 workers. The changes of all three workers merged automatically. One merge had to compare the files again, because the manager saved files at the same time. Plori compared them again and merged the changes in less than one second. npm test passed 22 tests. The test script in the prompt was node --test test/ at that time. That script works on Node.js 20 in the Workspace, but Node.js 22 does not accept a directory, so a reader on Node.js 22 gets a failure. We changed the script to list the three test files. Cost: $0.121.
3. The second run with 3 workers, with the changed prompt. One worker stopped and asked the owner to approve an rm -rf command in its own scratch folder. A worker that waits for input does not merge automatically, so the manager submitted its changes. Then the last turn of the manager did not start. Plori reported that the working storage of the Workspace did not have sufficient space, two times, for 8 minutes each time. The files of the job were small: the earlier test Workspaces held the disk space that Plori reserves on the host for each Workspace. After we deleted two earlier test Workspaces, one "Continue" message started the turn, and npm test passed 40 tests. We filed the approval request and the storage error as Plori defects. Cost: $0.091.
4. The recorded run. It used the same prompt as the second run, in a new Workspace. It needed no extra message and no approval. Cost: $0.090.

The four runs cost $0.376 in total. The number of tests is different in each run, because each worker writes its own tests.

How do you check it safely?

This test writes only the files of one new Workspace. It does not change anything outside the Workspace.

1. Create a new Workspace for the test. From the CLI, run plori workspace create units-test.
2. Send the prompt above to the Workspace. From the CLI, run plori workspace run units-test - < prompt.txt.
3. Make sure that the first reply of the manager names the three workers.
4. Wait for the last reply of the manager.
5. If a worker asks for approval, read the action before you approve it.
6. Make sure that the last reply lists the nine files and the agent that wrote each file.
7. Make sure that the last reply shows the output of npm test with 0 failed tests.
8. Download the nine files. Run npm test on your computer with Node.js 20 or later.
9. Read the cost of the Workspace. From the CLI, run plori workspace costs units-test.

What are the limits?

• Each worker must have its own files. Plori merges changes that have no conflict. When two workers change the same lines, the manager resolves the conflict. The recorded run had no conflict, so this guide does not show how the manager resolves one.
• The merge checks that the changes do not overlap. It does not run or test the code. The workers and the manager run the tests. In the recorded run, the test on the combined files passed with no fix.
• A worker that stops for an approval or a question does not merge automatically. The manager can submit the saved changes of that worker. This happened once in the third run.
• Each worker is a separate run, with its own model usage and run time. This guide measured 3 workers. It makes no claim about the time or the cost with more workers.
• An anonymous trial runs 2 agents at a time. This guide has no run on a trial.
• The recorded run started from the plori CLI signed in with an API key. This guide has no run from the web app or from an MCP client.
• The job ran four times on one day, and the recorded run is the fourth. This guide has no run on a different day.
• The workers can add code that the prompt did not ask for. In the recorded run, src/mass.js exports two more constants. Read the code before you use it.

Common questions about several agents on one product

Can several AI agents build one product at the same time? Yes. Plori runs AI agents that collaborate on one product in the cloud. In this run, the manager agent of a Workspace started three workers. Each worker wrote its part on its own copy of the files, and Plori merged their changes into the Workspace files.

Do I have to accept the changes of each worker? No. Plori merges the changes of a finished worker when they have no conflict. The manager tests the combined files and fixes problems in them.

What happens when two workers change the same file? When the changes overlap, Plori reports a conflict, and the manager resolves it. The recorded run had no conflict.

How much did the run cost? The recorded run cost $0.090: $0.028 for the manager and $0.062 for the three workers. Check the current pricing.

Can I start the workers myself? Yes. The CLI, the MCP tools and the REST API can start workers in a Workspace. The CLI guide gives the procedure. This guide has no run of that path.

Related

• Workspaces, for workers, automatic merges and conflicts
• plori CLI, for Workspace commands and the cost read
• Run a Node web service that scales to zero, for a Node.js service that one agent builds
• Pricing, for the cost of model usage and run time