The Agent Stack is Leaking: The Case for Universal Intent Representation

The agent stack is leaking.

You write a careful prompt to one model. It works. You switch to another model—same task, same goal, same constraints—and you have to write the prompt again. You connect a tool via MCP (Model Context Protocol). The tool gets a structured call. But the reason the call was made—what the user actually wanted, under what budget, against what success criteria, with whose authority—is gone. It was reconstructed locally inside the agent and discarded at the protocol boundary.

This is not a model problem. This is an infrastructure problem.

The industry’s response has been to scale models harder and hope the brittleness goes away. It won’t. The thing missing from the agent stack isn’t intelligence; it’s a representation for what intelligence is for.

At Algedonic, we call this Universal Intent Representation (UIR). To understand it, we have to speak in two different voices. One is what we believe UIR will mean for the next decade. The other is what UIR, the technical artifact, actually does. Conflating them is how good ideas die.

The Vision: The HTML of Desire

If MCP is the USB-C of tools, and A2A is the SMTP of agent-to-agent handoff, then UIR is the part of the stack that doesn’t yet exist: a way to write down what was wanted such that it can travel between agents, models, and tools without being re-derived at every boundary.

The closest analogy is HTML, but the analogy needs a footnote. HTML standardized the structure of information on the web—and in doing so, it created the conditions for browsers, search, and the entire content economy. UIR aims to do the same for intent. Not by being a simple markup language, but by playing the same role: a shared substrate that lets independent systems agree on what a thing is, so that downstream tooling can be built on top.

We think this matters for three reasons that have nothing to do with the technology itself:

1. Portability is a precondition for competition. When intent lives in a model’s context window, the model becomes the system of record. Switch the model and you start over. The web didn’t take off because the first browser was the best. It took off because the page was the source of truth and the browser was replaceable. Intent should work the same way.

2. Audit is a precondition for trust. As autonomous systems take on financial transactions or healthcare logistics, “what did the agent do” is the wrong question. The right question is: “What was the agent trying to do, and was the action consistent with that?” You cannot answer that if intent is not a recoverable artifact.

3. Authority is a precondition for delegation. Right now, when you tell an agent to handle something, you give it permission to do almost anything within a vague boundary. UIR makes a clean separation possible: the intent carries the authority; the action is checked against it.

This is the governance layer. Not a policy engine that UIR replaces, but a substrate that makes policy engines coherent because they finally have a stable thing to refer to.

The Artifact: An Algebraic Grammar for Intent

Here is what UIR actually is, said the way we’d say it to a reviewer.

UIR is an algebraic grammar—five operators, atom-shaped expressions, a refinement relation, and a normal form. The “atom” is a four-tuple:

• A goal predicate over world states.

• A set of constraints that must hold during satisfaction.

• Success criteria by which satisfaction is determined.

• Provenance (the history and authority of the intent).

The operators compose these intents: sequential, parallel, choice, refinement, and withdrawal. There is no negation, no iteration, and no conditional. Each exclusion is deliberate.

Key Architectural Decisions:

• Declarative, not action-shaped: An atom describes a state of the world that must hold, not an action to perform. It is “The invoice is paid,” not “Pay the invoice.” This allows one intent to bind to an MCP tool today and an A2A handoff tomorrow without rewriting the objective.

• Tool calls witness intent; they do not generate it: When a tool runs, its result is checked against the UIR expression. The arrow runs from intent to execution, never the reverse. If we let it run the other way, UIR would collapse into a planning language—and we already have those.

• Provenance is identity: Two atoms with the same goal but different authors or rationales are not the same intent. This property makes the algebra a substrate for governance and accountability.

• Refinement is the load-bearing relation: Most useful properties—decomposition, audit, and verification—reduce to checking whether one expression refines another.

What UIR is NOT:

It is not self-authenticating (signing happens in envelopes outside the spec), it is not a policy engine (executors enforce; UIR represents), and it is not a runtime monitor for constraint violations. It is the language those systems speak.

If you come to UIR expecting a JSON schema with semantic field names, you’ll be disappointed. The algebra has to be load-bearing. If you can describe it without the words compose, refine, or decompose, it isn’t UIR.

Why the Two Voices Matter

The vision is bold because we believe the observation is correct: intent is the missing layer of the agent stack. The technical voice is conservative because the difference between an idea that survives contact with the real world and one that doesn’t is the discipline of saying only what your specification actually supports.

We’d rather make the bold claim once, label it as a vision, and then ship something defensible—than make the bold claim and quietly walk it back when someone reads the spec.

UIR is a working draft, a specification, and a reference implementation in Rust. It is not a finished thing. The five operators may turn out to be four, or six. The propositional fragment may need to grow.

If you do programming languages, formal methods, or agent infrastructure for a living, we’d like to hear from you. The “HTML of Desire” is a way of pointing at a layer that needs to exist. The algebra is the way we think it should actually be built.

We hope you’ll help us find out if we’re right.