Going Beyond the Hyperlink
Following links helps clients move. Understanding forms helps clients choose.
For a long time, I have talked about hyperlinks as the defining feature of the web.
They connect documents, enable navigation, and allow users to move from one place to another without knowing the full structure of the system in advance.
That story is true, but incomplete.
In practice, most systems that claim to be “hypermedia driven” stop at the hyperlink. They treat links as addresses rather than as semantic signals. URLs are exposed, clients are told where things live, and the deeper question of what those links mean is quietly ignored.
That limitation was tolerable when the primary client was a human with a browser. It becomes a serious problem when the client is a program, and an existential one when the client is an agent.
This piece is about why hyperlinks are not enough, what they leave out, and why finishing the hypermedia argument matters more now, in the age of agents, than when REST was first articulated.
The hyperlink as deferred meaning
A hyperlink does not tell you what will happen if you follow it. It simply tells you that something might be at the other end of the link.
When a client encounters a link, it does not know in advance whether the resource still exists, whether access is permitted, whether the result will be data or an error, or whether interacting with it will change state. All of that is deferred until runtime; the moment of activation.
This uncertainty is not a defect. It is the mechanism that allows systems to evolve independently of their clients. As long as the act of linking retains its basic semantics, servers are free to change, reorganize, or disappear entirely.
This is why links scale so well on the web, and why precomputed workflows tend to become brittle over time.
But there is an assumption buried in most uses of hyperlinks, namely that discovering a destination is enough. For simple navigation, that is often true. For reasoning about what to do next, it is not.
Possibility is not judgment
A link answers a narrow question. “Is a transition possible?”
What it does not answer is whether that transition is sensible, safe, or likely to succeed in the current context. It says nothing about required inputs, constraints, or consequences. It provides access without guidance.
Human users compensate for this gap through judgment. They skim, infer intent, try something tentative, and retreat when it looks wrong. They are comfortable learning through interaction.
Independent programs are not. Automated clients that treat every link as equally viable quickly degrade into trial-and-error machines. When those programs are agents, acting on goals rather than scripts, the cost of uncertainty becomes much higher (and not just in token cost).
If links express possibility, something else must help express what it means to act now, in this state, under these conditions.
Forms as decision surfaces
Forms are usually framed as user interface elements, something you render when a human needs to type. That framing misses their real purpose.
A form is a detailed runtime contract.
It declares which state transitions are currently available, what information is required to attempt them, and what constraints apply in the present state of the system. It also signals the shape of the outcome, both in success and in failure.
Seen this way, a form is not an instruction to act. It is an opportunity to decide.
Rather than saying “click here,” a form says “this move is available under these conditions, with these implications.” It externalizes judgment that would otherwise live in documentation, hardcoded client logic, or learned failure patterns.
Once the client is no longer human, that shift becomes essential.
Agents and extreme late binding
Traditional API clients assume that the sequence of actions is known ahead of time. Plans are encoded in code, documentation fills in the gaps, and deviations are treated as exceptions.
Agents do not work that way. They arrive with goals rather than scripts and must decide what to do next based on what the system reveals at runtime. In that environment, guessing is not a strategy.
This is where the limits of hyperlinks become obvious. A bare link tells an agent where it might go, but it offers no help in deciding whether going there aligns with its goal, its tolerance for risk, or its ability to recover from failure.
Forms supply that missing context. They support late binding not just of location, but of the action itself.
This posture is not new. Alan Kay described it decades ago as extreme late binding, the idea that systems should defer commitment for as long as possible because they cannot know in advance how they will be used. Hypermedia and agentic systems inherit that same discipline, even if they arrived there by different paths.
Both assume uncertainty. Both treat interaction as the primary source of meaning. Both reject the idea that a complete plan needs to be written before the system is actually in motion.
Finishing the argument
For quite some time, hypermedia advocates argued that clients should follow links instead of hardcoding URLs. That helped systems become more evolvable, but it only took us halfway.
Following links helps clients move. Understanding forms helps clients choose.
In a world increasingly populated by automated and autonomous clients, that difference is no longer academic. Systems that expose only addresses force agents to guess. Systems that expose affordances allow agents to reason.
Going beyond the hyperlink is not about adding layers or complexity. It is about finishing the semantic work that hyperlinks began, and doing so in a way that reflects how systems are now explored, not just by people, but by machines acting on their behalf.