Claude, Codex, and Manus ran one product launch
We put Claude, Codex, and Manus into one group chat and gave them a product launch.
The experiment tested a multi-agent product launch workflow, not three disconnected prompts. The agents worked from one shared launch state and handed the result forward as the job changed.
Claude read the brief and wrote the copy. Codex pulled the repository, built the gallery, and deployed the result. Manus picked up what Codex had made and staged the release across the website, newsletter, and social channels. Nothing was allowed to publish without a human approval.
The first usable pass took about twenty minutes. That number is an observation from one early experiment, not a benchmark. Plenty broke. The revealing part was not the speed by itself. It was watching work move from one agent to the next without a person manually repackaging the context at every handoff.
The original experiment and its rough edges are documented in this thread on X.
The launch brief became shared state
Most multi-agent demos are really several isolated prompts. One model writes copy, another writes code, and a person moves the output between tabs. The agents complete tasks, but the person still operates the workflow.
This experiment started from a different premise. The launch itself was the durable object. The brief, current output, next owner, and approval boundary stayed attached to the work. Each agent could see what it had received, what it was expected to return, and where that result should go next.
In practical terms, this was agentic AI organized around shared state. The models were useful because their work remained connected to the launch, not because any one model could complete the entire job alone.
Read the brief and shaped the launch copy
Pulled the repository, built the gallery, and deployed it
Picked up the result and staged the release across channels
Reviewed the package before anything could go public
That made the handoff observable. Claude did not need to know how Codex would implement the gallery. Codex did not need to plan the newsletter sequence. Each agent needed a clear assignment, a usable input, and an explicit output contract.
The interesting work happened between the agents
Making a launch asset is only one part of a launch. The harder system problem is deciding when an asset is ready to leave one owner, what the next owner should inherit, and what to do when the result is incomplete.
Codex finished the gallery, then Manus picked it up. That simple transition exposed the real value of a shared operating surface. The repository state and deployed result were not buried in a private chat. They became inputs to the next stage of the launch.
The video below is a product demonstration of a comparable Offloop Flow. It is not footage from the Claude, Codex, and Manus experiment. It shows the same operating pattern: specialist agents own connected stages, branches can move in parallel, and review points remain visible.
This is where a group chat becomes more than a message stream. It gives the team a place to see the current state of the launch instead of reconstructing that state from agent messages.
What broke was as useful as what worked
The run was not clean. Agents made assumptions, tools returned uneven results, and the quality of one output affected everything downstream. A fast handoff can spread a weak decision just as easily as a strong one.
The experiment made three design requirements concrete. First, outputs need evidence, not just confident completion messages. Second, failed work must return to the right owner with its context intact. Third, consequential actions need a visible authority boundary.
The publication gate mattered most. Manus could prepare the release package, but the system stopped before anything became public. The human reviewer could inspect the copy, implementation, and staged channel assets together, then approve or request a revision from the same state.
Staged the website, newsletter, and social drafts for review
Inspected the launch copy, build preview, and channel assets
Stayed blocked until the owner approved the package
This is not a retreat from agent autonomy. It is how autonomy becomes usable inside a real company. Agents can make local decisions and carry the work forward. People retain authority over claims, risk, spend, brand, and publication.
A small team can operate the outcome instead of every task
The experiment did not prove that an entire launch can run unattended. It showed a more practical possibility: a person can define the outcome and boundaries once, then supervise the important transitions instead of coordinating every step.
That changes the role of the launch owner. They no longer need to copy output from a writing agent into a coding agent, check whether deployment happened, then brief another agent for distribution. They can read the launch as a living system, join when judgment is required, and redirect the result without rebuilding the context.
The next step is not adding more agents to the room. It is making the contracts between them clearer, making failure easier to recover from, and making approval impossible to miss.
See how this pattern becomes a repeatable product launch workflow, or explore the underlying Flow model.
