/ 05 /The Stack

Holochain, and the collective of projects it has stewarded over the years, hasn’t built a single product, but together delivers a layered architecture. Holochain, Holo, and HoloFuel were the original layers. But the newest layers, Unyt and the Decent Market, extend the reach far beyond the initial vision. Understanding what we built requires understanding how the layers relate.

Holochain is not a blockchain. It has fundamental architectural differences.

The comparison is worth making because blockchain is the reference most readers arrive with. But it isn’t like-for-like, and the mismatch runs in our favour: blockchains, as they are actually used, do one thing — order transactions on a shared ledger. Holochain is a framework for building group applications, of which currency is one case. What follows is drawn on blockchain’s terms, which understates the range rather than overstating it.

Blockchains are decentralised: they have many nodes and no central authority. But the architecture starts from a fundamentally centralising assumption: there is one truth, and every node must agree on it. The problem isn’t that agreement is required — every distributed system needs its peers to converge on what happened. It’s the scope: consensus about a single ordering of every event that has ever happened, reached before anything can proceed. This is why blockchain is fundamentally slow — the cost of a transaction grows with network size. It takes a decentralised system running on hundreds of thousands of processors and makes it behave as a single-threaded process, everybody marching in lock-step. There is no horizontal scaling: throwing more machines — or more powerful ones — at the network buys no additional throughput, because every node processes the same sequence regardless.

Global consensus itself is a central point of capture, as well as a fundamental vulnerability subject to attack. And this lock-step march is why blockchain, despite its libertarian framing, has reproduced the fee-extraction dynamics of the systems it was supposed to replace. Paying people to run infrastructure is not the problem — we intend to do exactly that. The difference is what the payment is for. Under proof-of-stake, the right to validate and the earnings that follow scale with capital already held; under proof-of-work, with hardware already bought. Both compound position rather than reward contribution, which is why they concentrate control over time.⁴¹ Hosting pays for service delivered. The rich get richer under one and the useful get paid under the other.

Holochain is agent-centric: each agent maintains their own cryptographically secured chain of actions, validated by peers according to shared rules, published to a distributed hash table for global visibility — without requiring global consensus. There is no single ordering of events that everyone must agree on before anything can proceed. Peers on a network do converge on the same set of validated data — that convergence is what validation means — but each agent derives its own view from it, and agreement between parties is required only where a transaction actually involves them. Yet agent-centric is only half the story: Holochain starts with empowered agency but always exercises it inside social accountability — an action is valid only if it plays by the shared rules of its network, and peers validate that it acted properly. The balance that keeps social systems healthy is written directly into the architecture. Agents interact directly. They reach agreement only when agreement is necessary.

The analogy that actually works is with version control software. Subversion — one of the dominant systems before Git — assumes a central server holding the canonical truth; every developer works against it. Git is already agent-centric: each developer maintains their own repository, makes their own contributions, and chooses who to share with and what to accept. Coherence emerges from those relationships, not from a central authority imposing it. The analogy has a limit worth naming: a Git branch can be rewritten before you share it, and a source chain action cannot. Once written, it stands — which is what makes it accountable. Holochain applies the same principle to computing generally: every agent maintains their own state, and shared truth is constructed through interaction, not consensus. Most developers today use Git through GitHub — a centralised platform operating adjacent to a distributed tool — which illustrates the access-layer centralisation problem described above.

One consequence trips up almost everyone: there is no such thing as ‘the Holochain network.’ Ethereum and Solana are each one global network with one ledger. Holochain is a pattern for spinning up as many independent networks as there are applications — each with its own rules, its own participants, and its own membrane. When something runs ‘on Holochain,’ it runs its own network built with Holochain; it does not join one big shared one.

There is a deeper point about security that the comparison table doesn’t capture. In a single-network consensus system, security is a collective problem — the entire network must invest the energy to protect non-monetary actions and micro-transactions for a fraction of a cent as if they are multi-million dollar transactions regardless of who those assets belong to. In a plurality-of-networks architecture, security is proportional. Each network calibrates its validation requirements, staking economics, or warrant thresholds to the value of what it is securing. Tweets don’t need (and shouldn’t pay cost in compute overhead for) the same security posture as a multi-million dollar transaction. This is how security actually works in the physical world: as we said earlier, you don’t build Fort Knox to protect a village post office. Blockchain’s monolithic design forces a single security economy on every action. Holochain’s architecture does not.

It’s also worth being precise about what Holochain’s security model actually does. Against invalid data — fraudulent records, fabricated transactions — the mechanism is detection and isolation: the network releases warrants against invalid actions, and the immune system responds. Against history rewriting — the equivalent of a blockchain fork or double-spend — there is no global consensus to attack in the first place. These are two different problems with two different solutions, and conflating them with a single ‘51% resistance’ metric obscures both. An agent who fabricates tokens or “double-spends” them by forking their chain finds themselves blocked and unable to spend or use them.

None of this is theoretical. The protocol is stable, audited, and running real applications today — from small-group collaboration in Moss, currently in preview, to Unyt’s crypto-accounting engine now in test. What we have not yet seen at scale is the immune response under sustained adversarial pressure in production. The mechanism is built and tested,⁴³ and the field trials are commencing.

The original Holo vision as described in the 2017 Green Paper was specific: a marketplace where ordinary people could earn by hosting Holochain applications on their own hardware, and where application publishers could access distributed compute without depending on AWS or Google Cloud. The architecture was sound. The timeline was catastrophically wrong. We said we would have it running in 2019. It’s 2026.

Three full codebase refactors, sixty people down to the essential few. Building genuinely novel distributed infrastructure is harder than the roadmaps suggest — and, as we argued earlier, holding a system decentralised against the constant pull back toward a centre is harder still. We didn’t always win that fight on time — and that’s a significant part of why this took as long as it did.

What exists now: distributed hosting infrastructure, operating. Edge nodes that keep an application’s data available when none of its users are online — work that enables hosting models the original 2017 design couldn’t anticipate, where a network persists independently of who happens to be connected. The HoloPort hardware programme put dedicated hosting nodes into the hands of early believers — and those devices remain part of the network. HoloPorts run the same node software as any commodity hardware. What’s evolved is the model: distributed hosting no longer requires dedicated devices, and the network is stronger for being open to any hardware that can run the software. The hosting vision is not abandoned. It’s operational, continuing to develop, and now situated within a broader stack that gives it substantially more to do.

The original economic argument — that commodity hardware aggregated across a distributed network can substantially undercut centralised cloud pricing — has since been validated by an entire sector. Decentralised compute networks now report general compute costs up to 85% lower than centralised cloud providers⁴⁴ with GPU access running at roughly one-third the cost of equivalent AWS instances in live marketplace comparisons.⁴⁵ The structural reason is unchanged from 2017: centralised cloud providers price for data centre overhead, redundancy guarantees, vendor margin, and the premium that comes with operating at monopoly scale. Thirty percent of global cloud spending — approximately $217 billion annually — is estimated to be waste: idle resources, over-provisioning, and timing inefficiencies⁴⁶ that a distributed model with no idle infrastructure simply doesn’t carry. Commodity hardware has none of that overhead — and it carries a further structural advantage: distributed hosting eliminates the cooling load that accounts for roughly half the electricity cost of a conventional data centre. In a home hosting model, that energy is simply waste heat absorbed into a living space rather than vented into the atmosphere. The argument was right. The delivery was late.

What’s evolved since 2017 is the hosting model itself, and the evolution solves a problem the original design left open. Holo will support two distinct hosting types. In micro-hosting, individual hosts set their own prices and make their nodes available for work negotiating directly with app providers. For this type of hosting, what Holo provides is the proof-of-service infrastructure for invoicing work in HoloFuel. This works well for smaller applications and developers who want flexible, cost-competitive infrastructure without platform lock-in. In macro-hosting, the customer sets their requirements and price range, and Holo acts as the single commercial counterparty for enterprise clients — aggregating capacity from across the host network and presenting it as a unified, contracted service — and the host bids for inclusion on the hosting project. A large deployment cannot practically negotiate with thousands of independent node operators at different prices; the macro tier solves that without centralising the infrastructure that delivers it. The hosting is still distributed. The commercial relationship is not.

These aren’t competing models. They serve different groups at different scales, and together they mean Holo can play credibly at both ends of the market — the developer building on cost-competitive commodity infrastructure, and the enterprise client who needs predictable pricing and a single point of accountability.

Unyt is the economic engine of the stack. It is the software that makes HoloFuel work — and that makes any mutual credit currency work on Holochain. Unyt is programmable economic infrastructure: an accounting engine that can denominate any economic relationship in any unit, weave value flows between parties according to rules they set, and settle with cryptographic integrity without requiring a blockchain or a trusted intermediary.

Unyt’s Smart Agreements are akin to smart contracts on a blockchain, but significantly more flexible. They are programmable economic logic that executes locally — between the parties to an agreement — rather than requiring global network consensus. And more powerful still: the agreements can be updated as a network’s needs evolve, without rebuilding anything.⁴⁷ In other words, Unyt works the way people work.

When I give my neighbour’s child $2 for lemonade, the only two people who need to know about, and validate, the transaction are me, and her. What we don’t need, and what would be an absurd waste, would be to have everyone in the entire neighbourhood see, review, and validate our transaction. Unlike traditional blockchain smart contracts — where upgradeability requires migration to a new contract address, breaking continuity — Smart Agreements are soft-coded: the rules can be updated by agreement of the parties in place, without migration. A single Unyt deployment can handle multiple currencies, and multiple accounting tokens per transaction simultaneously — flowing in both directions — alongside internal accounting units, loyalty points, reputation scores, and any other quantified value, all with the same cryptographic guarantees. One instance supports up to 65,000 units of account.

The Unyt crypto-accounting engine launched in September 2025. P2P payments, community currency tooling, and Smart Agreements shipped in Q4 2025. Bi-directional payments, blockchain bridging to EVM Layer 2 networks, and market oracles shipped in Q1 2026⁴⁸ — the infrastructure the HOT to HoloFuel migration will run on.

HoloFuel is a mutual credit currency designed as a medium of exchange, not a speculative asset. Mutual credit currencies have been in use for thousands of years, but are quite different from the fiat currencies that currently surround us. In a mutual credit currency the net supply is always zero — every positive balance is exactly matched by a corresponding negative balance. No currency is created from nothing; supply expands when credit is extended and contracts when it is repaid. The currency breathes in response to real economic activity.

HoloFuel is currently backed by computing capacity: the real-world cost of CPU cycles, bandwidth, and storage in commodity hardware markets. Not a peg to an external currency. Not an algorithmic stablecoin whose backing evaporates under stress. A grounding in real resource costs with a self-correcting feedback mechanism: if HoloFuel trades above compute cost, hosting becomes more profitable, more hosts join, supply increases, price corrects. If it trades below cost, hosts exit, supply tightens, price corrects. The commodity hardware market provides a natural floor and ceiling that no amount of speculative attack can permanently circumvent.

Most cryptocurrencies fail the most basic test of a functioning currency: stability. Bitcoin’s fixed supply was supposed to solve the trust problem inherent in fiat’s discretionary monetary policy. It solved supply predictability. It did nothing for price predictability — and a currency whose value can move 20% in an hour is unusable for any ordinary economic purpose. HoloFuel’s value is anchored to productive capacity, not scarcity. That anchoring is what makes it functional as a medium of exchange rather than a vehicle for speculation.

Credit limits are algorithmic and role-specific. Hosts earn credit capacity through demonstrated service delivery. End users require positive balances to spend. Publishers need collateral or revenue history. Holo earns through transaction fees capped at ≤1% of value. Reserve Accounts are 1:1 asset-backed. Productive activity generates credit. Gaming the system contracts it.

What’s changed since 2017 is the scope. HoloFuel was designed as a currency for distributed hosting. Given the added layer of Unyt, it’s now a more inclusive utility currency that any values-aligned project can adopt instead of launching their own speculative token. This matters because the overhead of token issuance is enormous: legal analysis in every jurisdiction, exchange negotiations, market-making, tokenomics management, governance of the token separate from governance of the project, and a speculator community whose interests may actively conflict with the project’s actual users. A project building on Holochain can use HoloFuel as its native currency without any of that.

A marketplace is where people meet. A market is where they do business. The distinction is old and it runs in one direction: the square came before the exchange, the fair before the trading floor. People gathered, discovered who else was there and what they were doing, and trade followed from that.

So that’s the order we’re building in; Decent starts as a marketplace.

What opens with the migration. Decent launches alongside the migration, as a directory of organisations building and operating decent infrastructure — a place where people working on similar problems can find each other, be visible to those seeking them, and connect with organisations doing adjacent work. Listing is open to any organisation whose work is aligned with what this paper describes. It’s self-serve: you supply your details, and each listing is verified by a person before it goes live, so the directory can’t be turned against the people relying on it.

What a listing gets you is visibility, connection to organisations working in the same direction, and — where there’s a fit — the beginning of a conversation with Holo Ventures about doing something together. Some of the organisations listed will want to accept HoloFuel for what they offer. That’s available, and the route to it is to get in touch; but it isn’t the price of entry.

Where it’s headed. With enough organisations wanting to transact with each other, a marketplace becomes a market — and at that point the architecture has a problem to solve that’s worth describing now, because it’s the reason the Unyt accounting engine was built the way it was.

Every cryptocurrency exchange operates on trading pairs. To exchange Token A for Token B, you need a market with liquidity on both sides. This seems manageable for two tokens. The mathematics become structurally untenable at scale. To support exchange between n tokens, a trading pair system requires n(n−1)/2 markets — 45 markets for 10 tokens, 4,950 for 100, 499,500 for 1,000. Each market requires independent liquidity — capital locked on both sides, held by market makers extracting fees for providing it. Capital that could be doing useful economic work sits idle in thousands of pools. Tokens without access to major exchanges or venture-backed market-making cannot participate at meaningful depth. The “permissionless” exchange ecosystem has a permissions layer enforced by capital requirements instead of approval processes.

The trading pair model is barter economics with better infrastructure. Barter has a double-coincidence-of-wants problem — to trade, both parties must simultaneously want what the other has. Trading pairs inherit it precisely: you can only swap Token A for Token B if someone is on the other side of that specific pair, right now, with liquidity to match.

The Decent Market applies a solution that commodity exchanges have used for centuries: a clearinghouse with a common unit of account. You do not trade TFT directly for HOT. You price both via oracles and convert atomically through a common accounting layer. Ten tokens: ten oracle feeds, not forty-five bilateral markets. One thousand tokens: one thousand oracle feeds, not half a million trading pairs. The cost to add a new currency to a clearinghouse is O(1). The cost to add a new currency to a trading pair network is O(n).

In that architecture, partner networks — DePIN projects, community currencies, regenerative finance instruments, impact initiatives — operate as sovereign nodes, running their own Unyt accounting instances with their own tokens and governance. Decent provides settlement services between them. Each node maintains full autonomy over its internal operations. The relationship is peer-to-peer: nodes connect to the clearinghouse when they need to exchange with other networks, and operate independently when they don’t. Unyt earns transaction fees on cross-network settlements — not on internal node operations. There’s no extraction point at the centre because the design doesn’t concentrate value at the centre.

While we’re in active design, only some of the components are already built. It’s where this goes if enough organisations find each other in the marketplace and start doing business — and if they don’t, it stays a description of an architecture rather than an account of one. We’d rather set out the direction and be judged on whether we get there than describe the destination as though we’d arrived.

Everything described so far sits beneath the surface — the protocol, the hosting, the accounting engine, the currency, the marketplace. None of it is what a person actually opens and uses. That top layer, the one people touch, is where decentralised technology has most often come undone: the usable products were either single-purpose silos, or — as with the crypto interfaces in Section 1 — quietly re-centralised at the access layer even while the protocol beneath them stayed open. What has rarely been built is an experience layer that is itself agent-centric: general-purpose, own-your-data, groups assembling their own interoperable tools with no platform in the middle. The Weave and Moss are that layer — early, but real.

The Weave is an open standard for social context. The web got three open standards that let anyone publish and link documents — HTML, HTTP, and the URL — but it never got one that let groups own and manage their shared context, which is exactly why that function was captured by the platforms: Facebook holds your group, GitHub holds your code, Google holds your collaboration. The Weave adds the missing standard — the Weave Interaction Pattern — for creating, searching, linking, and organising units of social context, so that independent groupware “Tools,” each a small Holochain application, interoperate, embed inside one another, and can be searched across every group you belong to, with no central server anywhere. Making an existing Holochain app Weave-compatible is a task of minutes, not months.

Moss is not an application; it is a runtime. If The Weave is the standard, Moss is the browser — what Mosaic and Netscape were to the early web: the thing through which ordinary people first actually use what lies beneath. Rather than doing one thing, Moss runs a whole suite of independent Holochain applications side by side, in a single coherent space that a group owns and controls — more than twenty of them in an open, free library, and growing. Among them:

Each group — and each Tool within it — is its own private peer-to-peer network; an asset created in one Tool embeds directly into another, and everything is searchable across the groups you belong to. Standing up a group’s tooling is closer to opening a web page than to procuring software.

Two features of this bear on the paper’s argument. First, it shows the move only agent-centric architecture permits: you can compose centralisation out of decentralisation — lock down permissions, predefine a group, run it privately — but you can never run that in reverse and recover decentralisation from something that was centralised to begin with. You can aggregate; you cannot disaggregate. Holochain lets a builder dial control to exactly what a use case needs while the foundation beneath stays sovereign. Second, The Weave and Moss are built by Lightningrod Labs — the studio of Holochain co-founder Eric Harris-Braun — and released as open source. The experience layer of this stack is not ours. That is the point: an ecosystem whose most important layer is built, and held, by more than one hand.