Local-first infrastructure
for open networks.
Commons is a peer-to-peer data coordination layer: every participant runs its own instance, and catalogs, registries, and transactions stay in sync between independent systems. Beckn and DeDi capabilities, coming soon, connect those instances to an open network.
Protocols connect.
The data still needs running.
Open protocols let independent systems find and transact with each other. Every participant still has to build the plumbing that keeps its catalogs, directory entries, and records in step.
Catalog sync, registry lookups, and message handling are implemented again on every platform.
Prices, availability, and participant entries change faster than each copy is refreshed.
Search and lookups depend on another participant’s server being up and fast.
Peer-to-peer.
Local-first.
Each participant runs a Commons instance in its own environment. Catalogs and directory entries sync to that instance as signed, versioned changes, so applications search and read locally.
No central platform holds the network’s data. An instance keeps working when a peer is offline, and catches up when it returns.
The protocols arrive
as capabilities.
Commons is primarily a data coordination platform. Beckn and DeDi capabilities extend each instance with the protocol interfaces an open network expects, alongside the network’s agreed schema.
An instance attaches only what its role needs, and the same data then powers the views, search, and AI tools that applications build on. Both protocol capabilities are coming soon.
Every side of the network.
One kind of instance.
Providers, consumers, registries, and service providers each run the same kind of instance with different capabilities attached. Each stays responsible for what it publishes.
Keep catalogs, prices, and availability on your own instance; every connected consumer app stays in sync.
Search and order against synced catalogs instead of calling every provider for every query.
Publish participant entries, keys, and policies as signed, versioned records others can look up.
Subscribe to catalogs and registries, then publish analytics, enrichment, or AI services of your own.
Messaging and discovery,
built in.
Every instance comes with the coordination an open network relies on: sync, discovery, messaging, and access control. Protocol capabilities build on them rather than reinventing them.
That leaves participants to focus on their catalogs, services, and applications, not on the infrastructure between them.
Agree the rules once.
Keep your own systems.
The network agrees what is collected and which records are valid, and packages that model in a signed capability release. Each participant attaches it in its own environment.
Ingestion interprets each source, schema checks every write, and participants keep their own formats and applications.
Explore the protocols
behind the network.
Commons builds on open protocols. Start with their own documentation.
How Beckn lets independent platforms discover and transact.
BecknCore specificationThe open API specification behind every Beckn network.
DeDiPublic registriesDecentralized directories for publishing and looking up entries.
DeDiPublishing guideHow to publish directory files others can discover.
Build the network.
Not the plumbing.
Run a local-first instance, attach the protocol capabilities, and keep every participant in step.