With four rounds of the Developer Contest successfully concluded, it is now time to look at the entries for the fifth. But before we look at each of the entries, a few words on the rounds to come.

As round 3 was cancelled and all entries got moved to round 4, the jury decided to extend the contest by an extra round. This means that instead of round 6 being the final round, an additional round 7 has been added. The deadline for entries to the following rounds are therefore:

Round 6: Thursday October 10th midnight UTC Round 7: Thursday October 24th midnight UTC

previous rounds’ entries were Autonomous Agents largely isolated from other systems, with the exception of some interaction via GUI wallets. This round has, however, seen a few examples of how Autonomous Agents could also be combined with external systems like chat bots.

Autonomous Agents Entries For Round 5

There are 7 entries for this fifth round, so without further ado, let’s examine each of them!

Entry 1 — “Time for Birthday Fiddle” by whoisterencelee

Just after the deadline of round 4, whoisterencelee submitted a new entry. This was already mentioned on Thursday’s edition of the Obyte Community Radio Show and it offers an elegant nod to the two hosts of the show as one played “Happy Birthday” on a fiddle to celebrate the birthday of the other.

Fiddles aside, the entry shows a refreshing approach to increasing user interaction by providing use cases, that users would have an incentive to interact with. This is indeed a very important factor and one that the jury acknowledges. The complexity of the Autonomous Agent isn’t all that high, but it doesn’t have to be in order to provide a useful and easy-to-follow real world use case.

The way it works is rather simple. A user registers an address and a date.This could be the birthday of the person owning that address, or something else like the wedding anniversary of couples. On the set date (or any time after) the owner of the address can trigger the Autonomous Agent to receive whatever amount was deposited to that address. After the successful withdrawal of the present, the date is increased by 1 year, making it impossible to withdraw again until the next birthday has occurred. Any user can send small tips or “gifts” to any registered address.

Autonomous Agent Definition

Autonomous Agent Address: VUZ5ONFZIMJXDGIBSA5AOY3QOSBSIL5H

Entry 2 — “Aaprox” by barborico

This is without doubt the entry that puzzled the jury the most. From the rather scarce documentation on the GitHub Repository, it wasn’t entirely clear from the beginning, exactly what this entry set out to solve.

This of course shows that proper documentation is a really important factor when introducing Autonomous Agents, because while the jury consists of developers familiar with the Oscript language, users of Autonomous Agents will only have the feedback from the wallet to go from.

While it became clear that the entry offers a kind of bank account to which users can send transfer orders, the exact problem it solves is still somewhat a mystery.

Autonomous Agent Definition

Autonomous Agent Address: 2C2Y5FK7GYA2WUS2N4DHQDAP5YPLYK23

GitHub Repository

Entry 3 — “Holder Of Linked List AA (HOLLAA)” by hey_monkey

Previously, hey_monkey has shown mastery of the Oscript language to a degree where he manages to structure an Autonomous Agent in a way that allows others to either directly use it or to learn from it in their own implementations.

This entry introduces a sort of a CRUD for lists/state variables, making otherwise cumbersome state variable manipulation a bit easier. The Autonomous Agent offers what you would expect from a CRUD, the ability to Create, Read, Update and Delete but in addition, it offers two different ways to access/retrieve values. The resulting value will be returned in a way that allows it to be used as a trigger for another Autonomous Agent.

The features offered are quite relevant and might come in handy, but for an entry like this to have even more relevance, it would be nice to see the documentation give an example or two on possible implementations where it would make the life of the developer easier.

Autonomous Agent Definition

Autonomous Agent Address: RIWHUVJMQA5DJHK3AOUK5ZBPFFYW5I3J

GitHub Repository

Entry 4 — “ByteKeeper” by vik

In the previous rounds, we saw different approaches to creating a safe or storage that allows only one user to withdraw from the Autonomous Agent. By focusing instead on locking up funds for a certain amount of time, vik introduces a new perspective to the escrow type entries.

Users deposit funds to the Autonomous Agent and specify a date at which funds can successfully be withdrawn. More deposits can be made but the date when withdrawal becomes possible cannot be changed.

The entry is another example of a rather simple yet powerful implementation, and the Autonomous Agent has checks for the common things that could go wrong, like trying to make a second payment where a different date is set.

Autonomous Agent Definition

Autonomous Agent Address: CHQAQTIGW2SGVJJM2TWFAZBXXJG5SMOE

Entry 5 — “Untouchable Private Pension Plan” by btctry

One could almost believe vik and btctry had coordinated which round to submit their entries, because both managed to come up with very similar ideas for Autonomous Agents.

The entry by btctry is thought to function in the same way as a pension plan would work, allowing users to deposit amounts to it and be able to withdraw at a defined expiry date. Again, setting an expiry date after which withdrawal is possible is used and the funds can only be withdrawn by the creating address. This, of course requires the owner to be in possession of the same wallet many years later, and therefore, backup is advised to keep the pension safe.

The two entries differ slightly in that the creator of a pension plan can define any wallet address as the owner of the pension plan. This means you can create a pension plan for others. Anyone is allowed to make deposits to the pension plan, and as long as the address defined as owner knows about this and requests a withdrawal after the expiration date, the pension will be paid out.

One quite important flaw in this entry is that the Autonomous Agent doesn’t seem to verify the inputs before processing it. Checks for valid addresses have been introduced and could potentially reduce the risk of user errors by mistyping addresses.

Autonomous Agent Definition

Autonomous Agent Address: YQRB6IXMAE32QCB3A6MKXVY3FJSL3C7Y

GitHub Repository

Entry 6 — “Joint Account Autonomous Agent (JAAA)” by hey_monkey

The second entry in this round from hey_monkey introduces a really interesting and surprising use of several Autonomous Agents working together to form a use case.

At first glance, one might mistakenly believe that the ability to create shared wallets where multiple owners all have to agree before funds can be spent is covered by the built-in multi-signature functionality the Obyte wallet already has. However, this use case takes multiple ownership to a whole new level!

The Autonomous Agent introduces two different plans or strategies for the shared wallet, one plan flat and the other hierarchical. The flat plan is basically the same as the built-in multi-signature wallet, but the hierarchical plan introduces an interesting and new approach, where any attempt to spend funds will pass through a hierarchy of owners, starting from “the bottom”. Only if that user approves, the user on the next level is asked, and so on all the way to the top level user. This reduces the need for the top user to bother with a spend attempt already getting declined at a lower level.

It does require careful consideration on setting up the shared wallet as the order in which owners are created will automatically represent the wallet’s hierarchy. A jury member suggested that by integrating with the HOLAAA entry previously described, it would be possible to reorganize the list of users. Enabling owners to be arranged automatically determined by amount deposited to the Autonomous Agent would actually somewhat resemble a proof of stake mechanism where the ones with most at stake would be the highest ranked owners. Other ordering mechanisms could be used as well to provide other interesting variants of use of this Autonomous Agent.

Autonomous Agent Definition

Autonomous Agent Address: BNYR4KQWO75M5FP2VSRF6VKPCUHPNHOI

Documentation

GItHub Repository

Entry 7 — “FIFO” by whoisterencelee

First In First Out mechanisms are very commonly used in computer processing and various other areas like plane boarding or packing delivery trucks. It is a fundamental principle in a lot of different use cases, and it has now also been implemented as an Autonomous Agent on Obyte.

The entry itself is quite simple, showcasing how effectively even the smallest pieces of code can potentially be. By storing variables and “popping” them upon request, the Autonomous Agent serves as a normal buffer for data stored on Obyte.

While the simple construction is definitely useful for a lot of things, it would have been nice to see an actual implementation making use of the FIFO Autonomous Agent for a concrete use case. Not only to show how to use it properly, but also to inspire others and seed ideas of use cases where a FIFO buffer could effectively improve on a system.

These smaller building blocks will make life easier for future development of Autonomous Agents but would probably require some sort of documentation to be published so others will know of its existence at a later point in time.

Autonomous Agent Definition

Autonomous Agent Address: I4N3UUYUPOJIME5P6WNZ37ZOWHS5QUYV

Guide And Tutorial Entries For Round 5

Knowing how to navigate the different aspects of writing Oscript and providing useful guides and tutorials remains one of the most important keys to success of the adoption by developers. Therefore, we are pleased to once again see some high quality entries in this additional contest category.

During the week, it was discussed how to make sure the full potential is realized and one very important factor is of course: Preservation. Only by making sure all these guides and tutorials are made readily available to everyone seeking help and information, will they make a difference. Therefore, we encourage all guide- and tutorial creators to help remind us to add them to relevant pages either on the developers website or on the Obyte Wiki which is maintained by Obyte veteran slackjore.

Entry 1 — “Find help to trigger your OPAA when you need it” by hey_monkey

The winning entry of Round 4, THAANKS — an entry solving the otherwise impossible mission of causing an Autonomous Agent to trigger in the future — will definitely prove useful to other developers of Autonomous Agents.

Therefore, hey_monkey created a very detailed article on the different use cases it enables and exactly how the many features it offers works.

By using a combination of illustrations and careful written documentation, the use of the Autonomous Agent becomes a breeze and it will surely be a very important resource for other developers as soon as the Autonomous Agents hits the main net.

The level of detail and attention to what aspects others might struggle with is really high, and proves without a doubt, that hey_monkey’s skills extends beyond those of many hardcore developers. Being able to objectively observe various aspects and provide useful documentation that others will find easy isn’t all that common.

Link to guide

Entry 2 — “How to set up devnet for rapid development” by pmiklos

Every developer having wrestled with writing Autonomous Agents in the Oscript language knows the insane amount of patience it requires. A triggering action doesn’t actually trigger an Autonomous Agent before it becomes stable, and even though the process is slightly sped up on the testnet, it still takes several minutes of waiting before you see the result of the code. This is what pmiklos successfully provided a solution to, by creating a devnet version of Obyte that allows for rapid development and testing.

The tutorial takes developers through an easy to follow step-by-step guide on how to set up their own devnet by carefully starting with required elements like git, yarn, docker and npm. It is required to run Linux or at least some equivalent that allows execution of bash scripts to make the installation process work out-of-the-box.

Everything is kept fully up to date on GitHub and with new releases of the Oscript editor and the GUI wallet, it will be easy for those having followed this guide to keep their development environment fully up to date, provided pmiklos keeps the GitHub repository up to date, of course.

While it will definitely prove useful to developers of Autonomous Agents, it might also prove to be an excellent guide to those wanting to experiment with setting up the entire Obyte platform from scratch. It comes complete with genesis units for both Bytes and Blackbytes and a witness. As the guide results in creating a full node, the hub isn’t required and only the full node and witness parts are set up and configured by the package.

Finishing the article, a couple of very useful tips are provided, like how to completely wipe the entire DAG and start from a fresh copy and how to fund the GUI wallet is described.

Link to guide

Entry 3 — “Reviews of Autonomous Agent Techniques” by whoisterencelee

With entries from past rounds as offset, whoisterencelee set out to look at some of the techniques used in the different entries. The explanations of each entry works it way up in complexity starting with a rather simple example and ending with the mighty impressive and extremely complex Red vs Blue Autonomous Agent that whoisterencelee developed.

The tutorial looks at some of the softer aspects like how to successfully structure an Autonomous Agent, which considerations should be made before starting the development and how developers can make their lives easier by applying common practices like flowcharts and diagrams.

To round off the article, whoisterencelee also states that prizes from previous rounds for his entries will be used to set up bounties for users who contribute to the marketing, further development and coming up with feasible monetization strategies for Autonomous Agents. A gallant way to reward the Obyte community on which the success of not only Autonomous Agents but also the awareness of Obyte relies heavily.

Link to guide

The Winners

Once again, the Autonomous Agents Developer Contest saw an impressive amount of work put into the entries and before celebrating the winners, a big round of applause to recognize the incredible efforts by all the contestants.

With two more rounds to go and seeing the increasingly complex and useful entries, one can only start to imagine where the next rounds will lead us. Let’s look at the three entries that the jury found to be the best.

Third Place

The third place and the prize of 35 GB and 73.85 GBB goes to:

“Time For Birthday Fiddle” by whoisterencelee

It successfully shows a fun and fresh approach to incentivizing users to interact and become an active part of the Obyte community. It also shows a way to make users return to a use case after a certain amount of time, which is also a really important factor in the jury’s decision. This Autonomous Agent will be fun to follow once it hits the mainnet.

Second Place

The second place and the prize of 70 GB and 147.7 GBB goes to:

“ByteKeeper” by vik

The entry is elegantly implemented. It isn’t super complex in its set of features but manages to cover exactly what it is supposed to and effectively handles user mistakes. It simply provides a safe and sound solution to the use case it is set out to solve.

The Winner

For the fifth round in the Autonomous Agent Developer Contest, the winner of 140 GB and 422 GBB is:

“Joint Account Autonomous Agent (JAAA)” by hey_monkey

Most of what can be said about this entry has already been covered in the description of it. Coming up with an idea that takes an existing feature on the Obyte platform and improves on it by the use of Autonomous Agent is really impressive.

Reading about the struggles of fighting the Oscript restrictions like maximum complexity and maximum number of calls back and forth between Autonomous Agents, it is clear an optimal result was reached. Reducing the complexity of another entry to allow for more complexity of this one also proves that this entry wasn’t created without blood, sweat and tears and quite possibly a substantial amount of swearing while trying to figure out the best approach considering the limitations imposed by the protocol.

Best Guide / Tutorial

This is the round with most entries for the category, and each of them once again take very different approaches. One describes a concrete use of one of the building blocks created with Autonomous Agents, one describes how to make life easier for other developers and one provides plausible thought process to build Autonomous Agents.

The jury finds that the most useful entry of this round, and the winner of 55 GB and 116.05 GBB is:

“How to set up devnet for rapid development” by pmiklos

A big congratulations and a heartfelt thanks to all participants. Not only are you directly contributing with high quality value to the Obyte ecosystem, you are also proving time and time again, that only imagination (and the constants set in constants.js) pose limits to what is possible. You keep amazing us by providing surprising, inspiring and useful entries in this contest.

Nobody managed to crash the testnet with their entries, so no Crash and Burn award for this round.

The deadline for entries to Round 6 of the contest is Thursday October 10th. Happy Oscripting, everyone!