Feedback Loops on FrenchForet

The Loop You Can't See

Mon, 01 Jan 0001 00:00:00 +0000

Goal: understand the problem this course solves, and why it is harder than “add some logging.” A modern agent decides and acts on its own — it picks tools, spends money, retries, and sometimes changes its own behavior. Each of those is a feedback loop: it senses something, decides, and acts. This course is about building those loops so you can trust them — and the thing that makes a loop trustworthy is observability. A loop you cannot see is a loop you cannot debug, cannot improve, and should not let run on its own. The course argues that autonomy is earned, and what earns it is the telemetry that makes every decision visible.

Joinable Signal: Trace & Session IDs by Hand

Mon, 01 Jan 0001 00:00:00 +0000

Goal: build the smallest piece of observability that everything else depends on — a joinable signal. Before a feedback loop can act, it needs to read a signal it can trust, and “trust” starts with being able to tie records together: this log line, that cost, this tool call all belong to the same run. You will build a tiny correlation primitive by hand — a session_id, a trace_id, and a step — and emit one joinable JSONL record per operation. It is an OpenTelemetry-shaped context, built without the SDK; Unit 11 meets the standard.

An Event Vocabulary, Not Log Lines

Mon, 01 Jan 0001 00:00:00 +0000

Goal: make the joinable signal from Unit 1 queryable. A log full of free-text strings — "calling search tool", "search done", "search failed!" — cannot be counted, aggregated, or alerted on, because nothing ties the three together. You will replace ad-hoc strings with a small vocabulary of semantic events: named constants, each with one fixed shape. Then you will separate the agent’s own background traffic from real user activity, so a feedback loop’s self-monitoring never looks like a user.

Spans & the Latency Breakdown

Mon, 01 Jan 0001 00:00:00 +0000

Goal: measure where a turn spends its time, not just that it was slow. “The turn took 4 seconds” is not an actionable signal — a latency or cost loop needs to know which phase burned the time. You will build a small span timer that records each phase of a turn on a monotonic clock, classifies spans into phases (setup, context, routing, inference, tools, synthesis), and emits a latency breakdown as one joinable record.

The First Closed Loop: a Runtime Gate

Mon, 01 Jan 0001 00:00:00 +0000

Goal: build the first loop that actually acts. Units 1–3 made the agent observable; now you use that signal to change what the agent does next, inside a single turn. You will build a small finite-state gate that watches an agent’s tool calls and blocks a runaway — the reflex-tier loop that, in Unit 0’s war story, was the one thing that worked. Sense → decide → act → emit a verdict, in milliseconds, with no human and no model in the loop.

Budget as Feedforward Control

Mon, 01 Jan 0001 00:00:00 +0000

Goal: build a loop that acts on what is about to happen, not what already did. The loop gate (Unit 4) reacts to a call after it runs — fine when the cost is a wasted iteration, wrong when the cost is real money you cannot take back. You will build a budget gate that reserves against a projected cost before the call and refuses it if it would breach the cap. This is feedforward control, and it is the right shape for any action you cannot undo.

Reflection: Self-Critique from Traces

Mon, 01 Jan 0001 00:00:00 +0000

Goal: climb from the reflex tier to the reflective tier. The gates in Units 4–5 act in the moment on simple rules. Now the agent does something slower and harder: after a turn finishes, it reads its own trace and critiques it — producing a written, structured judgment about what went well and what to change. You will build both halves: a deterministic pass that mines the failure path from a trace, and a model pass that turns it into a structured proposed change.

Closing the Reflective Loop

Mon, 01 Jan 0001 00:00:00 +0000

Goal: close the loop you opened in Unit 6. A reflection that is only saved to disk, or only shown to a human, is an open loop — the agent critiqued itself and nothing changed. You close it by feeding a small, relevant slice of past reflections back into the next turn’s context, so the agent re-reads its own observations. This is the clearest example in the course of an agent’s output becoming its future behavior — and it is mostly about deciding which reflections to trust enough to surface.

Hysteresis: Dedup & Promotion

Mon, 01 Jan 0001 00:00:00 +0000

Goal: build the mechanism Unit 7 leaned on. There you surfaced only reflections with seen_count >= 2, on the principle that “single-instance reflections are noise; recurring patterns are signal.” Now you build the part that produces that count — deduplicating equivalent proposals into one, counting recurrences, and promoting only the patterns that both recur and persist. This is hysteresis: a deadband that stops the slow outer loop from acting on a single, fresh observation.

Human in the Loop, Async

Mon, 01 Jan 0001 00:00:00 +0000

Goal: close a loop you should not close automatically. A promoted proposal (Unit 8) is a candidate change to the agent itself — its prompt, its config, its behaviour. That is the most irreversible, highest-stakes action in the course, so the loop stays open until a human closes it. You will build the async approval channel: a promoted proposal becomes a ticket, a human gives a verdict from wherever they are, a poller reads it back, and the verdict flows into the system — approve, reject, or re-evaluate. The human’s judgment is the loop’s closing signal.

Watching the Apparatus

Mon, 01 Jan 0001 00:00:00 +0000

Goal: build the loop that watches the other loops. You have feedback loops at every tier now — but each one trusts the signal beneath it, and that signal can become invalid without any alert (Unit 1’s cost ledger with 4,077 NULL trace_ids did exactly that). The meta tier closes a loop around the apparatus itself: a monitor that periodically checks the observability is still intact — that a run is still joinable across every store — and that the gates and background loops still run. The monitor is itself monitored.

Meeting the Standard: OpenTelemetry at the Boundary

Mon, 01 Jan 0001 00:00:00 +0000

Goal: meet the standard you have been hand-building all along — and decide whether to adopt it. Across Units 1–3 you built a trace_id, an event vocabulary, and spans. In Unit 10 you walked one run across four different stores and felt the hand-rolled approach strain. That strain is the need: a bespoke format is fine inside one process, but the moment signal must cross processes, services, and substrates, you need a shared contract. OpenTelemetry is that contract — and it is, almost exactly, the thing you already built.

The Measured Default

Mon, 01 Jan 0001 00:00:00 +0000

Goal: gather the whole course into one decision and one discipline. The decision is the autonomy gradient as a tree: which loops you close automatically, and which you keep human-closed. The discipline is how you know — evals run as a hypothesis, not a gate. This is the measured default the instrumentation earned, not the author: don’t ship a black box, and earn autonomy by being observable.

Where this fits: the final unit. It does not add a tier; it ties the five together (sense → reflex → reflective → deliberative → meta) and adds the outermost loop — evaluation — that tells you whether any of it is working.