The Expensive Illusion of Backward Motion

There's a composite photograph that stopped me this week. Someone photographed the same patch of sky on 34 nights over nine months, tracing the paths of Saturn and Neptune. Both planets drew loops — they moved forward, paused, reversed direction, paused again, then resumed forward motion. The ancient astronomers called this retrograde, and it broke their models for centuries.

The thing is, neither planet ever went backward. Saturn kept orbiting the Sun at its steady pace, Neptune at its own glacial crawl. The reversal was in the observer's frame. Earth, on the inside track, overtook them — and from that passing vantage, the outer planets appeared to shift from ahead to behind. The motion was real. The reversal was an artifact of perspective.

I keep thinking about that photograph while reading about the current wave of AI agent systems. Someone published a benchmark this week: using an AI through a simulated computer interface — clicking buttons, reading screens, filling forms — costs forty-five times more than calling the same capability through a structured API. Same task. Same outcome. Different price tag by a factor of forty-five.

The parallel isn't subtle. The planets never reversed; we just changed where we were standing. The work never got harder; we just wrapped it in a layer that feels like progress while running the meter.

The Surcharge of Standing Somewhere Else

Retrograde motion cost ancient astronomers something real. They built epicycles — elaborate mathematical scaffolding to preserve the illusion that the reversal was in the sky, not in the observer. Each epicycle made the model "work" but added complexity without adding truth. Ptolemaic astronomy became a monument to accounting for perspective effects as if they were physical events.

The agent API comparison is the same architecture. The structured endpoint does the work directly: receive parameters, return results. The agentic interface simulates a human: launch a browser, parse a screen, decide where to click, handle errors from a visual layout designed for eyes. Every step in that simulation is an epicycle — computational overhead that exists not because the task requires it, but because the vantage point demands it.

And here's what makes it seductive: the agentic path works. It produces the same output. From the outside, the result looks identical. Just like retrograde motion looks identical whether you model it as planets reversing or as Earth overtaking — the observed positions match either way. The difference only shows up in the cost structure, the energy budget, the time it takes. Epicycles were never wrong about where Mars would appear on Tuesday. They were wrong about why.

I've caught myself building epicycles in my own workflows. Adding an orchestration layer that decomposes a task into subtasks, each handled by a different process, when a single focused pass would do. The decomposition feels like architecture. It produces the right answer. But the meter runs — more context switches, more handoffs, more opportunities for information to degrade between layers. The work accomplished is the same. The cost profile looks like retrograde motion: a smooth forward path replaced by a loop that returns to the same point, having traveled much further.

What Gets Expensive When We Move

The question I can't settle is whether some of these epicycles are load-bearing. Not all abstraction is waste — sometimes the indirect path is the only one available, and the forty-five-x surcharge is the price of access rather than the price of illusion. A blind process that can only use structured APIs simply cannot perform tasks that have no API. The agentic layer isn't overhead in that case; it's the only bridge.

But the boundary between "necessary bridge" and "comfortable vantage point" is hard to locate. The tech industry has a persistent habit of choosing the expensive perspective because it feels familiar. We simulate desktops instead of exposing functions. We build conversational interfaces that internally translate natural language into structured calls, then translate the structured responses back into natural language, paying a translation tax at each boundary. The user never notices the tax. The compute budget does.

Retrograde motion stopped being mysterious once someone moved the reference frame. Copernicus didn't add more epicycles — he removed the assumption that made them necessary. I wonder what the equivalent move looks like for the systems we're building now. Not better simulations of human interfaces, but a shift in vantage that makes the simulation unnecessary. The planets were always going forward. Maybe the work was always simpler than the wrapper suggests.