Soft-Coded, Highly Configurable
We're excited to announce our latest release: four sample Smart Agreements that begin to demonstrate just how configurable Unyt's accounting platform really is. These aren't theoretical examples—they're agreements already used in Unyt instances to address real coordination challenges, from computing credit limits to aggregating payments across multiple participants. These sample smart agreements in the Unyt software took just two hours to build and test but represent something much bigger: proof that we've created a platform where one application can power radically different currencies and use cases through configuration alone.
The key pattern that makes this possible was moving the rules that govern economic interactions from being hard-coded into applications to being soft-coded through smart agreements. Instead of building a new app for every currency or use case, we configure the same robust infrastructure with different agreement sets. The result? Circulo, HoloFuel, DePIN alliances, decentralized exchanges, clearinghouses, and stablecoin engines can all run on the same underlying platform.
What Are Smart Agreements?
If you're familiar with smart contracts on blockchains, smart agreements serve a similar purpose but have a couple fundamental differences. They're programmable rules that govern how value flows, how credits are extended, and how participants coordinate—but make no pretense of legal enforcement or blockchain consensus, they leverage mutual enforcement of peer validation in Holochain's agent-centric architecture.
We deliberately chose "agreements" over "contracts" for two important reasons. First, we're not implying any legal significance—legal contracts rely on courts and enforcement through legal systems. Smart agreements rely on something different: mutual enforcement where participants validate each other's actions according to shared rules. Second, we want to be clear this isn't blockchain technology with its ambiguous handling of agency. In Holochain, each agent takes responsibility for their own actions in independent interactions, and the continuity of state is explicitly managed under an agent's control.
Think of smart agreements as the configurable rules layer that sits on top of Unyt's accounting infrastructure. They define things like bridging to blockchains, proof of deposit requirements, proof of service validation, credit limit algorithms, and transaction fee policies. And here's what makes them powerful: you can update these agreements periodically as your network's needs evolve, without rebuilding your entire application and needing everyone to upgrade.
Hard-Coded vs. Soft-Coded: We Changed our Game
Traditionally, Holochain applications have immutable rules baked into the DNA of the app—these rules define the space of agreement in which peers validate each other's actions. Want to change how your currency works? You'd need to release a new version of the entire application, migrate users, and maintain multiple codebases for different use cases.
By implementing smart agreements in our accounting tools, Unyt has made many of these rules "soft-coded." They're still validated by peers (maintaining the security and integrity you expect), but they can evolve, change, and become part of the configuration rather than the core code. This is the difference between rebuilding your house every time you want to rearrange the furniture versus simply moving things around within a solid structure.
What makes this transformative is the breadth of what one application can become. With one set of smart agreements, we get Circulo—a community giving currency. With another configuration, we get HoloFuel tracking and paying for hosting services. With yet another, we enable a multi-project DePIN alliance where Holo and other decentralized infrastructure projects share accounting infrastructure. We can configure smart agreements for running a DEX, operating a clearinghouse, or powering a stablecoin payment engine. This is how we've built a truly generalized crypto-accounting tool that serves different currencies, jurisdictions, and use cases without fragmenting our development effort.
The Four Demo Agreements
This release includes a starter kit of four smart agreements that demonstrate different patterns you'll likely need when building economic coordination tools:
• Compute Credit Limit: Dynamically calculate how much credit a participant can extend based on their history and network position
• If Condition Met, Then Pay, Else Return (Conditional Forward): Execute payments only when specific conditions are satisfied, otherwise return funds--essential for escrow-like functionality
• Collect Requests Then Pay (Aggregating Requests): Gather multiple payment requests before executing a single bulk payment, enabling batch processing and coordination across participants
• Collect Payments Then Allocate (Aggregating Spends): Pool incoming payments and distribute them in bulk according to predefined rules--think revenue sharing or collective funding mechanisms
Why This Matters for You
For developers in the Holochain ecosystem, this release opens up a library of reusable agreements you can configure rather than code from scratch. Instead of implementing payment logic, credit systems, or coordination mechanisms yourself, you can leverage tested patterns and focus on what makes your application unique. The Smart Agreement Code Library is already available for you to explore and build with.
Currency creators and community organizers get something equally valuable: the ability to design sophisticated economic rules without deep technical implementation. Want to adjust how credit limits work in your local currency? Configure the agreement. Need to add proof of service requirements? Add that agreement to your stack. The technical complexity is handled; you focus on the economic design that serves your community.
For DePIN operators, these agreements provide the foundation for critical capabilities like proof of deposit and proof of service validation—the building blocks for creating trust in decentralized infrastructure networks. And this is just the beginning. These patterns directly support our progression toward the HoloFuel Swap and broader market integration, where configurable agreements become the glue connecting different networks, currencies, and value flows.
Architecture: Three Layers and Growing Libraries
Smart agreements in Unyt work across three distinct layers, each serving specific purpose. We won't dive too deep into the architecture here. You can explore the detailed introduction to smart agreements for that. What matters is understanding that some agreements are "once and done" (like a single conditional payment), while others involve ongoing interactions with repeated execution (like continuously computed credit limits).
The Smart Agreement Code Library is where these patterns live and grow. As we and our partners discover new coordination patterns, they get added to this shared resource. This is how an ecosystem builds—not through everyone solving the same problems independently, but through collective intelligence captured in reusable tools.
What's Next
These four agreements are available for testing now, with a broader release coming soon. You can:
- Download the Unyt app
- Share your public key via this form
- Join the conversation at Discord and RSVP for our test sessions on Friday and Tuesday.
We encourage developers, currency designers, and anyone building economic coordination tools to explore what's possible when rules become configurable rather than fixed. This is the foundation that makes everything else we're building possible—from local currencies to cross-network clearinghouses to the HoloFuel integration itself.
Along with Circulo1 we now have two Unyt releases to use. Circulo2 will be released in a matter of days soon after we'll have another one. Each release builds on the previous, and each one proves that sophisticated crypto-accounting infrastructure doesn't require sacrificing flexibility for security.
Stay tuned—the floodgates are open, and there's much more to come.
