Afferents

What It Is

Afferents are the inbound channels through which reality reaches a system without a human relaying it — webhooks, inboxes, schedules, watchers, pings, re-entry cues. The word is borrowed from neuroanatomy: afferent nerves carry signal toward the center; efferent nerves carry commands out to the muscles. Every system has some balance of the two, and almost everyone builds only the outbound half — capabilities, tools, effectors, hands — while leaving the system deaf, waiting to be told that the world moved.

In computational terms: afferents are interrupts. A process with no interrupt sources runs only when explicitly invoked — it is a subroutine, not a service. The design question afferents own is not measurement but initiation: not "what does the system sense while running?" but "what makes it run at all?" A system whose only wake source is its owner's attention inherits its owner's attention as a hard dependency — and attention is the scarcest, most variable resource in the whole architecture.

The governing observation, from the audit that named the term:

"The repo has zero afferents… a body with superb proprioception, organs, and hands — but no ears and no reflexes."

Whatever Waits for You Dies

The audit finding behind the principle. Will's personal OS had organs, logs, search, effectors of every kind — a system that could do nearly anything when invoked. Then external structure (a demanding job) claimed his attention, and the failure pattern was perfectly clean: everything the AI operated on its own kept living; everything that waited for a human to initiate flatlined within a month. Not one cron, webhook, or watcher fired without someone typing.

This is the empirical content of "whatever waits for you dies." It is not a claim about discipline — it is a structural claim about wake sources. A system wired to a human trigger has exactly one afferent, and that afferent is load-balanced against everything else in the human's life. The month anything else spikes, the system's event rate goes to zero. The mechanism is mundane:

"This year I have started implementing the implications of my insights by turning them into organs / AI skills that can run without me." — and the residual risk shifted accordingly: no longer failing to build, but failing to run. Attention reallocates off correctly-identified levers on a multi-day timescale unless external structure holds them live. A config problem, not a character problem.

The distinction this forces is the sharpest line in the article:

"Until now I built things that amplify me, but I still have to trigger them."

A tool waits for you; an organism runs. A tool, however powerful, is inert between invocations — an amplifier with the input jack empty. An organism has a self-maintaining loop producing effects without depending on anyone's daily motivation. The difference between them is not intelligence, capability, or quality of construction. It is afferents. The agent body states the same test from the mind's side: a mind with a hundred tools and no triggers "has capabilities and no life."

The Wake Condition Is a Body Test

The test generalizes past software to any persistent pursuit. In the minimal body contract — the ten questions that specify a pursuit as a body — the one that discriminates hardest is:

"Wake condition — what event or time resumes it?"

A pursuit that cannot answer has no body, and the consequence is specific: it will be re-derived from scratch daily. Every "one day I will" item lives in this state — fully specified as a desire, entirely unspecified as a process, because nothing in the world resumes it. Each time it surfaces, it surfaces by accident of attention, gets re-thought from zero, and sinks again. The re-derivation is not a memory failure; it is a missing edge. Nothing in the environment points at the pursuit, so only spontaneous recall can reach it, and spontaneous recall does not scale.

This gives the wake condition its diagnostic power. Run any stalled project, habit, or goal through the single question what event resumes this? If the honest answer is "me, remembering" — the pursuit has no afferent, and its trajectory is already known.

Re-entry Cues: The Same Law, Product-Side

The identical mechanism, observed from the other side of the product boundary. Why do trial users churn?

"People just don't remember to open up the app if they're just trying it. Not dissatisfaction — memory decay. A tourist has no re-entry cue. All the fixes live OUTSIDE the app: pings, digests, integration embedding."

Churn, in this reading, is the user-side version of "whatever waits for you dies": the product waited for the user to initiate, and the user's attention reallocated. The corrective is structurally interesting — none of the fixes are in the app. Better features improve the experience of a visit that never happens. The missing component is an afferent pointed at the user: a digest that arrives, an embedding into a surface they already inhabit, a ping carrying something worth noticing.

With one hard constraint, learned from nudging users toward autopilot:

"The return loop is real only when the machine produces something they want to notice — automation without a delivery/ping channel is credit burn with no pull-back."

An afferent must carry signal someone wants, and the loop must close in both directions: reality wakes the system, and the system's output must land somewhere a human actually looks. Automation running unseen is not autonomy — it is spend with no return edge. The delivery channel is the afferent of the human half of the loop; omit it and you have built an organism that metabolizes in the dark, producing resentment instead of retention.

The Obligation Inversion

The constructive move, applicable to a whole backlog at once:

"Invert each recurring obligation. Instead of asking what [you] must repeatedly do, identify the persistent external object or organ that would make the desired state continue."

A recurring obligation is a wake condition implemented in the most expensive possible substrate: your own prospective memory. The inversion replaces it with a persistent object that holds the state true — a standing watcher instead of a weekly check, a subscription instead of a remembering, an organ that runs instead of a task that recurs. One act of installation retires an unbounded stream of self-initiated repetitions. This is prevention architecture's mirror image: prevention removes causal edges that lead into bad states; afferent installation adds causal edges that lead into wake states. Same graph surgery, opposite sign.

And the economics of standing structures run on time-in-place, not output: getting them up is the first priority, because every day they are up, they pay rent by capturing learning. A structure with live afferents accrues environmental observation every day it stands — it goes out and learns for you. The cost of delaying installation is therefore not missed revenue but lost accrual: days the ears were not yet listening. Priority follows the arrow of time.

The Afferent Principle

The installation rule, for any capability a body needs:

"Find the most programmable primitive and store the handle in the body — if it needs to live in a webhook, it gets written down as something the platform must provide."

For each domain of reality the system must react to, locate the most programmable primitive that emits events from that domain — payments emit webhooks, email has inbox APIs, time has cron, repositories have hooks, filesystems have watchers — and pull its handle inside the system's boundary. "Most programmable" is the load-bearing selector: prefer the primitive whose events are structured, subscribable, and machine-consumable over the one that requires a human to read a screen. The handle then lives in the body — owned credentials, a registered endpoint, a standing subscription — which is where this article meets its sibling: afferents are the channels that cross the membrane inward. The membrane answers what the system owns; afferents answer what wakes it. Two axes of one body, siblings rather than one mechanism.

Sorting the genus from its neighbors:

Failure Modes

Integration with the Mechanistic Framework

Connection to The Agent Body

The parent article. "Triggers before tools" is the body checklist's afferent clause; this article is that clause promoted to a mechanism — the asymmetry audit, the wake-condition test, and the installation principle. The body keeps the agent-specific application; the genus lives here.

Connection to The Membrane

Sibling axes of the body split: the membrane is the ownership boundary, afferents are the inbound channels crossing it. A sealed membrane with no afferents is a vault; afferents with no membrane have nowhere to deliver.

Connection to Zeitgebers

Zeitgebers are the biological body's clock-signal afferents — external time cues that entrain the organism so wake conditions fire on schedule rather than on deliberation. The special case that proves the genus predates software.

Connection to Cybernetics

Cybernetics supplies the running loop — goal, sensors, actuators, control — and assumes the loop is running. Afferents are the precondition it assumes: the wake edges that make there be a process for sensors to inform.

Connection to Prevention Architecture

Inverse operations on the causal graph: prevention deletes edges into bad states; afferent installation adds edges into wake states. Both replace continuous vigilance with one-time structural surgery.

See Also

• The Agent Body — the structure afferents wake; triggers before tools
• The Membrane — the ownership axis; what the channels cross
• Zeitgebers — clock-signal afferents for the biological body
• Cybernetics — the loop that runs once something wakes it
• Prevention Architecture — the inverse graph surgery
• Forcing Functions — waking humans, where afferents wake systems
• Reality Contact — afferents make the contact bidirectional and standing

Core Principle: Afferents are the inbound channels — webhooks, inboxes, schedules, watchers, re-entry cues — through which reality reaches a system without a human relaying it. Whatever waits for you dies: a tool waits for its owner, an organism runs, and the difference is not capability but wake sources. Test every pursuit with one question — what event resumes it? — and where the answer is "me, remembering," run the inversion: replace the recurring obligation with a persistent object, found by taking the most programmable primitive and storing its handle in the body. Close the return edge too — automation without a delivery channel is credit burn. Ears before hands; triggers before tools.

Everyone builds hands. Nobody builds ears. Then they wonder why the golem stands motionless in the workshop, magnificent and deaf, waiting for someone to remember it exists.