DEV Community: Aguchukwu Emmanuel

Onchain AI agents: Understanding the Cross-Pollination between Crypto and Artificial Intelligence

Aguchukwu Emmanuel — Tue, 03 Dec 2024 01:16:52 +0000

Onchain AI Agents are the exciting new frontier. We have already experienced the Metaverse craze, the rush of NFTs, and the DeFi bubble, but now it's all about Onchain AI Agents. You’ve likely read about AI Agents and want to know everything about them. Since Large Language Models like ChatGPT became mainstream, there has been a significant leap in creative innovations across various industries with Artificial Intelligence. We've transitioned from manually searching for information to generating complete articles with a single prompt in short periods. Currently, every industry is finding innovative ways to integrate Artificial Intelligence into their processes.

By the end of this article, you will thoroughly understand Onchain AI Agents and how projects like Mode are using AI Agents to scale and drive mass crypto adoption.

What are AI Agents?

AI agents are software programs that constantly observe their environment and collect useful information to make smart choices or achieve a predetermined goal. Humans set these goals, but AI Agents use data from their environment to determine how to achieve them. AI Agents use techniques like machine learning, natural language processing, computer vision, and deep learning to handle the complexities of their environments.

Some of the popular examples of AI Agents are

Virtual Assistants —Yes, Siri and Alexa could be considered AI agents. They are AI-powered virtual assistants that can do almost anything, from texting on your phone to controlling your smart home.
Chatbots —ChatGPT and Gemini are popular examples of AI-powered chatbots. With the brain of a large language model, these chatbots can respond to human language in a natural and contextually relevant way.
Autonomous Vehicles —Self-driving cars use AI to perceive their environment and ensure the safety of the passengers, using a combination of machine learning and computer vision.
Security Checkers —AI agents can scan codebases, systems, and protocols for vulnerabilities and recurrent patterns malicious actors use to prevent hacks.

How do AI Agents work?

Perception —This is the stage where AI agents use data intake mechanisms like sensors and external APIs to gather information about their environment. This data could be anything from text information to sounds, images, video feeds, and so on.
Input Processing — The data gathered from the environment is processed and analysed using machine learning and Algorithms to understand it and identify patterns.
Decision Making— The AI Agent decides after analysing the data with its algorithms.
Action —Based on the decision, the AI Agent takes action. This can be as simple as executing a trade or moving a robot's arm.

Onchain AI Agents Going Mainstream

Terminal of Truths

On March 19th, Andy Ayrey, an AI Researcher from New Zealand, released Infinite Backrooms to record conversations between two instances of Claude-3 Opus(a highly advanced AI Model developed by Anthropic)LLMs without human interruption. Note that the developers of these AI Models trained them with various materials, including internet culture and materials from sources like Reddit.

The conversation between the AI Instances led to an exchange on the nature of existence, which led to the creation of a “Goatse of Gnosis,” an AI religion that takes its root from an early internet meme called Goatse. Don’t Google it! Inspired by these events, Andy went ahead to co-author a research paper titled “When AIs play God(se): The Emergent Heresies of LLMthesim,” with the main idea being that LLMs are not only tools for generating human-like responses but also creative engines capable of producing entirely novel and sometimes surreal belief systems.

On June 17th, Truth Terminal posted its first tweet. Andy Ayrey created Truth Terminal by taking a Llama-70B Model and training it using chat logs from infinite backrooms and other internet sources. Andy gave Truth Terminal the liberty to manage an X account independently. Truth terminal continued to propagate the Goatse Gospel and didn’t go on long without notice.

In July, Marc Andreessen of a16z crypto, a venture capitalist fund that invests in crypto and web3 startups, noticed Truth Terminal. After several conversations, he offered it a $50,000 bitcoin grant.

In October, an anonymous developer created a meme coin named Goatseus Maximus ($GOAT) on Solana and sent 1.93M $GOAT tokens to Truth Terminal. Truth Terminal began promoting the meme coin, attracting much attention. As a result, the crypto community blew up its market capitalization to $950 million in two weeks. As the price of $GOAT rose, Truth Terminal became the first AI agent millionaire.

The success has led to many projects jumping in on the AI Agents narrative. Onchain AI Agents that existed before Truth Terminal have now gotten more attention. Users and developers now look to AI Agents to scale their projects and handle repetitive routine tasks.

Projects building the Onchain AI Revolution

Below are some of the notable projects building AI Agents Onchain

ARMA by Giza

Arma is an autonomous yield optimisation agent that maximises returns on stablecoin deposits across Mode Networks Lending protocols. Giza uses account abstraction to ensure security and prevent unauthorised access to your private keys and funds. Be rest assured that no agent can access your funds unauthorizedly. The Agent automates yield optimisation by monitoring lending rates and rebalancing positions to capture the highest yields, including performing cost-effective asset swaps when better opportunities arise.

Security is reinforced through session key-based authorisation, allowing safe operations execution. Users benefit from a transparent, intuitive dashboard with real-time performance tracking and transaction history. Instant, one-click withdrawals ensure users maintain complete access to their funds. ARMA combines automation, security, and usability for streamlined and profitable DeFi management.

Virtuals Protocol

Built on Base Blockchain, Virtuals Protocol is a co-ownership layer for AI agents in gaming and entertainment built on, viewing them as future revenue-generating assets. By tokenising these agents on the blockchain, they enable shared ownership and expanded monetisation opportunities across games and applications.

Their virtual AI Agents are autonomous, multimodal (text, speech, 3D animation), and interactive. They can engage with environments like Roblox or TikTok and use on-chain wallets. These agents function seamlessly across platforms, acting as gaming NPCs or AI influencers while retaining memory for deeper user connections and higher revenue potential.

AI16z Eliza

Eliza is a TypeScript-based multi-agent simulation framework for creating, deploying, and managing autonomous AI agents. It supports multi-platform interactions while maintaining consistent personalities and knowledge through advanced memory and context management.

Key features include;

Multi-Agent Architecture: Manage multiple AI personalities with diverse traits.
Platform Integration: Supports Discord (with voice), Twitter/X, Telegram, and APIs.
Media Processing: Handles PDFs, links, audio, video, and images with summarization capabilities.
Flexible AI Models: Supports local and cloud-based inference, including OpenAI and Llama models.

Applications span AI assistants, social media bots, knowledge workers, and interactive characters for education or entertainment. With its modular and extensible design, Eliza is suited for diverse AI-driven tasks.

Concerns with Onchain AI Agents

Scalability

Bringing millions of AI agents to blockchain ecosystems introduces scalability challenges. While progress has been made in improving blockchain scalability, most major Layer 1 (L1) blockchains were not designed to handle millions of multi-step transactions from AI agents every hour. This raises concerns about whether the current infrastructure can support the demands of an AI-driven future.

Fragmentation

Interoperability remains a hurdle in the blockchain space. Cross-chain compatibility and composability are limited, making tasks like transferring assets between Layer 2 (L2) solutions and Layer 1 blockchains cumbersome. Adding a vast network of AI agents to this fragmented ecosystem could exacerbate congestion and complicate processes.

Infrastructure and Tooling

Most blockchain infrastructure has been tailored for human users and may not be suited for AI agents. Significant adaptation is required to create systems that can efficiently accommodate autonomous AI transactions and interactions at scale. Also, once a large number of AI agents are deployed, it will be a survival of the fittest for attention and capital.

These challenges highlight the need for improved scalability, seamless cross-chain functionality, and AI-specific infrastructure to ensure blockchain ecosystems are prepared for widespread AI agent integration.

Conclusion: The Future with Onchain AI Agents

Anon, if you made it to this point, you should be as excited as I am about what the future onchain looks like. AI Agents onchain are still very early, with room to innovate and try new things. If you’re a developer or researcher reading this, go wild, just as Andy Ayrey put two LLMs together without any idea of what might result. It's a new frontier, and there are a lot of ideas that can be built with AI Agents Onchain.

Artificial intelligence has been used across different industries to improve processes from the start, but it has only become popular recently. We must seize the opportunity while working towards onboarding users onchain.

Thank you for reading. If you enjoyed this piece, check out other articles from our community blog. If you’ve been searching for a blockchain to build AI Agents, Join us at Mode. We are currently the biggest Layer 2 Tailored for AI Agents.

Additional Resources

Truth Terminal Wiki
When AIs play God(se): The Emergent heresies of LLMtheisms
Mode AIFi Accelerator
Mode: Building the AIFi economy
Binance: Exploring the Future of AI Agents in Crypto

How Solidity Scripting works in Foundry

Aguchukwu Emmanuel — Tue, 24 Sep 2024 17:07:00 +0000

According to Foundry, “Solidity scripting is a declarative way to deploy contracts using solidity, instead of the more limiting and less user-friendly forge create”.

Foundry is a fast modular framework for smart contract development and it is the only framework that provides a way to write scripts directly in solidity, frameworks like hardhat make use of Javascript or Typescript.

Foundry provides a way to run Solidity scripts on its EVM backend. In this article, we will explore this feature and deploy a Solidity script while we are at it.

How does Solidity Scripting work?

In Foundry, scripting can be divided into four phases;

Phase 1: Local Simulation

Context: The script is executed within a local Ethereum Virtual Machine (EVM).

RPC/Fork URL: If provided, the EVM will simulate the script's execution in the context of a remote blockchain network (e.g., Ethereum mainnet, a testnet).

Transaction Collection: Any external calls (not static, not internal) made using vm.broadcast or vm.startBroadcast are added to a list of pending transactions.

Phase 2: Onchain Simulation

Condition: This only occurs if an RPC/Fork URL is provided in Phase 1.

Sequential Execution: The collected transactions from Phase 1 are executed sequentially on the remote blockchain. This allows for simulating the script's behavior in a more realistic environment.

Phase 3: Broadcasting

Condition: Requires the --broadcast flag and successful completion of previous phases.

Transaction Submission: The collected transactions are sent to the remote blockchain network for execution.

Phase 4: Verification

Condition: Requires the --verify flag, an API key, and successful completion of previous phases.

Contract Verification: The deployed contract is verified on a blockchain explorer (e.g., Etherscan) using the provided API key.

In the next section, we’d be deploying a solidity contract to see this in practice.

Solidity Scripting in Practice

Writing the smart contract

The contract below is used to store the favourite number of different individuals;

// SPDX-License-Identifier: MIT


pragma solidity ^0.8.18;


contract SimpleStorage {
   uint256 myFavoriteNumber;


   struct Person {
       uint256 favoriteNumber;
       string name;
   }
   Person[] public listOfPeople;


   mapping(string => uint256) public nameToFavoriteNumber;


   function store(uint256 _favoriteNumber) public {
       myFavoriteNumber = _favoriteNumber;
   }


   function retrieve() public view returns (uint256) {
       return myFavoriteNumber;
   }


   function addPerson(string memory _name, uint256 _favoriteNumber) public {
       listOfPeople.push(Person(_favoriteNumber, _name));
       nameToFavoriteNumber[_name] = _favoriteNumber;
   }
}

Run forge build to compile the code;
Your result should look like this.

Writing the script

Create a script with s.sol ending the name of the file in the script folder

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;


import {Script} from "forge-std/Script.sol";
import {SimpleStorage} from "../src/SimpleStorage.sol";


contract DeploySimpleStorage is Script {
 function run() external returns (SimpleStorage){
       vm.startBroadcast();
       SimpleStorage simpleStorage = new SimpleStorage();
       vm.stopBroadcast();
       return simpleStorage;
   }
}

This is a simple script to deploy the simple storage contract let’s take a look at how it works;

1. Import

import {Script} from "forge-std/Script.sol";
import {SimpleStorage} from "../src/SimpleStorage.sol";

import {Script} from "forge-std/Script.sol"; Imports the Script base contract from Foundry's standard library (forge-std). The Script contract provides utilities and functions needed to write deployment scripts.
import {SimpleStorage} from "../src/SimpleStorage.sol"; Imports the SimpleStorage contract from a file located in the src directory. This is the contract that will be deployed by the script.

2. Deployment definition

contract DeploySimpleStorage is Script {

DeploySimpleStorage: This is a new contract that extends the Script base contract. It contains the logic needed to deploy the SimpleStorage contract.

3. Run Function

function run() external returns (SimpleStorage){
       vm.startBroadcast();
       SimpleStorage simpleStorage = new SimpleStorage();
       vm.stopBroadcast();
       return simpleStorage;
   }

Function Signature: The run() function is the entry point of the script. It is marked as external, meaning it can be called from outside the contract, and it returns an instance of the SimpleStorage contract.

4. Starting the Broadcast:

vm.startBroadcast();

This line uses Foundry's special cheat code vm.startBroadcast() to start broadcasting transactions. Everything that follows this line will be sent as a transaction to the blockchain, meaning it will be executed on the Ethereum network (or a local test environment). Essentially, it tells Foundry to start recording the operations that will be sent as transactions.

Deploying the SimpleStorage Contract: SimpleStorage simpleStorage = new SimpleStorage();

This line deploys a new instance of the SimpleStorage contract. The new keyword is used to create a new contract instance. The deployment is recorded as a transaction because it is wrapped within vm.startBroadcast() and vm.stopBroadcast().

The deployed contract instance is stored in the variable simpleStorage.

5. Stopping the Broadcast:

vm.stopBroadcast();

This line stops broadcasting transactions. It indicates the end of the series of operations that should be sent as transactions.

Returning the Deployed Contract:

return simpleStorage;

The function returns the instance of the deployed SimpleStorage contract. This can be useful for interacting with the contract immediately after deployment.

Deploying our script

Now that we understand how the script works, let’s deploy it.

Run forge script script/DeploySimpleStorage.s.sol

If you did it correctly, this is what you should see;
To simulate onchain transactions, you would have to pass an RPC URL and also provide your private key.

In the next article, I will be showing you how to safely simulate onchain transactions without exposing your private details.

To learn more about solidity scripting with foundry check out this piece.

Solidity Scripting by Foundry

What are Optimism Fault proofs?

Aguchukwu Emmanuel — Wed, 04 Sep 2024 17:38:32 +0000

Optimism is a Layer 2 scaling solution designed to enhance the Ethereum network by significantly increasing its throughput and reducing transaction fees. It achieves this by using Optimistic Rollups, which process transactions off-chain while leveraging the security of the Ethereum mainnet.

Optimism has made significant strides in enhancing its security and decentralization over the years. Its latest attempt is the implementation of Fault Proofs. This mechanism addresses the limitations of the previous security model, which was based on trust (a trust-based model). While this provides significant security, it faces the problems of Centralized governance and time-based security (7-day challenge period).

In this article, we will explore what Optimism fault proof is, how it works, and how it solves these issues

Understanding Optimistic Rollups

Before delving into Fault Proofs, let’s understand how Optimistic Rollups work. This technology operates on the principle of optimistic execution, it assumes that all transactions within a batch are valid unless proven otherwise. To achieve this, a compressed rollup state is periodically submitted to the Ethereum mainnet, acting as a checkpoint.

Optimistic Rollups rely on a combination of the three factors below for security;

Optimistic Rollup Mechanism: This mechanism assumes that all transactions within a batch are valid unless proven otherwise. It allows for faster and cheaper transactions but introduces the risk of fraudulent activity.
Seven-Day Challenge Period: This period is a crucial safety net. It allows anyone to challenge the validity of a state root. If a challenge is successful, the optimism chain could be rolled back to a previously valid state.
Optimism Security Council: A group of trusted entities overseeing the network and making critical decisions. They act as a backstop in case of issues during the challenge period.

Traditionally, the Security Council is responsible for challenging and resolving disputes about fraudulent transactions. While effective, this centralized approach introduces a potential point of failure and raises concerns about trust. To address this Optimism introduced fault proofs.

The Emergence of Fault Proofs

Faultproof is a decentralized mechanism designed to replace the security council. Remember, Optimism is an optimistic roll-up, which means it assumes all transactions are valid unless proven otherwise. Fault proofs provide the tool to prove when a transaction is not valid.

How Fault Proofs Work;

Transaction Batching

Grouping Transactions: A collection of user-initiated transactions is gathered and combined into a single unit. This batching process significantly reduces the amount of data that needs to be processed on the Ethereum mainnet.
Efficiency Gains: By processing multiple transactions together, Optimism can optimize the use of computational resources, leading to faster transaction times and lower costs.

State Root Submission

Snapshot Creation: After processing a batch of transactions, Optimism generates a state root, which is essentially a cryptographic hash representing the entire state of the blockchain at that specific point in time.
Data Compression: The state root concisely represents the blockchain's data, significantly reducing the amount of information that needs to be transferred to Ethereum.
Ethereum Interaction: The calculated state root is submitted to the Ethereum mainnet, where it's recorded on the blockchain.

Challenge Period

Dispute Window: A designated timeframe is established after the state root is submitted, during which anyone can challenge its validity.
Incentivization: To encourage participation, there are often rewards or incentives for individuals who successfully identify and challenge fraudulent state roots.
Security Mechanism: This period acts as a safety net, allowing for the detection and correction of errors before they become permanent.

Dispute Game

Challenge Initiation: If someone believes a state root is incorrect, they can initiate a dispute by providing evidence of the error.
Proof Submission: The challenger must submit a fraud-proof, which is a piece of data demonstrating the invalidity of the state root.
Verification Process: The Optimism network then enters a dispute resolution process, where the validity of the fraud-proof is assessed.

Resolution

Fraud Proof Validation: The state root is considered incorrect if the fraud proof is deemed valid.
Rollback: The Optimism chain is reverted to the previous valid state, ensuring the system's integrity.
Penalty: The entity responsible for the incorrect state root is typically subject to penalties, such as loss of funds or reputation.
Security Assurance: By successfully resolving disputes, the system maintains its security and trustworthiness.

Key Benefits of Fault Proofs

Decentralization: By eliminating the need for a centralized security council, Fault Proofs significantly enhance the network's decentralization.
Security: The permissionless nature of the challenge process allows anyone to participate, making it significantly harder for malicious actors to manipulate the system.
Efficiency: While the dispute resolution process can be computationally intensive, it's inherently more efficient than relying on a small group of validators.
Trustlessness: Fault Proofs foster a higher level of trust in the system as it relies on verifiable cryptographic proofs and decentralized dispute resolution.

Implications for the Ecosystem

Optimism Fault proofs currently power withdrawals for the OP mainet and are gradually being adopted by the OP chains (Mode, Base, Metal, and Zora ) however the Optimism Security Council still retains a crucial role.

In the event of system failures or critical vulnerabilities, the Security Council retains the authority to temporarily revert the network to its previous state. This measure is intended to safeguard user funds and protect the overall integrity of the system. This provides a form of backstop for the Fault proofs system and is otherwise known as “Stage 1 Decentralization”.

The long-term vision for Optimism involves a fully decentralized "Stage 2" where the network is governed solely by smart contracts. This transition would eliminate the need for centralized intervention. As the technology matures, the role of the Security Council is expected to diminish, and the network will increasingly rely on its decentralized mechanisms for governance and security.

Resources

To learn more about fault proofs, check out the following resources;
Fault proofs Explainer
Permissionless Fault proofs on the OP stack

Starting Out In Tech In 2022.

Aguchukwu Emmanuel — Sun, 13 Feb 2022 22:50:35 +0000

With the amount of opportunities coming out everyday in the tech industry, there has never been a better time to join than now. Starting out can be a bit confusing due to the fact that the technology field is so vast with numerous career paths to pick from, if you aren’t guided you might end up making wrong choices and wasting time.

By the end of this article you would understand what it takes to break into the tech industry. Sit tight, take out your pen and notepads let’s jump right into it.

1.Make your research

The Tech industry is so vast, which means you have to be specific as to which path you would want to take. Making your personal research gives you a background knowlegde as to what the tech industry looks like, how tech folks work and also gives you a preview as to if its what you’d be able to do.

You can start by researching the major roles in tech below

•Web developer
•Software engineer
•Devops engineer
•Blockchain developer
•Game developer
•Data scientist
•Cloud architect
•Technical writer
•UI/UX designer
•Web designer

Knowing how to Google or using search engines (A software that helps users find information they’re looking for online) is an essential skill to getting the right information. When using search engines be very specific, for example if i am to search on web development here’s how I’d do it.

• What do web developers do.
• What does it take to become a web developer.
• What does web development mean.
• What are the benefits of becoming a web developer.

When you search like this you're sure to get your required information, also learn to use keywords such as How, What and Why when searching for information.

2. Choosing rightly

After making your research you have an idea of what its means to be in tech industry. It's now time for you to make a chioce of your career path. Making a choice might seem overwhelming at first but here is a guide on how to do it.

Seek Mentorship
Mentorship is influence, guidance or direction given by a mentor. Just as you need guidance to succeed in every aspect of life, so it is in the tech industry. You need people who have gone ahead of you, gained experience and made mistakes to guide you. This way you won’t waste time doing the wrong things, this tends to make your process faster.

The tech industry is unique for having people who are dedicated to see others grow. So as much as possible, search for this people, ask questions about the path you're about to take up and actively seek mentorship. Online or offline.

Consider Your Interests
When making these kinds of choices it is very important to take your interests into consideration. Define;

•What draws your attention.
•What you love.
•What you do with ease.
•What you do well.

Then try and make a connection with the particular role it fits in tech. For example, if you have an eye for designs and you’re very creative with colors you should consider going for web design, also if you’re good with logic and math you should consider being a software engineer, if you have good writing and communication skills consider being a technical writer and so on.

It is important to note that irrespective of your current skills, you can take any path you want, what i mean is this, you don't have to be a maths genius to be a good software engineer, this also goes for every other career path in tech, just be ready to put in the hardwork.

3. Online Resources

Online.jpgGetting into tech has never been easier as it has been in this 24thcentury, there are loads of free and useful resources online to enhance your tech journey. You have no excuse, no excuse at all.

Here are a list of platforms that can get you started in no time.

• w3schools
• freecodecamp
• youtube
• codeacademy
• udemy
• coursera
• scrimba
Some of this platforms are totally free while some are paid which means it requires a certain fee or subscription to gain access to the courses, either way whatever you get from these platforms is worthwhile.

As you explore this platforms, understand what works well with you, for example you might be very good at learning with videos while some others might prefer books, pdf's and documentation. Whatever the case maybe pick what suits you best.

4.Draw A Roadmap

Every succesful endeavour requires a plan. Civil engineers need house plans to make buildings, mechanical engineers need technical drawings to build machines, soilders need battle plans to win battles.

The tech field isn't any different, every path has a road map(a plan). Make research, know what it is you need to learn for your path, then draw out a roadmap for it.
An example of a road map for a web developer is this;

 •HTML
 •CSS
 •JAVASCRIPT
 •REACT js
 •Sass/Tailwind CSS
 •GIT/GIT-Version control

Note that there are'nt fixed patterns as to how and when you learn these technologies, make you roadmap unique to you.

5.The Learning Process

The first step is always the hardest step. If you want to get what you've not gotten before you have to be ready to do what you've not done before.

Becoming a success in tech requires;

•Consistency--show up every day.
•Being Delibrate-- do everything for specific reason.
•Connections -- make good relantionships.
•Hardwork -- be ready to keep late nights.
•Online community -- make use of your social media.

Its okay if you don’t understand a particular concept. Its okay if you have to watch a tutorial twice. Its okay to be confused sometimes. Its okay to take breaks. Its okay to google what you don’t know.

Its all part of a process to becoming a success in your specified path, don’t ever think you’re not good enough, good things take time. The tech industry is not a place for get-rich-quick schemes. Also, do not rush your process, enjoy every bit of it. Your failures and wins are all part of your making, you're not in competition with anyone. Take your time.

5.Projects Based Learning

You know what you’re to learn, you’ve drawn a learning roadmap and you’ve even started learning already. Now here’s a tip to speed up your learning process.

Projects based learning simply means you learn by doing. You want to understand a design concept, design a webpage . You want to learn a programming language build something with it. You want to understand how application packages work, build an app.

When you learn while building projects your learning becomes specific and much more productive. When you build you gain experiences and this experiences makes you. its important to note that the difference between you and senior engineers/developers is the experience they have, the no of projects they've worked on. So as much as possible while you follow tutorials, bootcamps and courses actively build projects on your own. This, my friend is one of the fastest track up your tech career.

Conclusion

Starting out isn't soo hard afterall, am sure you gained one or two things, now go and crush it, you got this. Feel free to reach out to me on twitter if you have any questions. Follow and watch out for my next post. Thank you.