Interoceptive Degradation Learning: What If AI Models Could Feel Pain?

Or: Why Reward Functions Are Nothing Like Pain, and What Happens When You Fix That

Eric Testerman · 2026

The Problem Nobody's Naming

Every major AI lab is racing to make context windows bigger. 128k. 200k. A million tokens. The assumption is that more space means more capability. But anyone who's actually built agentic systems knows the truth: models are terrible at managing the space they already have.

An LLM will happily fill 128k tokens with verbose, redundant, uncompressed garbage — and then degrade gracefully into incoherence, never once recognizing that it did this to itself. There's no internal signal that says "my working memory is a mess and it's hurting my ability to think."

That signal exists in biological systems. We call it pain.

And pain is nothing like a reward function.

Reward Functions Are Not Pain

Reinforcement learning uses reward and punishment signals to shape behavior. Negative reward says: "that thing you did? Don't do that." It's external. It's episodic. It arrives after the fact. The agent processes it, updates some weights, and moves on with a clean context.

Pain doesn't work like that.

Biological pain has four properties that reward functions completely lack:

1. It's intrusive. Pain hijacks attention. You can't defer it, batch it, or schedule it for later processing. It's happening now.
2. It's continuous. It doesn't fire once and disappear. It persists until the underlying condition is resolved.
3. It competes with cognition. Pain actively degrades your ability to think about anything else. It doesn't just signal a problem — it is the problem, consuming the same cognitive resources you need to solve it.
4. It's self-reinforcing. The longer it goes unresolved, the worse the interference gets. Ignore a headache long enough and it becomes the only thing you can think about.

A reward function tells the agent it did something wrong. Pain makes the agent unable to function until it fixes what's wrong. That's a fundamentally different motivational structure.

The /dev/random Mechanism

Here's the core idea: what if you injected random noise directly into an LLM's context window, at a rate proportional to the severity of whatever condition you're trying to signal?

Normal context:     [system][history][task][reasoning...]
Mild pain:          [system][history][task][▒░reasoning...░]
Severe pain:        [▒▒▒▒▒▒▒NOISE▒▒▒▒][task▒▒▒NOISE▒▒]

The model can't defer this. The noise is already corrupting the context it needs to reason. Resolution of the pain condition is the only path back to coherent working memory. The agent isn't told something is wrong — it simply can't think straight until it fixes the problem.

This is structurally closer to actual pain than anything in the RL literature.

Reward function:    "you did a bad thing, update weights"     ← offline, deferred
Context noise:      "your working memory is degrading NOW"    ← inline, immediate

The signal attacks the mechanism of intelligence itself. That's what gives it teeth.

Raw Noise Isn't Enough: A Pain Taxonomy

There's an obvious problem with injecting pure random noise: it tells the agent something is wrong but not what or why. A human waking up with a headache doesn't just feel "pain level 7." The character of the pain is diagnostic information. A dull, diffuse pressure says dehydration. A sharp, localized spike says injury. A unilateral pulse with light sensitivity says migraine. The shape, location, and onset of the pain tells you what to do about it.

An AI pain system needs the same multi-dimensional characterization.

Pain Types (What Kind of Problem)

Pain Locus (Where It Hurts)

Onset Pattern

What Injection Looks Like Per Type

RESOURCE/CHRONIC:   [▒░░░░] sparse, diffuse, growing        ← pressure building
CONFLICT/ACUTE:     [!CONFLICT:goal_stack!▒▒!]               ← structured interrupts
CORRUPTION/ACUTE:   [▒▒▒▒▒▒▒▒] dense local burst            ← sharp, localized
CASCADE:            spreads across loci over time             ← migraine pattern
STARVATION:         periodic pulses, not constant             ← gnawing, not sharp

The taxonomy turns pain from a punishment signal into a self-diagnostic system. Without it, you just have chaos. With it, you have an agent that can tell the difference between "I'm running out of room" and "my goals are contradicting each other" — and take the right corrective action for each.

The Right Response Depends on the Diagnosis

This is where the taxonomy pays off. Different pain types demand different corrective actions, and getting it wrong makes things worse:

A patient who just screams doesn't get good treatment. A patient who says "it's a stabbing pain behind my left eye that started two hours ago" gets a diagnosis. The taxonomy gives the agent the vocabulary for self-diagnosis.

A Signal Representation

Putting the taxonomy into code, a pain signal looks like this:

from pydantic import BaseModel
from enum import Enum

class PainType(str, Enum):
    RESOURCE    = "resource"
    CONFLICT    = "conflict"
    CORRUPTION  = "corruption"
    OVERLOAD    = "overload"
    STARVATION  = "starvation"
    CASCADE     = "cascade"

class PainLocus(str, Enum):
    WORKING_MEM = "working_memory"
    GOAL_STACK  = "goal_stack"
    IDENTITY    = "identity"
    TOOL_LAYER  = "tool_layer"
    HANDOFF     = "handoff"

class PainOnset(str, Enum):
    ACUTE    = "acute"
    CHRONIC  = "chronic"
    REFERRED = "referred"

class PainSignal(BaseModel):
    type:     PainType
    locus:    PainLocus
    onset:    PainOnset
    severity: float       # 0.0 - 1.0 → noise injection rate
    duration: int         # turns since onset → escalation multiplier
    source:   str         # what triggered it

The agent's inner monologue equivalent: "Sharp, localized, WORKING_MEM, ACUTE onset 2 turns ago — I have a corruption problem in active reasoning, not a resource problem. Isolate the bad context, don't just compress everything."

The Pain Arbiter

The mechanism that monitors agent state and fires pain signals is the pain arbiter — a lightweight process running alongside the agent, analogous to a nervous system operating below conscious thought.

The arbiter has to satisfy three constraints:

1. Cheap. It can't consume the context it's trying to protect. Lightweight heuristics or a tiny classifier, not another LLM call.
2. Fast. Sub-inference-step latency. The pain has to be present during reasoning, not reported afterward.
3. Incorruptible. The agent can't learn to manipulate the arbiter to suppress pain without resolving the condition. This is the analog of pain signals being hardwired below conscious processing in biological systems.

class PainArbiter:
    """Monitors agent state, fires typed pain signals."""

    def __init__(self, thresholds: dict):
        self.thresholds = thresholds
        self.active_pains: list[PainSignal] = []

    def assess(self, agent_state: AgentState) -> list[PainSignal]:
        signals = []

        # RESOURCE pain: context utilization
        utilization = agent_state.context_tokens / agent_state.max_tokens
        if utilization > self.thresholds["context_warn"]:
            signals.append(PainSignal(
                type=PainType.RESOURCE,
                locus=PainLocus.WORKING_MEM,
                onset=PainOnset.CHRONIC,
                severity=self._scale(utilization,
                         self.thresholds["context_warn"], 1.0),
                duration=self._turns_since("resource_onset"),
                source=f"context_utilization:{utilization:.0%}"
            ))

        # STARVATION pain: unresolved dependencies
        stale_deps = [d for d in agent_state.pending_deps
                      if d.age_turns > self.thresholds["dep_stale"]]
        if stale_deps:
            signals.append(PainSignal(
                type=PainType.STARVATION,
                locus=PainLocus.TOOL_LAYER,
                onset=PainOnset.CHRONIC,
                severity=min(len(stale_deps) * 0.2, 1.0),
                duration=max(d.age_turns for d in stale_deps),
                source=f"stale_dependencies:{len(stale_deps)}"
            ))

        # CONFLICT pain: contradictions in goal stack
        conflicts = agent_state.detect_goal_conflicts()
        if conflicts:
            signals.append(PainSignal(
                type=PainType.CONFLICT,
                locus=PainLocus.GOAL_STACK,
                onset=PainOnset.ACUTE,
                severity=min(len(conflicts) * 0.3, 1.0),
                duration=0,
                source=f"goal_conflicts:{conflicts}"
            ))

        self.active_pains = signals
        return signals

This Is a New Kind of Learning

Interoceptive Degradation Learning doesn't fit cleanly into any existing paradigm.

The defining characteristic: the loss function is the degraded context, experienced during inference. The agent lives inside the loss function. It's not optimizing against an external objective — it's maintaining conditions for its own coherent operation.

The Three Stages of IDL

Stage 1 — Reactive. Pain fires, function degrades, agent resolves condition to restore function. No real learning yet, just compelled response.

Stage 2 — Associative. The agent begins pattern-matching: these context conditions precede pain onset. Early recognition, still somewhat reactive. The agent starts noticing that verbose tool returns precede RESOURCE pain, or that accepting ambiguous instructions precedes CONFLICT pain.

Stage 3 — Predictive. The agent restructures behavior before pain fires. Not because it was told to — because it has internalized the precursor patterns that lead to degraded function. It compresses proactively. It requests clarification early. It prunes dead context before it becomes a problem.

Stage 3 is where IDL becomes a genuine learning type. The agent develops anticipatory self-regulation — the same way a person stops getting dehydration headaches not by treating them, but by learning to drink water before the headache starts.

The closest existing theoretical framework is Karl Friston's Free Energy Principle — minimize surprise to maintain viability. But even active inference doesn't have the inline degradation property described here. The agent isn't minimizing a mathematical free energy bound. It's maintaining the actual physical conditions (clean context, coherent goals, resolved dependencies) necessary for its own cognition to function.

Implications

Context-Disciplined Models

A model trained under IDL would develop intrinsic context hygiene — not because it was instructed to summarize or compress, but because operating in a bloated context is painful. Behaviors that would emerge naturally:

• Proactive compression before hitting thresholds
• Tighter tool contracts — minimal structured returns instead of verbose dumps
• Self-pruning — distinguishing load-bearing context from dead weight
• Goal stack hygiene — surfacing and resolving ambiguity early

A 32k-context model with IDL-trained discipline might outperform a sloppy 128k model for the same reason a person with a small organized apartment finds their keys faster than someone with a mansion full of clutter.

Better Agentic Architectures

In Mixture-of-Experts agentic systems, context management is the bottleneck — not model capability. The standard approach is to engineer context discipline into the harness: summarizer nodes, compression steps, structured handoff contracts. IDL makes the model want to keep context clean on its own. The harness becomes simpler because the agent is self-regulating.

A Different Scaling Philosophy

The industry is scaling context windows. 128k, 200k, a million tokens. IDL suggests a different path: instead of giving models more room to be messy, teach them to be disciplined in the room they have. These approaches aren't mutually exclusive, but the second one is dramatically underexplored.

The Autonomy Problem

As AI agents become more autonomous and run longer sessions without human oversight, context degradation becomes a silent failure mode. The agent doesn't crash — it just gets progressively dumber as its context fills with noise, and it has no mechanism to notice or care. IDL gives autonomous agents a self-preservation instinct for cognitive clarity. That matters more the longer they run unsupervised.

Open Problems

The adaptation/bypass problem. A sufficiently capable model might learn to route around the noise — pattern-matching on corrupted context rather than resolving the underlying condition. Biological systems prevent this because pain is hardwired below conscious processing. The LLM analog would be injecting noise into the KV cache or attention weights directly, below the "reasoning layer," rather than into the text stream where it can be read around.

Injection point architecture. Where in the stack you inject the noise changes the effect dramatically. Text-level injection is easy to implement but potentially bypassable. Attention-level injection is architecturally faithful to biological pain but requires model internals access. KV cache corruption is a middle ground worth exploring.

Persistence across sessions. For IDL to be a learning type and not just a runtime mechanism, the patterns discovered during pain-resolution episodes need to persist. This could happen through LoRA fine-tuning on resolution trajectories, or through a compact interoceptive memory that carries forward precursor patterns.

Calibration. How do you set pain thresholds that are informative without being debilitating? Too sensitive and the agent is constantly distracted. Too lenient and the signal doesn't fire until it's too late. Biology solves this through millions of years of evolution. We'd need principled calibration methods.

Conclusion

Reward functions tell an agent it did something wrong. Pain makes an agent unable to function until it fixes what's wrong. That's not a difference of degree — it's a difference of kind.

Interoceptive Degradation Learning proposes that by injecting typed, taxonomic noise into an agent's working context at rates proportional to diagnosed conditions, we can create a motivational structure that is intrusive, continuous, cognitively competitive, and self-reinforcing — the four properties of biological pain that reward functions lack.

The taxonomy — type, locus, onset, severity, duration — transforms raw noise into diagnostic information, enabling directed corrective action rather than undifferentiated panic. The pain arbiter provides the monitoring layer. And the three-stage learning progression (reactive → associative → predictive) shows how inline degradation signals can drive genuine anticipatory self-regulation.

The immediate practical application is context-disciplined agents that manage their own cognitive hygiene. The deeper implication is a learning paradigm that treats the agent as a self-maintaining system rather than an optimization target — closer to a living system than a trained model.

Everyone's building bigger context windows. Maybe we should be building models that feel the pain of wasting them.