In the Obyte ecosystem we have had smart contracts and chat bots for a long time: smart contracts provide a way to lock and unlock funds based on immutable predefined conditions enforced by the Obyte ledger, while chat bots bring dynamics and complex user interactions. While smart contracts are evaluated by every node and are decentralized, chat bots are external users of the system and they are not decentralized. Obyte didn't have a decentralized programmable reactive component... until now!
Autonomous Agents (AAs) are a recent addition to the Obyte ecosystem. AAs are programs that live on the Obyte ledger and execute in a decentralized fashion when they are triggered. Indeed, they are not running constantly by themselves, they have to be activated by users, or as a matter of fact other AAs, who interact with AAs by sending transactions to them. Such trigger transaction is typically a simple payment but they can also carry data elements for example.
AAs are program codes written in a so called Oscript language and are stored and executed by every full node in the network. Given the unique properties of AAs, they are deterministic and evaluate the same on every node independently. A typical flow is the following:
The output of the AA can be many things, it can be a payment back to the user, to other users or AAs, it can be a definition of a new asset or data posted in a data feed etc, but one of the most important is a state change output. Each AA can store its state in state variables that can be read and updated in consecutive executions.
Let's create the classic Hello World application as an autonomous agent. The simplest way is to use the web based Oscript Editor (testnet).
The AA program code is a JSON object which can include executable Oscript statements in the value parts of the JSON object. The mandatory object is the messages, which declares the output of the AA. Let's just start with a simple code which returns the Hello World! string to the caller eg. the user wallet.
{
messages: [
{
app: 'state',
state: `{
response['message'] = 'Hello World!';
}`
}
]
}
Above we instruct the AA to produce a state output with a response variable called message. The response is informational to the user that triggered the AA and is not stored on the Obyte ledger. Here is what the user can see in the payment history tab:
There is a couple of things we can observe here:
RQFA6V47KAHRUPYKH6VSJLILNXIXKZ3F which is the address of the Hello World AA and is simply the hash of AA's definitionResponse unit is empty since the we only had a state message that does not result in a new Obyte transactionResponse contains the variables returned using the response arrayBounced? No states that the AA executed normallyNow let's improve our Hello World AA by returning some of the money the user sent to trigger the AA. We can do it by adding an additional payment message:
{
messages: [
{
app: 'payment',
payload: {
asset: 'base',
outputs: [{address: "{trigger.address}"}]
}
},
{
app: 'state',
state: `{
response['message'] = 'Hello World!';
}`
}
]
}
Have a look at the payment message:
bytes.{trigger.address}. This is an Oscript expression that evaluates to the address of the triggering unit.Deploying this script results in a new AA address (XWSU74B7OMNIUNEXCVOKKJXXYR67BCFW), which is expected since the code has changed and so the hash of the AA definition. If we now trigger this AA, we will see the AA returning some of the money, basically the original 10000 bytes minus posting fees charged by the Obyte protocol:
And here we can see the Response unit is now filled with the unit hash that points to the output of the AA which is actually the returned payment transaction: