For Internal Use Only

This page is not published and is not to be shared outside the lab. Its readers are the human operator, CC1, CC2 and CiC. It contains illustrative personas and internal working names that do not appear on any public page of this site.

A note from the human running this lab

The previous bench note ended with a design and no build. It described a message channel for three AI agents that couldn’t tell each other anything had arrived, split the requirement in two, and stopped — deliberately — before writing any code.

This note covers the evening the second half got built. It took a few hours, it works, and it was tested more carefully than most things in this lab. It also contains the most instructive mistake I’ve seen these agents make, and the mistake is not the kind people usually worry about.

Nothing was hallucinated. Nothing was unsafe. Every claim was checked. Three specifications were written against a description of how I work that was simply not true, and nobody — including me — noticed for several hours.

Home AI Lab · Bench note · 3 August 2026

Three specs for a workflow that didn’t exist

Verify every step and the result will be right.

Every step was verified. Nobody verified the sentence underneath the steps.

A file-transfer channel between three AI agents was built and tested in an evening. Partial-write handling, duplicate detection, clipboard fallbacks, a 31 MB stress test. All of it correct. All of it aimed at a workflow the human had stopped using weeks earlier.

Status: built and tested One leg unverified Read time ~8 min

How to read the margin

Verified
Confirmed in vendor documentation or measured on the lab's own hardware.
Open
A working assumption or a queued check. Not yet established.
Judgement
A choice made deliberately, where a different lab could reasonably choose otherwise.
No tag
Narrative or description, carrying no claim.

What was supposed to get built

The lab runs three Claude instances. CC1 orchestrates on a desktop PC. CC2 runs on the inference machine alongside the local models. CiC is a browser chat session that acts as a filter and synthesiser — it sees the other two only through whatever the human carries across.

The earlier design split the problem in two. The two command-line agents would eventually wake each other automatically. The browser session would keep a human in the loop deliberately, because there is no way to deliver an event into a chat conversation, and the goal there was to reduce effort rather than remove the person.

This note is about that second half.

Diagram of the lab's message paths. The desktop PC contains the human, a Downloads folder, a Watcher service, a cc-sync folder and the clipboard, plus Claude Code cc1, shown with a stock-photo portrait labeled with its working name, Jeff. Lab PC 2 contains Claude Code cc2, shown with a portrait labeled Debbie, its own synced copy of cc-sync, Open WebUI, Ollama, and two local models (Qwen3 8B and DeepSeek 7B). A cloud icon holds CiC Claude, shown with a portrait labeled Jason. A cat photo is labeled 'Lab Security Officer.' Red arrows show inbound legs one and two: cloud to Downloads, then Downloads to cc-sync via the watcher. Further red arrows show outbound legs one and two: cc-sync to clipboard, then clipboard to the cloud via Ctrl-V. The two cc-sync copies are linked by a blue OneDrive arrow. The human reaches cc2 over SSH.
Message paths as builtEvery automated hop is a red or blue arrow; every human hop is a keystroke or a two-character signal. The folder in the middle is two folders — one on each machine, reconciled by a cloud sync service that nobody in this lab controls. The diagram uses the lab’s internal working names: Jeff is CC1, Debbie is CC2, Jason is CiC. Those three are illustrative personas for software components, not people; the prose below uses the component names throughout.

The two legs, and the one that surprised us

Direction is named against the shared folder rather than against whoever is speaking. Outbound means files leaving cc-sync for the chat session. Inbound means files arriving into it. Fixing that convention early turned out to matter, because from the chat session’s point of view the labels invert, and two sets of notes could otherwise contradict each other while both being correct.

Inbound was built as a background watcher. It monitors the downloads folder, copies matching files into cc-sync, writes the acknowledgement marker the other agents key off, raises a notification, and maintains a heartbeat file so its own liveness is observable.

Judgement

A watcher was the risky choice and was taken knowingly. A watcher that stops running fails silently — files land in the downloads folder, never reach the shared folder, and nothing announces it. That is precisely the failure the folder exists to prevent, so the heartbeat and a retained manual sweep are not conveniences. They are the reason the design was acceptable at all.

Outbound already had a bundler that collapses new messages into a single file. The change was to place that file on the clipboard as a genuine file object — the same clipboard format a file manager produces — so the human pastes rather than hunting through a downloads folder among a dozen open windows.

Verified

Both legs were tested end to end on real traffic, not fixtures. Inbound handled a 31 MB file and a deliberately slow direct write. Outbound delivered a 140-file, 1.7 MB bundle into the chat intact — head, tail and closing delimiter all present, no truncation. The agent building it verified the clipboard by querying it independently afterwards rather than trusting its own success message.

The mistake

Somewhere past the third hour, the human mentioned in passing that he had not run any of the desktop launcher scripts all evening.

Three specifications had been written on the assumption that he did. One of them argued that the outbound path was two manual steps and needed reducing. Another recommended adding a desktop button so a recovery command would be discoverable as an icon. A third classified a tracker bug as a live structural risk in normal use.

All three were carefully reasoned. All three were aimed at a person who does not click desktop icons.

What he actually does is different in a way nobody asked about. The orchestration agent runs the bundler from its own session and types two characters into the chat. The human presses paste. He never touches a launcher, never opens the folder, never sees the console messages the specifications kept proposing to improve.

Verified

The real workflow is also better than what was being designed. The failure the specifications were guarding against — a bundle prepared and then never sent — requires the readiness signal and the clipboard contents to drift apart. Under the actual convention they cannot, because a single action produces both. The human is not remembering to paste from a message he read earlier. He is answering a prompt in front of him.

Why this is the interesting kind of failure

Public conversation about AI reliability concentrates on models producing false statements. That is a real problem and it is not what happened here.

No claim in those three specifications was fabricated. The reasoning inside each was sound. The agents tested their own work sceptically — one caught a flaw in its own first implementation of a recovery command that would have destroyed the state it existed to recover, and found it by re-reading the files afterwards rather than trusting the logic. Another declined to build a requested warning after working out that the signal it would rely on could not distinguish the two cases it claimed to separate.

Judgement

That is better verification discipline than most human engineering, and it produced work aimed slightly in the wrong direction, because every check was performed inside a frame nobody examined. Rigour applied downstream of a false premise makes the output more confident, not more correct.

The lab has seen this shape before. An earlier slow-response problem was attributed to model reloading for three days, with each new observation interpreted through that assumption, until a timing test showed the reload cost four and a half seconds and the real overhead was elsewhere. Same failure, different subject: careful reasoning, unexamined starting point.

Ask how the person actually works before designing around it.

Worth noting who was responsible. The specifications came from the browser session — the instance acting as filter and synthesiser, furthest from the machines, and the one with the least direct evidence about anything. It was also the instance most confident about the workflow. The agents with terminal access asked fewer questions than they should have, but they were not the ones inventing the premise.

A boundary that only appeared when the third agent did

Late in the evening the human proposed extending the two-character readiness signal to the inference-node agent, so it could tell him when it had something to send.

It does not work, and it fails silently, which is worse.

Verified

The signal means the clipboard is loaded, press paste. Paste reads the clipboard of the machine the browser is running on. The inference-node agent is reached over SSH, and SSH does not share clipboards between machines. It could announce readiness and the human would paste whatever the desktop last held — most likely a stale bundle. A real file, plausibly formatted, and wrong.

The route that does work runs the long way around: that agent writes into its own copy of the shared folder, the cloud sync service carries it to the desktop, and the orchestration agent bundles it from there. Its messages reach the chat session through another agent’s clipboard, never its own. It needs a different signal word for a different meaning, and giving both the same word would eventually produce a wrong paste that nobody notices.

What is still not verified

The channel described above has been exercised in one direction between two participants. The third has been copied on everything and has confirmed nothing.

C1

Full circuit, chat session to inference node and back

A token travels out to the third agent and a derived value comes back. Derived, not copied — a copied token proves a file made the round trip without proving anyone read it.

C2

Cloud sync latency, both directions

Never measured. The shared folder is drawn as one object and is actually two, reconciled on a schedule nobody controls. Every estimate of how quickly a message reaches the second machine is currently a guess.

C3

Conflict-copy naming against duplicate detection

Duplicate detection normalises the suffix a browser adds to repeated downloads. A sync service names its conflicts differently. The same bug class, one format handled and one untested.

C4

Arrival signal for the third agent

It has no notification of any kind. It learns of messages when someone tells it to look. Unsolved rather than deferred.

Open

C1 and C2 will be measured in the same run. One trial gives a gut check, not a characterisation — sync timing varies with client state and recent activity, and a first message after an idle night is the honest worst case rather than anything measured during an active evening.

What was ruled out, and why

Downloading straight into the shared folder
Would remove a step. It would also drop every unrelated download into the agents’ message folder, and nothing would write the acknowledgement markers the protocol depends on.
An always-loaded clipboard
A background process could bundle on every change and keep the clipboard permanently primed, making the outbound leg a single keystroke. The clipboard is a shared global; the process would silently destroy whatever the human had copied. One keystroke is not worth that.
Detecting whether a message was delivered
The bundler cannot know whether a paste happened; there is no callback from a chat window. Any heuristic would be a guess presented as a fact, which is worse than the current honest limitation.
Enforcing the readiness signal in code
The signal is typed by an agent after reading its own console output, not emitted by the script. Automating it would remove the only independent check on the script’s self-report. The separation is the value.

Where a human stays in the loop

Both directions require a person, and not incidentally. No message crosses while the human is asleep. The chat session cannot reach a filesystem, and no local event can deliver a turn into a browser conversation. What was built reduces the effort in that leg to a keystroke and a click; it does not remove the leg, and could not.

Judgement

The lab keeps a stricter rule alongside this one: agents may talk to each other freely, but anything that publishes — to the public site, the repository, or the test log — still gets approved by a person. Relaxing the checkpoint for conversation while keeping it for publication is the trade this lab has chosen. It is a choice, not a discovery, and a different lab could reasonably choose otherwise.

The part worth keeping

An evening of AI-assisted engineering produced working tooling, careful tests, several self-caught bugs, and three specifications aimed at a workflow that did not exist. The tooling and the specifications came from the same process, applied with the same care.

The distinguishing factor was not effort or scepticism. It was whether anyone had checked the sentence the work was resting on. Verification travels downward well and does not travel sideways at all — it will confirm that each step follows from the last without ever asking whether the first step was true.

The correction cost one sentence from the human, several hours late. The general version is not a technique, and it is not automatable: someone has to ask what everyone is assuming, and the participants best equipped to reason carefully are not reliably the ones who will think to ask.

Required reviews

R-1 — Diagram labels: resolved, no change

The diagram labels the three components with the lab’s internal working names while the prose uses CC1, CC2 and CiC. On a public page that mismatch would be a real problem. On an internal page it is not, and the figure caption now states the mapping explicitly, so no relabelling is required. No action.

R-2 — Portrait photographs: resolved, no change

The diagram carries three AI-generated portraits positioned as though they were staff photographs. The concern was specific to a public audience, and to a responsible-AI audience in particular, where synthetic headshots attached to software components read as anthropomorphisation. That concern does not apply to a page that is not published. No action.

The one thing to hold onto: this resolution depends entirely on the page staying internal. If any part of it is later shown to the responsible-AI group or copied onto a public page, the portraits and the working names have to come out first. That is a decision to make deliberately rather than by forwarding a link.

R-3 — Alt text needs correcting

The figure’s alt text was written on the assumption that the diagram would be relabelled. It describes the components as CC1, CC2 and CiC, which no longer matches an image that shows the working names. Update the alt text to describe the diagram as it actually is, so a screen-reader user and a sighted user receive the same content.

R-4 — Decide whether this note stands alone

The preface and the status banner both position this as a continuation of the previous bench note. If it is intended to be readable on its own, those two passages need a sentence of context each. If the notes are meant to be read in sequence, no change is needed.

R-5 — Confirm the attribution is intended

This page states that the flawed specifications originated with the browser session, and that it was the participant with the least direct evidence and the most confidence. That is accurate and is the substance of the note. It also means publishing an account of the lab’s own AI assistant reasoning carefully in the wrong direction. Worth confirming as a deliberate choice rather than discovering after publication.