One Request, Governed

Qensai · How governance works · 11 October 2026

One request, governed from the front gate to the finished page

A walk through how Qensai handles a request: a person asks, the system lets the request in, bounds what may happen, checks each step, and returns the result for a human decision. The example is the request that produced this page. Each stage also has its equivalent in a robot cell.

Recordedtaken from saved records of real runs
Designedhow the system is specified to work
Illustrationa worked example, not a recorded run

The request

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. Here is the request behind this page, written the way an A1 Request would capture it.

A1 Request · Governance walkthrough pageIllustration
Requested by
The operator (a person, signed in)
Intent
Show a family member who understands robotics how our 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 on the site
Deliverable
One HTML page describing the whole scenario
May
Read the saved records, draft the page, stage changes on a working branch
May not
Publish anything public, change post status, or invent results
Accepted when
Every claim on the page is labelled recorded, designed or illustration, and the operator approves sharing it

PlainlyThis request was typed to an AI assistant in a chat, not submitted on the A1 form, and it did not pass the front gate’s token check. The page shows how the same request moves when it does go through the system, and points out where today’s session behaved the same way.

The shape of it

A closed control loop, with a person as the setpoint

If you have tuned a servo loop, you already 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 the controller here governs permissions and evidence, not torque.

Governance as a control loop The person's 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. Person A1 Request Front gate token + identity Scope (NTF) may / may not Thread (2VP) checked steps Measure truth gate, record Response Table the person sees the result and decides Oversight record (SPOC) correction written down, scope revised feedback: next run new request

The signal path

Nine stages, from the request to a human decision

Each stage gives the system’s term, what it does, its robot-cell equivalent, and what happened in this session.

  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 cellA 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.

    This session: the request arrived as chat messages. 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, then writes a journal entry and issues an entry credential. Only after that is the task created.

    Robot cellThe 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.

    Illustration This session: there was no Qensai token check. The assistant’s own environment did enforce one boundary, which comes up again at stage 7.

    See it in operations: step 11: a person authorizes the work · step 12: only accepted work runs · operator diagram: how a card becomes a governed task

  3. Oversight record (SPOC form): one place for the job’s governance

    Designed

    The Synapse Protocol Oversight Cortex (SPOC) form holds the job’s gap, diagnosis, remedy and acceptance test, and its list of to-dos. Tasks created from an A1 Request are seeded from it, and every later correction is written back to it, so the next session starts from the corrected plan.

    Robot cellThe cell’s change log and its approved recipe. If the recipe changes, the change is recorded there, not on a sticky note on the pendant.

    This session: the closest equivalent is 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 already on record · What is a SPOC form? · operator diagram: how the oversight form is graded

  4. Scope (NTF): the operating envelope

    Designed

    A Named Type Frame (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 an NTF cannot take work at all; anything not listed is not authorized. A new NTF starts as exploratory and is promoted to provisional and then finite only after it proves itself on real runs.

    Nodes That Float is usage talk: drop an NTF into an agent chat to steer the agent; parts or combinations can be used on a threaded task when needed.

    Robot cellThe safety-rated envelope and the program’s allowed parameter ranges: reach limits, speed limits in collaborative zones, which I/O the program may write. A new program starts in a reduced-speed proving mode before it is released to full production.

    Illustration This session: the request’s own “may / may not” list played this role: read and stage 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 · operator diagram: how a new frame is added

  5. Thread (2VP): 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 cellA motion program as a chain of waypoints, where each move only starts once the previous one confirms it arrived, and the gripper only closes once the part-present sensor agrees. Dry-run mode logs faults; production mode stops on them.

    Illustration This 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 the thread · step 9: attach it to the task · operator diagram: how the 2VP links screens to records

  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 checks it followed the required route.

    Robot cellThe 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, and since 2 October, completion is checked against the task’s own acceptance criteria rather than the reply’s status line.

    Robot cellThe 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.

    Illustration Different-system example: the assistant tried to edit the public proof page. Its environment blocked that write as an unrequested public publication, so the assistant stopped and asked the operator. This is not part of the recorded truth-gate run; it illustrates the same principle that 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 their results there; the person answers, approves, rejects or redirects in place. Rejected answers stay on the record next to the corrections.

    Robot cellThe operator station: the fault list, the proposed recovery, and the button only a qualified person may press.

    This session: the chat served as the table. The operator answered “No, I need to confirm…” and redirected the work, which is why this page exists.

    See it in operations: step 1: start at the Response Table · step 15: return it to the record that governed it · annotated guide: how the Response Table is laid out

  9. Record and return: Flight Recorder and Signal Capture

    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 cellThe 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.

    Illustration This session: the series plan and scripts were committed to a working branch. This page later became public only after a separate human release decision.

    See it in operations: step 13: prove the result · step 15: return it to the record · What is the Flight Recorder? · Signal Capture, walked through as a family request

What has actually been recorded

The loop in real runs

These are from Qensai’s saved records, on the local development system. Each one is a single dated operation, not a statistic.

Recorded15 Sep 2026

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, authenticated.

Recorded15 Sep 2026

An approved correction changed the next response

An operator-approved correction was applied by a later run, and that run’s 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 governance rule applied at run time. Two separate cases, one run each.

Recorded1 Oct 2026

The gate caught a false “done”, then exposed its own gap

The same task ran twice with a different model each time. One model claimed the work was complete when nothing had been done; the truth gate held it and stopped the chain. 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.

Recorded2 Oct 2026

The feedback loop closed: completion 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.

Recorded2 Oct 2026

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 both delivered and armed by a person before it ran once. Each answer came back to the table.

Limit: one trial per agent on one workstation; not autonomous.

Recorded9 Oct 2026

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. The agent wrote the correction into the existing oversight record, linked the related reports without relabelling them, 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

A worked scenario: changing a palletizing program

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.

Illustration
  1. Request. A cell engineer submits an A1 Request: 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.

  2. 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.

  3. Scope. An exploratory NTF 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.

  4. Thread. The 2VP thread runs: 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. The proving steps run in observe mode; the full-speed step runs in enforce mode.

  5. 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.

  6. Response Table. The result appears on the table with the cycle-time change and the logs behind it. The engineer approves, rejects, or asks for a narrower change.

  7. Feedback. Suppose mis-places rose on the top layer. The finding goes onto the oversight record, a revised NTF 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 from exploratory to provisional.

  8. 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.

Glossary

The terms, translated

Qensai termWhat it isRobot-cell equivalent
A1 RequestThe single intake form for work: intent, scope, deliverable, acceptanceWork order on the HMI
Front gateToken, identity, entitlement and health checks before a task existsKey switch plus safety interlock
SPOC formSynapse Protocol Oversight Cortex: the job’s governance record and to-dosChange log and approved recipe
NTFNamed Type Frame: what an agent may and may not do, promoted only by proofSafety envelope and parameter limits
2VPTwo-Value Pair: one link in a threaded task, carrying work, next-step check and pointerVerified waypoint in a motion program
Truth gateHolds replies that claim work they cannot showSensor cross-check on “move complete”
Response TableShared board for questions, answers, reviews and human decisionsOperator station and fault list
Flight RecorderAppend-only log of every gate passage and decisionCell data logger
Signal CaptureKeeps the source records of real operations and drafts write-ups for human reviewShift report built from the logs

Honest boundaries

What this does not show yet