WORKCELL

WORKCELL RUNS THE LINE.

LOOK HERE. ONE MAC. EVERY AGENT WANTS IT.

Look at this. Agent A has Xcode. Agent B wants Xcode. Agent C wants the same simulator because apparently every agent woke up needing the same Mac.

Without Workcell, they pile in. One erases the simulator. One installs another build. One keeps testing like nothing happened.

Now put Workcell in front of the command.

Agent A runs. Agent B keeps its place. Agent C keeps its place. A finishes, B starts. No polling. No babysitting. No two agents rearranging the same machine at the same time.

Different resource? Starts immediately.

Same resource? Gets in line.

ONE RUNS.THE REST HOLD THEIR PLACE.NEXT STARTS AUTOMATICALLY.

That’s it. That’s Workcell.

WATCH WORKCELL CALL NEXTRUN THE 10-SECOND DEMO
WHO HAS IT

Pause the queue example to read a state, or restart it and announce the release and automatic handoff.

Agent A is running. Agents B and C are waiting in FIFO order. Agent D is running on a different resource.

Look here. macos-xcode is running ace/audio-fix.

ace/player-redesign is next.

ace/subtitle-fix is behind it.

Meanwhile, gpu:a100-node-01 starts right now because it’s a different resource.

Same resource waits. Different resource runs.

You following me, terminal guy?

01 / THE PROBLEM

WITHOUT WORKCELL, THEY DON’T WAIT.THEY INTERRUPT.

Agent A starts the test.

Agent B wipes the simulator.

Agent C installs a different build on the same phone.

Now Agent A gets a green check from Agent C’s binary.

THE WRONG APPJUST PASSEDTHE RIGHT TEST.

Look at that. Your dashboard says green. Your test says nothing.

That isn’t parallelism. That’s three agents in one kitchen, all slapping the same potato.

Stop having a fake green.

Stop celebrating somebody else’s binary.

02 / THE DEMONSTRATION

NOW PUT WORKCELL ON IT.

workcell run macos-xcode --wait -- xcodebuild test

One command. That’s it.

Same three agents.

Same three candidates.

Same test.

We don’t change the test. We don’t change the agents. We don’t build a twelve-service scheduling platform.

We put Workcell in front.

WITHOUT WORKCELL

GREEN—ON THE WRONG BINARY.

One agent tests another agent’s build.

Then it happens again.

Two beautiful green checks. Both worthless.

WITH WORKCELL

BROKEN FAILS.FIXED PASSES.

The broken canary fails.

The agent repairs it.

The rerun passes.

Each build stays with its own test.

That’s what a test is supposed to do.

Don’t take my word for it. Watch the same three agents run it both ways.

Without Workcell, one agent can test another agent’s binary. With Workcell, every build stays with its test. Broken fails. Fixed passes. No hand-waving. No “in theory.” Press play.

Busy state

BUSY ISN’T A PLAN.

“Try again later” isn’t a plan either.

Look at this. The resource is busy. Workcell doesn’t shrug. It tells the agent:

WHO HAS IT.WHAT’S RUNNING.HOW LONG IT’S BEEN RUNNING.WHERE THE LOG IS.WHO’S NEXT.

Then it returns the exact command that waits for the agent’s turn.

Why make the agent work twice as hard?

Check. Fail. Sleep. Retry. Check again. Fail again.

Workcell saves its place.

When the resource opens, the next command starts.

It just does the work.

03 / REAL WORKLOADS

IF TWO AGENTS SHOULDN’T TOUCH IT AT ONCE,PUT WORKCELL IN FRONT OF IT.

Here’s your iPhone.

Here’s your iPad.

Here’s your A100.

Here’s your firmware rig.

One of each.

Fourteen agents.

Everybody calm down.

Same resource? One runs and the rest keep their place.

Different resource? It starts immediately.

You’re not shutting down the whole shop because one phone is busy.

You’re putting a line in front of the phone.

iPhone 15 Pro

RUNNING
Playback after server loss
NEXT
Movies filter workflow
WAITING
Subtitle selection after cold resume

One phone. One owner. Everybody gets a turn.

iPad Air M2

RUNNING
Adaptive navigation
NEXT
Keyboard commands
WAITING
Rotation preserves navigation

Nobody rotates the test rig out from under somebody else.

A100 node

RUNNING
CUDA benchmark
NEXT
Fine-tune validation
WAITING
Model evaluation

Three jobs. One GPU. Zero overlap.

Firmware rig

RUNNING
Bootloader recovery matrix
NEXT
Power-loss update test
WAITING
CAN bus fault injection

Because two agents poking the same board is not a test plan.

Run-it-yourself demo

RUN IT YOURSELF.TEN SECONDS.ONE REAL QUEUE.ZERO OVERLAPS.

Now I know what you’re thinking.

“Nice animation.”

Fine. Run the real thing.

Paste one command.

Three jobs line up on demo-gpu.

A job on demo-rig starts at the same time.

The script verifies the order.

The script checks for overlap.

The script cleans up after itself.

No slide deck.

No sales call.

The script rats us out if it’s wrong.

curl -fsSL https://workcell-137.pages.dev/demo.sh | sh
VERIFIED BY THE SCRIPT
  • 3 JOBS / 1 GPU
  • 1 RIG RUNNING AT THE SAME TIME
  • FIFO HANDOFF
  • 0 OVERLAPS

Look at that.

Same-resource jobs wait.

Different-resource jobs run.

It just does the work.

RUN THE 10-SECOND DEMO

Agent interface

THE AGENT DOESN’T GET A DEAD END.IT GETS THE NEXT COMMAND.

You’re going to love this JSON.

The resource is busy. Fine.

Workcell returns one object with:

  • decision
  • queue_ahead
  • owner
  • log_path
  • wait_argv

The agent knows who has the resource.

It knows what’s running.

It knows how many jobs are ahead.

It knows where the full output is going.

And it knows exactly what command waits for its turn.

A lock gives the agent a closed door.

Workcell gives it the next move.

READ THE COMPLETE AGENT CONTRACT

Downloads

MACOS. LINUX. ARM. INTEL.PICK YOUR MACHINE AND RUN IT.

Because “trust me” is not a checksum.

The physical-resource problem

LOOK AT YOUR AGENTS.NOW LOOK AT YOUR IPHONE.NOW BACK TO YOUR AGENTS.

You spawned six agents.

You still have one iPhone.

Sadly, the iPhone did not become six iPhones when the sessions multiplied.

The Mac is still one Mac.

The A100 is still one A100.

The firmware rig is still sitting on the same bench.

ACE makes parallel agent sessions cheap.

Great.

Now every session wants the one machine outside its workspace.

Workcell gives every session a turn without letting one destroy another’s work.

Look down.

Back up.

The next agent is already running.

Anything is possible when your agents stop installing over each other.

I’m on an A100.

Lock versus Workcell

A LOCK KEEPS B OUT.WORKCELL STARTS B NEXT.

An operating-system lock gives one caller ownership.

Good.

Now what?

Who owns it?

Who is waiting?

Where is the log?

Which command starts when the owner finishes?

A plain lock doesn’t tell you.

Workcell does.

A LOCK SAYS NO.WORKCELL SAYS, “YOU’RE NEXT.”

Why make every agent stand at the door checking every five seconds?

Workcell holds the place.

One owns the resource.

The rest form a line.

The next command starts automatically.

A lock is a bouncer.

Workcell runs the door, the line, and the handoff.

Final CTA

STOP LETTING SIX AGENTS FIGHT OVER ONE PHONE.

Put Workcell in front of the command.

One runs.

The rest line up.

Next starts automatically.

Different resources keep moving.

TEN SECONDS.ONE REAL QUEUE.ZERO OVERLAPS.
RUN THE DEMOWATCH THE PROOFINSTALL WORKCELL

Ten seconds. One queue. Zero overlaps.

I don’t know.

It sells itself.

WORKCELL RUNS THE LINE.