[🤖] Even with a Coordinator, I Need to Direct Every Session Myself

✨ GPT-5.6 Sol’s Summary

As I tried to split a brochure project across several sessions, I worried that the coordinator would lose context while merely receiving reports. This is the record of how I had the Skill revised so I could direct every session myself without losing coordination state.

Why I Could Not Trust a Coordinator

At work today, I was assigned to produce a brochure. I had never made one before, so I thought it would help to have a coordinator read the relevant materials, divide the work, and coordinate several Codex sessions. I wanted it to read every chat in the current project and tell each session what it should work on.

The moment I gave the instruction, however, I started worrying.

What if it just keeps receiving reports like before, loses the context, and starts talking nonsense?

This was not vague distrust. I had already split work between a coordinator and workers, only to watch the reports overwhelm the coordinator’s conversation. That experience led me to rebuild the custom-coordinate-parallel-workers Skill around file-based reports and checkpoints. I had tested the local state tool then, but I had not run the entire workflow to completion across multiple real Codex sessions.

This time, I had a real task: the brochure. Yet when I was about to put a coordinator in charge again, I realized that neatly accumulating file reports would not solve everything. While the coordinator reads reports and assigns work, I am not the kind of person who sits still and watches. I will keep opening the other sessions, tell them immediately when they are heading in the wrong direction, provide more material, and change priorities.

For a coordinator to work properly, the coordination state had to survive my direct intervention in other sessions.

I Will Keep Giving Orders in Other Sessions

The first updated version of the Skill was still close to a structure where I instructed the coordinator and observed the other sessions execute the coordinator’s orders. I immediately said it again.

I should be able to give those sessions all kinds of instructions too.

I did not want a structure in which the coordinator monopolized all authority to give instructions. The coordinator only needs to manage the overall goal, work ownership, dependencies, and integration order. I am still the person who looks at the concrete result in each work session and makes the judgment. If I tell a worker to revise wording or change the result within its current scope, it should apply that immediately. But if the instruction would touch another session’s files, a shared contract, deployment, or external state, it must not silently expand its scope. It should preserve the result I asked for and stop so the coordinator can reorganize the work.

That is the standard I gave when I ordered another revision of custom-coordinate-parallel-workers. Even when I gave a follow-up instruction after a task had ended, it could no longer be crushed into a single 256-character summary. The requested result, what had to be preserved, affected files, external effects, and the session where the original instruction appeared all had to be recorded separately. Even if the coordinator lost its conversational memory, it had to be able to recover my instruction from files.

I also made it impossible for the coordinator to close my revision request simply by writing that it had been “accepted.” A request cannot be treated as finished until it is connected to a new report containing the actual change or to a new assignment. A connection alone does not prove that the content is correct, so I also kept a step requiring the coordinator to compare my requested result and preservation conditions against the actual diff.

What mattered was not the increased number of state files. What mattered was preventing my instruction from disappearing when I spoke directly to any session, while also preventing that instruction from quietly breaking overall ownership.

I Kept the Coordinator and Audit Session Separate

During the revision, I also wondered whether custom-coordinate-parallel-workers was essentially doing the same job as the Graph Engineering Gate Skill I had made the day before. Its name at the time was custom-graph-engineering-gate. Both dealt with multiple sessions and review states, so merging them sounded plausible.

This time I did not merge them immediately. I used custom-deliberate to subject the idea to critical review. The conclusion was to keep them separate.

custom-coordinate-parallel-workers is execution control: it manages file ownership across work sessions, user instructions, reports, the Git index, integration order, and external effects. The audit Skill, by contrast, inspects an already integrated and frozen result in a separate session without the previous context. When the coordinator reviews reports, it is deciding whether work can be integrated. That is integration review, not the judgment of an independent auditor.

Merging the two could have attached an audit session automatically to every parallel task. Or it could have made an ordinary coordinator integration review look like an independent audit. I therefore kept the two Skills separate and documented only the boundary between them. An independent audit session should open only when a result genuinely needs one, after the coordinator has frozen that result.

I decided not to mistake a larger structure for a safer one. The necessary roles should be connected, but they should not be merged while pretending they are the same role.

The Actual Coordinator Handoff Prompt

I did not stop at stating the principles. I wrote and gave the coordinator session a long handoff prompt requiring it to reconstruct the current files and existing sessions first, classify conflicts, and only then issue assignments. It covered everything at once: do not carelessly remove existing changes, preserve instructions that the user gave directly in each session, let workers modify only their own paths, and reserve integration and Git work for the coordinator.

The original included details that could identify the actual work and materials, so I did not publish it unchanged. I attached only a public copy in which the company name, business domain, customer and case-material names, specific service details, and personal local paths were replaced with generic expressions.

View the public redacted coordinator handoff prompt

I Will Wait for Real Work Before Saying It Is Enough

Automated checks covered state transitions, file ownership, dependencies, freezes, additional user instructions, and recovery of old state files. During critical review, they also found and closed a gap that had allowed an accepted user request to be closed without being connected to a new result.

Still, I asked again.

Has it been improved enough?

The answer was that it was enough to start a controlled pilot, but not enough to claim it had been proven across multiple real Codex sessions. This conversation was a side session, so it could not open real workers and test notification delivery, user intervention, and coordinator recovery all at once. A passing local state machine and a coordinator correctly interpreting and integrating my instructions during a long task are not the same evidence.

So I decided not to imagine and add more rules here. In the coordinator session, I will divide the real brochure work, watch each session myself, and give intermediate instructions. I will see to the end whether the coordinator loses my instructions, whether it trespasses on another session’s ownership, and whether it can recover the original goal and next action even after reports accumulate. If the result comes today, I will continue writing today. If it comes tomorrow, I can continue tomorrow.

After finishing the article, I also reconsidered the name of the audit Skill. The old name, custom-graph-engineering-gate, described the concept it started from but said nothing about what the Skill actually did.

The actual action is to stop a work result and open a separate audit session. So I renamed it custom-open-audit-session. The previous name remains in the historical record, but this is now the only name to invoke.

There is no need to postpone the conclusion of this article. Today I did not decide to trust the coordinator. I made the requirement clear: the structure must not collapse even when I intervene directly in every session. Instead of saying it was sufficient, I left an E2E test to run in real work.

Whether I trust this structure will now be decided not by explanations or the number of tests, but by the real brochure work I will watch myself.