|
Getting your Trinity Audio player ready...
|
TL;DR: URLs give the web a way to locate information, but ownership, permissions, history, and payment usually remain trapped inside individual applications. A different architecture could give digital objects persistent relationships that survive when data moves between services. Metanet was designed around this idea, using a graph of signed transactions to connect data, control, permissions, and value on a shared ledger.
Key Takeaways:
- URLs are excellent at locating web resources, but they don’t provide a native record of who controls them or what happened to them previously.
- Ownership, permissions, payment, and version history are usually managed separately by individual apps.
- Persistent identifiers and signed data can allow some of these relationships to travel with the resource instead.
- Metanet uses nodes, edges, keys, and signatures to build data structures with ownership and permission relationships on the BSV blockchain.
- If data has persistent relationships, several things can be brought closer together.
- An internet increasingly used by AI agents may need these relationships to be explicit, machine-readable, and scalable.
The URL is one of the foundations of the modern web. Give someone a URL and their browser can locate a webpage, image, document, video, or another resource. DNS helps resolve the relevant domain name, HTTP retrieves the resource, and TLS can establish a secure connection to the server.
However, locating information is different from determining to whom that information belongs. A URL doesn’t necessarily tell another system who created a resource, who currently controls it, who can modify it, whether it has changed, or what economic relationships are attached to it. These things exist on today’s web, but they are usually managed by the app hosting the data.
As the internet moves beyond humans clicking links and toward machines interacting directly with data, this becomes more important.
Ownership usually lives inside the application
Think about an article published on a website like CoinGeek.
The URL tells us where to find it while the content management system knows which account published it and the publisher controls who can edit it, copyright law defines ownership rights and an advertising or subscription system may determine how it generates revenue.
Obviously, these relationships exist in separate places. If the article is copied to another website, the copy doesn’t automatically carry a verifiable record showing who created the original. If editing rights change, that permission is stored in the CMS. If the article is licensed to another publisher, the commercial relationship may exist in a contract or another database again.
The same pattern appears all across the web. For example, Google Drive (NASDAQ: GOOGL) manages permissions for a document, GitHub manages repository ownership and contributor history, and social networks determine who controls an account and which users can access a post.
In each case, the application understands the relationships around the data, but the data itself doesn’t necessarily carry them when it leaves.
Newer web standards are already trying to separate some of these relationships from individual platforms. For example, W3C decentralized identifiers (DIDs) are designed to give people, organizations, and other parties persistent identifiers that can be controlled independently from a centralized identity provider. The latest DID Resolution work also supports retrieving current and historical states associated with an identifier.
The main point is that control doesn’t always have to reside with the app that stores the data.
Metanet treats data as part of a larger graph
The Metanet takes this idea further by treating data as part of a graph of persistent relationships.
The Metanet Protocol is an overlay protocol for creating data structures on BSV blockchain. It uses nodes and edges to form directed graphs that can represent things such as websites, file systems, ownership structures, and code repositories.
The basic concept is simple enough: nodes are transactions containing data or references to data, while edges connect one node to another using cryptographic signatures. This means a parent node can establish a relationship with a child, creating a larger structure of related data.
Those relationships can also create permissions. For example, a valid child node requires authorization from its parent, which means control over the relevant key determines who can add to that part of the structure. Write access can also be delegated to individual branches, allowing someone to grant another person control over part of a larger data structure without handing over control of the rest.
Imagine a publisher represented by one branch of a Metanet graph. Individual publications, sections, authors, and articles could exist underneath it, with different keys controlling each branch. An editor could have permission to manage one publication, a writer could control their own articles, and another party could be given access to a specific data object without gaining authority over the rest of the structure.
The important part isn’t simply that the information is connected; it’s that the relationships are signed. This means the structure can specify who has authority to create or modify parts of it, rather than relying entirely on permissions stored in one company’s private database.
Data could carry more of its relationships with it
Once data has persistent relationships, several things can be brought closer together. For example, a digital object could be connected to its creator, current controller, previous versions, access permissions, licenses, payments, or other related objects.
For example, an article could be associated with a key belonging to its publisher, linked to previous versions, licensed to another party, and made available to an AI agent for a small payment.
The article itself doesn’t need to contain every piece of information. The important bit is that the relationships can be referenced and independently checked.
This is different from simply putting files on a blockchain. Large or private data can remain elsewhere while hashes, signatures, permissions, payments, and other relevant state are recorded or referenced through a shared ledger.
Ownership still ultimately depends on law, contracts, and real-world identity. Code is not law, and a cryptographic key doesn’t magically decide who legally owns a photograph or article.
However, cryptography can provide stronger technical evidence about who controlled a digital object, who authorized a change, and what happened previously, turning ownership from something an app merely asserts into something other systems can verify.
A machine-first web makes persistent relationships more useful
This architecture becomes even more useful when machines are major users of the internet.
The current web was designed for humans, allowing us to open a page, recognize a publisher, read a copyright notice, understand that a button means “buy,” and work out from context whether we’re allowed to perform an action.
AI agents need more explicit information. An agent accessing a digital resource may need to determine who controls it, whether they have permission to use it, what it costs, whether its version is current, which license applies, and whether another agent is authorized to modify it.
The URL alone doesn’t answer those questions. Recent experimental work submitted as an Internet-Draft describes an agent-native web with structured machine interfaces, independently verifiable published content, and autonomous agents operating under recorded, bounded, and revocable authority. It’s an individual draft rather than an adopted IETF standard, but the problems it describes are becoming increasingly familiar.
Metanet was proposed years before today’s agentic web began to take shape, but its architectural assumptions remain more relevant today. Machines need relationships to be explicit—they need to know what data belongs to, who controls it, what they are allowed to do with it, what it costs, and what happened previously.
A scalable public blockchain can provide a common ledger underneath these relationships while private applications continue handling interfaces, sensitive data, and business logic. At the scale of the internet, the number of events could become enormous. Data can be continuously created, updated, licensed, transferred, paid for, delegated, and referenced by machines.
The next step is to give digital objects persistent ownership, permissions, history, and payment relationships that remain understandable even when the data moves between applications.
FAQs:
Doesn’t the web already support data ownership?
Yes, but ownership is usually established through law, contracts, accounts, and application-specific databases. The web itself doesn’t provide a universal mechanism linking a resource to persistent ownership and permission records.
What is the Metanet?
Metanet is a concept and protocol for building structured data and value relationships on BSV blockchain. Its protocol uses transactions, public keys, signatures, nodes, and edges to create graph-based data structures.
Does data need to be stored on-chain?
Not necessarily. Private data can remain off-chain while hashes, signatures, permissions, transactions, and other references are recorded on a shared ledger.
What is the difference between a URL and a decentralized identifier?
A URL primarily identifies where a web resource can be retrieved. A decentralized identifier can provide a persistent identifier controlled independently from a particular centralized identity provider and can resolve information needed for cryptographically verifiable interactions.
Why does scalability matter for a Metanet-style internet?
A web with persistent ownership, permissions, payments, updates, and machine interactions could generate a large number of transactions and state changes. Shared infrastructure needs to process those events cheaply enough to operate at normal internet scale.
Watch: How Teranode Brings the Metanet to Life




