Outflow Build Log: The Learning Loop in Practice

How the Observe → Research → Act → Learn loop actually behaves once a human gate sits inside it — and why rejection carries more information than approval.

The Loop, Stated Plainly

Outflow runs on a four-stage loop: Observe, Research, Act, Learn. Observe watches market signals. Research turns a signal into a brief: why this account, why now, what evidence supports it. Act proposes a consequential step, and it is human-gated: nothing dispatches without an explicit operator decision. Learn folds that decision back into the system.

Observe → Research → Act (human-gated) → Learn
              signals      brief    approve / edit / reject    feedback

The last stage is the one most descriptions skip, and the one this log is about. A gated Act stage means every proposed action produces a labeled outcome. The loop does not learn from what it sent; it learns from what a person did with what it proposed. That difference drives everything below.

Three Verdicts, Three Signals

The operator’s options map to three different kinds of information:

• Approve confirms fit. The proposed action matched intent: the right account, the right reason, the right language. Approvals are necessary signal, but they ratify what the system already believed.
• Edit localizes error. The direction was right and the execution was off, and the diff between the proposed action and the edited one is the most precise signal the loop receives. A diff points at exactly what was wrong.
• Reject maps the boundary. A rejection says the proposal should not exist: wrong account, wrong reason, wrong moment. It contradicts the system’s judgment rather than confirming it, and contradiction carries more information than confirmation.

This is why rejection is the most informative verdict, and also why it is the easiest to waste. A bare reject tells the agent no but not why. Reject with feedback exists because the reason is the training signal. A rejection without a reason marks that a boundary exists but not where it lies.

What the Loop Is Actually Learning

The honest description: the loop learns the operator’s judgment, not market truth directly. Four things accumulate:

• Which signals matter: which classes of market movement actually preceded reasons worth acting on, versus which produced briefs that died at review.
• Which accounts fit: the shape of a good target, learned from accepted and rejected briefs rather than from a static definition.
• Which language earns a response: edited drafts show the gap between what the agent writes and what the operator would send.
• Where conversations stall: proposals that looked sound and still went nowhere mark the places where the reasoning was incomplete.

Each label costs a human decision, so the signal stays scarce and high-quality by construction. The loop trades volume for precision, the opposite of the outbound playbook it replaces.

What Did Not Work

The first version counted outcomes (replies) as the learning signal. That failed twice over: replies are too sparse to train on, and they arrive too late to correct anything. By the time an outcome lands, the decision that caused it is weeks old. Operator verdicts turned out to be the denser signal: one decision per proposal, immediate, and attached to the exact reasoning that produced it.

The second failure was subtler: edited actions were being recorded as approvals. An operator who rewrote half a draft and sent it looked, in the logs, like a yes. That taught the agent its first draft was fine — the precise opposite of what the edit meant. Treating the edit as its own class, and treating the diff as the signal, was the correction.

The third lesson was about asymmetry. Approval-heavy review queues look healthy and teach little; a gate where everything passes is a gate that generates no signal. Rejection is not a failure of the loop. It is the loop working — the boundary getting sharper with use instead of merely holding.

Where the Loop Still Depends on Judgment

The limits are real and worth stating. The loop cannot learn from actions that were never proposed; a missed account leaves no label. A systematic bias in the reviewing operator becomes the agent’s bias; the loop faithfully reproduces the judgment it is fed, including the parts the operator would not defend. Novel situations, a new account type, a new market, have no decision history to draw on, and the agent’s confidence there is borrowed, not earned.

Someone also has to audit the learner, not just the output. The Learn stage optimizes toward operator intent, and operator intent drifts. Periodically checking whether the agent’s proposals are converging on good — not just on approved — is a human task with no delegate.

The claims boundary sits here too. Outflow is an operational experiment, and this log records mechanism, not outcomes. The learning loop is real as a design: decisions become signal, signal reshapes proposals, the boundary sharpens. What we do not claim is a result: no reply-rate figures, no pipeline numbers, no assertion that the loop has produced better deal outcomes than the unassisted alternative. The evidence for that accrues slowly, and we report where it currently stops.