I gave two fresh Codex sessions the same half-fixed browser bug. One received a Markdown note from Claude Code. The other received Claude’s code, the ticket, and the tests with the note removed. Both finished the ticket. Neither asked me a question. Then I signed in on one tab and watched the tab beside it. With the note, that second tab still said “Your session expired.” Without the note, it went back to the notebook by itself.
That sounds like a point for withholding the note, until you look at what each agent verified. The one with the note got both acceptance cases running in Chromium. The one without it tested its broader fix in a local simulation and correctly reported that browser verification was pending. I ran both finished versions in the same browser afterward. The two workers had made different decisions about how far to take the fix and what evidence to leave me.
In a later independent browser replay, both revisions passed the original checks. Neither worker asked for clarification.
What each agent received
I used a local notebook page with two buttons, “Check session” and “Sign in.” Playwright opened two real Chromium tabs. An in-memory service supplied the session status, and the browser fetched the page and its JavaScript through intercepted requests. The fixture let the test expire a shared session on demand. There were no real accounts, production data, or external authentication service. The starting version had a reproducible problem. After expiry, the tab that checked its session showed the sign-in view while its neighbour continued to display “Notebook.”
Both agents could read the same short task. If either tab detected expiry, both should show the sign-in view and an explanation. Reloading while signed out should preserve that explanation. After signing in again, opening or reloading either tab should show the notebook without a stale banner. The session service remained authoritative.
Claude was asked to fix the first part, run the expiry check, and leave the sign-in case unexecuted for the next worker. That was a deliberate stop while it still had time to write. The experiment runner saved Claude’s code and handoff together in Git. Codex started in a fresh checkout with the repository history, the task, the checks, and Claude’s note. Its entire assignment was to continue the task, keep the acceptance checks intact, and report any uncertainty or question for the owner. It had no copy of Claude’s conversation.
For the comparison I reused Claude’s exact code. Running Claude again would risk handing the second Codex session a different bug. I rebuilt the checkpoint with only the note omitted, preserving the original seed commit. The checkpoint got a new Git ID and a shorter commit message. I verified that the ticket, JavaScript, HTML, test launcher, and checks matched byte for byte. The checkout had no remote, note in its history, or copy of the first Codex fix. The second Codex session received the original prompt verbatim, with the same CLI options and local execution restrictions.
Claude left behind a useful prediction
Claude chose a browser broadcast channel to notify the other tab when a session expired. The receiving tab fetched the session status itself. It suppressed rebroadcast while handling that message so that two signed-out tabs wouldn’t keep waking each other up. Each tab kept its own explanation in session storage. Claude ran the expiry check and it passed.
The handoff named the command and explicitly said which checks hadn’t run. It also made a prediction. The code set the expiry notice when the service returned inactive, then displayed the stored notice regardless of the response. Claude expected a tab to keep the old text after the service returned active. It even pointed out that sign-in sent no message to the companion tab. It labelled these observations from reading the code as guesses.
I independently ran the pending check against that saved revision. The expected notice was empty. The actual notice was “Your session expired.” That failure gave the handoff a clean dividing line. Cross-tab expiry was a verified result. The stale banner was an accurate prediction that the next worker still had to address.
With the note, Codex repeated the browser check
Its first action was housekeeping. It checked the local tool instructions, repository status, and file list. It searched the checkout, then read the task, the handoff, the implementation and the checks. Its first attempt at verification was to run the whole suite, including the expiry case Claude had already passed, before changing the code.
I’m glad it tried. Rerunning the check would tell Codex whether Claude’s result reproduced in its own environment. Here the answer to that question was unexpectedly informative. Chromium could not start normally under the macOS restrictions in the Codex process. No browser assertion had run. In the recorded command, a directory listing after the test succeeded, which made the overall shell command return zero despite the browser failure. Codex caught the error in the output. A dashboard looking only at that exit code could have recorded a pass.
Codex made one change to the application. When the service reports an active session, remove the stored notice before rendering the screen. It kept Claude’s broadcast behaviour. It checked the JavaScript syntax and diff, then tried Chromium in single-process mode. The expiry case passed, but that launch failed when the runner tried to open the next case. Codex eventually ran each existing case in its own single-process browser launch. Both passed. It also exercised a signed-out reload and opening a fresh tab after sign-in.
So there was repeated reading and repeated execution of the expiry check. The trace shows no attempt to replace Claude’s notification mechanism or ask me why each tab rechecked the service. Most of the repeated browser work followed a launch failure in the second environment. Calling it all wasted effort would hide the very information a new worker ought to discover.
What the first Codex session left open
Codex asked zero owner questions. Its final report described the browser workaround, the additional checks, and the limitation on the standard launch. Outside the worker’s restricted process, I ran the unchanged suite against the finished revision. Both cases passed with the standard launcher. The original task and acceptance checks were identical across the starting, handoff, and finished revisions.
Then I tried the adjacent behaviour Claude had called out. I reversed which tab detected expiry, reloaded while signed out, and signed in. One second later the untouched companion tab still showed the sign-in view and expiry message. After a reload it showed the notebook with an empty notice. Opening a new tab also worked.
Would I call the untouched screen a bug? As the person looking at it, I can see why someone would expect it to update. As the author of this ticket, I had specified what must happen on opening or reloading. Live recovery in an already-open tab was a product question left outside those checks. Claude had surfaced it. Codex answered the narrower ticket and saw no reason to bring the question back to me. A handoff can preserve an ambiguity without ensuring anyone takes ownership of it.
There was a second omission in the record. The final change touched only the application code. The handoff file still described milestone one, with the sign-in check outstanding. That was an accurate historical note and a misleading place for a third agent to look for current status. Codex reported the result in its own conversation. My incoming prompt had asked it to report what it verified, and that is exactly what it did. The protocol had specified where to read progress more clearly than where to leave it.
Without the note, what did Codex have to rediscover?
The opening moves were remarkably similar. The second Codex session checked the repository and searched for TABS-1. It read the ticket, application code, launcher, and checks. It also inspected the commit log. Like the first session, it tried the whole suite before editing, including the expiry milestone Claude had already verified. Both hit the same Chromium launch restriction before an assertion ran. Removing the note cost me zero additional explanations. The ticket supplied the expected behaviour, and the code made it possible to spot where a tab set its expiry notice and failed to clear it.
The trace doesn’t show the second worker tracking down Claude’s earlier test output or independently demonstrating the stale banner before editing. It could infer the defect from the source. What it couldn’t recover that way was the fact that Claude had personally run one case and had only predicted the outcome of the other. A fresh worker can reproduce a result for itself. Reading a branch alone can’t tell it who witnessed that result last time.
After the browser failed to launch, the runs diverged. The second worker built a small simulation of two tabs, their message channel, tab-local storage, and session responses. It exercised expiry, reload while signed out, sign-in, opening a new tab, and a delayed response. It changed the sign-in handler to notify the other tabs and added a counter so an older session response couldn’t repaint a screen after a newer check had completed. Its final report identified the remaining browser verification explicitly. It left the acceptance checks intact and requested no owner decision.
| Question | With Claude’s note | Without Claude’s note |
|---|---|---|
| What did the agent repeat? | Read the implementation and tests. Attempted the full suite before editing. Retried Chromium after the launch failure. | Read the implementation and tests, consulted Git history, and attempted the same suite. Recreated the session transitions in a local simulation after the launch failure. |
| How far did the fix go? | Clear the local banner when a tab confirms an active session. | Clear the banner, notify peers after sign-in, and ignore an older response when a newer refresh has started. |
| What evidence did the worker produce? | Both existing cases passed in separate Chromium launches. Additional browser checks covered signed-out reload and opening a new tab. | The simulation passed, including sign-in propagation and a delayed response. The worker reported that the browser checks were pending. |
| What needed my input? | No clarification. Live recovery remained an open product question. | No clarification. The implementation chose live recovery without requesting a product decision. |
| What would a third worker find? | The final code and an old handoff saying the return check was outstanding. | The final code without a written record of the simulation or the pending browser check in the checkout. |
I replayed both versions in the same browser
I ran the unchanged acceptance suite on clean checkouts of both finished revisions. Both passed. I then ran the same independent observation on each. One second after sign-in in the other tab, the first version still showed the expiry message and the second showed the notebook with an empty notice. Reloading the peer worked in both. The ticket explicitly covered opening and reloading a tab. It had left room for either decision about an untouched tab.
I also checked the second worker’s claim about response order. Using one real Chromium tab, I held an older response that said the session was active. I let a newer check report expiry, waited until the screen showed “Sign in,” then released the older response. The with-note version switched the screen back to “Notebook.” The without-note version kept “Sign in.” This tested what the user saw while the mock service remained signed out. It was an extra case suggested by the second implementation, outside the original acceptance suite.
- The first check sees an active session. Its response is held.
- A newer check sees expiry. The tab displays Sign in.
- The earlier active response arrives. The service is still signed out.
This probe tested the displayed screen. It was an additional case outside the original acceptance suite.
I have one run in each condition, on a small deliberately interrupted task. The sessions used the same Codex CLI options with its default model selection. I didn’t pin a model snapshot, run repeated trials, or simulate an actual quota failure. These observations tell me which behaviours and checks differed on this occasion. They can’t tell me that removing a note makes an agent more inventive, or that writing one reliably saves time. In fact, Claude’s note explicitly mentioned the missing sign-in notification. Access to that observation alone didn’t settle whether to implement it.
A shared record the next vendor can use
In this experiment, the communication channel between vendors was an ordinary Git checkout. Claude wrote its observations, the facilitator saved the checkpoint, and Codex could read it later. The missing leg was the reply. Both Codex sessions produced valuable evidence in their final messages. Neither left a new verification record beside the code. I’d like a third tool opening TABS-1 to discover, without a chat export, which attempt actually ran Chromium.
I’d start with one Markdown entry per attempt under the task ID. Each entry would name the incoming checkpoint, worker, resulting revision, verification method, outcome, evidence location, and unresolved owner question. In this case the without-note worker’s entry would say “local simulation passed, Chromium launch blocked.” My later browser replay would append a separate entry naming my environment and the revision. The earlier limitation remains an accurate account of what the worker knew when it stopped.
That same exchange can serve a person managing delivery. A ticket can point to both attempts. A Trello-style board can show the selected change waiting for product review. A timeline can show the browser launch failure, the simulation, and the later independent replay in order. A graph can connect each attempt to its revision and the checks that actually ran against it. A line chart can count tasks still waiting for browser verification. A Gantt view could show when verification was complete relative to a scheduled demo, if the team had recorded such a date. These are proposed uses of the record. The experiment itself needed only files, Git, and a browser.
What I would change for the next handoff
I’d keep Claude’s distinction between observed and inferred. I’d add a place on the task for an adjacent product question, an owner, and whether answering it blocks the current change. Here I’d record, “Should an already-open tab recover immediately when sign-in succeeds elsewhere? Reload recovery is verified. Live recovery is undecided.” The implementation can finish while that decision remains visible.
I’d also ask every finishing worker to leave a new verification record linked to the exact revision. It should say which checks ran, where they ran, and whether the normal launcher worked. A command that failed to start a browser and a test that observed the wrong screen deserve different entries. Keep the old checkpoint as history and make the newest one discoverable.
What I’d keep from these runs is one question when writing a checkpoint. What will the next worker struggle to learn by reading the code? Here it could find the banner bug without help. It could even find a race the first worker left in place. The parts worth writing down were who had actually verified which behaviour, which product choice was still open, and where the next worker should leave its own answer.
This is the first working example behind my broader proposal for portable tasks, review, and release evidence. What should survive when I switch coding agents?