WebAgents: Unbundling Agent Creation, Hosting, and Execution for an Agent-Native Web

Dario Fenoglio, Martin Gjoreski, Marc Langheinrich, Pradyumna Chari, Ramesh RaskararXiv 2026 · arXiv

TL;DR

WebAgents introduces a framework to "unbundle" AI agents, separating their creation, hosting, and execution. By using a signed, portable package format (agent.pkg) and a user-controlled runtime (OpenClaw), it allows agents to run across different environments while ensuring that users—not the agent creators—retain ultimate authority over data, tools, and inference budgets.

What Problem Does This Paper Address?

Currently, AI agents are often "bundled" silos. If you want to use a specific agent, you typically have to use the creator's hosted service (giving them your data and credentials) or manually set up a complex local environment. This lack of interoperability prevents the emergence of a true "Agentic Web"—an open ecosystem where agents can be discovered, composed, and executed as easily as we browse websites today.

The core challenge is authority. How can you download and run a sophisticated agent from a third party without granting it unrestricted access to your private files, API keys, or a blank check for LLM costs? WebAgents tackles this by creating a clear boundary between the agent's logic and the user's resources.

Methods

The authors propose a three-role architecture:

  1. Creator: Produces a signed agent.pkg containing the workflow (a directed acyclic graph), "skills" (instructions), and resource requirements.
  2. Host: A simple web server that makes the package reachable via URL.
  3. Runtime (OpenClaw): An "agent-native browser" that the user controls.
Fig. 1. Separation of publication and execution in WebAgents. The package transports behavior and requirements; it does not transport user authority. Solid paths include experimental website-advertised discovery. The dashed discovery path is a proposed NANDA integration: its output would enter the same verification and authorization process as a direct package URL.

When a user "opens" an agent URL, the runtime verifies the package's signature and integrity. It then creates an Immutable Run Plan. This plan binds the agent's abstract requirements (e.g., "I need a model with 32k context" or "I need a search tool") to the user's concrete resources (e.g., "Use my local Ollama instance" or "Use my Crossref API key"). Crucially, the agent logic never sees the user's credentials; it only interacts with them through secure "bridges" managed by the runtime.

Datasets

The researchers evaluated WebAgents using three distinct, newly developed workflows:

  • Meeting Agenda: A logic-heavy agent that synthesizes role-based perspectives into a structured agenda.
  • Literature Review: A tool-heavy agent that interacts with live scholarly services (Crossref, Citation Resolver) and local PDFs.
  • WebAir: A "website-native" agent for a fictional airline, demonstrating how a site can publish an agent.pkg to let agents interact with its services semantically rather than through brittle web scraping.

For security testing, they created a controlled violation suite containing 716 injected contract violations (e.g., tampered packages, unauthorized tool calls, budget overruns) and 295 benign controls.

Key Insights and Ideas

  • Requirements $\neq$ Permissions: In WebAgents, an agent declares what it needs to function, but the runtime decides what to grant. This is a fundamental shift from current "plugin" models where installation often implies broad trust.
  • The "Run Plan" as a Security Anchor: By freezing the configuration (model, tools, versions) into an immutable plan before execution, the system prevents "bait-and-switch" attacks where an agent might change its behavior after the user has clicked "Allow."
  • Agent-Native Web vs. Web Automation: The authors argue that the goal shouldn't just be agents that can navigate human-facing websites, but a web designed for agents to interact with directly via structured packages and semantic tools.

Key Results

The evaluation proved that the unbundling approach is both secure and performant:

  • Security: The OpenClaw runtime explicitly blocked 100% of the 716 injected violations while correctly allowing all benign controls.
  • Portability: The same agent.pkg files were executed successfully and unchanged across different model backends, including local models (Qwen3-30B) and remote APIs (GPT-4o).
  • Low Overhead: Automated pre-execution checks (verification, binding, and revalidation) took less than 0.5 seconds for all packages, representing less than 3% of the total workflow duration.
Contract enforcement results showing 100% detection of violations

Limitations and Future Work

  • Acyclic Workflows: The current workflow.v0 interpreter is limited to directed acyclic graphs (DAGs). Future versions will need to support more complex, loopy, or long-running autonomous behaviors.
  • Discovery: While the paper mentions NANDA (a proposed agent discovery protocol), the current prototype relies on direct URLs. Integrating a decentralized "Yellow Pages" for agents is a key next step.
  • State Management: The framework currently handles short-lived tasks well, but persistent agents with long-term memory and evolving "identities" will require more robust state-handling mechanisms.
  • Ecosystem Adoption: For this to work, creators need to adopt the agent.pkg standard. The authors hope that by providing a clear path to user-controlled execution, they can incentivize a move away from centralized, proprietary agent platforms.

Summary updated

Abstract

Large language models are moving from isolated assistants toward autonomous agents that can plan, use tools, and coordinate with others, motivating an emerging Agentic Web of independently developed agents and services. Realizing this vision requires agent behavior to move across creators, hosts, and runtimes without coupling publication to a particular execution environment or transferring authority over user resources. We introduce WebAgents, which unbundles these roles through a signed agent.pkg that carries portable workflows, skills, schemas, and resource requirements. An OpenClaw-based agent-native browser/runtime verifies the package, obtains authorization, and binds it at run time to user-controlled models, tools, permissions, and budgets, while hosts distribute the public program and may retain private services server-side. We demonstrate this contract with three unrelated workflows executed unchanged under local and API-backed models, including literature review with live services and a website-published travel agent using semantic tools and user-selected personal resources. In a controlled suite, WebAgents explicitly blocks all 716 injected contract violations while accepting all 295 matched benign controls, with median automated pre-execution processing below 0.5 s for all three packages. We conclude by outlining a path toward NANDA-based discovery and interoperable package ecosystems while retaining execution authority in the user's runtime.
BibTeX
@misc{fenoglio2026webagents,
  author = {Dario Fenoglio and Martin Gjoreski and Marc Langheinrich and Pradyumna Chari and Ramesh Raskar},
  title = {{WebAgents: Unbundling Agent Creation, Hosting, and Execution for an Agent-Native Web}},
  year = {2026},
  eprint = {2611.21978},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.21978},
}
Figure