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 Lineage: What Classical Computing Already Solved

Before the vision, a small piece of history that matters.

Classical computing rests on a foundation of formal language theory: grammars, automata, type systems, process algebras. These tools gave us precise ways to reason about programs and systems independently of their execution. A C program is a well-defined object whether or not a compiler has touched it. A protocol is specified before any wire carries a byte. The substrate could change — vacuum tubes to transistors to multicore to GPU — and the formal apparatus kept working, because composition and equivalence are mathematical structures, not facts about hardware.

Probabilistic computing as embodied in current LLM systems has not, so far, had an equivalent foundation. The "program" — the prompt, or the intent inferred behind it — is informal. The execution is opaque. The relationship between the two is not specified. The reliability problems that follow are not, in our view, primarily problems of model capability. They are problems of missing formalism at a layer above the model.

A useful precedent: process algebras developed in the 1980s for classical concurrent systems (CCS, CSP) have, in subsequent decades, transferred largely intact to settings their authors did not anticipate — distributed protocols, security protocols, and, in the work of Gay and Nagarajan on CQP and Ying on qCCS, even quantum processes. The reason such transfers are possible is that an algebra captures composition and equivalence as mathematical structure, not as facts about an execution substrate. A well-chosen algebra for agent intent has a comparable claim to durability across changes in the underlying compute model.

We make this observation only to motivate the algebraic style. We do not claim UIR predicts or extends to any specific future substrate. We claim something narrower: when classical computing needed a stable substrate, formal language theory provided one. The same kind of substrate is what current probabilistic systems are missing, and what UIR is a first attempt to provide.

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.

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.

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. Every regulatory regime that touches automation in the next ten years will need this.

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 what we mean by 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.

On Stewardship

We believe this representation will be as fundamental to the next decade of AI as TCP/IP was to the internet. We also believe it will not be built by one company. So we are not building it as one.

UIR is being developed in the open from day one. The specification is licensed CC-BY-4.0; the reference implementation is Apache-2.0. Algedonic convenes the project and contributes the initial draft, but Algedonic does not own UIR and is not seeking to. Our intended governance home is the Linux Foundation, specifically LF AI & Data — the same sub-foundation that hosts A2A. The realistic path is Sandbox stage in roughly six months, Incubation when the metrics support it (multiple contributing organizations, working bindings, an active TSC), Graduation when adoption is broad. We are not trying to skip steps. Standards that try to enter at Incubation without the metrics get sent back, and that's a worse outcome than entering cleanly at Sandbox.

What Algedonic gets out of this is straightforward: a credible open substrate makes our governance products possible. What Algedonic doesn't get is any special technical authority over UIR. The governance document treats Algedonic employees on the TSC as individuals, not as company representatives.

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, the criteria by which satisfaction is determined, and provenance. The operators compose intents: sequential, parallel, choice, refinement, withdrawal. There is no negation, no iteration, no conditional. Each exclusion is deliberate.

A worked example will make this concrete. Suppose a finance agent receives an intent to pay an outstanding invoice. The root UIR expression looks like:

goal:        invoice_paid(INV-42)
constraints: amount_within_budget(BUDGET-Q2)
criteria:    payment_confirmation_received ∧ ledger_updated
provenance:  { author: finance-bot, time: 2026-05-09T10:00Z,
               rationale: "Q2 supplier invoice per AP-7" }

goal:        invoice_paid(INV-42)
constraints: amount_within_budget(BUDGET-Q2)
criteria:    payment_confirmation_received ∧ ledger_updated
provenance:  { author: finance-bot, time: 2026-05-09T10:00Z,
               rationale: "Q2 supplier invoice per AP-7" }

goal:        invoice_paid(INV-42)
constraints: amount_within_budget(BUDGET-Q2)
criteria:    payment_confirmation_received ∧ ledger_updated
provenance:  { author: finance-bot, time: 2026-05-09T10:00Z,
               rationale: "Q2 supplier invoice per AP-7" }

The agent decomposes this into three sub-intents executed in sequence: verify the budget, charge the gateway, update the ledger. Each sub-intent carries a causal_antecedent pointing back to the parent. The composition (verify_budget ; charge_gateway ; update_ledger) is a refinement of the parent — written ⊑ — if and only if four conditions hold: the sub-goals jointly imply the parent goal, the parent's constraints are inherited, the parent's criteria are strengthened (not weakened), and the antecedent chain is intact. This relation is machine-checkable, decidably so in the propositional fragment.

That is the load-bearing claim. The thing that makes UIR more than a schema is that the refinement relation is real, axiomatized, and computable. Audit reduces to checking refinement. "Did the agent do what was asked" reduces to checking refinement. The arguments humans currently have about whether an autonomous system behaved correctly become, in principle, formal questions about whether the witnessed execution refines the stated intent.

How UIR Binds to MCP and A2A

A common misreading is that UIR replaces MCP or A2A. It does not. UIR sits underneath.

Concretely: an MCP tool call carries arguments and returns a result. With UIR, the same call also carries a reference to the UIR atom whose criteria it is intended to satisfy. When the result returns, it is checked against those criteria — the call witnesses satisfaction of the intent, rather than constituting it. 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.

For A2A, the binding is similar in spirit. An A2A task message embeds a UIR expression as a structured-data part with media type application/uir+json. When a receiving agent accepts the task, it accepts the obligation to satisfy the UIR expression. Sub-intents produced by the receiver cite the original expression as a causal antecedent. The refinement chain spans the agent boundary; audit follows it across organisations the way packets follow IP across networks.

What UIR is Not

It is not self-authenticating (signing envelopes live outside the spec). It is not a policy engine (executors enforce; UIR represents). It is not a complete refinement checker (we ship reflexivity and stub the rest). It is not a runtime monitor for constraint violations — that's the executor's job, and we are explicit about it.

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

What Could Kill This

Three failure modes, in order of likelihood.

Yet-another-schema syndrome. If UIR ends up looking like a JSON schema with semantic field names, it's lost. The algebra is the differentiator. We mention this first because it is the failure mode most projects in this space have already succumbed to, and the temptation to soften the algebra — make refinement "advisory," normal form "optional" — will increase under adoption pressure. We will resist it.

No anchor implementation. Specs without a working binding to something people already use are ignored. The MCP binding has to ship with v0.1, not after. We are building it in public, in the same repository as the spec, on the same release cadence.

Premature foundation submission. LF AI & Data's TAC will not incubate a paper spec from a single company. The roadmap reflects this: spec and reference implementation public this quarter; external technical reviewers engaged; a co-author for the formal semantics annex recruited from a programming languages or formal methods group; sponsor outreach beginning when the metrics support it. Realistically that is six to twelve months from now. We would rather get into Sandbox cleanly than be rejected from Incubation.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.

What We're Asking For

This is not a finished thing.

The five operators may turn out to be four, or six. The propositional fragment will probably need to grow. The MCP binding will mature only with use. The formal operational semantics needs a co-author who does this kind of work for a living. The thing we have is a working draft, a specification, a reference implementation in Rust, and a credible path to the Linux Foundation. The thing we need is the rest.

Four specific asks.

Holes in the algebra. If you do programming languages or formal methods, we want you to read the spec and tell us where it breaks. Is the operator set right? Is normal form really decidable as claimed? Is refinement correctly axiomatized? The earlier these get found, the cheaper they are to fix.

Adversarial cases. If you build agent systems, we want to know what intents your systems express that UIR cannot. What real-world cases would force a sixth operator? Where does the algebra flatten or distort?

Co-author leads. The formal operational semantics needs a co-author with PL or formal methods training. We are looking for a PhD student or post-doc whose group could host that chapter; pointers welcome.

Sponsor leads. Eventually UIR needs an LF AI & Data member to sponsor it into Sandbox. If you work at a member company and think this fits, we would like to talk.

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 will help us find out if we are right.

UIR is being developed in the open. The working draft of the specification, and the governance document will be published in the coming weeks. To get in touch ahead of that, write to info@algedonic.ai.