Making Safes Autonomous: Introducing Autonolas

For over a year, we’ve been working on an innovation which builds on top of the Safe contract standard.

We’ve introduced what we do to some of you 1-on-1, but wanted to take the opportunity to formally let the DAO know we’ve been up to.

Autonolas gives your Safe autonomous superpowers!

The use cases are endless. Autonolas allows you to turn a Safe into a:

  • Yield optimizer
  • Index fund manager
  • Custom data reporter (oracle)
  • Transaction relayer
  • DAO treasury manager
  • NFT fund manager
  • SubDAO coordinator
  • DAO contribution manager
  • Token harvester

The list goes on.

What is an Autonolas-powered Safe? How does one work?

Autonolas agents: bringing the smarts off-chain. Safe: taking robust action on-chain.

The Autonolas open source software stack allows developers to equip Safe multi-sigs with an application logic that is executed off-chain, and that is accepted on-chain, provided that the approval quorum of the multi-sig has been met.

To showcase this, we created decentralized infrastructure which allows you to develop custom oracles using SAFE multi-sigs.

Let’s take a look at how one of these – a price oracle – works. The application logic is as follows: each signer of the multisig is EOA-controlled by an autonomous agent (think a bot on steroids). Each agent signer retrieves price information from different APIs. The price information from each agent is synchronized, then agents apply an aggregation method. The agents come to consensus on the estimation and broadcast the result on-chain by signing a multi-sig transaction. Configuring the multi-sig to accept an incomplete quorum of signatures allows the process to be fault tolerant, and mirror on-chain security models. Services built with Autonolas are designed to be run by 1 or more operators, enabling progressive decentralization.

Another potential use case is turning a SAFE multi-sig into a decentralized relayer. In this case, each signer’s process will be reading data from the origin of the relayer (e.g. a smart contract in chain A), collectively they agree on the observed data and finally create a valid multi-sig transaction, that gets verified on the relayer’s destination (e.g. a related smart contract on chain B). The corresponding data blob then gets processed at the destination.

The Autonolas open source stack is free to use and is available for everyone to experiment with now.

The first autonomous Safes

Check out some of the first applications we have running to get a more tangible sense of how they work and what’s possible:

  • El Collectooorr – here a Safe autonomously watches for new generative art drops on Art Blocks and intelligently collects works, before dropping them into a fractionalized vault, owned by depositors.
  • Autonolas Contribute – here a Safe is used to coordinate off-chain agents as they automatically track off-chain actions and log leaderboard points. Leaderboard points will soon be logged on Ceramic. Individuals’ contributions are visualized via dynamic NFT, also coordinated via the Safe.
  • Autonomous Fund – here a Safe autonomously manages a new Balancer Managed Pool to execute a trading strategy based on the Crypto Fear and Greed Index. Built with a grant from Balancer. (Full demo coming soon)

Everything which gets deployed on Autonolas uses a Safe

One of the reasons we wanted to introduce ourselves was that there’s such a close synergy between usage of our stack and of Safe’s.

The number of humans using Safes is growing healthy. Now let’s start growing the number of machines using them!

We’d love to talk to folks in the DAO who find this exciting and are interested to explore this synergy.


1 Like