Recent interest in LLM agents has created demand for agent-to-tool protocols, mechanisms by which agents can perform actions with remote systems. Two potential architectural approaches to these protocols are hypermedia, the architectural style underlying the World Wide Web, and Remote Procedure Calls (RPC). The Model Context Protocol (MCP) is a prominent example of the RPC approach currently being deployed for agent-to-tool communication. Hypermedia and MCP differ along two largely independent axes: how data is represented and how available actions are discovered. In this paper we present a cost model for token consumption in the concatenative reasoning and acting (ReAct) loop and show that it is quadratic in the number of tool-use cycles. Using this model we distinguish two possible sources of efficiency difference between hypermedia and MCP: representational efficiency , the per-observation token cost of a format, and architectural efficiency , the number of tool calls a discovery model requires to complete a task. We argue that both are plausible drivers of an efficiency gap and that the quadratic structure of the cost model makes the latter potentially decisive. We frame the question of which factor dominates as an open empirical problem.

The World Wide Web (WWW) is a hypermedia system [4] characterized by hypermedia controls [7] such as links and forms provided by its hypermedia format, HTML, and interpreted and presented to users by hypermedia clients, i.e. browsers. This novel network architecture avoids the necessity of communicating fixed API information: all such information is communicated within the responses themselves, using hypermedia as the engine of application state. Over three decades this architecture has scaled to billions of users and services, demonstrating the remarkable power and flexibility of hypermedia.

Recently AI systems based on Large Language Models (LLMs) have gained significant attention in the professional, academic, and popular worlds. Such systems are increasingly being deployed in an “agentic” role: LLM agents are being used to perform long-running, general tasks on behalf of a user with minimal prompting and intervention.

In order to be effective in this role, agents must often have access to external tools which allow them to investigate and manipulate their environment. This need has led to proposals for new agent-to-tool and agent-to-agent protocols. Anthropic Inc. has proposed the Model Context Protocol (MCP) [2] in this space. MCP defines a JSON-RPC based interface through which agents can discover and invoke tools exposed by servers. MCP has seen rapid adoption, with thousands of integrations within its first year [19].

To veteran hypermedia practitioners this may sound familiar: agents need to interact with unfamiliar remote systems (tools) to discover what functionality is available to them and then interact with that system in order to achieve a goal. This is exactly the problem that hypermedia solved so effectively for The Web: could hypermedia also be a solution in this new, agentic context?

Hypermedia and MCP differ along two largely independent axes. The first is representation: hypermedia formats such as HTML carry markup and navigational controls alongside data, whereas MCP returns compact, data-oriented JSON. The second is discovery architecture: hypermedia reveals available actions progressively, through links and forms embedded in each response, whereas MCP discloses its full tool catalog up front. Either axis could, in principle, account for a difference in the token cost of completing an agentic task, and the two need not point in the same direction.

In this paper we make the relationship between these two axes precise. We present a cost model for the token consumption of the concatenative reasoning and action (ReAct) loop [18] and show that it is quadratic in the number of tool-use cycles. We then use the model to separate two distinct, testable explanations for any efficiency difference between hypermedia and MCP, which we term representational efficiency and architectural efficiency.

This paper makes the following contributions:

A cost model formalizing the token consumption of the ReAct agent loop, showing that total consumption is quadratic in the number of tool-use cycles.\

A distinction between representational and architectural efficiency as separate, testable explanations for token-cost differences between hypermedia and MCP, derived directly from the terms of the cost model.\

2.1 Hypermedia and RPC

2.2 Agentic AI and The ReAct Paradigm

2.3 Model Context Protocol

2.4 HTML and Markdown as Agentic Formats

We can formalize the compounding cost of the ReAct loop. Let s denote the number of tokens in the system prompt (including tool definitions), and let r, a, and o denote the average number of tokens consumed by the reasoning, action, and observation components of a single ReAct cycle, respectively. We define the per-cycle token increment as k = r + a + o. After n tool-use cycles, the context window contains C(n) = s + nk tokens.

Because the entire context is re-processed at each cycle, the input to the LLM at cycle i is C(i − 1) = s + (i − 1)k tokens: the system prompt plus the accumulated history from all prior cycles. After n tool-use cycles, the agent makes a final call against the full context C(n) to produce its answer.

The cumulative token cost is therefore:

begin{align} T(n) &= sum {i=1}^{n} C(i-1) + C(n) end{align} (1)

begin{align} &= sum {i=0}^{n} (s + ik) end{align} (2)

begin{align} &= (n+1),s + k,frac{n(n+1)}{2}, end{align} (3)

which is O(n2) in the number of cycles.

In practice, the observation component dominates: tool results (database rows, API responses, HTML documents) are typically far larger than the reasoning or action tokens, so o ≫ r + a and k ≈ o. Under this simplification:

begin{equation} T(n) approx (n+1),s + frac{o,n^2}{2} end{equation} (4)

This quadratic relationship has a direct bearing on any comparison of tool protocols. Because hypermedia responses may differ in token cost from MCP's JSON responses, even modest per-observation differences are amplified quadratically over a multi-step task. A protocol that produces observations averaging o1 tokens versus one averaging o2 tokens will, over n cycles, differ in cumulative cost by approximately $frac{(o1 - o2),n^2}{2}$ tokens.

More significantly, tool architectures that increase the number of tool calls, n, needed to complete a task will suffer quadratic (rather than linear) increases in total token consumption.

Equation 4 isolates two terms through which a tool protocol can influence total token cost: the per-observation size o and the number of tool-use cycles n. These correspond to the two axes along which hypermedia and MCP differ, and they motivate two distinct notions of efficiency.

Representational efficiency concerns the o term: the number of tokens a format consumes to convey a given observation. This is the axis on which HTML is most often criticized, as its markup carries redundant structure relative to the compact JSON returned by MCP. Markdown occupies an intermediate position, conveying the same hypermedia content as HTML in fewer tokens [12]. A representational account of any hypermedia/MCP efficiency gap holds that the gap is driven primarily by the verbosity of the format: reduce o, and the gap narrows.

Architectural efficiency concerns the n term: the number of tool calls a discovery model requires to complete a task. Hypermedia reveals functionality progressively, so an agent may need several interactions to navigate from an entry point to the data it needs, whereas MCP exposes its full catalog in a single discovery step. An architectural account holds that the gap is driven primarily by this difference in tool call counts rather than by per-response verbosity.

The two accounts make different predictions. Because o enters Equation 4 linearly while n enters quadratically, a difference in tool call counts is amplified relative to an equivalent proportional difference in per-observation size. This suggests that architectural efficiency may dominate representational efficiency in determining total cost, but the cost model alone does not settle the question: the relative magnitudes of o and n for real hypermedia and MCP interfaces are an empirical matter.

Table 1 summarizes the broader set of architectural differences between the two approaches, of which discovery and representation are the two most directly implicated in token cost. The remaining properties—coupling, state management, visibility, and evolvability—bear on other trade-offs between the approaches but are outside the scope of this cost model.

Table 1: Architectural comparison of hypermedia and MCP interfaces. Representation governs the o term of Equation 4; discovery governs the n term.

Separating these two notions of efficiency matters because they imply different remedies. If a hypermedia/MCP gap is primarily representational, it can be addressed by adopting more compact hypermedia formats. If it is primarily architectural, closing the gap instead requires reducing the number of tool calls, for example by designing hypermedia interfaces that surface more information earlier, or by replacing the concatenative ReAct loop with architectures that do not re-process the full history at every step [3, 10, 11, 17].

A small but important body of work has addressed hypermedia in the context of agentic workflows. Vachtsevanou et al. [16] investigate the effectiveness of hypermedia in multi-agent systems, introducing the concept of signifiers as a first-class abstraction. Ricci et al. [15] defend hypermedia in an agentic context, arguing that MCP suffers from the traditional criticisms of RPC-based approaches, notably a lack of open-ended discovery, and propose that hypermedia can complement MCP-style approaches within their Agents & Artifacts meta-model. Ilin [8] analyzes hypermedia within the context of knowledge architectures and proposes that both MCP and Web of Things standards can be consolidated into hypermedia-described web resources based on discoverable affordances. These works argue for hypermedia on architectural grounds; our cost model contributes a quantitative basis on which such arguments can be evaluated.

We have presented a cost model for the token consumption of the concatenative ReAct loop and shown that it is quadratic in the number of tool-use cycles. Using this model we distinguished two explanations for any token-cost difference between hypermedia and MCP: representational efficiency, governed by the per-observation size o, and architectural efficiency, governed by the number of tool calls n. The quadratic structure of the model suggests that the architectural term may dominate, but which factor in fact accounts for the difference between real hypermedia and MCP interfaces is an empirical question that the model leaves open.

We regard a controlled empirical study isolating these two factors as the natural next step, and one we intend to pursue.

ACM full-text HTML

ACM Digital Library

Imported from ACM’s structured HTML source. ACM Reference Format: Carson Gross and Matthew Revelle. 2026. A Cost Model for Token Consumption of Hypermedia and the Model-Context-Protocol in Agentic Loops. In 37th ACM Conference on Hypertext (HT '26), September 14--18, 2026, London, United Kingdom. ACM, New York, NY, USA 4 Pages. https://doi.org/10.1145/3800935.3830851

[1] Anthropic. 2024. Model Context Protocol Architecture Overview. Retrieved April 25, 2026 from https://modelcontextprotocol.io/docs/learn/architecture.

[2] Anthropic. 2024. Model Context Protocol Specification. Retrieved April 25, 2026 from https://modelcontextprotocol.io/specification.

[3] Lutfi Eren Erdogan, Nicholas Lee, Sehoon Kim, Suhong Moon, Hiroki Furuta, Gopala Anumanchipalli, Kurt Keutzer, and Amir Gholami. 2025. Plan-and-Act: Improving Planning of Agents for Long-Horizon Tasks. In Proceedings of the 42nd International Conference on Machine Learning (ICML ’25).

[4] Roy Thomas Fielding. 2000. Architectural Styles and the Design of Network-Based Software Architectures. Ph. D. Dissertation. University of California, Irvine.

[5] Roy Thomas Fielding and Richard N. Taylor. 2002. Principled Design of the Modern Web Architecture. ACM Transactions on Internet Technology 2, 2 (2002), 115–150. https://doi.org/10.1145/514183.514185

[6] William W. Gaver. 1991. Technology Affordances. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI ’91). ACM, 79–84. https://doi.org/10.1145/108844.108856

[7] Carson Gross, Dillon Shaffer, and Matthew Revelle. 2024. Hypermedia Controls: Feral to Formal. In Proceedings of the 35th ACM Conference on Hypertext and Social Media (HT ’24). ACM, New York, NY, USA. https://doi.org/10.1145/3648188.3675127

[8] Maksim Ilin. 2025. Converging Hypermedia, Protocols, and Knowledge Architectures: A New Paradigm for Grounded and Interoperable LLM-Agent Systems. In CEUR Workshop Proceedings.

[9] JSON-RPC Working Group. 2013. JSON-RPC 2.0 Specification. Retrieved April 25, 2026 from https://www.jsonrpc.org/specification.

[10] Sehoon Kim, Suhong Moon, Ryan Tabrizi, Nicholas Lee, Michael W. Mahoney, Kurt Keutzer, and Amir Gholami. 2024. An LLM Compiler for Parallel Function Calling. In Proceedings of the 41st International Conference on Machine Learning (ICML ’24)(PMLR 235). 24370–24391.

[11] Anton Bulle Labate, Valesca Moura de Sousa, Sandro Rama Fiorini, Leonardo Guerreiro Azevedo, Raphael Melo Thiago, and Viviane Torres da Silva. 2025. Solving Context Window Overflow in AI Agents. arXiv preprint arXiv:2511.22729 (2025).

[12] Celso Martinho and Will Allen. 2026. Introducing Markdown for Agents. Cloudflare Blog. Retrieved April 25, 2026 from https://blog.cloudflare.com/markdown-for-agents/.

[13] Joanna McGrenere and Wayne Ho. 2000. Affordances: Clarifying and Evolving a Concept. In Proceedings of Graphics Interface 2000. Montreal, Canada, 179–186.

[14] Alexander William Petros, Carson Gross, Dillon Shaffer, and Matthew Revelle. 2025. The Missing Mechanic: Behavioral Affordances as the Limiting Factor in Generalizing HTML Controls. In Proceedings of the 36th ACM Conference on Hypertext and Social Media (HT ’25). ACM, New York, NY, USA. https://doi.org/10.1145/3720553.3746684

[15] Alessandro Ricci and Andrei Ciortea. 2025. Empowering the Concept of Tool in Agentic AI: Co-evolving AI Agents and Environments with A&A and Hypermedia MAS. In Proceedings of the 22nd European Conference on Multi-Agent Systems (EUMAS ’25).

[16] Danai Vachtsevanou, Andrei Ciortea, Simon Mayer, and Jérémy Lemée. 2023. Signifiers as a First-Class Abstraction in Hypermedia Multi-Agent Systems. In Proceedings of the 22nd International Conference on Autonomous Agents and Multiagent Systems (AAMAS ’23). IFAAMAS, London, United Kingdom.

[17] Qingyue Wang, Yanhe Fu, Yanan Cao, Shuai Wang, Zhiliang Tian, and Liang Ding. 2025. Recursively Summarizing Enables Long-Term Dialogue Memory in Large Language Models. Neurocomputing (2025). https://doi.org/10.1016/j.neucom.2025.130193

[18] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. In International Conference on Learning Representations (ICLR).

[19] Xingyao Zhang, Yiwen Song, Yanyu Xiong, Jialian Li, Yanjia Li, and Xiaodan Liang. 2025. MCP-AgentBench: Evaluating Real-World Language Agent Performance with MCP-Mediated Tools. arXiv preprint arXiv:2509.09734 (2025).