Web Verbs: Typed Abstractions for Reliable Task Composition on the Agentic Web

The Web is evolving from a medium that humans browse to an environment where software agents act on behalf of users. Advances in large language models (LLMs) make natural language a practical interface for goal-directed tasks, yet most current web agents operate on low-level primitives such as clicks and keystrokes. These operations are brittle, inefficient, and difficult to verify. Complementing content-oriented efforts such as NLWeb’s semantic layer for retrieval, we argue that the agentic web also requires a semantic layer for web actions. We propose \textbf{Web Verbs}, a web-scale set of typed, semantically documented functions that expose site capabilities through a uniform interface, whether implemented through APIs or robust client-side workflows. These verbs serve as stable and composable units that agents can discover, select, and synthesize into concise programs. This abstraction unifies API-based and browser-based paradigms, enabling LLMs to synthesize reliable and auditable workflows with explicit control and data flow. Verbs can carry preconditions, postconditions, policy tags, and logging support, which improves \textbf{reliability} by providing stable interfaces, \textbf{efficiency} by reducing dozens of steps into a few function calls, and \textbf{verifiability} through typed contracts and checkable traces. We present our vision, a proof-of-concept implementation, and representative case studies that demonstrate concise and robust execution compared to existing agents. Finally, we outline a roadmap for standardization to make verbs deployable and trustworthy at web scale.

💡 Research Summary

The paper “Web Verbs: Typed Abstractions for Reliable Task Composition on the Agentic Web” addresses a fundamental limitation of current large‑language‑model (LLM) powered web agents: they operate at the level of clicks, keystrokes, and low‑level DOM manipulations. Such fine‑grained actions are brittle, costly in terms of inference cycles, and difficult to verify, especially when tasks span multiple sites or require complex user‑interface flows (login, MFA, consent dialogs, shopping‑cart operations, etc.). While content‑oriented initiatives like NLWeb provide a semantic layer for information retrieval, the authors argue that a complementary semantic layer for web actions is essential for a truly agentic web.

Core Proposal – Web Verbs

A Web Verb is a typed, function‑like abstraction that encapsulates a complete site capability. Each verb:

1. Has a natural‑language description that makes its intent clear to both developers and agents.
2. Specifies typed inputs and structured outputs, enabling static checking and seamless composition.
3. Encodes pre‑conditions, post‑conditions, policy tags, and logging hooks, turning every invocation into a contract that can be audited.
4. Can be implemented either by calling an existing server‑side API or by driving a browser via automation tools (e.g., Playwright). The implementation details are hidden behind a uniform interface, so agents need not distinguish between “API” and “GUI” calls.

By exposing site functionality as a massive, web‑scale library of such verbs, the web itself becomes a typed, object‑oriented platform. Agents can discover verbs through a vector‑based metadata store (similar to NLWeb’s entity store), select the appropriate ones, and synthesize a concise program that orchestrates them.

Advantages Over Existing Paradigms

1. Reliability – Verbs are packaged and maintained by site developers, eliminating the need for agents to rediscover fragile UI sequences on each run.
2. Efficiency – A multi‑step workflow that would require dozens of low‑level actions collapses into a handful of function calls, reducing the number of LLM inference steps and overall latency.
3. Verifiability – Typed contracts and explicit logging enable post‑hoc checking, debugging, and security auditing. Policy tags can enforce safety constraints at verb boundaries.

System Architecture and Code Synthesis

The authors integrate the verb layer into an LLM‑based coding agent. The agent receives a natural‑language task, queries the verb metadata store for relevant signatures, and generates a complete program (in Java for the prototype) that calls the selected verbs. Because each verb’s interface is well‑defined, the agent can perform precise argument mapping and reason about data flow. The generated program may include control structures (conditionals, loops) that operate on verb outputs, allowing complex decision‑making to be expressed statically rather than incrementally during execution. This shifts the agent’s role from step‑by‑step action prediction to high‑level program synthesis.

Prototype and Empirical Evaluation

A proof‑of‑concept implementation was built:

• Verb registration: Developers annotate APIs or record browser interaction traces (via a Chrome extension) and store signatures, types, and docstrings in a vector database.
• Execution engine: For API‑backed verbs, direct HTTP calls are made; for UI‑backed verbs, Playwright scripts execute the required DOM actions and return structured results.
• Case studies: Two real‑world scenarios—travel planning (searching hotels, booking flights) and furniture shopping (browsing, adding to cart, checkout)—were implemented using a handful of verbs. The system completed each task reliably.
• Benchmark: A 100‑task benchmark covering diverse domains was assembled. Compared against two baseline agents (a pure browser‑agent and a pure API‑agent), the verb‑based system achieved 100 % success with reproducible results, while baselines struggled on multi‑site or UI‑heavy tasks (success rates 30‑50 %). Moreover, execution time was 2.7× to 8.3× faster than baselines.

Standardization Roadmap

Recognizing that widespread adoption requires community agreement, the paper outlines a roadmap:

• Naming conventions for verbs (e.g., site::action_name).
• Registration protocols (metadata schema, versioning, discovery APIs).
• Developer tooling (IDE plugins, automated trace capture, test harnesses).
• Security and privacy frameworks (policy tags, sandboxing, audit logs).
• Benchmark suites for evaluating verb coverage, latency, and safety.

Conclusions

Web Verbs provide a high‑level, typed, and auditable interface that bridges the gap between server‑side APIs and client‑side UI automation. By elevating the abstraction level, they enable LLM‑driven agents to synthesize concise, reliable programs, dramatically improving success rates and efficiency on complex web tasks. The authors argue that a global, action‑centric semantic layer is a prerequisite for the next generation of “agentic web” applications, and they invite the broader web community to collaborate on standardizing and deploying Web Verbs at scale.