From pipeline jungles to orchestration jungles

In 2015, a team at Google published a paper that changed how the industry thinks about production machine learning. “Hidden Technical Debt in Machine Learning Systems” by Sculley et al. argued that real-world ML systems accumulate maintenance costs far beyond the model itself — in data pipelines, configuration, monitoring, and the glue code that holds everything together. The paper coined terms that became industry vocabulary: pipeline jungles, glue code, hidden feedback loops, and the CACE principle.

A decade later, agentic AI systems are relearning many of the same lessons — and encountering a few new ones. The agentic technical debt framework (forthcoming in Communications of the ACM, October 2026) explicitly builds on Sculley’s foundation while identifying the failure modes that agents introduce beyond what traditional ML anticipated.

This post maps the lineage: which concepts carried over, which evolved, and what is genuinely new.

Key takeaways

• Five of Sculley’s core concepts have direct agentic equivalents — the patterns are structural, not technology-specific.
• The agentic framework adds one concept that Sculley’s model did not need: autonomy and the principal–agent gap.
• Stochastic tax — a per-transaction operating cost absent from Sculley’s framework — is the second major addition.
• Understanding the lineage helps teams avoid reinventing mitigations that already exist and focus effort on the genuinely new challenges.

What carried over

Pipeline jungles → orchestration jungles

Sculley described pipeline jungles as data-preparation logic that becomes “a jungle of scrapes, joins, and sampling steps, often with intermediate files output.” The jungle forms because data processing evolves organically — each new data source gets its own ingestion path, and eventually the tangle becomes so complex that only end-to-end integration tests can verify it.

The agentic equivalent is the orchestration jungle: multi-agent workflows where sequential handoffs, shared state, and retry wrappers become so intertwined that modifying one agent requires revalidating the entire chain. The formation mechanism is identical — organic growth under delivery pressure — and so is the primary remedy: step back and redesign the graph rather than adding another patch.

The difference in severity is that pipeline jungles process data. Orchestration jungles process decisions. A data pipeline that produces a malformed row in a training set has a delayed, statistical impact. An agent chain that makes a wrong tool call has an immediate, concrete one.

Glue code → prompt wrappers and retry logic

Sculley found that ML systems accumulate massive amounts of glue code — the infrastructure between the model and the rest of the system. His estimate: only a small fraction of a real-world ML system’s code is the model itself.

In agentic systems, the glue takes different forms — prompt patches, fallback chains, error-handling shims, format converters — but the structural role is the same. This layer is now called the agent harness: the constraints, verification gates, and state management that wrap the agent’s reasoning loop. Understanding which layer is failing — the reasoning loop or the harness around it — is the first diagnostic question when an agent misbehaves.

CACE principle → semantic ambiguity

Sculley’s CACE principle (Changing Anything Changes Everything) describes the entanglement problem in ML feature spaces: because features interact in complex ways, modifying one feature can change the model’s behavior on inputs that seem unrelated.

The agentic version is semantic ambiguity: natural-language instructions lack the precision of formal syntax, and small wording changes in a prompt can shift which tools the agent calls, how it reasons, and when it escalates. The entanglement mechanism is different — feature correlation versus instruction interpretation — but the practical consequence is the same: local changes have non-local effects, and there is no static analysis tool that can predict the impact.

Prompt drift is the cumulative result of CACE applied to prompts. Each individually reasonable edit shifts behavior incrementally, and the cumulative drift is visible only in hindsight.

Hidden feedback loops → persistent state

In traditional ML, hidden feedback loops occur when a model’s output influences its own future training data. A recommendation system that drives user behavior creates training data biased toward its own recommendations, gradually narrowing the range of content it surfaces.

Agent memory creates an analogous loop in real time. The agent’s decisions get encoded into persistent state — customer preferences, risk assessments, workflow outcomes — that influences the agent’s future decisions. A classification that was correct at write time becomes a constraint at read time, long after the underlying reality has changed.

The velocity of the loop is different. ML feedback loops operate over retraining cycles (weeks to months). Agent memory loops operate at conversation speed (minutes to hours). The faster loop means the debt compounds faster and the detection window is shorter.

Configuration debt → tool schema drift

Sculley warned about configuration debt: the accumulating cost of system parameters that are hard to reason about, difficult to test, and interact in unpredictable ways.

In agentic systems, the configuration surface is the combination of tool schemas, model parameters, orchestration graphs, and autonomy tier definitions. These interact in ways no single team member fully understands, and changes to one component can alter behavior in another. Tool schema contracts are the agentic mitigation — treating tool interfaces like APIs with enforced contracts rather than informal descriptions.

What is genuinely new

Autonomy

This is the concept that Sculley’s framework did not need because traditional ML systems do not have it. A predictive model does not decide what to do next. It takes an input and returns a score. The decision about what to do with the score — and whether to act on it — belongs to the surrounding system.

An agent decides what to do next. It selects tools, sequences steps, and determines when to escalate. This creates a principal–agent gap: the distance between what you intended and what the agent actually does. The gap is irreducible in any system where the executor has discretion, and managing it requires graduated autonomy — tiered permissions based on action risk and agent competence.

No concept in Sculley’s framework maps to this. It is the core contribution that the agentic technical debt framework adds to the lineage.

Stochastic tax

Sculley’s paper discusses the cost of maintaining ML systems, but the costs are all debt-like: accumulated liabilities that can be reduced through refactoring, simplification, and better engineering practices. There is no concept of an irreducible per-transaction operating cost.

Stochastic tax fills this gap. It is the recurring cost of running a non-deterministic system reliably — evaluation, monitoring, retries, escalation, revalidation — that exists even in a well-governed system. You cannot refactor your way to zero stochastic tax because the tax is a consequence of non-determinism itself, not of poor engineering.

This distinction has practical implications. If your operating costs are high because of debt (fragile prompts, undocumented schemas, tangled orchestration), the fix is refactoring. If your operating costs are high because of tax (irreducible evaluation and monitoring costs for inherently uncertain tasks), the fix is budgeting and optimization, not redesign.

Consequence coupling

Traditional ML systems predict. The prediction is consumed by a downstream system that decides what to do with it. There is a separation between the probabilistic output and the real-world action.

Agentic systems couple probabilistic output to real-world consequence directly. A single prompt determines which tool is called, which record is modified, and which customer receives a decision. This coupling changes the risk calculus: the same error rate that is acceptable for a recommendation (the user sees a slightly less relevant result) is unacceptable for an agent (the customer receives a wrong refund amount).

Sculley did not need to address this because the systems he analyzed had an explicit separation between prediction and action. Agents eliminate that separation, which is why governance controls that bound the agent’s action space — graduated autonomy, tool schema contracts, deterministic gates — are essential in a way they were not for traditional ML.

Why the lineage matters

Understanding where agentic technical debt comes from — which patterns are inherited from prior ML systems and which are genuinely new — has practical value.

For the inherited patterns, mitigations already exist. Pipeline jungles have a known remedy (redesign the graph). Glue code has a known remedy (investment in shared infrastructure). Configuration debt has a known remedy (typed contracts and automated testing). Teams that recognize these patterns in their agent systems can adopt the existing playbooks rather than inventing new ones.

For the new patterns, novel mitigations are needed. Autonomy management (graduated tiers), stochastic tax measurement (per-transaction dashboards), model gateways that absorb upstream provider changes, and consequence-aware governance (golden-set evaluation with trace diffing) do not have precedents in Sculley’s framework. These are the areas where the agentic technical debt framework makes its primary contribution.

The worst outcome is treating agentic systems as entirely new and ignoring the decade of ML operations research that came before. The second worst is treating them as just ML and missing the genuinely novel failure modes that agents introduce.

For the full framework — both inherited and new — see Agentic technical debt: a governance framework for AI agents.