Code Overlord vs Conductor: agent workflows and workspaces

One instruction to Claude: have Codex implement the change, ask another agent to review it, correct the findings, run independent checks and get a final review. Setup, approvals and waits are shortened in this recording.

Watch the sidebar. Codex appears as a new session. The hierarchy shows it beneath the agent that called it. This is the coordinator creating its own worker.

I open Codex inside the same window. The implementation is ready, with thirty tests passing. The coordinator checks its result and moves the workflow forward.

Now a separate Claude reviewer joins the workspace. The coordinator sends it the review task. I switch back to the conversation, where both Claude sessions have their own tabs.

The review finds real issues in the keyboard handling and tests. Those findings go back to the original implementer through the coordinator.

Back in Codex, the requested corrections are complete and forty tests pass. The task stayed with its implementer; I did not copy the review between agents.

The coordinator creates another session for independent checks. Watch its tab appear alongside the reviewer. Each stage has its own agent and its own visible work.

The coordinator also created an independent checker. Here is its own session, confirming the test results and that the work remains uncommitted.

Back at the coordinator, here is Code Overlord’s completion message from the checker. The coordinator reads the result and sends the work into final review.

Final review catches one more keyboard-layout issue. The coordinator sends a precise correction back to Codex and keeps the reviewer ready to verify it.

Codex finishes that correction with forty-two passing tests. The completion returns to the coordinator, which starts a fresh check alongside final verification.

The reviewer confirms that all eight findings are fixed, forty-two tests pass, and the regression checks catch the broken versions. Its review is complete.

The fresh checker independently verifies the updated keyboard behavior and reports all five checks passed. Both the checker and reviewer have now finished.

The original coordinator brings the whole run together: implementation, review, corrections, checks and the final verdict. The changes are left here for my review.

Here is the completed team in its native hierarchy. One workflow instruction; real agents handling the handoffs. Everything stayed inside Code Overlord.

A product rarely lives in one repository. This prepared Ember Studio workspace contains an app and its website. Both appear in the file tree, while each keeps its own Git history. Now give the agents a job that crosses that boundary.

When launching Codex, the directory chooser offers both workspace folders. I choose app for the coordinator. Its working directory matters: the website worker will receive the other repository explicitly.

Directly in the agent terminal, I ask for an app inspection and an independent website inspection. Compare the saved-search behaviour with the public promise, write two reports, and add one shared Quill note. Keep the application code unchanged.

The completed result identifies both real sessions, their repository roots and unchanged Git commits. The app's sixteen tests pass. The reports agree that search survives a reload, and identify details the website could explain more clearly.

Open Summon and choose Ember Planning under Recent Strongholds. This is an actual workspace switch. The next project has its own folder and its own notes.

Here is Planning's repository, and its note about choosing a release date. The Studio review note is in Studio. Switching projects changes the context you see, so a planning task stays with its planning workspace.

Use Recent Strongholds again to return to Ember Studio. Waiting is cut from this film. Let's check the saved work after the switch.

The app report opens in Peruse, both repositories are back in the tree, and Studio's original note is visible again. The recorded repository identity and test results remain available to read.

The website report is here too, in its own repository. Give each agent an explicit working directory, coordinate work across the product, and switch to another workspace when the job changes. Each repository keeps its own commit boundary.

One tangle. Three worthy chronicles. Here in the real Code Overlord agent terminal, I ask for a commit plan before anything is staged. The working tree contains an empty-result fix, saved-search persistence, their tests, and an independent documentation update. The agent must inspect the actual diff and preserve every existing change. This is a demonstration repository; waiting between stages has been cut.

The agent proposes three groups from the actual changes. The filter fix stays with its six regression tests. Saved-search persistence stays with its seven application tests. The local-data documentation gets its own commit. These changes separate cleanly by file. When changes overlap inside a file, ask the agent to show and separate the relevant hunks before approving.

I approve those exact groups directly in the same terminal. The instruction names the order, keeps reports and local configuration outside the commits, and asks for the checks, commit contents, and a comparison with the reviewed working tree. The agent now performs the agreed Git operations.

Here are the three actual commit identifiers and the files in each commit. All sixteen tests pass. The file hashes confirm that the five committed files still match the contents we reviewed, and the remaining local files stay outside the commits. Nothing was pushed. A clear plan, an explicit instruction, and a result you can inspect: a fitting end to the tangle.