The Agent Web: A New Paradigm for Data Ownership and Rental
The modern web is at a stalemate. On one side, we have users drowning in ads, tracking scripts, and paywalls. On the other side, we have AI agents and scrapers trying to extract value, locked in an infinite arms race against Cloudflare and CAPTCHAs.
The model is broken. Agents are treated as parasites because they consume bandwidth without viewing the ads that pay for it.
But what if we flipped the script? What if the agent wasn't a thief, but a customer? And what if the browser wasn't just a window, but a localized database?
At datom.world, we are building the architecture for the Agent Web—a new ecosystem where autonomous discovery, local-first storage (DaoDB), and capability-based transfers (ShiBi) solve the data deadlock.
1. The Edge Oracle: Turning the Web Browser into a Sensor
Traditional scraping is server-side and brittle. It uses data center IPs that get blocked instantly, and it lacks the context of the user.
We are proposing a different approach: The Browser-Equipped Agent.
The datom.world agent runs as a ClojureScript application within yin.vm, which is embedded in a WebView within the client-side Flutter application. This turns the user's device into an "Edge Oracle". The agent doesn't browse like a human; it browses with the human.
- Residential Identity: It uses the user's local IP and network, bypassing anti-bot filters naturally.
- Shared State: If you are already logged into a website, the agent inherits that session. If a site requires a login, the agent can notify you to authenticate, unlocking access to your private data on sites like Gmail, your bank, or your Airbnb account. This allows the agent to securely organize your personal information on your behalf.
This isn't a bot farm attacking a server. It is a digital extension of the user's own eyes, reading one page at a time, strictly for personal utility.
2. From HTML to Ontology (The Cognitive Layer)
The "old way" of extracting data involved fragile CSS selectors that broke every time a developer changed a
The datom.world agent uses an LLM as its cognitive layer. The workflow is semantic, not structural:
- Ingest: The WebView captures the raw text of a page.
- Cognition: The LLM analyzes the text against the user's local DaoDB schema.
- Alignment: If the data fits existing attributes (e.g., :product/price), it's harmonized. If it finds new concepts, the LLM proposes a schema extension (e.g., :crypto/staking-yield).
- Assertion: The data is stored locally as atomic facts (datoms).
The result? A "Personal Knowledge Graph" that grows smarter the more you browse.
3. The Pivot: ShiBi and the "Pay-for-Truth" Protocol
Here is where the vision expands beyond technology into economics.
If agents become the primary way we consume information, websites lose ad revenue. To survive, they must evolve. This is where ShiBi enters the equation.
We envision a Semantic Handshake between the User Agent and the Server.
Instead of fighting the agent, the publisher puts up a "Data Menu". When an agent requests a page, the server can offer a structured DaoDB Feed—a lightweight, pure-data payload—in exchange for a utility transfer.
- The Protocol: The server responds with HTTP 402 Transfer Required.
- The Transfer: The agent automatically sends a fraction of a ShiBi (e.g., 0.05 ShiBi) to the publisher.
- The Delivery: The server streams the clean, structured data directly to the user's local DaoDB.
4. The Bifurcated Web
This creates two distinct experiences on the same internet:
- The Human Web: Visual, heavy, ad-supported, and slow. (For browsing).
- The Agent Web: Semantic, lightweight, tokenized, and instant. (For knowing).
For publishers, this is a dream scenario. They stop selling user attention to advertisers and start selling facts directly to users. They lower their bandwidth costs (serving JSON is cheaper than serving HTML/Video) and gain a direct revenue stream that ad-blockers can't touch.
5. Data Rental: The Ephemeral Agent
Not all data is for sale. High-value proprietary models, sensitive algorithms, or premium content often require a 'rental' model where the user gets the utility of the data without gaining permanent ownership. yin.vm enables this through sandboxed, ephemeral agents.
In this mode, the publisher sends an agent to the user's device. In yin.vm, agents are continuations—self-contained execution contexts that carry their own code and data (e.g., a diagnostic medical model or a financial trading algorithm).
The agent executes locally, leveraging the user's hardware for performance, but it runs within a strict sandbox. It interacts with the user, computes results, and then—crucially—self-destructs. Once the terms of execution are complete, the agent deletes its code and data state, leaving behind only the results the user compensated for.
This transforms the browser from a passive document viewer into a secure runtime for transient software. Publishers can 'rent out' their most valuable IP without fear of leakage, while users get the benefits of local execution—privacy, speed, and offline capability—without the burden of indefinite storage.
Conclusion: Ownership and Rental
Ultimately, this architecture is about sovereignty. Current web browsers are just viewports for rented data. datom.world transforms the browser into a tool for data ownership, while simultaneously enabling a new model of secure data rental.
When your agent scrapes a page or accesses a ShiBi feed, that data lands in your local DaoDB. It becomes yours to query, link, and use forever. But when you need temporary access to high-value intelligence, you can rent a transient agent that visits, serves, and vanishes.
We aren't just building a better scraper; we are building a browser for the economy of facts—whether owned or rented.
Learn more: yin.vm explains how agents are continuations that can migrate across nodes. DaoDB covers the local-first database where your knowledge graph lives. ShiBi describes the capability-based utility token system that enables machine-to-machine transfers.