The "What Next?" Loop

What kind of loop are you running?

The Validated Virtuous Feedback Loop — Flow

Agents and Alter-Egos

An AI Agent is actually a System Prompt recipe — prose, tools, permissions, model, and limits in one artifact. Writing a good recipe requires Systems Thinking; without feedback loops in the design, you get a mindset without a gauge.

A System Prompt is like a mindset or alter-ego you step into to see the world from a new perspective. It answers who is processing.

A Command Prompt is a discrete unit of work — input, tools, know-how, output — whose outcomes have first-, second-, and third-order effects. It answers what is being done.

Two examples of frames an agent can wear:

Rhetorical frames (Greek)

• Pathos — emotional appeal
• Ethos — credibility and character
• Logos — logic and evidence
• Kairos — timing, the opportune moment
• Topos — common ground, shared place

Control-system roles (VVFL stations)

1. Hopper — catch all ideas; filter what's worth acting on
2. Pump — transform inputs to outputs following best practices
3. Gauge — measure what matters; read early signals and self-correct
4. Feedback — are results and outcomes aligned with intentions?
5. Invisible — perspective on the big picture; is this the best use of time and energy?

Frames are who the agent is. Roles are where in the loop it operates. A well-written system prompt names both.

Rhetoric as Navigation

Rhetoric is the Control leg of a three-system navigation instrument. Value names what correct looks like. Belief maps where the audience needs to arrive. Control — this section — deploys the Greeks at the right station to move them there. All three must run true or the argument navigates toward the wrong destination.

The Greeks are what the controller says. The stations are where the controller stands. Stacked, they form a rhetoric control system — not an argument machine, but an argument regulator. Two tight fives, orthogonal, combining into one matrix.

Declare the Setpoint

Before any loop runs, declare what correct looks like. Without the setpoint, rhetoric runs as a reinforcing loop — more heat, more volume, no convergence. With the setpoint, rhetoric runs as a corrective loop — each argument measured by distance from declared truth, not by applause. See The Setpoint below: rhetoric is no exception to the rule.

Greeks × Stations

The Greeks answer what kind of appeal. The stations answer where in the loop. They are independent, which is why combining them generates the matrix:

Station	Pathos	Ethos	Logos	Kairos	Topos
Hopper	Gather stories of harm	Identify who moves the room	Pull hard data	Scan the calendar	Map the shared ground
Pump	Narrate the stakes	Lead with status	Build the base-rate argument	Frame for this moment	Build from agreed ground
Gauge	Read affective response	Check whose authority is deferred to	Test for logical holes	Read the room	Test whether agreement held
Feedback	Dial tone up or down	Swap messengers	Patch gaps, acknowledge counters	Re-time, stand down, accelerate	Move the ground wider
Invisible	Is emotion the right lever here?	Does our messenger reduce ethos?	Is the logic downstream of an unaudited belief?	Are we creating the moment by arguing?	Are we on the right battlefield?

Read rows to train a discipline — one Greek through every station. Read columns to run a live argument — one station, pick the Greek it needs now.

Greek Diagnostic

When the argument stalls, the controller reads the symptom and names the missing mode:

Symptom	Missing Greek
"Why should I listen to you?"	Ethos
"Where's your proof?"	Logos
"Why should I care?"	Pathos
"Why now?"	Kairos
"We don't even agree on the basics."	Topos

That turns a failed argument into a targeting signal. The feedback station runs the fix.

Truth Not Winning

The difference is the gauge. Rhetoric-for-winning measures applause. Rhetoric-for-truth measures distance from a declared correct outcome. The Greeks are the same in either; only the gauge separates persuasion from manipulation.

A loop without a setpoint amplifies whichever Greek lands hardest, regardless of direction. A loop with a setpoint corrects toward truth even when ethos bounces, logos drags, or pathos overshoots.

Make the case for what is correct by engineering the argument like a control system — not by hoping the right line lands.

Validate Virtuous Value

This is not a brand graphic. It is the logo expanded — every P&ID element opened to show what lives inside it. The question mark becomes a complete operating system for making better decisions faster. Same loop the logo draws in one breath — see The Thinking Loop — how the logo reads as a process of evolving state of mind.

Three Loops

Most people confuse these. The confusion costs them agency.

Loop	Setpoint	Measurement	What Happens
Positive (reinforcing)	None	None	Runaway — doom scrolling, panic selling, addiction
Negative (corrective)	Defined	Yes	Control — but toward what?
VVFL	Values-aligned AND reality-tested	Validated against outcomes	Progress that compounds AND serves

"Positive feedback" sounds like praise. In engineering it means amplification without correction — a microphone pointed at a speaker. No setpoint, no gauge, no control. Without a clear picture of what good looks like, you're a passenger.

The VVFL is the third kind. Not just corrective — validated (tested against reality, not just believed) and virtuous (the setpoint serves beyond self).

The Setpoint

The most important element in any control loop is the one most people skip: declaring what good looks like before the loop runs.

Karpathy's autoresearch is the proof. Three files, one metric, "NEVER STOP." The agent runs 100+ experiments overnight. Not because it's intelligent — because the constraint is clear. Constraints enable autonomy. A loop without a setpoint is a microphone pointed at a speaker. A loop with a declared northstar runs itself.

Loop Element	Without Setpoint	With Setpoint
Gauge	Reads numbers that mean nothing	Reads distance from target
Controller	Reacts to noise	Corrects toward declared intent
Agent	Busy but drifting	Autonomous and converging

The pain primitives are the gap made visible. Pain is the distance between where you are and where you declared you'd be. No declaration, no gap. No gap, no loop. The five voyage pains — no direction, no map, no ship, no mates, no compass — are five missing setpoints.

DECLARE SETPOINT → RUN LOOP → MEASURE GAP → CORRECT → REPEAT
     ↑                                                    |
     └──── evolve the setpoint when reality teaches ──────┘

The setpoint is not fixed forever. The outer loop evolves it. But at any moment, the inner loop needs ONE clear target to measure against. That's what turns a reinforcing loop into a corrective one, and a corrective one into a virtuous one.

The Vote Is the Setpoint

In a room running the Tight Five, the vote is the declaration. Debate in good faith. Vote. Then everyone commits to making the winning order work until the scheduled review or the gauge says you are off course.

Phase	What it fixes
Debate	Turns opinion into coordinates
Vote	Names one target the gauge can read
Commit	Protects the pump from endless re-litigation
Review	Reopens the filter on purpose — not on mood

Assumption Setpoints

Every assumption in a plan is an undeclared setpoint. "Users will pay $50/month" is a setpoint. "The API responds in under 200ms" is a setpoint. "The generator output passes pre-commit hooks" is a setpoint.

Undeclared assumptions are unmeasured loops. They run without a gauge, without a controller, without correction. When the assumption breaks, you discover it at production time — not at planning time.

Assumption type	Declared	Undeclared
Price point	Tracked against conversion data	Discovered when nobody buys
Performance threshold	Tested in CI	Discovered when users complain
Template completeness	Validated at creation	Discovered when plan produces nothing
Dependency existence	Checked before execution	Discovered when chain stalls

The fix: tag every assumption with a conviction level (HIGH/MEDIUM/LOW/NONE) and a measurement method. An assumption without a measurement method is a reinforcing loop waiting to run away.

The Stations

Reading the diagram clockwise from top-left:

Capture

The hopper — where raw material enters. Inspiration, problems, ideas, signals from success and failure. Trends and capabilities flowing in.

Without capture, you run on old inputs. The system starves.

Priorities

The filter between capture and action. Disagree with integrity. Record decision logic. Commit your capital. Not everything that enters the hopper deserves the pump.

Attention

The pump — what drives flow through the system. Focused. Collaborative. Coordinated. This is where agency meets action. The pump doesn't care about quality — that's the filter's job. The pump cares about movement.

Value

Where first principles transform state. Raw attention becomes directed effort. The pump creates motion; value gives it direction.

Systems

The feedback mechanism at the base. Automate to reduce decision fatigue. Trigger processes to adjust tactics. Adapt and adjust — this is where the loop becomes self-correcting rather than one-shot.

Standards

The gauge — raise the platform. Without measurement, you can't know if the loop is working. Standards are what make improvement systematic rather than accidental. The gauge reads reality.

Distribute

Maximize benefit, minimize waste. Goodwill compounds here — what you distribute returns. This is what makes the loop virtuous rather than merely corrective. Extraction breaks loops. Distribution strengthens them.

Reflect

The controller — practice asking deeper questions. The controller reads the gauge, compares measurement to setpoint, and asks: is this where we should be? Perspective is the controller's output.

Questions are the instrument of this station. The quality of the controller is the quality of the questions it asks. See Evolving Questioning for the Question Evolution Loop — the protocol that makes the controller sharper each cycle.

The Record: The Controller's output is not just a decision — it is a decision trace. That trace is the node in your context graph. See The Mycelium for how Systems of Decisions capture this.

Evolve

Change the game. Not just improve within the current frame — question whether the frame itself is right. This is where the loop compounds rather than merely repeats.

The Center

Flow. Make connections.

When all stations are running clean — capture feeding priorities, attention driving value, systems enabling standards, reflection driving evolution — the center holds. That's flow state. Not luck. Architecture.

Laminar vs Turbulent

Flow at the center is not metaphor — it is the physical diagnostic the loop produces. The question is not whether the loop is running. The question is whether it is running laminar or turbulent.

Laminar flow is what the loop looks like when every station operates at its natural rate. Capture feeds filter without forcing. Filter passes only what the pump can move. Pump drives value without context switching. Gauge reads cleanly. Controller corrects smoothly. The loop expands at the rate the outer loop can sustain. Energy moves forward, nothing spins in place.

Turbulent flow is energy spinning without translating into forward motion. Eddies form whenever a station fails to hold its boundary. The architecture looks intact but output drops. The gap between effort and result widens. The system starts consuming itself.

Every failure mode in the loop maps to an eddy type:

• Re-litigating closed decisions — eddy at the filter/pump boundary. The filter already passed the decision; reopening it blocks the pump and spills energy backward.
• Skipped debate — turbulence enters the pump directly. A decision with no resistance becomes drift. The pump is running but the direction is wrong.
• Undeclared setpoint — the whole system runs chaotic. Without a setpoint there is no gauge reading, and without a gauge the controller has nothing to correct toward.
• Politics — institutional eddies consuming energy at scale. Committees replace measurement. Votes replace feedback. The loop churns without advancing.
• Scope creep — eddy at capture. The neck stays open and the filter is overwhelmed. Nothing resolves because everything is still incoming.

The rate principle: do not grow faster than the loop can sustain without turbulence. Forcing growth — hiring faster than culture, shipping faster than quality, scaling faster than process — creates eddies. Eddies dissipate energy. Revenue may look good while energy output per unit drops. The diagnostic is not the growth number. The diagnostic is whether the flow is laminar.

The self-gauge: laminar or turbulent? That is the single question the loop produces as its output signal. No eddies means the architecture is holding. Eddies appearing means a station upstream is failing. Find the station, correct the boundary, restore flow.

Why Not Politics?

Nobody in power wants to make decisions. They want enough votes to stay relevant. Consultancies exist because "no one ever got fired for hiring McKinsey" — outsourced accountability dressed as expertise. This is not a control system. It's a reinforcing loop of self-preservation.

Politics is what happens when systems fail.

When feedback loops break — when the gauge is ignored, the filter is corrupt, the controller is absent — you get committees, votes, and lobbying instead of measurement, correction, and progress. The idea that governments will decide how to control AI is a fantasy. The people making those decisions have spent careers distancing themselves from decisions.

Political Loop	VVFL
Optimize for staying in power	Optimize for goodwill
Outsource accountability	Own the measurement
Enough votes to remain relevant	Enough trust to remain useful
Top-down control	Bottom-up coordination

The answer is not waiting for someone to save you. The answer is talking to your neighbours. Using tokenomics and tokenisation to share ownership in important assets and distribute the value that comes from them fairly. Futarchy — backing decisions with bets rather than votes — replaces opinion with skin in the game. Building culture at the community level where feedback loops are short enough to actually work.

Intelligence is no longer a competitive advantage. AI leveled that field. Culture is. And the strongest cultures are judged by how they look after their weakest. See Governance for what happens when we try to build systems that don't fail.

The Gauge

A loop without a gauge is motion. This section is the gauge — the outcome map filled in, the picture we measure against.

Three Signals

Level	Signal	Proxy	Proves
Self	Decisions improve	Choices that reference the model	The system works for its builder
Transfer	Better questions out than in	Link depth from entry point	The architecture creates value
Compound	Connections create emergent value	Cross-referral from /meta/ into /docs/	Links are edges, not decoration

Level 1 before Level 2. Level 2 before Level 3.

Success Measures

Binary. Did we or didn't we.

• Someone traverses Journey → Science → Standards → Systems → Scoreboard → Journey
• Someone fills a template and shares the output
• A meta article generates conversation that references /docs/
• Three decisions improved by externalizing the mental model

Evidence Loop

Cycle	Hypothesis	Outcome	Better Question
1	Cross-linking nav sections creates traversal

Fill this table. The empty cells are the gauge reading.

OODA Is VVFL

Boyd's OODA loop (Observe → Orient → Decide → Act) is the VVFL compressed to four stations. Same loop. Different vocabulary. Same center.

OODA	VVFL Station	Control Function	The job
Observe	Capture	Hopper	What signals are entering the system?
Orient	Priorities + Standards	Filter + Gauge	What do the signals mean against what we measure?
Decide	Reflect	Controller	What's the one correction that matters most?
Act	Attention + Value	Pump + Transform	Execute. Change state. Ship.
(loop)	Systems + Distribute + Evolve	Feedback	Did it work? Distribute the gain. Evolve the setpoint.

Boyd's insight: the side that cycles faster wins. Not the side with more information. Not the side with better plans. The side whose loop runs tighter — shorter time from observation to action, faster feedback from action to next observation.

The VVFL adds what Boyd left implicit: the setpoint (what "winning" looks like) and the gauge (validated measurement, not just observation). OODA without a setpoint is fast reaction to noise. VVFL with OODA speed is fast convergence toward declared intent.

Tool Adoption

The fastest-moving affordance in any knowledge worker's stack is their AI coding environment. Features ship weekly. Practitioners innovate daily. A configuration that was optimal last month leaves potential on the table today.

Apply the VVFL:

Station	Applied to tool adoption	Cadence
Capture	Scan changelog, practitioner feeds, community innovations	Daily
Priorities	Map each new feature against current configuration. Score each affordance 0-5. Which gap is largest?	Daily
Attention	Pick ONE feature. Not a batch. One.	Per cycle
Value	Test it now. In this session. Not "investigate later." Load the tool, run the command, try the config.	Per cycle
Systems	Did it work? Update the baseline. If it failed, note the blocker.	Per cycle
Standards	Track affordance utilization over time. The gauge reads: what percentage of your tool's potential are you extracting?	Weekly
Distribute	Share what worked. Document the pattern for the next person.	Weekly
Reflect	Did the adoption process itself work? What did you have to improvise that should be baked in?	Monthly
Evolve	Improve the adoption procedure. The loop that adopts tools should itself be adopted by the loop.	Monthly

The inner loop (daily) cycles in minutes: observe one feature → test it → adopt or reject. The outer loop (monthly) evolves the adoption process itself. That's recursion — the loop improving the loop.

The failure mode this prevents: Listing 17 new features, creating a deployment plan with four phases, and executing none of them. Batching kills loops. Cycling one feature at a time through the full VVFL keeps the loop alive.

The origin lesson: Writing "I don't know what the mechanism is" while the mechanism was listed in your own tools. The gauge was there. The capture was there. The filter never ran. If you don't cycle the loop, the loop doesn't exist — no matter how well you've drawn the diagram.

The Bottom Line

Make better decisions faster.

Each cycle through the loop:

• Sharpens the questions (better inputs)
• Strengthens the filter (clearer principles)
• Focuses the pump (more directed action)
• Raises the gauge (higher standards)
• Deepens the controller (wiser reflection)

The loop doesn't guarantee good outcomes. It guarantees that each failure makes the next attempt better. That's what separates the VVFL from hope.

Loop Eats Itself

The VVFL describes the loop for a person or business. The platform that teaches it must run it too.

Spaghetti code is a runaway loop. No setpoint declared for architecture quality means logic accumulates without correction — one file grows to 2,700 lines, three delivery surfaces each reinvent the same business logic, and the loop that was supposed to answer "what next?" becomes the thing slowing you down. No gauge, no controller, no correction. A microphone pointed at a speaker.

Hexagonal architecture is the declared setpoint. "Business rules in libs/. CLIs under 100 lines. No database calls in scripts." These are not style preferences. They are the setpoint that makes the corrective loop possible.

The three delivery surfaces — terminal CLI for an internal agent, API for external agents, user interface for humans — are the Distribute station of the platform's own VVFL. When they share the same use cases, distribution compounds. When each reinvents the logic, extraction breaks the loop.

Surface	Consumer	Loop Type
CLI	Internal agent (Nav)	Runaway until refactored
agent-api	External agents (A2A)	Corrective — thin, shared use cases
UI	Humans	Corrective — thin, shared use cases

One surface still runs a runaway loop. The refactor is not cleanup. It is the corrective loop running on the codebase itself.

Boyd's insight applies here too: the side that cycles faster wins. A 2,700-line CLI cycles slower than three thin delegators pointing at the same use case. Fixing the architecture is a speed upgrade on the OODA loop — shorter time from observation to action, tighter cycle from "what next?" to shipped.

The VVFL does not just describe how to build things. It describes what things must look like when built well. If the platform runs a runaway loop while teaching corrective ones, the lesson fails before it lands.

Hopper's Geometry

The hopper is wide at the top and narrow at the bottom. That shape is not decoration. It encodes a decision about where openness belongs and where rigor begins.

At the wide mouth — intake — any idea enters. A Collision meeting fills it: divergent energy, no pre-filtering, raw signal welcome. This is the right stage for openness. Closing the intake early means you miss the idea that changes everything.

The narrow neck is where the Filter does its work. Before anything reaches the pump, the Debate meeting runs: options scored, rationale spoken in full sentences, vote cast. Quorum is always an odd number so a majority always lands. Silence counts as abstain, not consent. One-word rationales are rejected — the filter requires honest argument, not polite nods.

The five-phase sequence is built into the shape:

Phase	Geometry	Meeting Type	Output
Intake	Wide mouth	Collision — divergent, Hopper station	Raw ideas captured
Filter	Narrow neck	Debate — rigorous, Filter station	Scored options, time-boxed
Vote	Neck closes	Council casts — odd count, majority always	Named verdict: advance / revise / kill
Commit	Pump opens	Decision — committed, Pump station	100% energy from all voters, including those who lost
Review	Gauge reads	Accountability — reflective, Gauge station	Pre-mediated checkpoint or off-course signal triggers re-opening

The commit is not "I agreed." It is "I bet my attention regardless of agreement, because the vote closed." Losing a vote in good faith does not cancel the obligation. Between the vote and the scheduled review, the answer to "should we revisit?" is no.

Endless re-litigation is a runaway loop pretending to be rigor. The hopper's narrow neck is the physical expression of the rule: argue hard, vote once, pump as one.

Driver's Own Loop

The driver runs the same five stations the team runs. Not a metaphor — the same architecture, zoomed in.

A day's Daily Protocol maps directly to the stations: open with intention (Hopper), protect deep work at peak energy (Pump), process and filter reactive work (Filter), connect and distribute (Distribute), close with reflection and tomorrow's intention (Gauge + Evolve). Same sequence. One person. One day.

The week extends the same pattern across a team. Monday loads the priority stack (Hopper → Filter). Tuesday ships (Pump). Wednesday debates pending plans and reviews the last sprint (Filter + Gauge). Thursday tests production against the stories (Gauge). Friday extracts one lesson and folds it back into Monday's intake (Evolve).

The quarter is the same pattern again — a venture's intake cycle, filter round, build phase, measurement, and setpoint revision.

Scale	Hopper	Filter	Pump	Gauge	Evolve
Day	Morning open — set intention	Process batch — reactive work	Deep work — single task	Evening close — gap read	Tomorrow's one thing named
Week	Monday — priority stack	Wednesday — Debate on open plans	Tuesday — deep build	Thursday + Friday mirror	Friday lesson extracted
Quarter	Intake cycle	Debate round	Build phase	Measurement cycle	Setpoint revision

Inner-outer harmony follows from this. The driver's daily filter determines what reaches the team's pump. If a day has no Filter phase — no time set aside to evaluate what should actually move — undebated intake reaches the pump and wastes it on work that never should have passed. A team's loop quality is bounded by the driver's loop quality. The driver cannot install in the team a discipline they are not running themselves.

The picture is fractal. The same loop at every zoom level is what makes it compound rather than merely repeat.

Context

• The Thinking Loop — how the logo reads as a process of evolving state of mind
• The What-Next Algorithm — How the three loop types map to routing decisions across every domain, and why the VVFL is the meta-algorithm that governs them
• Essential Algorithm — The VVFL stations mapped to INTENT → ROUTE → INFRASTRUCTURE → SETTLE → FEEDBACK
• Outcome Map — The blank version of the gauge section above
• The Logo — The compressed version: four P&ID shapes forming a question mark
• Control System — PID mechanics: setpoint, sensor, controller, actuator
• VVFL Loop — Standards as the compounding force
• Pain Primitives — Five voyage pains: five missing setpoints
• Agency — The capacity the loop builds: Resources × Know-how × Character, compounding through each cycle
• Evolution — The VVFL is intentional evolution: declared setpoint instead of random drift, gauge instead of blind selection, controller instead of survival pressure
• Flow State — What happens when all stations run clean
• Meetings — Five meeting types, each mapped to a station: Collision (Hopper), Debate (Filter), Decision (Pump), Accountability (Gauge)
• Ideal Day — The five-station daily protocol the driver runs
• Ideal Week — Engineering cadence: how the driver's week maps to team station rhythm

Questions

What is your setpoint — and who declared it?

• If your loop has been running for months without converging, is the loop broken or is the setpoint missing?
• When your team skips the Debate meeting and moves directly to execution, which station in the hopper geometry did you remove — and what did the pump receive instead?
• If the driver's daily Filter determines what reaches the team's pump, what passed this week that shouldn't have — and where in the day did the filter fail?
• When the outer loop evolves the setpoint, how do you know the new target is wiser than the old one?