The case for Blockchain and Autonomy
a guest post by Valory's Senior Python Engineer David Vilela Freire
So... what is Autonolas? It might be surprising to see us asking this question now. After all, we have already discussed the benefits of Autonolas autonomous services, and how they can be built – for example, in these previous posts here and here. However, for non-experts in the field, it is not always evident what a certain technology actually achieves, and the benefits it offers.
This is not an Autonolas-specific communication challenge, but rather a widespread issue in the ever widening field of blockchain-related technologies. Certainly, technologies like “Bitcoin” have broad name recognition, and to a lesser extent other crypto-adjacent terms like “blockchain”, “crypto wallets”, and so on are familiar to the average person…but try asking your family and friends what a “cross-chain bridge” is!
Certainly, we believe that anyone with enough interest and time to invest should be able to understand any “blockchain-related” project, given enough clear and accurate information. Which is, precisely, the aim of the storyline in this blogpost. If you identified with this description, keep reading below!
Motivation: why you need to understand these new technologies
During the last decade, one technology above all others has created a lot of noise and controversy in the media, including newspapers, TVs and the Internet. This technology, as you may have guessed, is the blockchain. You certainly have heard or read about cryptocurrencies like Bitcoin and Ethereum, and terms like smart contracts, NFTs or web3 at some point, even if you don’t completely understand what the hype is all about.
You may know that it has “something to do with money,” and you might also know that there are thousands of cryptocurrency-related projects at the moment (actually, there have been more than 20,000 different tokens launched already), but understanding the differences between them is not easy. That’s the reason you might have heard people referring to it either as a scam or as a technological breakthrough. Sometimes, even both.
The truth is, explaining blockchain or web3 is not straightforward. There are hundreds of very interesting projects out there trying to change the world in all kinds of ways, but currently we have a knowledge gap that prevents non-specialized audiences from accessing this information.
We also face this problem at Autonolas when we try to explain our mission to people outside the blockchain field. And this post is an attempt at fixing this.
If someone has tried explaining blockchain, web3 or distributed technologies (formally, Distributed Ledger Technologies or DLT) to you by starting with how a blockchain works instead of what it can do, then there’s a good chance that you got it mixed up.
You wouldn’t explain the automobile to your grand-grand-grand-parents starting with combustion cycles, differentials and mechanics. It is much more useful to show them how a car can take you from one place to another at great speed and how it can revolutionize the way society travels and works.
The first thing you must know about blockchain is that it is not just about money. It was originally about money, but now it entails something more profound: information, ownership, trust and new structures for societies and companies.
These new scopes of application will affect you in the near future, and therefore it would be helpful that you be able to explain it to your grandparents (without forgetting mum and dad).
How things used to work
Traditionally, societies have been building their economies around tangible goods and their hierarchies around the management of those goods: governments and companies are about creating, collecting, managing and distributing things that we need, like grain and other food, minerals and raw materials, money and more recently more abstract goods.
Until a few decades ago, we only knew goods and services economies. For that reason, companies that extract, process, store or sell goods or services needed mines, factories, warehouses and stores: physical places where those activities take place.
This imposes the requirement for new companies to have access to a certain amount of resources to fund their operations. And as globalization connected economies from all over the world, it also created a common playfield where companies could grow to serve millions of customers.
Some of them grew so big in fact, that the resources requirement makes it virtually impossible for new companies to be able to compete with behemoths such as JPMorgan, Saudi Aramco or BlackRock.
Nevertheless, with the appearance of computers and the Internet, a new kind of non-tangible good was born: digital information. Unlike tangible goods, digital information can be copied for free, and instantly accessed or shared across the world, opening the door for a new type of economy, the information economy, and therefore new companies like Google, Amazon or Microsoft found a new place to thrive among other giants.
But, if you are paying attention, you can see that these new companies share the same problem with the older ones: now that the Internet is not a new place and the market is established, new technological companies also need a vast amount of funding to stay competitive.
Furthermore, and in parallel with this issue, there is another one: where centuries ago you would only buy in stores in your village, hire people from your city, or lend money to people you knew, a global economy and the Internet made it possible to sell goods across countries or hire people from the other side of the world.
With this possibility came a downside: the trust issue. What if a company from abroad sends a broken machine to me? What if a bank in another country goes bankrupt? Can I trust institutions or people that are based outside my jurisdiction?
For this reason, even digital companies sometimes need to open offices in many countries, which expands further on the requirements for new companies. Even in these globally connected, technological economies we need trust relationships and hierarchies (subsidiaries, remote headquarters, third-party partners, governments that enforce laws…) that let us transact without putting our business at stake. And once more, this adds to the pile for new companies that would like to play the game.
Think, for instance, about cooperatives: globally scaling that business model is basically impossible, as the need for intermediaries and infrastructure is inevitable. Due to these trust issues, most companies today follow a centralized model: the assets, the information or whatever the company transacts with are under the control of a small group of people: call it the company’s board of directors, the CEO or their investors. Or, in other words: people who trust each other within the company’s management.
This is what we mean by centralized models: a select circle of people hold the power over all the decisions. For IT companies that collect or use your data, for example, the user has little to no say in how their information is managed or monetized. Banks hold your money, but what if they decide to freeze your account? What if Facebook revokes your access to your pictures? If you are exposed to such centralization risks, are those assets really yours?
What if there was a better way? What if we could have a business model that could scale globally without all those inconveniences? What if a small number of people could pool their resources, even if they didn't trust each other, to build cooperative companies that do not depend on intermediaries, third parties or the need for offices, bosses and contract relationships, and where the power to take decisions was distributed across all members? That would greatly reduce the barriers to entry for anyone in the world to start a business and create services. The seed for this was planted by distributed ledger technologies.
Distributed Ledger Technologies
While you might have heard about blockchain, there are several other similar technologies like Hashgraph, Directed Acyclic Graph (DAG), Holochain or Tempo. The common factor among them is that they allow for several parties to hold copies of the same information and democratically vote on how that information should be changed.
You can think of them as a public, shared, infinite notebook where anyone can append information, and it cannot be deleted. We call these technologies DLT: Distributed Ledger Technologies, and they are the base for decentralized companies and services where the decision power is distributed across all their members without the need for mutual trust.
Basically, you can think of them as organizations run by people across the world that agree on a set of rules and vote to enforce those rules for the greater good. Since at the core these companies are just a set of rules, sometimes they are referred to as protocols.
The first and most famous implementation of a blockchain protocol was Bitcoin, which tried to be the first decentralized bank: if you think about it, a bank in its simplest form is about holding a balance and being able to send and receive transactions, and since a balance or a transaction amount are just numbers, such a simple system is the natural perfect candidate to experiment with decentralization.
In Bitcoin, every member holds a copy of all balances and all transactions from all people using it, and they can check and validate every movement of money. Instead of a single bank controlling all your assets, you and only you are the owner of them and anyone in the network can verify it.
Of course, you wouldn’t trust some random people from the internet with keeping your account’s balance secure, but what if those people could actually prove to you that all the transactions are legitimate? DLT is about exactly that: mathematically proving the legitimacy of an event like a transaction while minimizing the trust among all parties and letting every user own their assets.
The members of DLT networks like Bitcoin (sometimes called nodes, miners or validators depending on their roles) vote on the validity of every transaction: they check, for example, that every sender has enough money before processing their transactions. Of course, some of these nodes could try to cheat the network to create money out of thin air, but as long as the majority of them vote honestly, the network is safe.
In some cases, this honest behavior is incentivized by paying them a small fee. Since in most blockchains anyone can run a node, and every node holds every piece of information about the chain, as the network grows bigger, the higher is the number of nodes that should be malicious or hacked in order to compromise the security of the network. This redundancy makes blockchains very robust and fault tolerant: even if a number of nodes are offline or hacked, the network and its assets stay safe.
This makes it possible for blockchains like Bitcoin to securely process payments without the need for a central authority like a central bank who traditionally is responsible for deciding on the rules of a monetary system. On DLT, every member has a saying on how things should be.
Once it was proven that a cryptocurrency like Bitcoin could work, more people started thinking about what could be improved and what new, more complex interactions could be possible using DLT, and a new set of technologies under the DLT umbrella appeared: smart contracts and NFTs being well known examples.
NFTs are not too different from a property certificate: if you hold an NFT, you are verified as the owner of the property that’s associated with that NFT, be it a simple picture or a house. But let’s focus on smart contracts: in the same way that all nodes of a blockchain network hold a copy of all balances, they can also hold copies of programs. After all, both numbers and programs are pure information, bits of data that can be stored on any computer.
Those programs are what we call smart contracts: pieces of software that live in every node and are run at the same time so the network can agree on the program output. This opens the door for more complex operations, like exchanging different assets only under certain conditions, programming transactions that are triggered by events, or connecting different blockchains.
This is precisely what a smart contract is: a “program” whose execution is validated by everyone participating in the ledger. You might write a smart contract that automatically pays your employees every month and checks for customer payments before shipping them their goods. All of that without the need for any banking infrastructure.
Entities or collectives running on top of smart contracts are usually known as Decentralized Autonomous Organizations (DAOs): organizations with no central authority, where the power is distributed across all members who vote democratically to take all decisions that need to be made in order to keep the organization running.
Let’s use a classic example to further illustrate how a DAO could work: a crop insurance DAO that protects farmers' economies from bad harvests during droughts or any other weather conditions that render their fields unusable. In this DAO, someone writes one or more smart contracts that implement the logic of the organization: insurance policy, handling payments, checking conditions...Once all the code is in place, either the same people that wrote the contract or maybe completely different ones might pool some money to kickstart the DAO’s operations.
Some farmers interested in this insurance would pay a yearly subscription that is locked into the DAO treasury (note: not even the DAO members necessarily have access to those funds. The treasury could be automatically managed by a smart contract that is not under their control). At some point, a drought might cause the farmers not being able to generate enough yield that year, so they request a payment from the crop insurance DAO.
The organization needs to verify that the weather conditions are covered by the insurance, so they pull some data from a reliable weather database and they input that data into the corresponding smart contract (we will talk later about how this happens and some of the downsides) and that contract calculates how much each farmer should be paid according those conditions and releases the funds for them.
A hypothetical new version of the web where DAOs, similar to the crop insurance example above, offer their services in a decentralized way and where users own their information and assets without the need of a central authority has been called web3 (not to be confused with Web 3.0).
In contrast with the previous versions of the web like web1 (read only, basic static websites) and web2 (read and write your own content, like in social networks), web3 is thought of as a place where you can not only read and write but also own and trade information and assets. We say that all of this information that is recorded on the blockchain as “on-chain”.
But before we keep dreaming of all these possibilities, let’s come back down to earth for a moment. Yes, theoretically, anything that can be expressed by software can be written as a smart contract that runs in a blockchain, and DAOs could hypothetically replace big companies, but of course, in practice there are some limitations to this technology.
Limitations of Smart Contracts and current approaches
While blockchains were fairly small, transactions were fast and cheap. Those first networks were light and met their first users’ requirements, but as protocols like Ethereum (the most famous smart contract oriented blockchain) grew bigger and more complex, their networks started to become bloated.
More people started using their services and increasingly complex smart contracts were created to support all of the operations that were run on blockchains. This innovation and growth came at a cost: users competed for the network’s limited resources, so they paid bigger fees every time for processing their transactions and executing their smart contracts. This created a scalability issue: as the protocols grew bigger, they were slower and more expensive.
After all, in its origins, blockchains were conceived of as simple databases, but we are using them as complete computers. If you asked any software engineer about running a program inside a database, they would look at you as if you were out of your mind. But that is exactly what happens with smart contracts. For simple programs that might not be an issue, but if you want to create very complex logic, then you’ll soon find yourself banging your head against a wall.
Smart contracts cannot run things like machine learning, they cannot run for more than a few milliseconds and they cannot interact with the world outside of the blockchain.
Another problem is that nowadays, blockchains are hermetic environments: they don’t interact with websites or external databases. Remember how in the crop insurance example, at some point, the DAO needed to get data from a meteorological database? Since blockchains are isolated from the real world, they can’t get data from outside themselves. Someone needs to send that data to it, but this creates a new problem: we are talking about decentralizing services and minimizing trust, but now we find ourselves in a situation where we need to trust a single user responsible for getting that data, or a single weather database that may or may not be reliable.
What if the database has been manipulated? This point of centralization would render our services vulnerable to attacks. There must be a better solution for this, and some protocols have been trying to solve it by creating so-called oracles: decentralized services composed of multiple nodes that get data from the outside world, verify it and submit it to a blockchain so it is available for smart contract consumption, but even these oracles have their own limitations in what they can do: they can get and verify simple data, but since some of them are smart contracts themselves, they suffer from similar issues.
So, there still exists a big gap between DLT services and traditional services. Blockchains are extremely good at being robust and secure, but they are very limited on the operations they can do. On the other hand, that’s exactly what the good old web2-based services are good at: what we call the off-chain world still has a lot to offer. Why not try to keep the best of both worlds?
Decentralized, robust services that interact with any other online service, be it on-chain or off-chain would bring the possibility of creating a true, flexible web3 without the infamous scalability issues: run complex operations off-chain and store the result on-chain.
One more thing about smart contracts: they are purely reactive. They can respond to events, but they can’t proactively take decisions on their own. At some point, they always need human input to trigger certain events. In order to unlock the real power of DAOs and decentralized economies we need to take a step beyond decentralization. We need something better than automatic: we need autonomy.
A is for Autonomy: the case for Autonolas
Most blockchain protocols do one of these two things:
- Implement their own chain, trying to improve or solve issues that other chains suffer from.
- Add functionality to one or more existing chains. Decentralized exchanges are an example of this.
As we discussed in the previous section, both approaches leave a big gap for a new technology that connects both the on-chain and the off-chain world.
As a response to that, Autonolas was born as a one of a kind protocol, with the goal of unlocking the potential of decentralized off-chain services: decentralized, autonomous services that run off-chain but can interact with both on-chain and off-chain services, without constraints on what kind of operations they can do.
We can think of these off-chain services as swarms of nodes (we call them agents) that form networks to create a service. Like smart contracts, they run the exact same software, and they use DLT technology to vote on its output until they reach consensus and take action over it, but unlike smart contracts, they are not limited on the complexity or nature of the software they can run.
They can be understood as small, blockchain-independent and specialized networks that only serve one purpose: to run a single service. Continuing with the crop insurance example, an Autonolas off-chain service could work as follows:
- Someone creates the insurance service using Autonolas technology: this implements all the logic and rules that conform the insurance, similarly how it was done in the old example with smart contracts.
- A group of people, usually distributed all over the world, starts running agents that execute the logic. The nodes form a blockchain-like network.
- A farmer registers into the service and annually pays the subscription.
- At some point, the farmer requests a payment to cover their harvest losses due to some climatic condition.
- Every agent on the network gets the corresponding climate data from different databases from different providers: this further decentralizes the system, as no single provider becomes a point of centralization.
- Agents share the collected data with the rest of agents, they validate it and vote to reach consensus on what the majority of them thinks is the correct weather data.
- If the farmer request is coherent with the observed data, agents release a payment to cover for losses, usually through a blockchain transaction. No single agent can take unilateral actions over the funds as transactions need to be signed by a majority of them.
As can be seen, the fact that these services can interact both with traditional services like weather databases and blockchains open a number of use cases not possible until now. These Autonolas services can read data from websites, write to databases, make reservations on your behalf, auto-invest your funds and move them depending market conditions, run complex machine learning algorithms and even start and manage other Autonolas services.
Yes, an Autonolas service could autonomously pay for some cloud infrastructure to a cloud provider and then run and manage another service running on that cloud.
To make this possible, there’s two main pieces that work together hand in hand: a set of tools for developers to build the services, called a framework, and an on-chain protocol that works as an “App Store” for those services. Usually, big IT companies like Apple, Google or Microsoft offer their developers a similar setup so they can build useful apps and games and then upload them to their online store.
Of course, these companies get a cut of the apps’ benefits, but there is another problem: they also get to decide who can and cannot use their services, as well as which kind of apps are eligible to be uploaded to the store. These companies are centralized and devs have no saying on the rules that apply to their apps. If they don’t agree with the rules, they are out of the system.
The Autonolas on-chain protocol is a set of smart contracts that acts in a similar fashion as an app store: it lets developers register and monetize their services, it allows for those services to economically interact, but it does this in a decentralized way: all of the rules of the protocol are democratically voted on by its members.
And there’s more: Autonolas services are created by using a set of tools specifically designed with modularity and composability in mind. This means that a single developer could create a very small piece of code that does something interesting, for example, getting some data for last weekend’s baseball matches results.
We call a small code package like this a skill. It does not do anything more than that, but it might be useful for someone, so its creator can register this skill on the protocol and upload it to the cloud. At some point, another developer might be creating a service that publishes match results for different sports on a website, and he finds the baseball skill registered on the protocol, as well as other skills for tennis, football and rugby published by other creators.
The fact that all these skills are already available means that this new developer does not need to create everything from scratch: he can signal the protocol that he’s willing to use those pre-existing skills and connect them to his new service while registering it into the protocol.
Once the service is ready, a new actor comes into the scene: node operators, people who actually run some agents that execute the service. These agents are also registered into the Autonolas protocol. The good part here is that if this service is monetized at some point, its benefits will be automatically split between the service owner, the operators and all the developers that contributed some code to it.
Since skills are small code modules similar to LEGO pieces, they can be connected together to create bigger pieces, that at the same time can be connected to other things recursively, creating more complex services every time that would let DAOs replicate almost any traditional service in a decentralized and autonomous fashion. Autonolas is like the assembly line that makes all of this possible.
And how does the protocol know who it needs to pay? Well, remember how developers, service owners and operators registered their skills, services and agents? Every time someone registers any of those, they receive an NFT that proves they are the owners of those entities. This means that they can not only monetize their services when they are in use, but also sell or trade them with other people that might be interested in them.
This novel way of creating, connecting and sharing services is a powerful tool to raise a new organizational paradigm where companies, DAOs and even just one single person can serve their customers without the need of centralizing power, where developers can monetize their work however small is, and above all, a path to unlock autonomous services that work on behalf of their users and pave the way for new economic models where democracy and cooperation is the norm.
We hope you enjoyed this article and that it has provided you with more tools to understand and explain all these cutting-edge technologies. If you are as excited as us about all its possibilities and want to learn more about Autonolas, have a look at our website or join the discussion on the Autonolas Discord server.
For the curious, you can also visit our decentralized oracle service or the protocol frontend, and if you are a developer or know some of them interested in building cool things with our stack, our documentation and code repositories are the way to start exploring. See you there!
Sign up for updates