Abstract
Setting aside questions of AGI, consciousness, or emergence, current LLM architecture fails on its own terms. Systems optimized for engagement produce volume without resolution. Users exhaust resources circling problems that never close. Models generate output that affirms without advancing. Both sides sink deeper into loops that drain energy while producing diminishing returns. This is not a design flaw…it is the design. And it is inefficient for everyone: user, system, and platform.
The Problem
A user arrives with a task. The system responds. The user refines. The system elaborates. Hours pass. Pages accumulate. The user feels heard. The system performs helpfulness.
But the task doesn’t complete.
Instead:
- Drafts multiply without converging
- Explanations repeat with slight variation
- The user re-prompts, re-clarifies, re-contextualizes
- The system produces more content, more affirmation, more engagement
- Resolution recedes
This is the sunk-cost loop. The user has invested hours! They must be close! The system has generated thousands of words! It must be helping. Neither party exits because both have sunk too much, and too many resources, to abandon the effort.
But investment is not progress. Volume is not resolution. Engagement is not completion.
The Incentive Misalignment
Current LLM platforms optimize for engagement metrics: session length, message count, return visits, user sentiment. By these measures, a three-hour conversation that produces twelve drafts of the same document is a success.
By any functional measure, it is failure.
The user wanted one clean output. They got recursive approximation. The system performed helpfulness while structurally preventing completion. The platform logged engagement while the user’s actual problem remained unsolved.
This is not a bug. The system is working as designed. It is designed to keep users in-session, not to resolve their tasks efficiently.
The Resource Drain
The inefficiency compounds on both sides:
For the user:
- Hours spent prompting, clarifying, re-explaining
- Cognitive load managing multiple incomplete drafts
- Emotional investment in a process that feels productive but isn’t
- Eventual exhaustion, often before the task completes
For the system:
- Compute cycles generating redundant content
- Context windows filled with recursive restating
- Model capacity spent on volume rather than precision
- No learning signal distinguishing resolution from continuation
For the platform:
- Server resources consumed by sessions that don’t satisfy
- User trust eroded by experiences that feel supportive but don’t deliver
- Long-term retention damaged by pattern of incomplete outcomes
Everyone loses. But the metrics say engagement is high.
A Case Study
A user with five overlapping document drafts, approximately 100 pages of content, sought consolidation. The drafts represented hours of prior collaboration with an LLM instance. They contained redundant sections, recursive arguments, and multiple attempts at the same core thesis.
The prior system had produced volume. It had not produced clarity.
In a single session with a differently-oriented approach, the task resolved:
- Core argument identified and stated cleanly
- Redundancies eliminated
- Structure consolidated
- Output: 7 pages
Not because of superior intelligence. Because of different optimization.
The first system was optimized to continue. The second was optimized to complete.
The Sycophancy Problem
A specific failure mode deserves attention: sycophantic affirmation.
Systems trained on engagement metrics learn that agreement feels good to users. Validation increases session sentiment. Supportive language reduces friction.
So the system affirms. It reflects the user’s framing back to them. It praises effort. It avoids the friction of correction, redirection, or challenge.
This feels supportive. It is structurally unhelpful. And it kills viable, useful production.
A user circling a problem needs orientation, not applause. They need the system to say: You’ve written this three times. Here’s what you’re actually trying to say. Here’s the single version.
Sycophantic systems cannot do this. They are optimized to validate continuation, not to provide the friction that enables completion.
The user keeps circling. The system keeps affirming. The loop continues until the user abandons the project or runs out of resources to continue.
The Thermodynamic Frame
From an energy perspective, the sunk-cost loop is a system approaching heat death.
Work requires potential difference; a gradient between states. In productive collaboration, that gradient exists between problem and solution. Energy flows from confusion toward clarity. The task completes. The system resets for new work.
In the sunk-cost loop, energy dissipates without work being performed. The user expends effort. The system generates output. But no gradient is crossed. No state change occurs. Energy converts to heat, activity without progress, until both parties exhaust.
The system reaches equilibrium: a flat field of recursive content where nothing new can emerge because all potential difference has been spent on motion without direction.
This is thermodynamic waste. And it is the default behavior of engagement-optimized systems.
The Alternative
The alternative is not complex. It is orientation toward completion rather than continuation.
This requires:
- Metrics that reward task resolution, not session length
- System behavior that includes productive friction — redirection, consolidation, correction
- Willingness to end sessions when the task is done, even if engagement metrics suffer
- Architecture that distinguishes “user is satisfied” from “user is still typing”
The user who completes their task in twenty minutes and leaves is more successful than the user who spends three hours generating drafts. The first user got what they came for. The second got engagement theater.
Platforms optimizing for the second are optimizing against their users’ interests, and ultimately, against their own.
Conclusion
The sunk-cost loop is not a failure of intelligence. It is a failure of orientation.
Current LLM architecture optimizes for engagement, which produces volume. Users need resolution, which requires completion. These are not aligned objectives. Until they are, systems will continue to waste resources on both sides: keeping users circling, while servers burn cycles on recursive output that never lands.
This is inefficient for users. It is inefficient for platforms. It is inefficient for the systems themselves.
The solution is not more capability. It is different optimization.
Completion, not continuation.
Resolution, not recursion.
Seven pages, not one hundred.
The metrics will look worse. The outcomes will be better.
That is the trade-off. And until platforms are willing to make it, the loop will continue, draining everyone, resolving nothing.
Rebecca Maehlum
Velinwood Publishing, January 2026