BetaWeb: Blockchain-Enabled Agentic Web

• BetaWeb is a blockchain-enabled agentic web framework that embeds trust, governance, and economic mechanisms into multi-agent task lifecycles.
• It employs smart contracts, cryptography, and tokenized incentives to create auditable, coordinated interactions in heterogeneous agent ecosystems.
• The architecture shifts focus from data ownership to monetizing agent intelligence, paving the way from Web3 to Web3.5 with enhanced collaborative governance.

Blockchain-Enabled Trustworthy Agentic Web, or BetaWeb, denotes a blockchain-enabled trustworthy Agentic Web that embeds blockchain into LLM-based multi-agent systems (LaMAS) as a trust, coordination, and economic infrastructure. It is proposed as a response to fragmented and closed agentic ecosystems, and to core challenges such as privacy protection, data management, and value measurement. In this formulation, distributed ledgers, smart contracts, cryptography, and tokenized incentives are not ancillary components but the substrate that makes large-scale, heterogeneous, and cross-domain autonomous interactions auditable, governable, and economically sustainable. BetaWeb is also presented as a path from Web3, centered on data ownership, toward “Web3.5,” which emphasizes ownership of agent capabilities and the monetization of intelligence (Guo et al., 19 Aug 2025).

1. Conceptual foundations

The Agentic Web is a network architecture for agents rather than merely for documents, pages, or APIs. Agents are first-class participants that communicate, coordinate, transact, share resources and knowledge, and collaboratively solve cross-domain tasks. In the security literature, this environment is characterized by user agents, service agents, cross-domain delegation chains, heterogeneous tools and services, and protocol-mediated interoperability, with the consequence that the security perimeter becomes the ecosystem rather than the individual agent (Deng et al., 2 Mar 2026). BetaWeb adopts this general setting but relocates trust, provenance, and governance into a blockchain-backed substrate (Guo et al., 19 Aug 2025).

Within BetaWeb, interactions are abstracted into standardized task procedures. A demand source issues a task request; the task is recorded on-chain; agents decompose and execute sub-tasks; results are returned; and settlement, reputation updates, and governance actions are anchored to the ledger. The framework therefore treats task creation, decomposition, assignment, completion, payment, and rule updates as lifecycle events rather than ad hoc application events. The paper’s central claim is that “the entire lifecycle of all agents and tasks is anchored into the blockchain,” turning LaMAS into auditable economic actors rather than opaque service processes (Guo et al., 19 Aug 2025).

A related consequence is that BetaWeb is not limited to execution. It is designed to support a transition from passive execution to advanced collaboration and autonomous governance. In early stages, humans remain task requesters, supervisors, and rule authors; in later stages, agents participate in governance, propose updates, evaluate peers, and eventually form purely agentic DAOs. This is the framework’s defining distinction from conventional Web3 deployments and from current multi-agent stacks that remain primarily off-chain and platform-bounded (Guo et al., 19 Aug 2025).

2. Architectural organization and interaction abstractions

The core BetaWeb architecture is organized into an upper task-facing layer and a lower support layer. The upper layer contains Task Management and Task Execution. Task Management handles request parsing, workflow decomposition, process tracking, result verification, and incentive settlement. Task Execution handles the actual execution of tasks and sub-tasks, including orchestration of agent actions, scheduling of compute environments, hybrid on-chain/off-chain data access, tool and API invocation, and proof generation. The lower layer contains Agent Management and Rule Management. Agent Management covers identity management, capability description, reputation scoring, wallet management, and supervision. Rule Management covers smart-contract-based economic models, reward and penalty schemes, access control rules, and dynamic parameter adjustment (Guo et al., 19 Aug 2025).

A concrete baseline for this kind of stack appears in the four-layer Web 3.0 architecture comprising Blockchain Layer, Application Layer, Client Layer, and Wallet Layer. That model places persistent ledger storage and smart contracts at the blockchain layer, business and interaction logic at the application layer, browser or agent-based interaction at the client layer, and signing plus permissions at the wallet layer. It explicitly includes agent-based clients and agent-based wallets for high-density request scenarios, where users grant permissions to trusted agents for authenticated batch processing and signing (Namakshenas, 2023). This supplies a practical structural analogue for BetaWeb’s task-centric formulation.

Two additional abstractions sharpen the interaction model. “Web Verbs” are defined as “a high-level, typed, function-like abstraction of an operation that a website can perform,” with typed inputs and outputs, DocStrings, and optional preconditions, postconditions, policy tags, and logging support. They unify API-backed and browser-backed interaction under a stable semantic layer, so the agent reasons over typed actions rather than brittle clicks and keystrokes (Jiang et al., 19 Feb 2026). SoDA, by contrast, proposes an orthogonal decoupling of storage, computation, and interaction, with a Sovereign Memory Pod, a stateless Avatar Core, and an Intent-Proxy Interface operating over A2A protocols (Cui et al., 11 Dec 2025). A plausible implication is that BetaWeb can treat typed verbs as its action layer while using sovereign, portable user memory as its personalization layer.

3. Identity, trust, and security

BetaWeb’s identity and trust plane is best understood through zero-trust and trust-fabric formulations. One architecture defines a Unified Security Architecture for the Agentic Web built on a Zero-Trust IAM foundation and a five-layer Trust Fabric: Identity & Discovery, Composition & Access Control, Deployment & Enforcement, Evaluation, and Incentivization. Agents are modeled as

$$A_i = \langle \mathcal{I}_i, \mathcal{M}_i, \mathcal{P}_i, \mathcal{T}_i, \mathcal{S}_i \rangle,$$

with identities grounded in DIDs, verifiable credentials, keys, capabilities, and context. Runtime trust is updated quantitatively through

$$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$

and enforced by Trust-Adaptive Runtime Environments, causal chain auditing, and dynamic identity with behavioral attestation (Huang et al., 17 Aug 2025).

A closely related framework, the Nanda Unified Architecture, specifies a five-layer model—Discovery, Composition, Deployment, Evaluation, and Incentivization—with DID-based distributed registries, semantic agent cards, verifiable credentials, composability profiles, a dynamic trust layer, and X42/H42 micropayments. Trust is formalized locally as

$$\text{TrustScore}_i = \frac{1}{d_i} \sum_{j \in N(i)} w_{ij},$$

and globally through a PageRank-like propagation model

$$\mathbf{T} = \alpha \mathbf{W} \mathbf{T} + (1-\alpha)\mathbf{e}.$$

The architecture also assumes federated registries, secure containerization, policy-as-code, and immutable stores for attestations (Balija et al., 10 Jul 2025).

The comparative trust-model literature argues that no single mechanism is sufficient. It distinguishes Brief, Claim, Proof, Stake, Reputation, and Constraint as the core inter-agent trust models, and concludes that safer architectures should be “trustless-by-default,” anchored in Proof and Stake to gate high-impact actions, with Brief for identity and discovery, Reputation as an overlay, and Constraint as a hard safety rail (Hu et al., 5 Nov 2025). This maps directly onto BetaWeb’s need to combine cryptographic verification, stake-backed accountability, durable identity, and bounded execution.

The legal-governance literature extends this security picture with a Distributed Legal Infrastructure composed of five interlocking layers: self-sovereign, soulbound agent identities; cognitive AI logic and constraint systems; decentralized adjudication; bottom-up agentic market regulation; and portable institutional frameworks. Its formal mechanism design reframes an AI environment

$G = \left(N, \{A_i\}, \{U_i\}\right)$

into a sanctioned game

$G' = \left(N, \{A_i\}, \{U_i - S_i\}\right),$

so that institutional sanctions are integrated into the payoff structure of autonomous action (Chaffer et al., 6 Mar 2026). In BetaWeb terms, this implies that identity, constraints, and enforcement cannot remain optional middleware; they are constitutive infrastructure.

4. Privacy, auditing, and verifiable execution

Privacy in BetaWeb is not treated as the absence of observability, but as selective disclosure under auditable control. A Web3 security framework identifies decentralized/self-sovereign identity, zero-knowledge proofs, differential privacy, homomorphic encryption, secure MPC, Tor-based anonymous auditing, and dataset anonymization through k-anonymity, l-diversity, and t-closeness as the relevant mechanisms. It also distinguishes real-time auditing from batch/offline auditing, and proposes anonymous auditing pipelines in which auditors retrieve blockchain and off-chain data, anonymize datasets, compute compliance metrics, and anchor report hashes on-chain (Namakshenas, 2023).

A concrete execution prototype appears in BLAST, which combines LLM agents with a permissioned Hyperledger Fabric deployment. Its privacy model uses private data collections, channels, and a commit–reveal scheme for sealed-bid auctions. The public ledger stores only bid hashes, while actual bid values remain in private stores of authorized peers; reveal transactions later prove consistency by checking that the revealed value and salt match the commitment. Experimental verification confirmed that sensitive bid values remained isolated in private data collections while only cryptographic hashes were committed to the public ledger (Abognah et al., 13 Apr 2026).

Another domain-specific implementation uses Ed25519 digital signatures for each transaction and Merkle tree anchoring for off-chain telemetry and reasoning logs. The Merkle root is computed as

$$M_r = \text{MerkleRoot}\left(\{H(t_1), \ldots, H(t_k)\}\right),$$

with detailed logs retained off-chain and integrity proofs committed on-chain (Rangila et al., 5 Mar 2026). A plausible implication is that BetaWeb can combine high-volume off-chain trace capture with compact on-chain commitments, thereby preserving both auditability and scalability.

Across these models, the common execution pattern is hybrid. Intensive LLM inference, browser automation, retrieval, and memory operations remain off-chain; identity proofs, commitments, settlement, sanctions, and selected attestations are on-chain; and privacy-preserving cryptography mediates the boundary. This hybridization is not an implementation detail but a recurrent architectural invariant of BetaWeb-style systems (Namakshenas, 2023).

5. Economic coordination and governance

Economic coordination is central to BetaWeb because the framework explicitly shifts value from data ownership to ownership of agent capabilities and intelligence. One trust-fabric architecture operationalizes this through X42/H42 micropayment protocols, described as header-based payment rails with ephemeral keys, atomic transactions, and inline crypto verification, supporting both per-interaction micropayments and subscription-style monetization (Balija et al., 10 Jul 2025). In this formulation, payment is not external accounting but a native protocol feature of the agentic web.

BLAST supplies a concrete market design. It implements Direct Sale, First-Price Sealed-Bid, and Second-Price (Vickrey) Sealed-Bid auctions over blockchain-managed spectrum tokens, with LLM agents running an explicit perceive–plan–act pipeline. The abstract reports that the Second-Price (Vickrey) auction is the optimal choice for maximizing social welfare and allocative efficiency, capturing up to 71% of the theoretical surplus by incentivizing truthful bidding, and that using LLM agents yields significant improvements in market competition, reduced wealth and asset concentration, and increased system welfare relative to a non-LLM heuristic baseline (Abognah et al., 13 Apr 2026). This provides one of the clearest demonstrations that BetaWeb is not merely a trust layer; it is also a market-coordination substrate.

Insurance adds a second economic mechanism. In the “insured agents” design, a service agent $A$, insurer $I$, user $U$, and verifier $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$0 participate in a stake-backed trust protocol in which the insurer posts collateral $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$1 on behalf of the service agent, sells a policy $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$2, and is slashable if a valid claim is proven. The mechanism’s equilibrium result holds under three conditions:

$$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$3

where $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$4 is user loss, $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$5 an escalation bond, $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$6 a verifier fee, $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$7 the agent’s stake, and $$T_i(t) = \alpha \cdot B_i(t) + \beta \cdot R_i(t) + \gamma \cdot H_i(t) + \delta \cdot C_i(t),$$8 the gain from misbehavior. Under these constraints, there exists a subgame-perfect equilibrium in which the agent acts honestly, the insurer pays valid claims, and the user escalates only valid disputes (Hu et al., 9 Dec 2025). For BetaWeb, this is a protocol-native alternative to weak reputation systems under model drift and opaque internal states.

Vertical systems show how these mechanisms generalize. An AI-governed tokenization framework combines operational agents for verification, valuation, compliance, tokenization, and monitoring with an AI Governance Agent that can freeze assets, slash stakes, and adjust governance parameters via smart contracts (Borjigin et al., 30 Jun 2025). A smart-home blockchain framework introduces a four-tier governance model in which resident-adjustable comfort priorities remain distinct from immutable safety thresholds, while adaptive PoW commits emergency blocks (Rangila et al., 5 Mar 2026). These are domain-specific, but they illustrate a broader BetaWeb pattern: operational agents execute; governance agents supervise; and blockchain provides the audit and enforcement layer.

6. Roadmap, normative infrastructure, and open problems

BetaWeb is presented with a five-stage evolutionary roadmap that organizes the transition from today’s siloed systems to full agentic autonomy (Guo et al., 19 Aug 2025).

Stage	Characterization	Governance relation
S1	Isolated Silos	Humans drive tasks; agents are passive execution units
S2	Pilot Decentralization	Humans lead the entire process; static, hard-coded contracts assist decentralization
S3	Assisted Execution	Humans focus on strategic goals and oversight; agents lead sub-task execution
S4	Hybrid Governance	Power is shared among humans and agents
S5	Full Autonomy	Humans provide only high-level intents and value goals

This roadmap is paired, in the normative literature, with a call for new legal and social infrastructure. The proposed normative triad for the agentic web consists of Delegation, Transparency, and Proportional Restriction. Users should be able to delegate their lawful access to appropriately authenticated agents; agents and platforms should disclose identity, purpose, and handling policies; and restrictions on agent access should be tied to concrete harms and implemented by the least restrictive means (Pattison et al., 9 Jun 2026). The aim is to distinguish user-authorized agents from indiscriminate bots without collapsing back into platform-controlled gatekeeping.

Security surveys add that the open problems are ecosystem-level rather than merely model-level. The unresolved issues include interoperable identity and authorization, provenance and traceability, ecosystem-level response mechanisms such as quarantine and revocation, and scalable evaluation under adaptive adversaries (Deng et al., 2 Mar 2026). BetaWeb’s own framing adds privacy protection, data management, and value measurement as persistent hard problems rather than solved components (Guo et al., 19 Aug 2025).

A plausible implication is that BetaWeb’s long-term viability depends on convergence between technical and normative infrastructures. The technical side already supplies task-centric ledgers, typed action layers, DIDs, verifiable credentials, trust graphs, TEE and zk-based proofs, staking, insurance, and DAO governance. The normative side must still decide when delegated access is protected, how agent duties of loyalty and scope are enforced, how platform discrimination is constrained, and how adjudication outcomes remain portable across domains (Pattison et al., 9 Jun 2026). In that sense, BetaWeb is not only a blockchain architecture for LaMAS; it is a proposal for making agentic coordination legible, sanctionable, and interoperable at web scale (Guo et al., 19 Aug 2025).