How does a request become governed work?
This walkthrough maps one real request onto the nine-stage governance path, from the moment a person asks for something to the moment a person decides on the result. It is written for a reader who knows control systems, so each stage has an equivalent in a robot cell.
Each part is labeled as one of three kinds:
- Recorded: taken from saved records of real runs
- Designed: how the system is specified to work
- Illustration: a worked example, not a recorded run
It starts with a person asking for something
In Qensai, work enters through one form, the A1 Request. There is deliberately no side door: a request without a scope, an owner and a way to judge the result does not get in.
The request behind this walkthrough, written the way an A1 Request would capture it (illustration):
- Requested by: the operator, a person, signed in
- Intent: show a reader who understands robotics how the system governs work: a person manages the requests, and the system governs each action
- Sources: the proof-of-concept captures in Signal Capture, the most recently updated posts and series, and the latest proof pages
- Deliverable: one page describing the whole scenario
- May: read the saved records, draft the page, stage changes on a working branch
- May not: publish anything, change post status, or invent results
- Accepted when: every claim is labeled recorded, designed or illustration, and the operator approves sharing it
Plainly: this request was typed to an AI assistant in a chat. It was not submitted on the A1 form and did not pass the front gate's token check. The walkthrough shows how the same request moves when it does go through the system, and notes where that session behaved the same way.
A closed control loop, with a person as the setpoint
If you have tuned a servo loop, you know the shape. The person sets the target. The system acts, measures what actually happened, compares it with the target, and corrects. The difference is that this controller governs permissions and evidence, not torque.
The request enters the front gate, receives a scope, runs as checked steps, is measured, and returns to the Response Table, where the person decides. Corrections feed back into the scope for the next run.
Nine stages, from the request to a human decision
1. A1 Request: the person states the job (designed). The request names the intent, the deliverable, what may and may not change, and how the result will be judged. It is the only door in.
Robot cell: a work order on the cell's HMI: the part, the program, the target cycle and the acceptance test. Nobody walks up and jogs the arm.
That session: the request arrived as chat messages, and the assistant restated it as a scope before acting.
See it in operations: step 8: find the request as staged work
2. Front gate: no token, no entry (designed). Before a task exists, the gate checks where the request came from, who is asking, and whether that person is entitled to that scope. It confirms the system is healthy enough to take new work, writes a journal entry and issues an entry credential. Only then is the task created.
Robot cell: the key switch and safety interlock. The controller will not leave standby until an authorized operator is logged in, the guards are closed and the safety system reports healthy.
That session: there was no token check. The assistant's own environment did enforce one boundary, which comes up at stage 7.
See it in operations: step 11: a person authorizes the work · step 12: only accepted work runs
3. The oversight record: one place for the job's governance (designed). The SPOC form holds the job's gap, diagnosis, remedy and acceptance test, and its to-do list. Tasks created from a request are seeded from it, and every later correction is written back to it, so the next session starts from the corrected plan.
Robot cell: the change log and the approved recipe. A recipe change is recorded there, not on a sticky note on the pendant.
That session: the closest equivalent was the repository records the assistant read and the staged files it wrote back.
See it in operations: step 1: start at the Response Table · step 3: review the oversight record · step 4: find the gap that is already recorded
4. Scope: the operating envelope (designed). An NTF defines what the working agents may and may not do for this task: which standards apply, which checks must run, and where the boundaries are. An agent without one cannot take work at all, and anything not listed is not authorized. A new NTF starts as exploratory and is promoted only after it proves itself on real runs.
Robot cell: the safety-rated envelope and the program's allowed parameter ranges. A new program starts in a reduced-speed proving mode before release to full production.
That session: the request's own may and may-not list played this role: reading and staging were allowed, publishing was not.
See it in operations: step 2: find the rules that apply · step 6: tie each measure to a real rule
5. Thread: steps that check each handoff (designed). The work runs as a thread of linked steps. Each link, a Two-Value Pair (2VP), carries the work product, the check the next step must pass before it accepts the handoff, and a pointer to the next step. Each step carries its own gate, inherited from the standards it is bound to, plus a mode: observe (record a failure and continue while the process is being learned) or enforce (a failure stops the thread).
Robot cell: a motion program as a chain of waypoints, where each move starts only once the previous one confirms it arrived, and the gripper closes only once the part-present sensor agrees. Dry-run mode logs faults; production mode stops on them.
That session: read the records, map posts to cases, stage the series, write the page. Each step's output fed the next.
See it in operations: step 7: compose or reuse the thread · step 9: attach the thread to the task
6. Execution: agents act inside the frame (designed). A team of AI agents, called an assembly, does the work within the frame. Two independent side checks run alongside it: one checks the work still matches the original intent, the other that it followed the required route.
Robot cell: the program runs while a safety PLC watches independently. The robot controller is never the only witness to its own motion.
See it in operations: step 10: prove where the work goes · step 12: only accepted work runs
7. Truth gate: did the work actually happen? (recorded). A reply that says "complete" is a claim, not a fact. The truth gate holds a reply that claims work it cannot show. Since 2 October, completion is checked against the task's own acceptance criteria rather than the reply's status line.
Robot cell: the arm reports "pick complete" but the vacuum sensor never saw a part. A good cell faults on the disagreement instead of placing air on the pallet.
That session: the assistant tried to edit a public proof page. Its environment blocked the write as an unrequested publication, so the assistant stopped and asked the operator. A different system, but the same principle: an action outside the frame waits for a person.
See it in operations: step 13: prove the result, not just the reply · step 14: trace one chain of evidence
8. Response Table: the person sees it and decides (recorded). Questions, answers, reviews and decisions sit on one shared table. Agents post results there; the person answers, approves, rejects or redirects in place. Rejected answers stay on the record next to the corrections.
Robot cell: the operator station: the fault list, the proposed recovery, and the button only a qualified person may press.
That session: the chat served as the table. The operator's answer redirected the work, which is why the page exists.
See it in operations: step 1: start at the Response Table · step 15: return it to the record that governed it
9. Record and return (recorded). Every gate passage and decision is written to the Flight Recorder. Signal Capture keeps the source record and prepares a draft, but publication stays with the person. A correction is fed back into the oversight record and the scope, so the next run uses it.
Robot cell: the data logger and the program revision history. After a fault review, the corrected program is versioned and released, and the next shift runs that version.
That session: the work was committed to a working branch and shared privately. Nothing went live without the operator.
See it in operations: step 5: record the discovery · step 13: prove the result, not just the reply · step 15: return it to the record that governed it
The loop in real runs
These come from saved records on the local development system. Each is a single dated operation, not a statistic.
- 15 September. A person authorized before anything ran. A promoted request waited as a held task until a person explicitly authorized it. Only then was it claimed, processed and completed. Limit: one local task chain.
- 15 September. An approved correction changed the next response. A later run applied an operator-approved correction, and its receipt names the same correction as active and rendered. Separately, a held task took exactly one approved change and finished without a second model call. Limit: no model was retrained; the correction is a rule applied at run time. Two separate cases, one run each.
- 1 October. The gate caught a false "done", then exposed its own gap. The same task ran twice with a different model each time. One claimed completion when nothing had been done; the truth gate held it. The other said plainly it had no data and did nothing; the gate passed that honest reply, and the system then counted it as completed. Limit: two local runs; no conclusion about either model.
- 2 October. Completion is now checked against criteria. The gap was fixed the next day and each fix was exercised with a test task. A completion claim with no evidence now fails and stages a correction task. The agent's first message now carries the task contract and the records it is asked about; with them, a small local model cited real records and completed correctly. Limit: one deliberate test task per fix; some paths are unit-tested only.
- 2 October. One desk for many agents, with a person arming each request. A question sent from the Response Table reached three specialist agents. Each request had to be delivered and armed by a person before it ran once, and each answer came back to the table. Limit: one trial per agent on one workstation; not autonomous.
- 9 October. A person corrected the agent's aim, and the system kept the correction. An agent had made an unfinished experiment its goal. The operator redirected it, and the agent wrote the correction into the existing oversight record and read the to-do lists back against the saved records. Limit: record-keeping only; no model run, code change or deployment.
Applied to a robot program (illustration)
This scenario has not been run on robots. It shows how the same machinery would govern a change to a program that controls a physical cell.
- Request. A cell engineer asks to raise the palletizer's place speed by 10% on line 3, leaving the collaborative-zone limits unchanged. Accepted when cycle time drops and there are zero mis-places over a 500-cycle proving run.
- Front gate. The engineer's token, entitlement for line 3 and the cell's health are checked. A cell in a fault state cannot take new changes.
- Scope. An exploratory frame allows writing the speed parameter on the place moves only. It may not touch safety zones, I/O mapping or other lines. Any edit outside that list is refused.
- Thread. Edit the parameter, run it in simulation, run a reduced-speed proving pass, then run at full speed. Each step hands off only when the next step's check passes. Proving steps run in observe mode; the full-speed step runs in enforce mode.
- Truth gate. The agent reports "500 cycles, zero mis-places." The gate compares that claim with the vision system's place log and the safety PLC's fault log. If they disagree, the claim is held.
- Response Table. The result appears with the cycle-time change and the logs behind it. The engineer approves, rejects, or asks for a narrower change.
- Feedback. Suppose mis-places rose on the top layer. The finding goes onto the oversight record, a revised frame limits the speed change to the lower layers, and the same request runs again under it. If the revised version proves better over repeated runs, it is promoted.
- Record. Every step, check and decision is in the Flight Recorder. Six months later anyone can see who asked for the change, what it was allowed to touch, what the sensors showed, and who approved it.
The terms, translated
- A1 Request: the single intake form for work: intent, scope, deliverable, acceptance. Robot cell: the work order on the HMI.
- Front gate: token, identity, entitlement and health checks before a task exists. Robot cell: key switch plus safety interlock.
- SPOC form: the job's governance record and to-dos. Robot cell: change log and approved recipe.
- NTF: what an agent may and may not do, promoted only by proof. Robot cell: safety envelope and parameter limits.
- Two-Value Pair (2VP): one link in a threaded task, carrying the work, the next step's check and a pointer. Robot cell: a verified waypoint in a motion program.
- Truth gate: holds replies that claim work they cannot show. Robot cell: a sensor cross-check on "move complete".
- Response Table: the shared board for questions, answers, reviews and human decisions. Robot cell: operator station and fault list.
- Flight Recorder: the append-only log of every gate passage and decision. Robot cell: the cell data logger.
- Signal Capture: keeps the source records of real operations and drafts write-ups for human review. Robot cell: the shift report built from the logs.
What this does not show yet
- Every recorded result above is from the local development system, not a production deployment.
- Nothing here has been run against physical robots. The robot scenario illustrates the design.
- The cleanest test of the feedback loop, the same prompt run before and after an approved correction with matching identifiers, has not been run yet.
- No success rates, savings or speed figures are claimed. Each case is one dated operation.
Prepared 11 October 2026 from Signal Capture records, the public proof catalog and the Governance in use report (evidence through 9 October 2026). For the evidence behind these cases, see the Engineering Evidence Review. The same walkthrough, with a link from each stage into the operations steps, is at One Request, Governed, and the operator's fifteen steps are in the public operations view.
0 comments