GUTSGeneralized Operations Nervous System — L2 Coordination
DESIGNED · MVP 3–4
Continuity of Intent Designed · MVP 3–4
The organization keeps its own pulse
Humans are poor at maintaining continuity across time: preserving operational
momentum, propagating goals under interruption, reacting coherently to state changes.
Organizations solve this with managers, coordinators, reminders, escalation chains,
meetings. GONS is the factory's designed coordination layer: it will externalize that
continuity pressure into event-driven routing, so that only meaningful
intervention points remain human.
In the design, every event faces one question: can this continue without you, or
does it need you? The answer decides everything downstream: handle it, queue it
for the brief, or interrupt the human.
You finish a deep work session and lose the thread. The repo runs CI overnight and three things break. A scheduled GEDS inference completes at 3am and goes stale. A WhatsApp message arrives with a question you'd have answered immediately if you'd seen it. The morning arrives and none of it advanced.
The cost is not the individual missed signal. The cost is that you became the continuous driver of every loop — status relayer, routing layer, escalation chain, reminder system, scheduler. The organization can't sustain its own momentum without you in the loop.
The Split
One organ, two rooms
A single coordination program would have to be both a reliable daemon and a good
conversationalist, and those are different programs. So the design splits GONS in two:
a foreman that runs the floor, and a command room that faces the human. They share one
spine: everything the Core does becomes GIMS sentences, and everything the Console says
is read back out of them.
GONS-CORE · MVP 3
The foreman
Runs the factory floor. Talks to sessions and to the ledger, not to you.
Spawns and monitors tmux sessions for GOMS objectives: a body, a branch, a worktree, a work claim.
Routes every question: no agent ever writes into another agent's terminal.
Tracks heartbeats and detects stalled or silent sessions.
Enforces operating modes before execution, not after.
Writes every event to GIMS as an append-only sentence.
Packages raw session life into episodes: the digestible units GEDS interprets.
Escalates to the human when the routing question answers "this needs you."
BORING · RELIABLE · OPERATIONAL — it keeps the factory running. It is not the chatty narrator.
GONS-CONSOLE · MVP 4
The command room
Faces the owner. Reads the ledger and speaks plain language.
The daily brief: what happened, what needs your judgment, what already advanced.
Cited answers: every claim traces to GIMS, GEMS, or GEDS records, never to vibes.
Devlogs and reports on demand, assembled from the event trail.
The approval queue: dangerous actions wait here for an explicit yes.
Redirection in plain language: "pause the auth work, prioritize the pilot" becomes routed instructions.
WHERE THE HUMAN REMAINS SOVEREIGN — command flows down; evidence flows up.
The two rooms never gossip. The Console does not ask the Core what happened; it asks GIMS.
If the Core died mid-shift, the Console could still reconstruct the whole shift from the
ledger. That is the point of the shared spine.
Constitution — Rule 02
The routing rule: nobody talks directly
Agents never inject text into each other's terminals. Every exchange routes through the
foreman and lands in the ledger, so every exchange is attributable, replayable, and visible
in the Console. tmux is the last-mile display, not the source of truth.
What a routed question will look like: not a line of terminal text, but a record.
question.raisedfrom_session:agent-auth-1requested_specialist:gedsquestion:"does removing the legacy token path contradict any standing tension?"context_refs:[claim: backend/auth/** · episode: ep-2026-06-30-auth-refactor]urgency:blocking
Because the question is a ledger sentence, the answer arrives the same way: delivered by
GONS back into the asking session, with the whole exchange on the record. And because
absence is computable in an append-only ledger, a question that sits unanswered too long
is itself a trigger.
Triggers
What will wake the foreman
GONS-Core is event-driven by design. It will not run on a schedule of its own; it reacts
to the factory. For each trigger, the same routing question: does this continue on its own,
queue for the brief, or interrupt the human?
Agent stopped, waiting
A worker finishes or blocks. The Bridge detects this today: the captured screen is hashed across polls — changing means working, identical means ready.
Heartbeat missed
A session that should be reporting goes silent, or stalls mid-task. Absence is computable: the sentence that should exist and doesn't is itself the signal.
Question raised
An agent hits something it cannot decide and files a question record. GONS-Core will route it: to GEDS, to another agent's queue, or up to the human.
Approval requested
A merge to main, a migration, a spend. The action stops at the gate and waits in the Console's approval queue for an explicit human yes.
GEDS packet arrived
The relevance engine finishes digesting an episode and hands back an anomaly, a tension, or a prepared handoff packet for a stronger reasoner.
GOMS objective activated
A sprint task goes live. GONS-Core will give it a body: a tmux session in a git worktree, holding a GIMS work claim over specific paths.
Mode violation attempted
An action collides with the current operating mode: No Outbound, No Code Changes, No Spending. Blocked before execution, recorded as a sentence.
External inbound Later
Messages, offers, and requests from outside the factory. Deferred by design, and only ever through GRAMS, the market membrane.
The Mechanism
What the foreman will do with an event
Every event passes through the same routing question: can this continue without you,
or does it need you? The answer determines everything downstream.
01 — Event Ingestion · Every signal becomes a sentence
The design wraps every input in an adapter that converts it into the GIMS grammar:
subject · verb · object · at · by · under. The router never reasons about raw
terminal output or a raw cron tick; it reasons about ledger records with predictable
attributes. That separation makes new input sources cheap to add, and
it means the routing layer and the memory layer are fed by the same act of writing.
02 — The Routing Decision · Autonomous vs. escalate
Every event hits the same question: can this continue without you? GONS-Core
will resolve it through a policy stack: type-specific defaults, past judgments, context,
and above all the current operating mode. Three outputs: handle
autonomously (deliver an answer, restart a body, package an episode),
queue for the brief (no urgency, surface it in the morning), or
escalate now (interrupt the human).
03 — Continuity Propagation · Goals that survive the gaps
The hardest part of running anything is not the work; it is the gap between work
sessions. Goals slip in that gap. The factory already has half the answer: tmux
gives workers persistent bodies that survive disconnects and overnight runs. GONS-Core
will hold the other half: when you close the laptop, the loops that do not need you
keep turning, and when you return, the Console hands you a coherent state,
not a pile of unprocessed events.
04 — Organ Invocation · The foreman does not do the work
When an event resolves to an action, GONS will invoke whichever layer owns that
primitive: GOMS defines the work, GEDS interprets the episodes, GIMS remembers all of
it, and the Bridge shows the human the sessions being driven. GONS packages the context,
dispatches the call, and watches the response. The router is narrow. The organs
are deep.
The Hard Part
Escalation policy — what the human still owns
The design stands or falls on GONS-Core being correct about what it can handle alone.
Wrong toward the autonomous side and meaningful decisions get auto-resolved without you.
Wrong toward the escalation side and you are buried under interruptions. Operating modes set
the outer boundary: whatever the policy stack would decide, the mode is enforced first.
Mechanical continuation
Handle autonomously. Deliver a routed answer to a waiting agent. Record a heartbeat. Recreate the default sessions. Package a finished episode for GEDS. Things with a known correct response.
Simple operational decisions
Handle autonomously. Mark a stalled session and preserve its episode. Requeue a task whose work claim expired. Retry a flaky test once and note it in the ledger. Reversible, low-stakes, well-defined.
Meaningful ambiguity
Queue for the brief. An agent question with two plausible answers. A GEDS packet the engine itself marks low-confidence. Anything where the system has a guess but should not act on it.
Mode boundaries
Stop before execution. In No Code Changes, a merge request does not queue politely, it halts. In No Spending, nothing that costs money runs. Modes are enforced ahead of the policy stack, not painted on the UI.
Irreversible actions
Escalate now. Push to main, run a migration, kill a session with unmerged work, send anything external, spend money. Confirmation-gated, always human, always a sentence in the ledger.
The dial is set per domain and per operating mode. Pause All Agents collapses the whole arc to escalation; Normal keeps the mechanical loops green.
The Defining Capability
The morning brief
The single moment that will define whether GONS-Console is working: you open the Bridge in
the morning. This is the scene the design exists to produce.
Overnight, the factory ran. Three agents worked in their worktrees; two finished and
stopped, their session cards ready-green. One stalled at 3am on a failing integration
test; GONS-Core marked the session, preserved the episode, and left it paused. Two merges
sit in the approval queue with diffs and claim histories attached. A GEDS packet arrived:
Mode 1 flagged an anomaly between the auth refactor and a standing tension, evidence
chain included.
You open the laptop. You see one morning brief: what happened, what needs
your judgment, what already advanced. The brief is short (eight items, not
eighty), and every line cites the ledger records behind it. You approve one merge, hold
the other, redirect the stalled agent in plain language, and queue the GEDS packet for the
afternoon. Then you start the day.
You stopped being the continuous driver of every loop. The organization kept its
own pulse.
This scene is not built yet, but its embryo is. The Bridge's ready/working
border is the embryonic heartbeat: the captured screen hashed across polls, working while it
changes, ready once identical. The dashboard cards, each showing a working directory, a last
output line, and a status badge, are the embryonic brief. GONS-Core and GONS-Console grow
out of a window that already works.
Where It Fits
GONS in the stack
GONS sits at L2, between memory below and interpretation above. In the design, nothing
routes around it: objectives come down from GOMS, episodes go up to GEDS, every event lands
in GIMS, and the human watches and commands through the Bridge and the Console.
GONS — Core & Console
The foreman will run the floor; the command room will face the human. Every event routes through here, and every routed thing becomes a sentence.
↕ GIMS
Writes everything, reads state. Every spawn, question, approval, and routing decision lands in the ledger; the Console answers only from what is written there.
↕ GEDS
Episodes out, packets back. GONS-Core packages raw session life into episodes; GEDS returns anomalies, tensions, and handoff packets for routing.
↓ GOMS
Objectives in. GOMS defines the sprint and the tasks; GONS decides which sessions need to exist and which contexts must be loaded.
◉ BRIDGE
The human's window over the sessions GONS will drive. Built today: lock screen, session tabs, dashboard cards, agent-stopped detection.
↑ HUMAN
Sovereign at the gate. Approvals, redirection, and operating modes flow down; briefs and cited answers flow up. GAMS and GRAMS join this orbit later, by design.
GONS is narrow on purpose. It will not interpret (that is GEDS), it will not define the work
(that is GOMS), and it does not remember (GIMS is memory). It routes, monitors, enforces,
and escalates. The depth is in the routing policy, not the action.