bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 3쪽 중 1쪽
Nexus: A New Standard for Decentralized Autonomy
The Talus Labs Team
hi@taluslabs.xyz
21 August 2025
v1.1
Abstract
Blockchain provides a well-tested and reliable environment for hosting high-value computa-
tion and assets. Equipping blockchain with modern AI capabilities can significantly enhance its
functionality and user experience. In this work, we introduce the T alus Agentic F ramework
to standardize onchain services and coordination protocols, enabling the modular onboarding
of AI services as onchain components. The modular design supports varying levels of onchain
security, ensuring auditability and transparency in a decentralized manner with acceptable per-
formance.
We implement Nexus to realize the Talus Agentic Framework on the Sui network, serving as
a platform for building and utilizing onchain AI services with composability and secured financial
capability. Developers can build two types of applications on Nexus: (i) Agent as a Service,
which integrates secure onchain AI services or workflows to enhance existing Web3 applications;
and (ii) Agent Marketplace, which uses onchain infrastructure to monetize AI services, such
as amortizing AI computation costs or rapidly deploying and monetizing state-of-the-art AI
technology.
1 Introduction
Blockchain technology is a decentralized and trust-minimized platform for providing global function-
alities such as immutable storage, execution, and randomness (via a verifiable randomness function
(VRF) [MR V99]). This paper defines an onchain service as a set of smart contracts that expose a
specific functionality for external parties to use. In general, new functionalities available onchain can
create new opportunities and improve the behavior of existing onchain services, enabling people to
access cheaper and safer services more easily. One of the most promising capabilities to be extended
is the availability of artificial intelligence (AI) services.
Current AI agents are autonomous software programs that perceive environments, use large lan-
guage models (LLMs) to make decisions, and execute actions through tools to achieve specific goals.
An agent can be tuned for specific tasks, and coordinating multiple agents with ordered steps to
tackle more complex challenges creates a more promising approach—an agentic workflow [SEKK24].
At Talus, we believe AI agents have the potential to revolutionize the entire digital world with the
help of blockchain technology.
Integrating AI agents with blockchain technology creates a powerful synergy:
T rust and T ransparency:Onchain deployments bring transparency to AI execution processes
with configurable trust. Since onchain execution inherits security from the consensus layer,
1
onchain services can provide functionality with transparency and auditable service quality.
Users can also apply onchain verification to secure the outputs of an AI service.
Automated Finance: AI agents can automatically manage onchain assets, execute trades, and
allocate resources with predefined rules and dynamic market conditions. On the other hand,
blockchain provides a trustless financial infrastructure to monetize AI capabilities. Integrating
these two technologies expands the subject and strategy space for decentralized finance (DeFi)
and autonomous organizations, enriching the onchain ecosystem.
The combination of AI agents and blockchain technology can also introduce new possibilities to
existing Web3 industries:
Finance: Since AI agents can automate onchain assets, this immediately implies that we can use
them to implement autonomous trading systems and yield-generating strategies. These agents
inherit security from onchain computation, creating a fair investment market that anyone can
join transparently, with a minimized information gap.
Governance: AI agents can simplify decentralized autonomous organizations (DAOs) by prepro-
cessing user requests and converting them into valid proposals with proper auditing and evalua-
tion before community voting. AI agents make the entire process transparent and standardized,
ultimately contributing to high-quality onchain collective decision-making.
Gaming & Virtual W orlds: AI-driven non-player characters and virtual assistants can interact
directly with smart contracts in a predefined manner to offer dynamic in-game experiences.
AI agents can transparently provide additional randomness and fairness.
1.1 Related Works
This section reviews two existing directions for onboarding AI services onchain: onchain AI model
computation and offchain agents with wallets.
1.1.1 Onchain AI Model Computation
The most straightforward and ambitious way to integrate AI services onchain is to write all compu-
tations of the AI service into a smart contract. This idea aligns with the fact that most blockchain
virtual machines (VMs) provide a Turing-complete computation engine, capable of executing arbi-
trary programs, including AI algorithms. With deterministic randomness onchain, all validators in
the blockchain system can agree on the input and output of the model, thereby enabling the use of
AI services. Due to computational resource limitations, most prior attempts have only implemented
traditional machine learning methods (e.g., decision trees, support vector machines, etc.). One of the
leading players in this field is DecideAI [Teaa], which successfully brought GPT-2.0 onto the Inter-
net Computer (ICP) [Teab] network. Projects like Tensorflowsui [Tead] also provide infrastructure
to run general deep learning models through smart contracts. However, hardware limitations make
further improvement of model capability difficult, and it is extremely costly compared to offchain
AI services, making its use cases very limited.
One variant of onchain AI model computation transforms the computation task into a verification
task, using zero-knowledge proofs (ZKPs) [GMR85] to ensure onchain verifiability. ZKPs can guar-
antee that an offchain computation procedure correctly follows its onchain commitment. Therefore,
we can compile the AI algorithm program into a provable circuit that allows an offchain AI agent
to generate a proof for verifying its output. zkML [zT] is a pioneer in this direction, successfully
2
onboarding TensorFlow Keras models into circuits that can be verified onchain. As ZKP technology
advances, more powerful verifiable onchain AI models will become possible.
1.2 Offchain Agents with Wallets
The second approach uses mature offchain agent solutions and exposes their inputs and outputs
through an oracle system [ZCC +16, BCC +21]. An oracle system builds a bridge between onchain
and offchain data. An offchain agent can use these oracle capabilities to communicate with the
onchain state. Typically, the agent uses a wallet and an offchain secret to manage its onchain assets,
and listens to onchain queries through an outbound oracle. Secure computation environments such
as Trusted Execution Environments (TEEs) [CD16] or authenticated communication [CHH97] are
widely used to ensure the security of this service. ElizaOS [WGN+25] is one of the leading solution
providers in this direction. ElizaOS is an offchain agent solution that provides plugins for agent
communication with the blockchain. The identity of the agent is represented through a wallet
plugin. This offchain agent architecture provides flexibility in agent functionality without requiring
heavy onchain development.
This strategy has a decentralized variant that replaces the single trusted offchain agent with
an independent decentralized computation system. In general, a properly configured decentralized
system can provide better security guarantees, although likely with increased latency. The decentral-
ized network of agents can use various mechanisms, from auditor voting to consensus algorithms, to
agree on the outputs and use a threshold signature scheme (TSS) [Sho00] to validate them onchain.
Ritual [Teac] is a service provider following this approach, using a subset of computation nodes for
computing model outputs. This subnet typically operates with independent security assumptions to
ensure that tasks assigned to the system are correctly computed.
1.2.1 Limitations
Existing works have three main limitations:
Lack of composability: Making AI services composable with existing onchain services requires a
standard protocol to define requirements (i.e., input schema), liability (i.e., output schema),
and entitlement (i.e., payment in the crypto context). Existing agent solutions lack interop-
erability and composability, as they do not provide general input/output schemas or payment
contracts between onchain callable services. As a result, onchain services struggle to interop-
erate and cannot efficiently reuse existing ecosystem tools.
Insufficient asset management capabilities: Onchain asset management is tied to the owner-
ship mechanisms of onchain virtual machines, which typically rely on digital signature schemes.
While modern AI models excel at decision-making and automated execution, they also intro-
duce the risk of hallucination. This creates the need for fine-grained permission control for
AI services managing onchain assets, which must be integrated into a general and composable
framework.
Limited service quality choices: Onchain AI services face a fundamental trade-off between per-
formance and security. Onchain computation is generally expensive and non-scalable compared
to offchain alternatives, while offchain computation involves greater risks in terms of computa-
tional security. Applications must navigate this trade-off to optimize user experience according
to market demands—a challenge that cannot be solved by a single solution.
3
One solution to the above issues is a standardized onchain protocol that allows secure interop-
erability between AI services and onchain services. AI services and other onchain services can be
designed modularly and composed together through the protocol, where each component can have
independent verifiability and cost considerations based on arbitrary business logic. In addition, we
can use smart contracts to set up permissions for each module of the service, provide transparent
and secure asset management, and minimize the trust over offchain private keys.
1.3 Our Contributions
We propose the Talus Agentic Framework (TAF) as a composable framework [BDKJ23, BMZ24]
to define onchain services with interoperability. The Talus Agentic Framework can fully leverage
different solutions for onboarding AI services with optimized cost and performance per user requests.
Thus, we can provide real onchain AI agents and agentic workflow services. Our results are twofold:
1. We define the Talus Agentic Framework based on modular onchain services called Talus Tools.
In our framework, a Talus Agent is an aggregation of standard onchain services (including
those providing AI services) that support various underlying AI system implementations. Talus
provides AI services in a tool-based solution, where onchain services (AI or not) are abstracted
as Talus Tools and integrated with others through composable execution flows. We implement
the Talus Agentic Framework on the Sui Network through the Nexus engine. Nexus enables
developers to integrate state-of-the-art (SOTA) AI technologies with composability, censorship
resistance, and a native payment protocol. Our design provides flexibility between security
and performance, allowing other onchain services to integrate offchain components easily.
2. We formalize two types of products based on Nexus: Agent as a Service (AaaS) and Agent
Marketplace. AaaS focuses on improving onchain services with transparent AI technologies
through the Talus Agentic Framework. Web3 service providers can use Talus Agents as asyn-
chronous components to enhance their offerings and functionalities with transparent and secure
AI services. Agent Marketplace represents another type of service aimed at enabling closed-
source AI service monetization through onchain infrastructure. Users can select one or multiple
agents to complete tasks collaboratively or competitively in a decentralized manner using an
onchain payment infrastructure and output verification.
This white paper is organized as follows: Section 2 explains the background knowledge of
blockchains and AI agents. If you are already familiar with the topic, you can skip it. Section 3
explains the Talus Agentic Framework (TAF) as a solution to realize onchain agentic workflows, and
Section 4 introduces Nexus as an implementation of TAF. Section 5 presents the two categories of
onchain services Nexus aims to support. Finally, Section 6 explains our future directions.
2 Preliminary
In this work, we use the following notations:
Onchain service: A callable service based on smart contracts.
AI service: A service that exposes AI models for calculating inputs and returning outputs.
AI agent: An AI service that processes both user input and external data, plans and performs
actions through integrated tools (iteratively), and provides outputs.
4
Onchain AI agent: An AI agent that can be triggered through a smart contract.
Figure 1 illustrates the scope and position of the Talus Agentic Framework (Section 3) and
existing works.
Figure 1: Position of the different concepts and related works
2.1 Blockchain Technology
This work uses a public blockchain as the coordination platform [PHdB22] for AI services. Public
blockchains are typically structured in layers [ZXD+17]. In this report, we focus on the core software
layers: the consensus layer and the execution layer. These layers work together to securely manage
the onchain state (i.e., the ledger) and execute programs (smart contracts) with transactions (ex-
ternal inputs and commands) on a decentralized network (Figure 2). The security of the consensus
algorithm and the determinism of the execution layer imply the security of services defined on smart
contracts.
The consensus layer is responsible for agreeing on the ledger’s state and the order of transactions
across all nodes. It ensures that all participants (validators) reach a consistent view of valid trans-
actions and blocks. Once a block of transactions is agreed upon and added, it becomes extremely
difficult to alter records without breaking the consensus rules.
The execution layer is where blockchain programs and end-user applications reside. The core of
the execution layer is a virtual machine (VM) that defines how the global state can be modified.
Developers write programs for this VM as smart contracts to define business logic and interaction
interfaces. In the public blockchain model, users interact with smart contracts through wallets
to update the ledger. These smart contracts are transparently placed onchain and are executed
faithfully, assuming a secure consensus layer. Therefore, blockchain enables secure decentralized
applications.
2.1.1 Secure Onchain Service
This work assumes all users have an ideal wallet to interact with onchain services accessible through
the blockchain execution layer. Therefore, a secure onchain service can be exposed as a secure
decentralized application that satisfies blockchain-adapted safety and liveness [AS87]:
5
Figure 2: Functionalities of a blockchain
Safety: If an onchain service is triggered, its execution will always follow the contract where it is
defined.
Liveness: If an onchain service is triggered, it will always output a result that follows the contract
where it is defined.
Onchain services can be secured in three different ways, each offering different guarantees and
trade-offs. Figure 3 gives an example of cost estimation for different security sources.
Onchain Computation: The most direct approach is inheriting the security of the consensus layer
and the deterministic VM through onchain computation. Deploying the service logic as a smart
contract naturally ensures safety and liveness. However, computation in the onchain VM is
generally expensive and is measured through a gas system in most public blockchains.
V erifiable Computation: To reduce the onchain computation complexity, proof schemes have
been introduced, which use a shorter verification procedure to ensure that offchain computation
is correct. Depending on the statement to verify, onchain verifiable computation can use
correctness proofs to ensure correctness or assume the computation is correct and open a
window for fault proofs (optimistic proofs) [CSYW24]. The onchain verification guarantees
safety and liveness, while the proof scheme ensures that the business logic has been properly
computed. This procedure has two disadvantages: the offchain proof logic is often more
complex than the original computation task, and the liveness of the offchain component requires
additional mechanisms.
T rusted Computation: Trusted parties are introduced to ensure the security of offchain compo-
nents. The most direct solution is to execute all offchain logic in a TEE, such as Intel Software
Guard Extensions (SGX) or other confidential computing services. However, this does not
resolve the liveness issue, which typically requires a decentralized system to improve the ro-
bustness of offchain components. Decentralization improves offchain logic, similar to how the
6
Figure 3: Cost of Security
consensus layer secures onchain logic, but on a smaller scale. Tokenomics forms a supplemen-
tary mechanism that further enhances trust under the assumption of rational participants.
Well-designed token economics can ensure that all participants of a decentralized system are
incentivized to behave honestly.
However, the trade-off between performance and security may vary across different services.
Therefore, supporting as many possible security sources as possible reflects the compatibility of a
framework for coordinating onchain services.
2.2 AI Agent
In recent years, an AI agent has been defined as an autonomous software entity with a Large
Language Model (LLM) as its core reasoning engine and multiple tools or plugins for extended
functionalities. For example, a conversational agent can interact with users via various interfaces,
use the LLM for chain-of-thought (COT) reasoning, store conversation history in a database, and
utilize external tools (such as a search index) to retrieve information from the internet. To make
an AI agent service onchain, we must first understand its architecture and then determine the
appropriate methods for onboarding each component as an onchain service.
2.2.1 Architecture
Modern AI agents [YZY+23] incorporate components analogous to a human problem-solver [POC+23],
with four modules: perception (input via web, SMS, voice), cognition (e.g., LLM reasoning), memory
(agent context and chat history in a database), and tools (external knowledge bases or function-
alities). These components are orchestrated to resolve tasks given by users. The overall flow is
iterative, as shown in Figure 4.
First, the agent receives input from the user (Step 1). This input can be a command, question, or
request. The agent then initiates the perception phase, where Perception Tools evaluate the current
state of the Execution Environment (Step 2.1). Next, the evaluations are parsed, meaning they are
processed and transformed into a structured format that the AI can understand and reason over
(Step 2.2). This may include extracting intent, filtering signal from noise, or identifying relevant
context.
The agent then moves into the planning phase (Step 2.3), where it uses memory and context to
determine a course of action. This could involve reasoning through a chain of steps, selecting tools,
7
Figure 4: General Architecture of an AI agent.
or deciding how to proceed based on the parsed environment and user input. Following that, the
agent triggers Action Tools to carry out the plan (Step 2.4). This could include executing smart
contract functions, interacting with APIs, updating states, or any external operation within the
execution environment.
The ou프로젝트로 돌아가기