Winners of the second round of the Obyte Autonomous Agents Developer Contest
Roughly 1 month has passed since the announcement of the Autonomous Agents Developer Contest. Since the new feature was introduced, the Autonomous Agents channel on Discord has been one of the most active, and it is great to see how this is catching on. Experienced developers as well as newcomers discuss on equal grounds as the topic is something new, and the amount of creativity and sheer desire to want to understand every aspect is breathtaking.
For this round, four entries have been submitted in time for the deadline, Thursday midnight UTC.
Autonomous Agent Entries For Round 2
Entry 1 — “The Attested Reputations Autonomous Agent” by hey_monkey
The Autonomous Agent introduces an entire reputation system controlled by a single Autonomous Agent. It has several modes, that allows users to create a new “reputation domain” and allows users to participate in generating and building the reputation.
Particularly in the chaotic cryptocurrency industry, where the balance between privacy and transparency is constantly challenged, reputation systems are by many seen as viable solutions. It is the first entry to integrate other Obyte features as attestor-data is used to establish reputation.
The entry is huge and contains a lot of different functionality. The jury found the code to often be overly complex, and the attempt to obfuscate details that would still be possible to extract or deduct often makes things even harder to follow. Separating into individual AAs handling specific parts of the logic could potentially reduce complexity and make updates easier and assist in making each function stand out better.
Entry 2 — “OAAAAA” by Whoisterencelee
The entry is a further improvement of an entry from round 1. In the first round it was mainly an idea, but this time the developer has implemented the actual Autonomous Agent making it possible for others to use it and see how it works. The concept is to allow AA developers to point to new versions of an AA, thereby making it possible for users to decide whether an AA they stored the address of is the one they want to use, or if they want to use a newer version, that perhaps has added features or corrected bugs.
The jury acknowledges that the topic is a hot one. The implementation wouldn’t carry state variables to the updated AA and when triggered from another AA, the possibility to use an upgraded version wouldn’t be possible. The solution would also introduce a single point of failure, in that the author’s compromised wallet would allow malicious updates to be posted.
The possibility to update an AA does seem interesting, but exactly how it would work and in all scenarios is hard to imagine. For secondary AAs, the primary AA would have to be created to make use of the service and contain logic to select the latest version of the secondary, with limited transparency to the user when triggering the AA.
Entry #3 — “EOS-like Crowdsale” by alvarlaigna
To those familiar with crowdsales on crypto platforms, this entry shouldn’t be too hard to understand. It allows for the creation of a new token, which is then sold to an initially unknown number of buyers at a fixed rate of new tokens issued.
By having all the rules of the sale locked by the immutability of Autonomous Agents, it eliminates potential shady things or new rules being introduced halfway through the crowdsale. Another really interesting feature of this entry is the ability to increase the yield of the sale by maximizing the revenue from a fixed amount of tokens.
The jury found the code to be short and clean but agreed that it would benefit from a bit more documentation to make it even easier to read.
Entry #4 — “Autonomous Subscription Service” by pmiklos
Recurring payments are used in a wide range of industries that offers products to end users on subscription based terms. This entry introduces the possibility to have an AA handle subscriptions, payments, cancellation of subscription and withdrawal of funds by the users. Service providers create a new service that users can then subscribe to. Both subscriber and provider can cancel the subscription contract any time they like.
As long as the customer is subscribed to a service and has enough funds deposited on the AA, the service provider can withdraw funds from the customer’s account on the Autonomous Agent. When a customer no longer wants any subscriptions, funds can be withdrawn.
Generally, the entry is carefully thought through and handles all the various cases in well structured and easy-to-understand code. The documentation added to the readability of the code and the jury finds this particular use case highly relevant in a wide range of real world cases. A possible improvement would be to set state variables to false for cancelled subscriptions to prevent unnecessary use of storage on full nodes.
Entry #5 — “AA Asset Exchange” by Barborico
Introducing an entire exchange as an Autonomous Agent makes it fully transparent what is happening and doesn’t rely on a single potentially flawed entity running the exchange service.
The entry allows for exchange of any token on the Obyte platform to bytes and back. While there is a template for exchange between assets, this entry expands the example. The various keywords to be sent to the Autonomous Agent could probably benefit from a web UI making it easy for users to navigate and interact with the exchange.
The code of the entry seems really complex and it made it difficult for the jury to follow. Particularly exchange of assets is usually something you want to have someone audit before use and therefore a bit better structure and more documentation could potentially improve its potential.
Guide And Tutorial Entries For Round 2
Just like in round 1, this round also had 2 entries in the tutorials contest. And just like the first round, this time the entries are made by the two experienced and hardworking developers pmiklos and Genievot.
Entry 1 — “Stateful Agents” by pmiklos
Moving on from the first entry, pmiklos takes the user one step further and introduces state variables. The entry does a great job at picking up where the user left and gradually introduce more and more complex aspects of Autonomous Agents.
Particularly by providing a piece of code and then describe in detail what each part of the code does, makes the entry rather easy to follow. The use of state variables seems like a good decision to introduce, since some of the more advanced use cases will require the Autonomous Agent to be able to store a given state to be used in future executions.
The structure of the guide seems carefully thought through and doesn’t move too fast or introduce things that aren’t explained.
Entry 2 — “Build Your Own Lemonade Stand” by Genievot
In a refreshing (in more than one way) approach to tutorials, this entry introduces a simple real world example — a lemonade stand — and shows how an Autonomous Agent could handle the payment process.
The tutorial contains links to relevant documentation on Autonomous Agents and the Oscript language, and serves as a refreshing and fun entry. This might be a better way to learn for some as opposed to reading in detail what all parts of a piece of code actually does.
To someone not necessarily interested in building their own lemonade stand, the greatest take-away will be the links to the official documentation, so in that regard, the entry would probably serve a slightly smaller audience than the more traditional tutorial.
To select the winners of this round, a jury of mainly Obyte developers scored each of the entries on a scale from 1 to 5 points. Each jury member scores the entries entirely based on own preference and taste but is required to provide explanations about the pros and cons of each entry. These comments have been included to some extent in the description of each of the entries above.
Based on the score of each of the entries, it is now time to celebrate the winners of the second round of the Autonomous Agents Developer Contest!
The third place and the prize of 35 GB and 73.85 GBB goes to:
hey_monkey — “The Attested Reputations Autonomous Agent”
The entry addresses a highly relevant topic and uses attestations and crowdsourcing to establish reputation.
The second place and the prize of 70 GB and 147.7 GBB goes to:
Alvarlaigna — “EOS-like Crowdsale”
Adding several highly useful features to a regular ICO and reducing the complexity by providing a set of rules allowing ICO issuers to benefit the most in a fully transparent and predictable way.
In this second round of the Autonomous Agents Developer Contest. The first place and the prize of 140 GB and 422 GBB goes to:
pmiklos — “Autonomous Subscription Service”
The entry provides a highly useful alternative to any national subscription payment method and allows for near-zero fee payment of subscriptions. The use case is already seen in various fintech use cases and can potentially be applied in a variety of industries.
The attention to detail, documentation of the code along with the highly useful use case makes this entry the favourite and thereby the winner of this round.
Best guide / Tutorial
The two entries competing for the extra prize worth 55 GB and 116.05 GBB were really different this time. Taking entirely different approaches to teaching users, or getting new users interested in building Autonomous Agents, there is no doubt that they address two entirely different user segments. Had there been a category for teaching developers to write Oscript and one for getting more people interested in writing Autonomous Agents, they would have both won. But there has to be only one winner, and the winner of the best tutorial / guide in the second round of the contest is:
Pmiklos — “Stateful Autonomous Agents”
On behalf of the Obyte Core Team and the Jury, we congratulate the winners and look forward to even more entries for the second round. The deadline for entries is August 29th and winners of round 3 will be announced on September 1st.