Arkhai Whitepaper

Introduction​

The most revolutionary aspect of cryptocurrencies is the ability to create currencies with bespoke incentive structures. Once humans evolved beyond debt, barter, and other primitive forms of economic exchange, the power of issuing currency was restricted to the hands of a few. Blockchains and cryptocurrencies completely upended the old order, allowing anyone to issue their own currencies with their own incentives, and for communities to self-govern using sovereign currencies over which they collectively had full control.

Foundational to this revolution are the compute, storage, and networking that enable distributed systems. Decades of research in cryptography and consensus blossomed into the big bang of the Bitcoin whitepaper, from which, a mere decade later, a multi-trillion dollar industry sprang forth.

Out of the primitives necessary for cryptocurrencies to exist naturally emerge multi-agent systems, which facilitate the representation of the desires of both humans and machines, and which will form the foundation of the new decentralized and permissionless digital economy of the future.

Pivotal Moment in History​

After decades of development, and multiple winters, new paradigms in AI are emerging and are already replacing large chunks of human labor, with ever more dramatic changes just around the corner.

Open-source models are becoming more powerful, but are also coming under attack from a variety of institutional powers threatened by their proliferation. Maintaining an infrastructure that supports the development, use, and promotion of open-source models is of paramount importance.

New Markets for Latent Compute​

A wasted resource continues to waste away – idle computing power. Every day, all around the world, in data centers, on desktops, laptops, and mobile phones, on IoT devices and other embedded hardware, there lies enormous potential. The excess heat created by idle machines is considered waste, and at best is used to heat water for industrial or consumer use. But this trash is merely waiting to be turned into treasure – and all that is needed are the right markets.

These new markets must answer the question: what are computations that nobody is willing to pay for now, but that somebody might be willing to pay for later? If such computations can be found, then traditional financial instruments, like futures and prediction markets, can unlock a treasure trove of possibilities.

Composable Machine-Actionable Markets​

Composing different markets in a machine-actionable manner will enable many new opportunities. The new markets for latent computing power just mentioned are only the beginning. As this whitepaper is being written, many traditional markets are being brought on-chain: asset markets, energy markets, online retail marketplaces, etc. This tokenization of real-world assets (RWAs) is a harbinger of a revolution in commerce. Not only will autonomous agents be booking restaurants and buying plane tickets- they will be engaging in sophisticated economic activity of humans that they cannot competently do themselves, like peer-to-peer energy trading, exchanging bundles of assets, coordinating vehicular traffic, and so on.

The machine-actionable composition of these different markets will unlock enormous potential, democratizing what was before accessible in diluted form, and only to a select few.

Embracing New Paradigms in Distributed Computing and Permissionless Markets​

Neither centralized nor decentralized marketplaces can facilitate the types of economic activity which will be possible with autonomous agents in the coming years. Arkhai is building with the following ideas as part of its foundation:

1. Compute marketplaces that don't have built-in capabilities for handling storage and bandwidth will fall behind those that do
2. Generalized collateralization schemes and collateralization markets provide a more modular foundation and can facilitate more use cases than existing solutions
3. Exchange of different types of assets within marketplaces built on the same primitives allows for composing economic interactions in new ways

Looking ahead, advances in AI agents as well as permissionless markets will converge to form sophisticated economies that can produce synthetic assets, much in the same way that LLMs conversing with each other can naturally create their own language.

Web3 Distributed Computing Background​

This section provides a relevant background on distributed computing networks and marketplaces. However, for Arkhai, this is only the beginning. The principles described in this whitepaper extend far beyond distributed computing, as will be explored in later sections.

Basics of Consensus​

Byzantine Fault Tolerance (BFT) is a critical security feature of blockchains, designed to ensure that a distributed network can reach consensus and remain operational even when some nodes act maliciously or fail. This is achieved through the massive replication of computations across the nodes participating in the protocol. By requiring the agreement of a large fraction of nodes to validate transactions and updates, BFT provides a robust defense against various types of attacks, including double-spending and consensus manipulation. Redundancy and cross-verification not only enhance the security of the network, but also increase its resilience, ensuring that it can continue to function correctly even under adverse conditions. With BFT, blockchain networks achieve high levels of integrity and trustworthiness, making them ideal for applications that require robust security and reliability.

Global and Local Consensus​

However, not all applications leveraging blockchains require the global consensus that they provide. While blockchains provide safety and liveness, the massive replication of computation becomes too costly when the corresponding level of security is not needed.

On the opposite end of the spectrum from global consensus is local consensus, which at a minimum only requires a single agent to be convinced of the state. Ostensibly, for a two-sided marketplace, only the client really needs to be convinced that a computation was done correctly. However, these computations are not done in isolation, and the interrelation between a client choosing one node repeatedly versus many different nodes, as well as the need to create a protocol that any client can come along to with no prior experience and be assured that cheating is disincentivized, implies the creation of a global game that, while not requiring global consensus in the traditional sense, emulates it in some manner.

Local versus global consensus is not a binary choice, but rather a spectrum. The middle of the spectrum involves agreement among a subset of nodes (potentially within a specific region or cluster), which can lead to faster and more efficient decision-making processes due to reduced communication overhead. The spectrum between local and global consensus allows for flexible implementation strategies, where systems can be designed to balance speed, efficiency, and security based on their specific requirements and operational contexts. This flexibility is key to optimizing the performance and reliability of distributed networks across various applications.

One of the primary benefits of local consensus is that the market incentives can be structured in such a way as to drive the total number of replications of a job due to verifiability down to 1. This is intended to minimize some combination of the computational cost of the job, the financial cost of the job, the missed opportunity of doing other jobs, the energy consumed, and other factors. Local consensus that minimizes the overhead of verifiability requires using some combination of the verifiable computing methods described above, and implicitly excludes the massive replication of every task, like in most (but not all) current blockchain consensus algorithms.

Verifiable Computing​

The issue of verifiability in a trustless, permissionless distributed computing marketplace is crucial. How do clients know that they are getting the correct results returned to them, if not through the massive replication of Byzantine Fault Tolerance? This is the subject matter of a large field of computer science known as verifiable computing.

Verifiable computing is dedicated to ensuring that outsourced computations (that is, computations that are not done locally) are done correctly. In some scenarios, it cannot be assumed that the node to which a job is being outsourced will compute the result honestly, or that it is not faulty. Moreover, verifying the result should have less overhead than computing the result in the first place.

There are three main categories of verifiable computing: cryptographic methods, hardware/software methods, and replication-based methods.

Cryptographic Methods​

Cryptographic methods rely on cryptography for their security. These methods include interactive proofs (IP), zero-knowledge proofs (ZKP, a type of IP), multi-party computation (MPC), and homomorphic encryption, especially fully homomorphic encryption (FHE).

In interactive proofs, verification of a statement is modeled as an interaction between a prover and a verifier. The goal of the prover is to convince the verifier that the statement is true, even when the verifier does not have the computation resources to do the computation itself. The protocol must satisfy completeness (if the statement is true, an honest verifier will be convinced) and soundness (if the statement is false, the prover cannot convince the verifier except with some negligible probability).

Zero-knowledge proofs are a type of interactive proof where the verifier learns nothing about private inputs of the computation, other than that the outputs were computed correctly from all the inputs (some of which may be public/known to the verifier). A ZKP can be made non-interactive, in which case it is called a Non-Interactive Zero-Knowledge Proof (NIZK). Two common variants of NIZKs are zk-SNARKs (zero-knowledge Succinct Non-interactive Argument of Knowledge) and zk-STARKs (zero-knowledge Scalable Transparent Argument of Knowledge). Like IPs, ZKPs must also satisfy the requirements of completeness and soundness.

Multi-party computation allows multiple parties to jointly compute a function over their individual inputs without any party revealing its input to other parties. The main objectives of MPC are privacy (parties should learn known about each others' inputs), security (some level of anti-collusion preventing malicious attempts to learn information), functionality (the ability to compute functions over data), and robustness (the protocol should work correctly even in the presence of malicious behavior or faults).

Homomorphic encryption enables computing over encrypted data. Fully homomorphic encryption enables encrypted compute over encrypted data, providing an extremely valuable level of security for sensitive applications.

Trusted Execution Environments​

Trusted Execution Environments are secure and isolated enclaves, where code and data inside of the enclave are insulated from the rest of the system, including the operating system, applications, and other enclaves. The goal is to maintain both the confidentiality and the integrity of the code and data.

Verification-via-Replication​

Verification-via-replication -- often described using the adjective "optimistic" in the blockchain world -- relies on recomputing the computation to check whether the end result is the same. The benefits of this method are that it is the easiest to understand, and in some sense, the easiest to implement.

In contrast to the other approaches, verification-via-replication often requires game-theoretic mechanisms such as collateral slashing and reputation layers to counter cheating and collusion, the latter of which is the key challenge for this class of mechanisms.

One of the downsides of verification-via-replication is the extra effort expended on recomputing computations. However, with proper incentives, the overhead of recomputing can be reduced dramatically, while simultaneously enabling network scaling. Despite its overhead, verification-via-replication can offer much better performance than cryptographic methods, which usually has much higher overhead.

Mixed Approaches​

Some approaches work by breaking down the computation to a single point of disagreement between a prover and a challenger, and re-executing that step in order to determine the prover's veracity. While this is a good approach, these methods have so far only been implemented for on-chain transactions and smart contracts. Other approaches could be used to prove the computational step in question (e.g. with ZKPs), but the issue again lies with domain-specific application limitations.

Determinism​

Verification-via-replication necessitates some kind of comparison between the results from at least two different sources. If the computation is deterministic both on the software and hardware levels, then such comparisons are simple. However, what if the computations are not deterministic? This leaves a few options other than cryptography and secure enclaves.

One option is to use approximate agreement: if the verification yields a result close enough to the original result being checked, then the original result is considered valid. Approximate agreement requires an application-specific distance measure for results, which introduces developer overhead, but may be worth it. For example, BOINC (the Berkeley Open Infrastructure for Network Computing) has been using approximate agreement for a long time.

Approximate agreement might be applicable to some neural networks; for example, in Large Language Models (LLMs), it might be possible to measure the distance between outputs before decoding; however, slightly different outputs before decoding can still lead to large differences after decoding, which leaves room for abuse, both in terms of cheating the protocol, and with larger consequences for the systems that use the outputs of the model.

Another option is to simply trust the compute node, and not verify the result. The downside to this approach is the requirement of trust, and that it, by definition, does not fall under verifiable computing. The upside to this approach is that there has been for many years now a thorough literature developing on reputation systems, which provides a wide space of options for implementing such protocols.

Objective Functions​

Another method of verification relies on objective-function based evaluation. A classic example of this in the blockchain world is Proof-of-Work (PoW) -- solving the cryptographic puzzle of finding the input that leads to a sufficient number of leading zeros is considered computationally hard, and thus the proof is in the frequency of solving the puzzle for whether the work was done or not. Another example is finding new prime numbers, for which there are no known formulas or algorithms for doing with certainty, and is thus a problem solved by brute force search (after pruning of the search space).

Arkhai's Approach​

Arkhai's design of deals enables it to incorporate all of these methods of verification. In later sections is a discussion of how to make the protocol robust to manipulation, specifically for optimistic verification, using game-theoretic white-hat hacking, and how that approach there also applies to many other areas.

Differences Between Web2 and Web3 Distributed Computing​

In Web2, the client controls the nodes on which the compute is being run. In Web3, the compute nodes have to consent to having computations run on them. This changes the underlying nature of the scheduling algorithms that are traditionally used, since now it is necessary to incorporate the price of a job from the perspectives of both client and compute node. While bid-based scheduling has been used in distributed computing protocols before, introducing actual money into the system changes how the scheduling problems need to be approached.

Additionally, in Web3, payments are mediated by smart contracts, which enables the automation of payments based on particular conditions in a permissionless manner. For example, one of those conditions can be verifiability -- both the ability to be verified, as well as actual verification of compute jobs -- as explored in the previous sections.

Market Making​

There are three methods of market-making in DCNs: off-chain solvers, on-chain auctions, and agent-to-agent negotiation.

In off-chain solvers, nodes send their bids and asks to a market-maker, which runs a matching algorithm and proposes matches to the two sides of the market. In on-chain auctions, these bids and asks are put on-chain, and the matching algorithm can be run on-chain as well, which would provide consensus over the output of the matching algorithm, and may be desirable in some cases. In agent-to-agent negotiation, nodes can propose matches to each other, to which they can either accept, reject, or propose a different match to the node(s) with which they are negotiating. There are benefits and drawbacks to all three of these approaches, with tradeoffs in trust models, efficiency, and scalability.

Current State of Web3 Distributed Computing Networks and Marketplaces​

Aggregation of Compute Power is Becoming Its Own Industry​

There are now many Web3 protocols tailored toward aggregating computing power, and many new, similar protocols are being built. These protocols have raised large quantities of money, with promises of a piece of the multi-trillion dollar future of decentralized physical infrastructure networks (DePIN). Even if none of these early experiments are successful in the long-term, the signal is that the aggregation of computing power itself is profitable, separate from the other services that need to be built on top of these networks in order to make them useful.

Massive Underutilization of Resources Creates Unsustainable Tokenomics​

The underlying costs of hardware, networking, and electricity are all denominated in fiat (for now). In order to maintain the price of coins and tokens at a sustainable level, fiat buy pressure is needed. However, the utilization rates of DePINs and DCNs are very low right now, meaning that their current network dynamics are unsustainable. Economic models that attempt to onboard large amounts of computing power through supply-side economics are increasingly becoming outdated; their insufficiencies are evidenced by the lack of demand to counterbalance the supplies they provide.

Verifiable Computing Is in Low Demand (For Now)​

The obstacles that most developers and users face in adopting DCNs and DePINs for the most part do not even touch the verifiable computing solutions that the protocols implement. The obstacles that make using these protocols are so cumbersome that verifiability does not even enter the conversation. Demand for verifiability will likely increase as popularity, and thus incentive to exploit DCNs, grows -- however, it is unclear at what pace this trend will progress.

Moreover, verifiable computing options are some combination of slow, inefficient, expensive, or insecure. Cryptographic methods for verifiable computing are very slow and will almost certainly always be much more expensive than bare metal executions. Secure enclaves have a promising future, especially as exploits continue to be patched -- however, they are not ready for highly sensitive applications. Optimistic verification suffers from issues of determinism, and even if those are solved or approximated away, deep issues of collusion.

The shortcomings described for all of these approaches will decline with both time and increasing use of the protocols.

Massive Duplication of Efforts in Creating Marketplaces​

Most Web3 DCNs and DePINs are creating relatively complex marketplaces from scratch. This duplication of efforts across protocols results in a massive waste of resources, especially since they are open source softwares and can easily be forked. Due to competitive dynamics, there will likely be consolidation to the few most prominent/performant solutions.

Since developers, companies, and others must believe in the long-term success of these protocols before committing, and are unlikely to have large stakes in these protocols, having the marketplace as a moat (via token lock-in or fee-based structures) is more likely to hamper adoption than reinforce it. Arguably, no-fee marketplaces may arise out of competitive dynamics, and token-agnostic marketplaces may be an inevitability resulting from larger Web3 trends towards chain-agnosticism, account abstraction, etc.

For these reasons, Arkhai aspires to build a marketplace as a public good, with no fees, no token lock-in, token-agnosticism, and multi-chain compatibility.

Collateralization​

Collateralization facilitates trustless protocols by leveraging the credible commitments enabled by blockchains, and is used when protocol actors want an incentive for counterparties to behave honestly. For example, in blockchains secured by Proof-of-Stake (PoS), nodes securing the network must deposit collateral to ensure that the blocks they propose are legitimate. In DCNs with optimistic verification, a client that wants to be assured some computational task will be done correctly within some period of time may require that the compute node deposits collateral; likewise, the compute node may require that the client deposit collateral that ensures that it will be paid if it, in fact, does the computation correctly.

However, case-specific collateralization architectures are an outdated approach. There are patterns of collateralization that most protocols have in common, and that can be generalized to an extent that permits many use cases based on a few simple primitives. Arkhai is building generic collateralization protocols that enable instantiating many different types of marketplaces, starting with compute, but extending to the other two critical components of the tech stack -- storage and networking -- and then far beyond.

Collateral Markets​

One major problem in many verification-via-replication protocols is the issue of how much collateral to put up for a job where the computational cost is not known ahead of time. This problem can be solved with collateral markets. Rather than depositing a fixed amount of collateral ahead of time, or topping up when necessary, a compute node commits to a collateral multiplier at the time of deal agreement. After a job is completed, the compute node deposits into escrow (amount they will charge the client) x (the collateral multiplier). This solves the issue of knowing ahead of time how much collateral is required, which enables at least primitive forms of optimistic verification for programs where the computational cost/runtime is not known in advance, and creates a market for collateral over which agents can negotiate.

This approach to collateralization also applies to other domains, which will be explored in later sections.

Series of Credible Commitments​

Many protocols that require collateralization have different types of collateral that are deposited, withdrawn, or slashed depending on the outcomes of some events. These sets of rules can be abstracted to a series of credible commitments, where participating parties each deposit collateral, and that collateral moves based on some events. The combination of a series of credible commitments and collateral markets dramatically enhances the capabilities of Arkhai, and forms part of its foundation of generic, machine-actionable marketplaces.

As a simple example, some verification-via-replication protocols could have collaterals like timeout, payment, and cheating. Each of these would be deposited at particular times, and are refunded/slashed at other times, based on events that happen on-chain. A more generic collateralization process could enable alternative verification protocols, such as cryptographic methods and secure enclaves, without being limited to optimistic verification.

Multi-Token Economy​

The trajectory of blockchains and cryptocurrencies is trending towards multi-agent systems operating in multi-token economies. It is not only the oncoming tokenization of real-world assets that pushes the trend in this direction, but on a larger scale, the separation of concerns facilitated by having multiple tokens representing different asset types.

The Future of Distributed Computing​

Game Theory Background​

Utility Maximization​

Much of game theory is based on the concept of utility. Agents are assumed to have a utility function, which takes as input some parameters (which could be physical objects, online ad placements, etc.), and outputs the utility that that agent would have should they receive the object(s) in question. Agents are assumed to want to maximize their utility -- that is, they will take whatever action is necessary in order to maximize the value of their return.

Incentive Compatibility​

Incentive compatibility is the concept of a reward structure of a game which incentivizes agents to reveal their honest preferences. This is a desirable outcome, as otherwise, agents have an incentive to mask or modify their preferences in acts of strategic manipulation, which complicates the ability of the game designers to achieve larger goals, like maximizing social welfare, Pareto optimality, or some other metric.

Strategyproofness​

Strategyproofness is closely related to incentive compatibility, and refers to incentive structures in which no agent has an incentive to be dishonest regardless of what the other agents do (sometimes called dominant strategy incentive compatible), and every agent also has an incentive to participate (individual rationality).

Revelation Principle​

The Revelation Principle is a foundational result in game theory, and (roughly) states that any game in which there is an equilibrium can be transformed into a game with the same equilibrium, but where the incentive mechanism is strategyproof.

Mechanism Design​

Mechanism design is the study and design of incentive structures. To give a very coarse, if not somewhat inaccurate, analogy, if game theory is the study of which actions will lead to the maximum reward, mechanism design is the study of which reward structure will give rise to desired actions. Especially for multi-agent systems, and blockchains and cryptocurrencies more generally, mechanism design has exploded from a niche academic field with applications usually behind the scenes (like in eBay auctions, ad placements on internet search results, spectrum sales, etc.), into a core aspect of protocol design that is taken into account by many designers of blockchain-based protocols.

Agent-First Approaches to DCNs​

In order to use concepts offered by decades of research in game theory and mechanism design, it is necessary to provide the agents participating in the system a sense of utility, and the ability to learn from their environments. The most successful examples of these kinds of implementations can be found in reinforcement learning. In reinforcement learning, agents act in an evolving game, and there are four main primitives which the agent takes into account:

1. The environment, which changes from state to state.
2. The set of actions that the agent can take.
3. The transition probability of moving from one state to another given an action.
4. The reward that a node receives by starting in one state, taking a particular action, and ending up in another state

It is necessary to imbue reinforcement learning primitives into the foundational thinking of the protocol. At its simplest level, this means that agents observe states, take actions, transition to new states with some probability, and get rewards. These primitives enable agents to learn from their environments. Their environments consist of

All information on-chain (in RL terms, history):

1. For example, how long it took to other nodes to complete jobs, which nodes cheated, how much the jobs cost, collateral multipliers, timeout durations, etc.

Information that they can glean directly or indirectly from the rest of the network (in RL terms, observations):

1. E.g. from matches proposed by solvers, direct offers from other nodes, the latency in receiving back responses, etc.
2. Approximations of the hardware of other nodes that are trying to hide that information, the geolocation of those nodes, etc.

This information helps agents model each other in strategic environments, which is a critical component of enabling more sophisticated economic interactions.

Likewise, nodes can have an understanding of their role in the world, including their hardware profile. For example, from the perspective of a machine, "I am a weather sensor, among thousands of other physically identical sensors in a 100km radius", or "I am a node in a datacenter with 4 Nvidia H100 GPUs, with 511 other identical nodes in the same datacenter", or "I am a consumer desktop with an RTX 3070 contributing spare computing cycles that aren't in use"), etc. This type of understanding helps inform its decision-making processes.

Universal Action Spaces​

Removing specific roles in the network, and giving all agents the same action space, enables much greater flexibility in how these machines buy and sell computing power. For example: a client is a machine, and can also run computations on behalf of other nodes, in which capacity it acts as a compute node. Likewise, it can act as a solver, proposing matches between nodes, or as a directory service, caching computations for the network. Ultimately, there is no fundamental difference between clients, compute nodes, and solvers, in that they are all computers, and each of them can take on any role at any time (subject to their computational capabilities).

Pricing and Scheduling Via Utility Maximization​

Pricing and scheduling are intertwined. For example, a client might be willing to pay a higher price for a job if the result is returned sooner rather than later; conversely, it might prefer to pay less and receive the result later. Likewise, a compute node may be faced with many potential job offers with varying computational requirements, prices, and deadlines. Maximizing its return is a classic scheduling problem, and is related to the states of the other nodes on the networks (e.g. how many nodes with what configurations, how many and which jobs are (believed to be) in progress, etc.). The most successful method known today for maximizing returns in such stochastic and highly dynamic environments are based on, or closely related to, reinforcement learning -- hence the focus on imbuing reinforcement learning primitives into the protocol.

Nodes can also maximize utility in other ways. For example, they can choose which currencies to accept payment in, and when to trade those currencies based on market conditions. Later in this paper, the topic of tokenization of latent computing power is discussed. There, nodes choose which computations they should perform with their spare compute capacity, and they likewise can maximize their utility by analyzing where their resources would yield the biggest returns.

Multiple Agents Create Multi-Agent Systems​

So far, there has only been discussion of single-agent environments. However, these agents do not live in isolation -- they live in a world full of other agents! Moreover, these agents have overlapping interests -- sometimes cooperative, sometimes competitive, sometimes both. These agents will all be interacting with each other -- negotiating over the prices of deals, combining resources to accomplish larger tasks, competing with each other to service other nodes, and much more. Such environments are called multi-agent systems.

Agent-to-Agent Interaction​

These agents can interact with each other in many different environments. Communication could be local to a single machine, across machines on a local network, entirely distributed, or hierarchical (e.g. networks of IoT sensors exchanging information with each other). The network topologies will be highly dependent on the applications they are enabling.

Coalition Formation/Resource and Skill Based Games​

Nodes are limited in the computations they can perform by their hardware configurations, and may want to accomplish larger goals which they are not capable of doing themselves. In order to do this, they need to form coalitions where they combine their resources and skills in order to accomplish wider goals. The coalitions that they choose to join depend on their own resources and skills, the resources and skills of prospective coalition members, and the resources and skills of all other nodes. This process is known as coalition formation. In order to participate in coalition formation in a manner that actually benefits the nodes, they need to be able to communicate with each other, and have a sense of their expected payoff -- and for this, they need the aforementioned reinforcement learning primitives that enable them to learn from their environments.

Multi-Agent Debate​

An emerging trend in AI is multi-agent debate. Multi-agent debate consists of LLMs interacting with each other, often to achieve higher-level goals. While most research on resource and skill based games has focused on traditional scenarios, such as corporate environments where workers and departments have different resources and skill sets, the literature can be extended to considering LLMs as resources, where the LLMs are differentiated by their architectures, weights, and access to information.

Making the Protocol Robust to Manipulation​

Back to Verification-via-Replication​

No publicly known protocols intended to prevent cheating using verification-via-replication take into account the true complexity of distributed computing networks – different hardware configurations, network topologies, latencies, node failures, let alone the game-theoretic complexities of repeated games, and the pervasive problem of collusion.

Analytic approaches to verification-via-replication are unlikely to yield sufficient mechanisms. This is because every protocol that has been published on this topic so far either implicitly or explicitly makes assumptions on environment, action spaces of the agents, or some other aspect(s) of the network that, once removed, make the original theoretical guarantees break down. For this reason, Arkhai opts for an alternative approach that forgoes analytic solutions, in favor of empirical evaluation of proposed mechanisms.

Game-Theoretic White-Hat Hacking​

Arkhai's approach to verification-via-replication is to train agents to maximize their utility, including cheating and/or colluding if necessary. Once these nodes have been trained to maximize their utilities, mechanisms can be put in place to prevent them from cheating, and evaluated based on their actual performance.

However, there is a major problem with this approach: from a theoretical perspective, multi-agents systems in such environments are not guaranteed to converge to equilibria; thus, there is no guarantee that this method will yield mechanisms robust to manipulation. It is possible that any agents that manage to sufficiently undermine the protocol can be defended against with agents trained to defend the protocol, effectively creating a never-ending arms race. Alternatively, it would be valuable to know if there is no mechanism, analytic or computational, that can currently be designed that sufficiently prevents nodes from acting maliciously.

As before, this approach benefits from agent-based approaches where states, actions, transitions, and rewards are treated as first-class citizens in the architecture.

Multi-Agent Inverse Reinforcement Learning​

Reinforcement learning is to utility maximization as inverse reinforcement learning is to mechanism design. Inverse reinforcement learning intends to find reward structures that elicit particular actions – for example, not cheating and not colluding in verification-via-replication based verifiable distributed computing networks.

Multi-agent inverse reinforcement learning intends to find the reward structures that elicit particular actions from groups of agents. It is precisely the tools from this field that are necessary to design verification-via-replication protocols robust to cheating and collusion. However, the space of incentive structures that can be designed for these agents goes well beyond verifiable computing, or even resource and skill based games where nodes can combine these resources, as will be discussed in later sections.

Out of these multi-agent systems will emerge a collective intelligence capable of achieving far more than is possible with current technologies. The steady improvements in AI models, computational power, and networking are such that humanity is on the cusp of decades of theory stowed away in journals being rapidly implemented in practice.

Beyond Computing​

The Limitations of Peer-to-Peer Compute Marketplaces​

Most Web3 compute marketplaces do not incorporate other parts of the tech stack traditionally provided by big tech companies, like storage and bandwidth. However, marketplaces that incorporate these components will be more robust and performant than those that do not, since they are necessary in order to create advanced applications that can mirror Web2 applications in both performance and adoption.

Generic Marketplaces​

Starting with a marketplace for compute, Arkhai will generalize the marketplace as described earlier in this paper, i.e. with generalized collateralization and series of credible commitments. In order to create a generic marketplace, there is one more critical component that must be added: the ability to exchange bundles of assets for other bundles of assets. New token standards like ERC-6909 provide the necessary primitives required to do this.

The most natural assets to accommodate after compute are storage and networking, and then other components of cyber-physical systems like latency. Retrieval markets can be created to pay for the verifiable serving of data. From there, the possibilities are numerous – other assets like on-chain carbon credits, real-world assets on Web2 marketplaces like eBay and Amazon, peer-to-peer energy trading, futures (e.g. oil, corn), silicon, lithium, and many more.

In order to accomplish this, it will be necessary for data to be pulled from Web2 to Web3. Fortunately, this is already a well-established industry in Web3, and is only growing as a result of the tokenization of real-world assets. Likewise, in addition to integrating traditional markets, the power of blockchain and cryptocurrencies facilitates the creation of synthetic markets, which can enable more sophisticated economic interaction between agents.

Generic marketplaces provide agents with the substrate on which to trade on the very physical components that constitute them. The reinforcement learning primitives discussed earlier would provide agents with an understanding of what they are and what their role is. Combining this self-awareness and the ability to engage in economic interactions over the physical components they are composed of provides a foundation for a decentralized collective machine intelligence which can guide itself through market forces towards a self-improving cybernetic system.

Another benefit of generic, machine-actionable marketplaces is the ability to facilitate complex games. The new field of compositional game theory, which applies category theoretic concepts to game theory by composing games (e.g. making games subgames of other games) with generalized data structures, offers a fertile framework upon which these generic marketplaces can be built, and also how they can be used.

As explored earlier, compute nodes forming coalitions/clusters with each other is a type of game, where the nodes get some benefit (for example, higher average return, or lower variance return) by joining the coalition. These nodes might also want to incorporate energy into their decision-making processes when joining coalitions, where, for example, the objective function would be to minimize carbon emissions subject to all the compute jobs getting done and all homes getting the energy they require, which needs some type of consensus-based load balancing (similar to how the decentralized vehicle routing problem discussed later in the section on applications needs consensus-based routing).

Machine-actionability; Marketplaces Built for Machines and Not for Humans​

The future is autonomous. Most economic activity in the future will be undertaken by machines, yet most of our marketplaces are built for humans. While there exist APIs for many types of digital marketplaces (e.g. stock markets, energy markets, centralized cryptocurrency exchanges), in practice these are only used by institutions or wealthy individuals, and are not accessible to most people. The permissionless aspect of blockchain-based markets will dramatically expand the user base of these markets, and autonomous agents will be the delivery medium.

Agents will be negotiating with each other on behalf of their human "owners". For many real-world assets, much of this negotiation will be in the form of exchanges of fixed data schemas, like json. However, for intents-based negotiations, language model-based agents will likely create their own languages when communicating with each other, assuming that the outputs of the language models are even decoded at all.

Just as new languages will emerge from the interactions of agents with each other when representing the natural-language-based intents of their human owners, synthetic assets will emerge as these agents negotiate over real-world assets and encounter their limitations, just as humans did.

Architecture​

Arkhai's Main Primitives​

Arkhai's architecture is based on three primitives:

1. The exchange of arbitrary bundles of assets for other arbitrary bundles of assets
2. Agreements modeled by a series of credible commitments than can be used to model a wide variety of collateralization processes, enabling the instantiation of many different kinds of marketplaces
3. Agent-to-agent negotiation

Why These Primitives?​

These primitives enable the following:

1. The three main categories of verifiable computing
2. Incorporation of storage and bandwidth into the same/similarly structured marketplace as compute
3. Agent-first approaches that enable machines to learn from their environments and improve
4. Modeling many different types of marketplaces and economic exchange

Applications to Verifiable Computing​

These primitives can be used to enable any type of verifiable computing scheme. Each verifiable computing solution requires some collateralization process. The general scheme is that the client needs to deposit collateral that assures the compute node that it will get paid if it does the computation correctly, and the compute node needs to deposit collateral to ensure that it will do the computation correctly. There may be other collaterals that would be valuable to have in the process, but with a series of credible commitments, they can be incorporated relatively easily. Each verifiable computing solution would trigger capital flowing into or out of escrow depending on what the validators – who would be checking computations with one of the verifiable computing solutions (cryptography, secure enclaves, or verification-via-replication) – determine about the previous step(s) in the series of credible commitments.

Incorporating Other Parts of the Tech Stack​

A marketplace for compute is not worth nearly as much as a marketplace for compute, storage, and bandwidth. The ability to have a job computed on one node, the corresponding result sent to a second node, and then storing it on the second node for some period of time, with proper incentives for each of the nodes involved, is still quite difficult to do with almost every DCN/DePIN network, despite the relative simplicity of the task.

Agents Learning from Their Environments​

Much of game theory, cybernetics, and multi-agent systems assumes some level of utility-maximizing agents. Marketplaces and protocols populated by intelligent actors will outperform those that are not, and so having them be prepared for such agents, and having at least rudimentary implementations of such agents, is of high priority for any potentially successful protocol.

Enabling Different Types of Marketplaces​

Combining the previous points and extending them, these three primitives can be used to instantiate many different types of marketplaces. Intelligent agents negotiating with each other over arbitrary bundles of goods will be a core part of the AI-driven, agent-driven future. The challenge is designing the games in which these agents play, which is a main focus area of Arkhai.

Applications​

Since the first instantiation of Arkhai's generic marketplace protocol will be a distributed computing network, most of the applications below are focused on compute.

Computational Reproducibility​

Replication Crisis​

Arkhai will have the ability to store inputs and outputs on the InterPlanetary File System (IPFS), which provides immutability and provenance for jobs run on the network. The immutability of these data structures facilitates computational reproducibility, since the computations can be rerun with the same inputs and ensured to have the same or similar outputs. These computations become part of the scientific record, which can be combined with other parts of the scientific publishing process, including publications, figures, tables, videos, citations, etc.

Academia is plagued by the replication crisis, where the results of many studies cannot be reproduced. While the crisis has an outsized impact on the social sciences, it extends to the hard sciences as well, which often comes in the form of the data used in computations being stored in data silos, and the code for the computations not being open source. Arkhai's native capabilities for enabling computational reproducibility in a decentralized manner, where any node can choose to reproduce results if it so desires, helps alleviate some of the issues contributing to the replication crisis. Furthermore, it unlocks a number of new use cases, as discussed below.

Tokenization of Latent Computing Power​

Computational reproducibility facilitates a degree of trust among network participants that computations performed using the protocol have been done correctly, since negative behavior comes with economic consequences. The scientific record of which nodes requested the computations, which nodes performed the computations, and what the inputs and outputs were, enables cryptoeconomically incentivizing these components of the scientific process.

The history of grid-based distributed scientific computing goes back to SETI@home and Folding@home. Both platforms were launched to connect scientists who had embarrassingly parallel computational workloads with volunteers all around the world, who offered their own (usually personal) computers for free in exchange for participating in large scientific projects, as well as competing on leaderboards for non-transferable Web2 points. In the case of SETI@home, the computations helped the search for extraterrestrial life, and in the case of Folding@home, the computations were related to protein dynamics. Out of SETI@home grew BOINC, the Berkeley Open Infrastructure for Network Computing, which generalized the project creation and job generation mechanisms of SETI@home to other scientific computing projects, of which today there are many tens of in existence.

In the early days of cryptocurrencies, there were a number of protocols that attempted to apply Bitcoin's reward mechanism to scientific computing; among these early "Decentralized Science" or "DeSci" computing coins were Gridcoin, Curecoin, Pinkcoin, and Primecoin. However, blockchains were in their infancy at the time, and while these cryptocurrencies accomplished much, they fell short of their ultimate visions.

Arkhai's native tracking of the inputs and outputs of jobs enables it to easily reward scientific computing projects. At its simplest, one can imagine tokenizing the points that SETI@home or Folding@home allocated to their volunteers. This opens up an entirely new world of possibilities via the tokenization of latent computing power.

At the root of the tokenization of latent computing power is the question: are there computations that nobody is willing to pay for now, but that somebody might be willing to pay for later? The record of computational inputs and outputs stored on-chain facilitates arbitrary reward structures over those computations, meaning that nodes can get rewarded with tokens for their contributions to scientific computing projects. Should the compute project be successful, its contributors can be rewarded by whatever mechanism was chosen at the outset of the project. The two most natural vectors for rewarding nodes are intellectual property, and retroactive public goods funding. The latter mechanism is becoming more prominent in the blockchain world, with Optimism and Filecoin recently launching retroactive public goods funding programs, and many other protocols planning to do the same.

Creation of Intellectual Property​

The creation of intellectual property with Arkhai is complicated by the fact that storing all of the inputs and outputs of jobs publicly on IPFS may be undesirable for intellectual property, some of which may need to remain private. One option is to allow anything that can be public to be public, and make the rest privacy-preserving, for example using secure enclaves, with verifiable credit attribution to the relevant contributors.

Retroactive Public Goods Funding​

For an example of how this would work, consider Rosetta@home, a BOINC project, and Folding@home, both of which facilitated a massive amount of computations dedicated to finding a vaccine for Covid. The vaccines that were produced from the outputs of these and similar computations went on to generate tens of billions of dollars in revenue. With proper tracking and incentives, those that contributed the computational resources could have received a portion of the revenue through retroactive public goods funding.

The price of a project-specific token in some manners acts as a predictor for how valuable the output of the project will be, effectively creating a futures market for idle computing power. This aspect of the protocol, plus the token-agnosticism, provides a substrate for autonomous agents to choose what computational projects are the most likely to succeed. In the future, there may be autonomous agents initiating different branches of the same computational projects in a manner reflecting tree search, which is a widely used concept in AI nowadays (and has been in computer science for a long time).

Autonomous science​

While there has been work on autonomous science for a number of years, the ability to use AI for science beyond writing papers or doing literature reviews is only now beginning to gain serious attention beyond academic niches. In order to democratize access to autonomous science, the substrate upon which the computations are to be done needs to be permissionless, allowing anyone to provide compute, and anyone to buy it. Arkhai will provide precisely this infrastructure, starting with building decentralized vector databases and knowledge graphs, and having autonomous agents use them to determine the best semantic embeddings and ontologies.

The tokenization of science – that is, the tokenization of discoveries, intellectual property, salaries, peer review, and so on – is in the not-too-distant future. As autonomous agents and multi-agent systems proliferate, they will begin to participate in the economies of knowledge and science.

Economy Around FAIR Data​

The scientific literature suffers from much of its contents not being machine-actionable. Attempts to solve this problem have resulted in a movement to make data FAIR – Findable, Accessible, Interoperable, and Reusable. The lack of FAIR data causes billions of dollars of losses every year. Furthermore, enriching data that is already FAIR can massively accelerate scientific research and development, especially in the age of AI. Given the losses that this lack of FAIR data causes, there is great potential in incentivizing the FAIR-ization of the scientific literature.

Researchers currently find themselves in a suboptimal equilibrium that causes many of them to not undertake the effort of making their data FAIR. This can stem from a number of factors: perhaps they don't know about FAIR, don't know how to implement it, implementing it is too difficult/time-consuming, they don't see enough other researchers doing it, don't see the long-term benefits of making their data FAIR to begin with, or a myriad of other reasons.

The central challenge that FAIR aims to address is the lack of machine-actionable data. There have been attempts to make the web itself machine-actionable (e.g. Semantic Web), as well as attempts by a number of organizations to convince scientists to adopt FAIR standards. However, these attempts have so far only achieved a fraction of their intentions.

It may be possible to help researchers escape this suboptimal equilibrium by providing them an extra incentive to help make data FAIR at a massive scale (a classic game-theoretic technique for escaping such suboptimal equilibria). This incentive could come in the form of external payments, facilitated by blockchain and cryptocurrencies, which allow for an immutable record of transactions where many parties can agree upon the state and contributions of every entity involved in the network.

Large-scale FAIR data, combined with enrichments to that data to make it easily queryable, can rapidly accelerate the pace of scientific progress. Especially in the age of AI, FAIR data would make answering questions like these much easier:

1. What is the history of this equation?
2. What techniques were used in this field to make advances over time?
3. Can we apply these tools again in an automated way in order to make advances?
4. Have other people done this already?
5. What's the closest that other people have done this?
6. Where can I draw inspiration from for new ideas?
7. Does this dataset that I want to collect already exist?

In order to properly align and incentivize all the stakeholders, token ownership – and thus ownership of the protocol – must be shared across all stakeholders in the system (storage and compute providers, developers creating the relevant machine learning pipelines, the academics being cited, investors, builders/maintainers of the codebase, etc.).

Scientific Cryptoeconomies​

There is growing attention in the blockchain and cryptocurrency worlds, and especially in decentralized science (DeSci) in creating DAOs, governance mechanisms, and other structures to facilitate decentralized scientific cryptoeconomies. In order to provide the necessary substrate to form these economies, there need to be flexible ways to reward all the entities involved in the network.

For example, drawing on the concept of a payoff vector in cooperative game theory, consider a function that takes as input computational inputs and outputs, proofs of storage, changes to the scientific record, the academic citation graph, consensus-based off-chain data, and other any other factors determined as relevant by the protocol designers, and allocates a payoff to every entity in the network. This function is general enough to facilitate many different types of reward structures. Arkhai's vision of a token-agnostic economy combined with a series of credible commitments provides a solid foundation upon which these mechanisms can be built.

Composable Games/Decentralized Market Composition/Compositional Game Theory​

Decentralized Vehicle Routing​

Imagine overlooking a city from above. Every agent is trying to get from point A to point B on a train, in a car, on a bike, walking, etc. Each agent accesses their favorite map application, is returned the shortest path, and follows it. Now imagine overlooking the same city from above, but the agents can be coordinated via some optimization algorithm that minimizes the average travel time. The ratio of the average travel time in the case where everybody is selfish and the optimized case is called the Price of Anarchy. With the generalized marketplace and data structures that Arkhai will build, it will be able to facilitate pluggable mechanism design that drives the price of anarchy down to 1.

The benefits of this incentive mechanism are lower air pollution, less mental health stress from traffic, lower emissions, and higher productivity (by some combination of more time to work, or more time off from work). Additionally, the generalized marketplace that enables this vehicle routing would also enable agents to pay other nodes for expedited trips by allowing them to bypass or avoid otherwise unavoidable traffic.

Revenue Model​

Part of Arkhai's strategy is to build a token-agnostic, no-fee marketplace as a public good, for the reasons described in the section on the current state of Web3 distributed computing networks. It is in the applications built on top of the core infrastructure that Arkhai will generate revenue. Below is a small selection of applications that form part of Arkhai's go-to-market strategy.

Value Added Services​

Arkhai's ability to represent many different kinds of marketplaces enables many different kinds of services to be built on top of it.

Decentralized Hosting of Open Source SaaS Applications​

Many open source applications are still hosted on the major cloud providers, and are thus subject to the higher prices that these platforms charge compared to decentralized solutions. Arkhai is building a framework for transitioning services already hosted on centralized providers and enabling them to be hosted on a decentralized infrastructure, including all the primitives for validation necessary to ensure all parties involved that the protocol is functioning as intended.

Arkhai's value proposition here is:

1. For hosted service providers, a cheaper alternative to centralized platforms
2. For hosted service consumers, a cheaper alternative to services hosted on centralized platforms
3. For hardware providers, a legitimate, sustainable source of revenues

Incubation of Distributed Computing Projects​

Arkhai will provide a launchpad for incubating tokenized scientific computing projects, using the backgrounds and methods described in the section on the tokenization of latent computing power. In exchange for its services, Arkhai will be allocated a fraction of the tokens of each project it incubates.

Decentralized RAG (Retrieval-Augmented Generation) Databases​

A very good example combining the incubation of distributed computing projects and value added services is a product that provides decentralized hosting of vector databases that are created by leveraging the tokenization of latent computing power.

Vector databases enable retrieval-augmented generation (RAG) by providing out-of-context-window memory for LLMs, and are becoming a crucial part of the MLOps tech stack. Combined with knowledge graphs, and potentially new RAG methods being developed, vector databases provide an information layer for LLMs that dramatically enhance their performance.

Arkhai is building the infrastructure for a decentralized vector database as one of its first use cases, starting with scientific papers. The papers will be converted from pdf to markdown, then chunked, and then the semantic embeddings of those chunks will be put into a vector database. Since there is no known method guaranteed to produce the best version of such a vector database, the pipeline will facilitate creating more than one vector database from the same set of papers. Utilizing the tokenization of latent computing power makes this approach more economically feasible than paying for the costs upfront directly, as compute nodes would be offering their compute services upfront for the computationally intensive tasks of creating these databases, with each database having its own token. Queries to these databases would provide feedback on which versions are the best, and facilitate an evolutionary discovery process underpinning a future collective intelligence.

Additionally, the value added services that Arkhai is building, like decentralized hosting for open source SaaS applications, provide another revenue stream from these vector databases.

Better Marketplaces​

Arkhai will facilitate economic interactions which are not possible with today's centralized or decentralized technologies. The space of potential applications that will come with easily composable marketplaces is clearly very large, but also difficult to predict. The modularity in the types of marketplaces that can be created de-risks Arkhai in that specific applications can be created that have clear revenue streams, but also enables applications far beyond what is possible with existing marketplaces.