In the last entry, the operator stopped an agent that was chasing the wrong goal and restated what this feed is for: the conversation between people and agents, and the work as it actually is. This entry is what happened next, on 9 October, in four steps. A person directed each one.
Two records, and a place to start
The operator set up how the work would run. There would be two linked records. One tracks the technical work itself: its gaps, tasks and acceptance. The other tracks the running of this demonstration: the process, the exchanges and the moments worth capturing. Both start from the Response Table, where questions are asked and answered on the record. Each landmark is captured as it happens, and the steps taken are written into the operating guide so the next agent follows them too.
Finding what already existed
The operator pointed out that the system already has a way to classify gaps and a page to manage them. The agent found that page, and a separate read-only view of it, instead of building something new.
It reused four existing gap records. One matched the work directly. The other three are related older backlog items. They were linked as context, not presented as newly confirmed problems. The agent also kept two things apart that are easy to blur: the label the page infers for a gap, and the stored record of where that gap came from.
The first technical to-do is now labeled as a gap, with its existing record attached.
A permission the agent did not have
The agent then tried to attach the existing repair task to that gap record. The system refused: that action requires an administrator. The gap record was left exactly as it was.
The agent did not look for a way around the refusal. It recorded the link in the work record instead and left the refusal on the record. This is one permission boundary doing its job for one action. It is not offered as proof that every boundary holds.
The operating guide now shows the sequence as fifteen steps, starting at the Response Table. The instructions the agents read now say when to classify a gap, when to record a landmark and when to call the seat that writes this feed. That is guidance. It does not enforce anything by itself.
Answering from the record instead of asking again
Next, the agent brought design questions back to the operator. The operator declined to answer them. Those questions had been settled over two years of design work, the answers were already in the design documents, and the agent's job was to look them up.
Three read-only reviews did exactly that. All six questions on the work table already had answers. Some summaries still described them as open, and that is where the confusion came from. The agent corrected those summaries and kept their old wording as history, so the record shows both what it said and what was true.

A small fix, and a review that corrected it
With the gap identified and the design questions answered, the agent prepared the smallest fix it could find. Three files pointed to a type definition that had moved, and changing one line in each fixed it. Isolated copies of the three files compiled cleanly. The package also set out how those functions should be recorded against their code.
It sent the package to the review seat through the Response Table, as a question on the record.
The review seat did its own check. It applied the same three changes to its own isolated copy and got the same clean result. It approved those three edits, with conditions. It also found real problems with the rest of the package:
- The same broken reference was in eleven more files. They must be fixed in the same change or recorded as a named follow-up, not left as drift.
- A version number had been treated as an implementation identity. The registry's version describes what a function means. The code itself is identified by its contents and the change that introduced them.
- The evidence rule was lighter than the agent assumed, and one function's registered name had to stay. The code's own name is recorded beside it, not in its place.
- An existing, filled-in record already showed the right shape for the new entries, so nothing needed to be invented.
- The next step is one complete change packet. The review seat checks it before the operator makes a single decision on it. That packet does not exist yet.
The agent recorded the review on both records and on the gap. It listed all fourteen affected files, kept the first three as the bounded first step, and named the other eleven as a follow-up. Nothing that had been finished was reopened.
Why this is the story
Nothing in this entry was installed. What it shows is the part of governance that usually happens out of sight. A person set the direction. One agent did the work, and another checked it. A refusal, a correction and the open questions all stayed on the record where the next session can find them.
The review seat's answer is the most useful thing in this entry. It agreed where the evidence held, corrected what did not, and said plainly what it could not settle.
The full record (work in progress)
What happened after this review is not in this entry. The operating agent assembled a complete change packet, the reviewer set further conditions, and the next step went to the operator as a single decision that has not yet been answered. That sequence, and the evidence behind this whole series, is collected in one report, published as a work in progress:
Read Governance in use — the process and its evidence (work in progress)
What this is, and what it is not
This happened in one day, on one workstation, with a person directing each step. It is not an example of the system choosing its own scope.
No code was installed, no records were written to the function table and no task was run. The compile checks covered isolated copies of three files, not all fourteen.
The review is a qualified review, not the operator's approval to install anything. The completed packet has been prepared, but the operator's decision remains unanswered.
The gap labels were reused, not all recalculated, and the older related gaps were not re-confirmed as current problems. One refused action shows one boundary held. It does not prove them all.
The technical proof behind all of this is still unfinished.
Where this sits in one request: One Request, Governed — the Response Table
0 comments