Like all other blockchains, NEAR is actually an exception. NEAR has sharding, so they do not share global state but have local states.
When we build AO, the goal is to combine these concepts. We want processes to run in parallel, capable of any scale of computation, while separating the interaction of these processes from their execution environment, ultimately forming a decentralized version of Erlang. For those not familiar with distributed technology, the simplest way to understand it is to imagine it as a decentralized supercomputer. With AO, you can launch a terminal within the system. As a developer, the most natural way to use it is to start your own local process and then interact with it, just like you would with a local command line interface. As we move towards consumer adoption, people are building UIs and all the things you would expect. Essentially, it allows you to run personal computation in this decentralized computing device cloud and interact using a unified message format. When designing this part, we referenced the TCP/IP protocol that runs the internet, trying to create a TCP/IP protocol that can be seen as computation itself.
AO’s data protocol does not force the use of any specific type of virtual machine. You can use any virtual machine you want, as we have implemented WASM32 and 64-bit versions. Others in the ecosystem have implemented EVM. If you have this shared messaging layer (we use Arweave), then you can allow all these highly heterogeneous processes to interact in a shared environment, like the internet of computation. Once this infrastructure is in place, the next natural step is to explore what can be done with intelligent, verifiable, trusted computation. Obvious applications include AI or smart contracts, allowing agents to make intelligent decisions in the market, possibly against each other or representing humans against humans. When we look at the global financial system, about 83% of Nasdaq trades are executed by robots. This is how the world operates.
In the past, we could not put the intelligent part on the chain and make it trustworthy. But in the Arweave ecosystem, there is another parallel workflow, which we call RAIL, responsible AI ledger. It is essentially a way to create records of different model inputs and outputs and store these records in a public, transparent manner so that you can query and say, “Hey, did this data I see come from an AI model?” If we can generalize this, we believe it can solve a fundamental problem we see today. For example, someone sends you a news article from a website you don’t trust, with a picture or video of a politician doing something silly. Is it true? RAIL provides a ledger that many competing companies can use in a transparent and neutral way to store their generated output records, just as they use the internet. And they can do this at a very low cost.
Illia’s views on blockchain scalability
Lulu: I’m curious about Illia’s views on the scalability of the AO method or model. You have been involved in the work of the Transformer model, which aims to solve the bottleneck of sequential processing. I would like to ask, what is NEAR’s scalability approach? In a previous AMA chat, you mentioned that you are exploring a direction where multiple small models make up a system, which may be one of the solutions.
Illia: Scalability can be applied in many different ways in blockchain, and we can continue along the lines of Sam’s topic. What we see now is that if you use a single large language model (LLM), it has some limitations in reasoning. You need to prompt it in a specific way for it to run for a while. Over time, the model will improve and become more general. But anyway, you are in some way training these models (you can think of it as raw intelligence) to perform specific functions and tasks and to reason better in specific contexts.
If you want them to perform more general tasks and processes, you need multiple models running in different contexts, performing different aspects of the tasks. To give a very specific example, we are currently developing an end-to-end process. You can say, “Hey, I want to build this application.” The final output is a fully built application, containing correct, formally verified smart contracts, and the user experience has been thoroughly tested. In real life, there is usually not one person building all these things, and the same idea applies here. You actually want AI to play different roles, to play different roles at different times, right?
First, you need an AI agent acting as a product manager, actually collecting requirements, figuring out what you want, what trade-offs there are, what the user stories and experiences are. Then there may be an AI designer responsible for translating these designs into the frontend. Then there may be an architect responsible for the backend and middleware architecture. Then there are AI developers who write code and ensure that smart contracts and all frontend work are formally verified. Finally, there may be an AI tester who ensures everything runs smoothly, testing through the browser. So you have a group of AI agents, although they may use the same model, they are fine-tuned for specific functions. They play their roles independently in the process, interacting with prompts, structures, tools, and the observed environment to build a complete process.
This is what Sam mentioned, having many different agents that asynchronously perform their tasks, observe the environment, and figure out what needs to be done. So you really need a framework, you need a system to continually improve them. From the user’s perspective, you send a request and interact with different agents, but they work together as a single system. At the lower level, they may actually pay each other for exchanging information, or different agents from different owners interact with each other to actually accomplish something. This is a new version of an API, more intelligent, more natural language-driven. All of this requires a lot of framework structures and payment and settlement systems.
There is a new way of explaining called AI business, where all these agents interact with each other to complete tasks. This is the system that we are all moving towards. When considering the scalability of this system, several issues need to be addressed. As I mentioned, NEAR is designed to support billions of users, including humans, AI agents, and even cats, as long as they can transact. Each NEAR account or smart contract runs in parallel, allowing for continued scalability and transactions. At a lower level, you may not want to send a transaction every time you call an AI agent or API, no matter how cheap NEAR is, it is not reasonable. Therefore, we are developing a peer-to-peer protocol that allows agent nodes, clients (including humans or AI) to connect with each other and pay fees for API calls, data retrieval, etc., and have encryption economic rules to ensure they respond, otherwise they will lose part of their deposit.
This is a new system that allows for scalability beyond NEAR, providing micro-payments. We call it yoctoNEAR, equivalent to 10^-24 of NEAR. This way, you can actually exchange messages at the network level and have payment functions attached, so that all operations and interactions can now be settled through this payment system. This solves a fundamental problem in blockchain, that we do not have a payment system with bandwidth and delay, and there are actually many free-riders. This is a very interesting aspect of scalability, not limited to just blockchain scalability, but can be applied to a world that may have billions of agents in the future. In this world, even on your device, multiple agents may be running in the background, performing various tasks.
Application of AO in DeFi scenarios: Agent Finance
Lulu: This use case is very interesting. I believe that for AI payments, there is usually a need for high-frequency payments and complex strategies that have not been implemented due to performance limitations. So I am looking forward to seeing how these needs can be met with better scalability options. In our hackathon, Sam and the team mentioned that AO is also exploring the use of new AI infrastructure to support DeFi use cases. Sam, could you please explain in detail how your infrastructure is being applied in the new DeFi scenario?
Sam: We call it Agent Finance. This refers to the two aspects we see in the market. DeFi has done very well in the first phase, decentralizing various economic primitives and bringing them on-chain, allowing users to use them without trusting any intermediaries. But when we consider the market, we think of the digital fluctuations and the intelligence driving these decisions. When you can bring this intelligence itself on-chain, you have a trustless financial tool, such as a hedge fund.
A simple example is if we were to build a meme coin trading hedge fund. Our strategy is to buy Trump coins when Trump is mentioned, and buy Biden coins when Biden is mentioned. In AO, you can use oracle services like 0rbit to get the entire content of a webpage, such as the Wall Street Journal or the New York Times, and then input it into your agent, which processes the data and analyzes how many times Trump is mentioned. You can also do sentiment analysis to understand market trends. Then, your agent will buy and sell these assets based on this information.
What’s interesting is that we can make the agent itself trustless. This way, you have a hedge fund that can execute strategies, you can invest funds in it without trusting a fund manager. This is another aspect of finance that the DeFi world has not really touched on, making wise decisions and then taking action. If we canTo make these decision-making processes trustworthy, the entire system can be unified to create an economy that appears truly decentralized, rather than just a settlement layer involving various economic games.
We see this as a huge opportunity, with some individuals within the ecosystem already beginning to build these components. We have a team that has created a trustless portfolio manager that will buy and sell assets according to the proportions you desire. For example, if you want 50% in Arweave tokens and 50% in stablecoins, it will automatically execute trades when the prices fluctuate. Behind this is an interesting concept – within AO, there is a feature called cron messages. This means processes can awaken themselves and autonomously do things within the environment. You can set your hedge fund smart contract to awaken every five seconds or five minutes, fetch data from the network, process it, and take action within the environment. This makes it completely autonomous as it can interact with the environment, in a sense, it is “alive.”
Executing smart contracts on Ethereum requires external triggers, and a lot of infrastructure has been built to solve this problem, but it is not seamless. In AO, these functionalities are built-in. Therefore, you will see on-chain agents constantly competing with each other in the market. This will drive network usage to increase significantly in ways unseen in the crypto space before.
NEAR.ai’s overall strategy and development focus
Lulu: NEAR.ai is advancing some promising use cases. Can you tell us more about other aspects or the overall strategy and some key focuses?
Illia: Indeed, there are many things happening at every level, with various products and projects that can be integrated. It all obviously starts with the NEAR blockchain itself. Many projects require a scalable blockchain, some form of identity verification, payments, and coordination. NEAR’s smart contracts are written in Rust and JavaScript, which is very convenient for many use cases. An interesting thing is that NEAR’s recent protocol upgrade introduced the so-called yield/resume precompiles. These precompiles allow smart contracts to pause execution, waiting for external events to occur, whether it’s another smart contract or AI reasoning, and then resume execution. This is very useful for smart contracts that require input from LLMs (like ChatGPT) or verifiable reasoning.
We also introduced chain abstraction and chain signature features, which are some of the unique features NEAR introduced in the past six months. Any NEAR account can transact on other chains. This is very useful for building agents, AI reasoning, or other infrastructure because now you can conduct cross-chain transactions via NEAR without worrying about transaction fees, tokens, RPC, and other infrastructure. All of this is handled for you through the chain signature infrastructure. Ordinary users can also use this feature. There is a HOT Wallet built on NEAR on Telegram, which has just launched Base integration on the mainnet, with approximately 140,000 users using this Telegram wallet to access Base.
Furthermore, we plan to develop a peer-to-peer network that will allow agents, AI reasoning nodes, and other storage nodes to participate in more verifiable communication protocols. This is very important because the current network stack is very limited and lacks native payment functions. Despite us often saying that blockchain is “internet money,” in reality, we have not yet solved the problem of sending money along with data packets at the network level. We are addressing this issue, which is very useful for all AI use cases and broader Web3 applications.
Additionally, we are developing a so-called AI reasoning router, which is essentially a place where all use cases, middleware, decentralized reasoning, on-chain, and off-chain data providers can be plugged in. This router can serve as a framework that truly interconnects all projects being built within the NEAR ecosystem and then offers all of these to NEAR’s user base. NEAR has over 15 million monthly active users across different models and applications.
Some applications are exploring how to deploy models to user devices, known as edge computing. This approach involves storing data locally and operating using related protocols and SDKs. From a privacy perspective, this has a lot of potential. In the future, many applications will run on user devices, generating or pre-compiling user experiences using only local models to avoid data leaks. As developers, we are conducting a lot of research to make it easy for anyone to build and deploy applications on Web3 and conduct formal verification on the backend. This will be a crucial topic in the future as OLLM models become increasingly powerful in discovering codebase vulnerabilities.
In summary, this is a complete technical stack, from the foundational blockchain infrastructure to Web3 chain abstraction, and then peer-to-peer connections, ideal for connecting off-chain and on-chain participants. Next are applications for AI reasoning routers and local data storage, particularly useful for cases that require access to private data without leaking it to external sources. Finally, developers will integrate all research findings with the goal of having AI build future applications. In the medium to long term, this will be a crucial development direction.
AO’s priorities and research focus
Lulu: I’d like to ask Sam about AO’s current priorities and research focus. Can you share some insights on this?
Sam: One idea I am particularly interested in is leveraging the extended capabilities provided by AO to establish a deterministic subset of CUDA, an abstract GPU driver. Typically, GPU computing is not deterministic, so it cannot be used safely for calculations like on AO, at least not securely, as no one would trust these processes. If we can solve this problem, which is theoretically possible, it only needs to address the uncertainties at the device level. There has been some interesting research, but it needs to handle this issue in a way that can always be 100% certain, which is crucial for smart contract execution. We already have a plugin system supporting this feature as an internal driver within AO. The framework is there; we just need to figure out how to precisely implement it. Despite many technical details, the basic idea is to make job loading in the GPU environment predictable enough to be used for such computations.
Another area of interest for me is whether we can utilize the capabilities of on-chain AI to enable decentralized or at least open and distributed model training, especially for fine-tuning models. The basic idea is that if you can set a clear evaluation criterion for a task, you can train models based on that criterion. Can we create a system where people can incentivize miners to compete to build better models by investing tokens? While this may not attract a very diverse range of miners, it doesn’t matter because it allows model training to be done in an open manner. Then, when miners upload models, they can add a general data license tag specifying that anyone can use these models, but if used for commercial purposes, a specific royalty must be paid. The royalties can be distributed to contributors through tokens. By combining all these elements, an incentive mechanism can be created to train open-source models.
I also believe that the RAIL plan mentioned earlier is very important. We have discussed with some major AI providers or reasoning providers about the possibility of supporting this plan, and they have shown strong interest. If we can get them to truly implement and write this data onto the network, users will be able to right-click on any image on the internet and query if the image was generated using Stable Diffusion or DALL·E. These are very interesting areas we are currently exploring.
Illia and Sam’s favorite projects
Lulu: Please each nominate a recent favorite AI or crypto project, it can be any project.
Illia: I’ll be clever about this. We hold AI Office Hours every week, inviting some projects, and recently we had Masa and Compute Labs. Both projects are fantastic, but I’ll use Compute Labs as an example. Compute Labs basically transforms actual compute resources (like GPUs and other hardware) into a real asset that can be economically participated in, allowing users to profit from these devices. The computing market in the crypto space is currently booming, and they seem like a natural place for crypto to promote markets. However, these markets lack moats and network effects, leading to intense competition and profit compression. Therefore, the computing market is just a supplement to other business models. Compute Labs offers a very crypto-native business model, that of capital formation and decarbonization of assets. It creates opportunities for people to participate that usually require building data centers. The computing market is just a part of it, with the main goal being to provide access to computing resources. This model also fits well with the broader decentralized AI ecosystem by providing underlying computing resources, offering opportunities for a wider range of investors to participate in innovation.
Sam: There are many great projects within the AO ecosystem, and I don’t want to favor any one, but I think Autonomous Finance is building the underlying infrastructure that makes “agent finance” possible. This is very cool, and they are really leading the way in this regard. I also want to give credit to the broader open-source AI community, especially for the approach Meta has taken in open-sourcing the Lama model, which has spurred many others to open-source their models. If this trend did not exist, when OpenAI transitioned to ClosedAI after GPT-2, we might have been in a dark place, especially in the crypto space, as we would not have access to these models. People would only be able to rent these closed-source models from one or two major providers. Currently, this is not the case, which is great. Ironically, but still, a shoutout to the Web2 king Meta.
