The "What Next?" Loop

What kind of loop are you running?

The Validated Virtuous Feedback Loop — Flow

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.

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
• 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?