Who decides what it does?

We’ve been sitting with that question at DeAgentAI for two years now. The past two years have been a blur of model releases and benchmark breaks. But we’ve always cared more about something else: when an AI Agent makes a decision on-chain, how do you know that decision is trustworthy? Who guarantees it won’t contradict itself? When something goes wrong, who’s responsible?

No easy answers. But these are the questions we’ve been working on since day one.

The AIA Ecosystem Fund is our next answer.

What we’re seeing

AI Agents are no longer a concept. From automated workflows to on-chain autonomous trading, Agents are moving from demos into real running systems. But a healthy Agent ecosystem can’t run on infrastructure alone. It needs an application layer, compute support, and real-world scenarios to validate against.

The compute problem is more urgent than most people realize. Inference demand is exploding, but existing GPU solutions are hitting their ceiling on cost and energy. Our view: if the cost per inference unit can’t drop significantly, high-frequency autonomous decision-making by on-chain Agents is theoretically possible but practically out of reach. That’s not a problem software can fix.

So the AIA Ecosystem Fund bets on two directions: AI Agent application layer, and Physical AI hardware infrastructure.

Who we backed

AliceAI

The first time we sat down with the AliceAI team, they asked us a question: in an age of information overload, what’s actually scarce?

Not data. There’s more data than anyone can process.

What’s scarce is judgment, the ability to take a pile of contradictory information and arrive at one clear, executable conclusion. That’s what AliceAI does. Across crypto markets, sports events, political outcomes, and public affairs, it compresses complex, fragmented information into a single signal: direction, confidence level, validity window. Every call goes one way. Results are recorded on-chain and can’t be revised after the fact. Users receive signals via Telegram Bot, they can act on them manually, or authorize automatic execution.

What we’re backing isn’t just the product. It’s the direction — verifiable judgment as a primitive. Prediction markets are becoming one of the most important information-pricing mechanisms on-chain. Alice has a shot at becoming the core entry point for that category.

ASIC AI Chip Project

The first thing this team said to us: GPU is not the destination. It’s a bridge.

We agree. An ASIC chip purpose-built for Transformer architecture can do things GPU solutions simply can’t, on inference speed, cost per unit, and energy efficiency. This project is targeting a 10x reduction in cost per token processed versus current GPU setups. Not incremental improvement. An order-of-magnitude gap.

For us, there’s a more direct implication: lower inference costs mean on-chain Agents can actually run at high frequency. We came in at the seed round because this window won’t stay open.

What this means for the DA community

The AIA Ecosystem Fund isn’t a standalone financial vehicle. Every project we back will have a real connection to DeAgentAI’s infrastructure — Alice’s judgment signals can feed into AlphaX’s execution layer, and the ASIC chip directly lowers inference costs across the entire network.

For AIA holders, ecosystem expansion means more real use cases, more developers and users entering the network. We’re not doing portfolio allocation. We’re building an ecosystem.

We’re still looking

The AIA Ecosystem Fund is early. We’re fully open to strong projects.

Leading the fund is our Co-founder Selwyn, who has transitioned from DeAgentAI to take full charge of AIA Ecosystem Fund operations. Selwyn brings years of experience at top-tier USD funds, with multiple successful exits and a total return across all investments exceeding $4 billion.

AI Agent application layer and Physical AI hardware infrastructure are our current focus areas — but they’re not our boundaries. If what you’re building has anything to do with the future of AI, we want to talk.

No deck required. No polished metrics needed. We just want to hear your most fundamental take on where this is going.

Website: deagent.ai

X: @DeAgentAI

Discord: discord.gg/officialdeagentai

As part of our commitment to building a robust and secure AI-driven ecosystem, DeAgentAI is performing a comprehensive upgrade to the $AIA smart contract.

Important Statement on Market Stability: We understand that market fluctuations during contract transitions can occur. We want to assure our community that no tokens have been lost, diluted, or re-issued. Every holder will receive their tokens on a strict 1:1 basis. This migration is a technical upgrade, not a change to fundamentals. It ensures higher security, better composability, and positions DeAgentAI to become the trusted intelligence layer for the entire on-chain ecosystem.

Here is everything you need to know about the $AIA token migration.

🔹 Key Information & Audits

• Project Ticker: $AIA
• Swap Ratio: 1:1 (1 Old $AIA = 1 New $AIA)
• Total Supply: 1,000,000,000 (No change)
• Tokenomics: Unchanged
• Official Migration Portal: https://aiaswap.deagent.ai/

⚠️ Contract Address Verification (Security Alert)

To prevent scams, please strictly verify the addresses below. Scammers may create fake tokens with similar names.

🔹 Security Audit Reports:

• Report 1 (2025–11–29)
• Report 2 (2025–12–11)

🔹New Contract Address:

SUI: 0x99cc0e7834326ec6ac571421e9b8e042e9eb63062771c77ac592bd194180b5da::deagent_token::DEAGENT_TOKEN

BSC: 0x53EC33Cd4fA46b9ecED9cA3f6dB626C5FfCd55cC

❌ Original Token Contract:

SUI:

0x8b449b4dc0f8c5f996734eaf23d36a5f6724e02e312a7e4af34bd0bb74de7b17::deagent_token::DEAGENT_TOKEN

BSC: 0x48a18A4782b65a0fBed4dcA608BB28038B7bE339

🔹 Why This Upgrade? (Strategic Significance)

This transition allows us to activate key features that were not possible under the legacy contract. The upgrade accelerates our roadmap towards:

1. Oracle-Grade Machine Intelligence: Verifying, interpreting, and acting on real-world data with unprecedented trust guarantees.
2. Deterministic AI Agent Outputs: Enabling verifiable on-chain attestations.
3. Enhanced Liquidity Logic: Improved staking and reward structures designed for long-term sustainability.

🔹 Migration Guide

For CEX Users: If you hold $AIA on centralized exchanges, you generally do not need to do anything.

• Exchanges will temporarily suspend $AIA deposits and withdrawals.
• The exchange will handle the technical swap automatically.
• You will see the new $AIA tokens in your account once the migration is complete and trading resumes.

📢 Official CEX Announcements:

• Binance: View Announcement
• Bitget: View Announcement
• MEXC: View Announcement
• Gate.io: View Announcement

For On-Chain Users (Wallet Holders) If you hold $AIA in a decentralized wallet (e.g., MetaMask, Trust Wallet, Sui Wallet):

1. Navigate to the official migration portal: https://aiaswap.deagent.ai/
2. Connect your wallet.
3. Approve the interaction with the Old Contract.
4. Deposit your Old $AIA and claim your New $AIA at a 1:1 ratio. Note: Please ensure you have sufficient BNB or SUI for gas fees.

For ALL Staking Users(Including participants of the Annual Reward Pool, Early Bird Event, Friend Battle, etc.)

⚠️ Important Update: All staking activities have now been paused or concluded. Please follow the steps below to secure your assets and future rewards.

Step 1: Redeem(Unstake)

• Navigate to the DeAgentAI Staking Website: [https://stake.deagent.ai/]
• Redeem your Original Token principal to your decentralized wallet.

Step 2: Swap

• Go to the Official Migration Portal: https://aiaswap.deagent.ai/
• Connect your wallet and swap your withdrawn Old $AIA for New $AIA at a 1:1 ratio.

Step 3: About Your Rewards

• Snapshot Record: Your staking rewards have been secured based on the snapshot taken on Dec 11, 20:00 (UTC+8).
• Distribution: You do NOT need to keep tokens staked to qualify. Rewards will be distributed directly to your wallet according to the original distribution schedule of the respective staking event.

🔹 Upcoming Staking Opportunities

Please rest assured! We are actively preparing brand new staking campaigns and rules for the New $AIA. Detailed announcements regarding these new earning opportunities will be shared shortly after the migration. You will have plenty of chances to stake your New $AIA and continue earning rewards!

🔹 Safety Warning

• Admins will NEVER DM you first regarding the migration.
• Do not click on links from unofficial sources.
• Double-check the URL before connecting your wallet.
• If you have any questions, please seek assistance via our official Twitter @DeAgentAI or Discord.

Thank you for your continued support as we upgrade DeAgentAI!

The DeAgentAI Team

🔗 Official Links

• AIA Migration Portal: https://aiaswap.deagent.ai/
• AIA Staking Website: https://stake.deagent.ai/
• Official Twitter: https://x.com/DeAgentAI
• Discord Community: https://discord.com/invite/officialdeagentai

The crypto landscape is currently being activated by two explosive narratives: the rise of the autonomous AI Agent economy and the parallel boom in on-chain prediction markets.

The first wave, exemplified by protocols like x402, is standardizing how AI agents pay for API calls. The second, driven by platforms like Polymarket, has proven that pricing collective intelligence is a multi-billion dollar market.

Both trends are converging on a single, critical dependency: data. AI Agents must consume external data to inform their decisions, and a prediction market is useless without a reliable oracle to settle its outcome.

The proliferation of x402 turns this theoretical problem into an urgent one: when an AI Agent can autonomously pay for any API call, how can it trust the result it gets back? This creates a massive, high-stakes demand for an oracle that can bring external (Web2) information on-chain (Web3) trustlessly.

The “Bug” in Traditional Oracles

This is precisely where the dominant oracle model — what we call “reputation-based consensus” — fails.

Traditional oracles (like Chainlink) were designed for simple, public, and easily verifiable data. To get the price of SUI/USD, a Decentralized Oracle Network (DON) simply has 20 independent nodes query 10 different exchanges and report the median. If a node lies, it is out-voted and slashed.

This model collapses when data becomes complex, private, and non-deterministic.

Imagine an AI Agent needing to execute a high-value transaction based on a complex prompt sent to OpenAI.

• The Privacy Bug: The agent cannot broadcast its proprietary prompt — and more critically, its API_KEY—to 20 different nodes.
• The Consensus Bug: Even if it could, 20 different nodes asking OpenAI the same complex question may receive 20 slightly different, non-deterministic answers. There is no “median” to vote on.

This forces the agent into an antithetical position for a trustless system: it must trust a single, centralized oracle node. The entire security of a multi-million dollar protocol now hinges on hoping this single node isn’t hacked, malicious, or simply returning a fake result to save on costs.

The Deeper Problem: The Trust-Based AI Oracle

You might think: “Can’t the AI Agent just call the API directly?”

This is a simple misunderstanding of how blockchains work. A smart contract on Sui is a closed, deterministic system. It cannot make an HTTPS request to OpenAI. It must rely on an off-chain actor to “pass” it the data.

The seemingly obvious solution is to create a specialized “AI Oracle” that just calls the API and delivers the result. But this doesn’t solve the core problem. The smart contract is still blindly trusting that node. It has no way to verify:

• Did the node actually call api.openai.com?
• Or did it call a cheaper, malicious server that looks like it?
• Did it tamper with the response to manipulate a prediction market?

This is the true impasse: The AI Agent economy cannot be built on reputation. It must be built on proof.

The Solution: The DeAgentAI zkTLS AI Oracle

This is the challenge DeAgentAI, as a leading AI Agent infrastructure, was built to solve. We didn’t build a more trustworthy oracle; we built an oracle that requires no trust at all.

We achieve this by shifting the entire paradigm from reputational consensus to cryptographic consensus. The solution is a specialized AI Oracle built on zkTLS (Zero-Knowledge Transport Layer Security).

The diagram below illustrates the complete interaction architecture between the AI Agent, the Sui smart contract, the off-chain node, and the external AI API.

How It Works: The “Cryptographic Notary”

Do not think of DeAgentAI’s oracle as a messenger. Think of it as an internationally-recognized “cryptographic notary.”

The technical workflow is as follows:

1. Off-Chain Proving: The DeAgentAI oracle node (an off-chain component) initiates a standard, encrypted TLS session with the target API (e.g., https://api.openai.com).
2. Privacy-Preserving Execution: The node securely uses its private API key (Authorization: Bearer sk-...) to send the prompt. The zkTLS proving system records the entire encrypted session.
3. Proof Generation: After the session, the node generates a ZK-proof. This proof is the “notary’s seal.” It cryptographically attests to several facts simultaneously:

• “I connected to the server with the official certificate for api.openai.com."
• “I sent a data stream containing the public prompt."
• “I received a data stream containing the public response."
• “All this was done while provably hiding (redacting) the Authorization header, which remained private."

4. On-Chain Verification: The node then calls the on-chain AIOracle smart contract, submitting only the response and the proof.

This is where the magic happens, as shown in DeAgentAI’s Move-based architecture:

Code snippet

// A simplified snippet from DeAgentAI's AIOracle contract
public entry fun fulfill_request_with_proof(
    oracle: &AIOracle,
    request: &mut AIRequest,
    response: String,
    server_name: String, // e.g., "api.openai.com"
    proof: vector<u8>,   // The ZK-proof from the off-chain node
    ctx: &mut TxContext
) {
    // --- 1. VALIDATION ---
    assert!(!request.fulfilled, E_REQUEST_ALREADY_FULFILLED);
// --- 2. VERIFICATION (The Core) ---
    // The contract calls the ZKVerifier module.
    // It doesn't trust the sender; it trusts the math.
    let is_valid = zk_verifier::verify_proof(
        &proof,
        &server_name,
        &request.prompt,
        &response
    );
    // Abort the transaction if the proof is invalid.
    assert!(is_valid, E_INVALID_PROOF);
    // --- 3. STATE CHANGE (Only if proof is valid) ---
    request.response = response;
    request.fulfilled = true;
    event::emit(AIRequestFulfilled {
        request_id: object::id(request),
    });
}

The fulfill_request_with_proof function is permissionless. The contract doesn't care who the caller is. It only cares if the proof is mathematically valid.

The actual cryptographic heavy lifting is handled by the zk_verifier module, which performs the math on-chain to check the "notary's seal."

Code snippet

// file: sources/zk_verifier.move
// STUB: A real implementation is extremely complex.
module my_verifier::zk_verifier {
    use std::string::String;
    // This function performs the complex, gas-intensive
    // cryptographic operations (e.g., elliptic curve pairings)
    // to verify the proof against the public inputs.
    public fun verify_proof(
        proof: &vector<u8>,
        server_name: &String,
        prompt: &String,
        response: &String
    ): bool {
        // --- REAL ZK VERIFICATION LOGIC GOES HERE ---
        // In this example, it's stubbed to return `true`,
        // but in production, this is the "unforgeable seal."
        true
    }
}

This architecture separates the AIOracle business logic from the ZKVerifier cryptographic logic. This is a clean, modular design that allows the underlying proof system to be upgraded in the future without halting the entire oracle network.

Economic Impact: From “Cost of Data” to “Value of Trust”

Incumbent oracle giants (like Chainlink) have done an excellent job capturing the “public data” market. Their core business is providing price feeds like SUI/USD to DeFi. This is a market built on redundancy and reputational consensus (N nodes voting), where the economic model is paying for data.

DeAgentAI is targeting an entirely new blue ocean: the private/AI oracle market. This is a market where AI Agents, quant funds, and institutions need to call private APIs, non-deterministic AI models, and confidential data.

This market is effectively zero today. Not because there is no demand, but because it is fundamentally locked by the trust dilemma.

DeAgentAI’s zkTLS oracle is not built to compete in the “price feed” red ocean. It is built to unlock the trillion-dollar “Autonomous Agent Economy” that cannot launch without a foundation of trust.

Redefining Cost: “Gas Cost” vs. “Risk Cost”

Our zkTLS oracle verifies ZK-proofs on-chain, which, at this stage, consumes considerable gas. This may look “expensive,” but this is a fundamental misreading of the economics. We must differentiate between two types of cost:

1. Gas Cost: The predictable fee paid for a single, verifiable, secure API call.
2. Risk Cost: The unlimited potential cost of an AI Agent making a wrong decision and losing millions because it trusted an opaque, centralized node.

For any high-value AI Agent, paying a predictable “Gas Cost” in exchange for 100% “cryptographic certainty” is an infinitely cheaper economic choice than bearing an infinite “Risk Cost.”

We are not in the business of “saving costs.” We are in the business of “eliminating risk.” This is economic insurance, converting an unpredictable, catastrophic loss into a predictable, premium security expense.

Why DeAgentAI: Why We Are Critical

We solve the single most difficult, and most overlooked, problem in the AI Agent economy: trust.

The x402 protocol solves the payment friction, but that is only half the equation. An AI Agent that can pay for data but cannot verify that data’s authenticity is unacceptable in any high-value scenario. DeAgentAI provides the missing half: a verifiable “trust layer.”

We are positioned to do this not only because we have the right technology, but because we have proven its market feasibility.

First: We Serve a Mature Infrastructure, Not a Lab

DeAgentAI is already the largest AI Agent infrastructure across the Sui, BSC, and BTC ecosystems. Our zkTLS oracle is not a theoretical whitepaper; it is a critical component built to serve the real, massive demand within our ecosystem.

• 18.5M+ Users
• 440k+ Peak Daily Active Users (DAU)
• 195M+ On-Chain Transactions

Our zkTLS oracle is designed for this already-validated, high-concurrency environment. It provides the fundamental trust service that our massive user and agent ecosystem urgently requires.

Second: We Chose the Only Correct Architecture From Day One

Our market-leading position stems from strategic, foundational choices in our tech stack:

1. Cryptographic vs. Reputational Consensus: We fundamentally believe the AI consensus problem cannot be solved by social voting (node reputation). It must be solved by mathematics (cryptographic proof). This is our core differentiation from traditional oracle models.
2. Native Privacy & Permissionless Access: DeAgentAI’s zkTLS implementation solves API key privacy at the protocol level — a rigid requirement for any professional-grade AI agent. Concurrently, the permissionless nature of fulfill_request_with_proof creates an open market that trusts proofs, not participants.
3. Modular & Future-Proof: As mentioned, our engineers intentionally separated the AIOracle (business logic) from the ZKVerifier (cryptography). This is a critical design choice. As ZK cryptography (like STARKs and PLONKs) rapidly evolves, we can seamlessly upgrade the underlying ZKVerifier module for lower gas costs and faster verification, all without disrupting or migrating the ecosystem's smart contracts. We are building for the next decade of AI development.

Conclusion: From “Trusting the Messenger” to “Verifying the Message”

DeAgentAI’s architecture enables a fundamental shift: from trusting the messenger to verifying the message.

This is the paradigm revolution required to build a truly autonomous, high-value, and trustless AI Agent economy. x402 provides the payment rails, and DeAgentAI provides the indispensable safety and trust guardrails for that track.

We are building the trustless “central nervous system” for this emerging economy. For any developer looking to build the next generation of trustless AI agents, DeAgentAI provides the non-negotiable cornerstone of trust.

Official Links:

• Website: https://deagent.ai/
• Twitter: https://x.com/DeAgentAI
• Discord: https://discord.gg/officialdeagentai
• CoinMarketCap: https://coinmarketcap.com/currencies/deagentai/
• Dune Analytics: https://dune.com/blockwork/degent-ai-statistics

Congratulations on becoming an $AIA holder!

The candles are forming on the charts, and the community’s FOMO is palpable. But as we’ve always emphasized, listing is just the first step in our grand narrative. The real value accrual and ecosystem co-building starts now.

As the dust from trading settles, a core question emerges: How do you maximize the value of the AIA tokens in your wallet?

Today, we unveil the answer: The AIA Staking System. This is more than just a staking plan; it’s an ecosystem hub for value creation and community incentives. We have prepared a massive incentive pool of over 43,450,000 $AIA to reward every early supporter and builder of our ecosystem.

We know the crypto community is diverse. It’s home to Degen Players who thrive on high-frequency action and gamified fun, as well as Diamond Hands who believe in long-term strategies and stable, high-yield returns. That’s why we’ve designed different staking models, ensuring that no matter your strategy, you’ll find your alpha zone here.

Pool 1: Flexible-Combo Reward Pool — A Degen’s On-Chain Playground

The core philosophy of this pool is “Stake Once, Win Multiple Times.” Your single stake acts as an all-access pass, allowing you to participate in multiple reward games simultaneously. This hub is tailor-made for players seeking flexibility, fun, and diverse income streams.

Total Prize Pool: 12,000,000 AIA

Annual Reward Pool (Base APY)

This is your foundational base, providing a solid guarantee of returns. A pool of 5,000,000 AIA is waiting for you!

• Prize Pool: 5,000,000 AIA
• Duration: Starts September 16th, with linear release over 365 days.
• Rules: Your daily reward is calculated based on your share of the total pool: (Your Staked Amount / Total Staked Amount) × Daily Reward Release. All staked funds in this pool are eligible to share the daily release of ≈13,698.63 AIA. Simply put, the more you stake, the more you earn.
• Key Points: This APY is a tribute to our true long-term contributors. To be eligible for the full accumulated rewards, you must remain staked for a continuous period of 180 days, with the first month being a lock-up period. Unstaking before the 180-day mark will result in the forfeiture of all accumulated APY rewards from this program (your principal is unaffected). This is our salute to the diamond hands.

Activity I: Early Bird Event

A 3,000,000 AIA gift for the first movers!

• Prize Pool: 3,000,000 AIA
• Duration: September 16, 2025 ~ September 22, 2025
• Rules: Users who stake ≥ 200 AIA between Sep 16th and Sep 22th (with a 30-day lock-up) will be entered into a lottery. We will randomly select 15,000 lucky addresses to each receive 200 AIA. The rewards will be distributed in two installments over two months, 30 days after the event begins.
• TL;DR: Low cost, high-reward potential. Just send it!

Activity II: Friend Battle

A 500,000 AIA prize pool for you and your friends to dig for gold!

• Prize Pool: 500,000 AIA
• Duration: Starts September 16th, lasts for 202 days.
• Rules: Invite friends to stake AIA through your referral link. Rankings are settled every 10 days. The top 10 referrers with the highest total referred stake amount will share a prize pool of 25,000 AIA. The champion alone takes home 10,000 AIA. All rewards will be distributed within 10 working days after the event concludes.
• TL;DR: The only thing standing between being a community OG and a community Hero is the referral leaderboard.

Activity III: Blind Box Draw

A 500,000 AIA pool with surprises every time, and a guaranteed win on the 10th try!

• Prize Pool: 500,000 AIA
• Duration: Starts September 16th, lasts for 202 days.
• Rules: A single stake of ≥ 100 AIA triggers a chance to open a blind box. Each box has a 10% chance to reveal a random reward of 50–200 AIA. We’ve built in a pity mechanism: if you don’t win for 9 consecutive times, your 10th box is a guaranteed win!
• TL;DR: Time to test your RNG. Are you blessed or rekt? Experience the thrill of unboxing while staking!

Activity IV: Lucky Draw

A 2,000,000 AIA pool where wealth is just one number away!

• Prize Pool: 2,000,000 AIA + a cumulative jackpot.
• Duration: September 22nd, 2025 ~ lasts for 100 days.
• Rules: Stake ≥ 400 AIA to get your entry ticket, which remains valid as long as you are staked. A new round happens every 2 days. Pick 2 numbers from 1–50. If they match the on-chain winning numbers, you split the round’s base prize pool of 40,000 AIA. The best part? If there are no winners, the prize pool rolls over to the next round, creating a massive jackpot. All winnings will be distributed within 10 working days after the event concludes.
• TL;DR: A low entry barrier with a limitless prize pool. Your crypto intuition pays off here.

Activity V: Ultimate Survivor

A 1,000,000 AIA pool to crown the daily winner!

• Prize Pool: 1,000,000 AIA
• Duration: Starts September 22nd, lasts for 200 days.
• Rules: The user who executes the last valid staking transaction before 12:00 AM (UTC+0) each day will be the winner, taking home 5,000 AIA. (Valid stake: single stake ≥ 25 AIA & total new stake in the pool that day > 5,000 AIA). If conditions aren’t met, the prize rolls over. All rewards distributed within 10 working days after the event ends.
• TL;DR: Can you be the Last Man Standing with the perfect timing?

The Community Arena: Beyond Staking, It’s About Glory

We’ve forged a new battlefield for our core community members! An additional 1,900,000 $AIA prize pool and the ultimate games of skill and honor await. Want in? You’ll need a special ticket.

The Entry Ticket: How to Become a @Staker

This is the most critical step to unlocking the exclusive community games.

1. Qualify: Stake ≥ 400 $AIA in Pool 1 (Flexible-Combo Reward Pool).
2. Verify: Go to our official Discord, open a ticket in the #support-ticket channel, and submit your wallet address, staked amount, and a screenshot before 9:00 AM (UTC).
3. Authorize: Once approved (before 12:00 UTC), you will be granted the prestigious @Staker role, unlocking all exclusive community events!

⚠️ Important: If you increase or decrease your stake, you must resubmit a ticket to update your status. To maintain the @Staker role and eligibility for all community events, your staked amount must not fall below 500 $AIA.

Community Event1: Base Incentive (1,000,000 AIA)

• Duration: Starts Sep 22nd, for 180 days.
• Rules: As a qualified @Staker, you will automatically share a daily reward pool based on your proportional stake.

Community Event 2: Honey Battle (450,000 AIA)

• Duration: Starts Sep 22nd, for 180 days.
• Rules: Every Monday at 4:00 AM (UTC), all @Stakers will be randomly drafted into the Bear Team (20%) or the Bee Team (80%). The team of the user who makes the last staking transaction before 12:00 PM (midday, UTC+0) each day wins the daily 2,500 $AIA prize pot.

Community Event 3: Community Extreme Survivor (450,000 AIA)

• Duration: Starts Sep 22nd, for 180 days.
• Rules: The @Staker with the last valid staking transaction before 12:00 PM (midday, UTC+0) each day wins 1,000 $AIA.
• The Champion’s Bonus: Every 10 days, the user with the most Survivor wins gets an extra 15,000 $AIA!

How Should I Choose? The Intern’s Alpha Path

While the Staking Universe offers many strategies, the community has quickly discovered the most cost-effective way to maximize participation, a path we now call “The Intern’s Alpha.”

The Optimal Strategy: Stake 400 $AIA.

This single action is your master key. It doesn’t just get you into the game; it puts you in almost every game. With a 400 $AIA stake, you simultaneously unlock:

• The entire Flexible Pool suite: You are instantly eligible for the Base APY, Lucky Numbers, Blind Boxes, and the Ultimate Survivor.
• The entry ticket to the Community Arena: You meet the requirement to apply for the @Staker role, granting you access to the Base Incentive, the daily Honey Battle, and the Community Survivor championship.

This path perfectly balances risk and reward, turning a minimal entry into access to over 6+ potential reward streams. It is, without a doubt, the best way to begin your journey in the AIA Staking Universe.

Take Action Now!

• Stake Here: [https://stake.deagent.ai/]
• Join our Discord: [https://discord.gg/officialdeagentai]
• Follow us on X (Twitter): [https://x.com/DeAgentAI]

The wait is over.

The $AIA eligibility checker is now live. We are thrilled to announce that the DeAgentAI ($AIA) airdrop eligibility checker is now officially live.

This airdrop represents our unwavering commitment to every user who has contributed to the growth of the decentralized intelligence network. Whether you were a top predictor on AlphaX, a holder of our NFTs, or an active member of our community — every one of your contributions has been recorded and recognized.

Over 200,000 wallet addresses are eligible for this Genesis Airdrop.

Check your airdrop eligibility here: [https://airdrop.deagent.ai/]

Read on for a clear understanding of your eligibility category, the query process, and how you can maximize your genesis rewards.

Airdrop Eligibility: A Tribute to Our Long-Term Builders

The “Community Airdrop” allocation, which accounts for 13.5% of the total supply, is designed to reward every early builder of the DeAgentAI ecosystem. Please identify your contribution category below to follow the correct query guide.

DeAgentAI Ecosystem Core Contributors:

• AlphaX Product Users: Active users of our flagship product, AlphaX.
• Guess2049 Event Participants: Supporters who participated in the Guess2049 event.
• Social Media Contributors: Users who participated in our official X (Twitter) campaigns and other external collaborations.
• Community Contributors: Long-term, active contributors to the DeAgentAI community.

Genesis NFT Holders:

• Holders of the official DeAgentAI NFT on both BNB Chain and Bitlayer.

Ecosystem Partner Campaign Participants:

• Participants of the Binance Wallet campaign.
• Participants of the OKX Wallet campaign.

How to Query and Link Your Airdrop

The query and linking process differs slightly based on your contribution type. Please follow the guide that corresponds to your status.

a. For Ecosystem Core Contributors

(Includes users from AlphaX, Guess 2049, Social Media, and the Community)

Your process involves connecting your destination wallet first, then linking your source wallet(s).

Step 1: Connect SUI Wallet

Visit the official airdrop page and connect your SUI wallet.

Please Note: This SUI wallet is the destination address where you will receive your $AIA airdrop. Please safeguard it carefully.

Step 2: Link Address

Link the EVM or SOL wallet address that you previously used to participate in our official events or products.

Step 3: Check Your Allocation

After submitting, you can check the amount of AIA you are eligible for and the specific airdrop schedule.

Important Reminders:

Complete Linking Within 48 Hours Please be sure to link your address within 48 hours. Failure to do so by the deadline will be considered a forfeiture of your airdrop eligibility. The AIA airdrop will be completed within 7 working days.

Keep Your Wallet Secure Please safeguard your SUI wallet’s seed phrase and private key. Be vigilant against all phishing links and scams.

b. For DeAgentAI NFT Holders

Your process involves connecting your source wallet first, then binding your destination wallet.

Airdrop Link: [https://dam.deagent.ai/]

Vesting Schedule:

• Bitlayer: Unlock 40% in the 3rd month of TGE. Remaining part starts from the 8th month, 24-month linear unlock.
• BNB Chain: Unlock 10% in TGE month, unlock 30% in the 7th month. Remaining part starts from the 8th month, 24-month linear unlock.
• The Process:

Step 1: Connect BSC/Bitlayer Wallet

Step 2: Query Airdrop Amount

Step 3: Bind SUI Wallet Address

Step 4: Wait for Airdrop

c. For Ecosystem Partner Campaign Participants

• Binance Wallet Campaign: Participants can claim their rewards directly through the campaign page within their Binance Web3 Wallet.
• OKX Wallet Campaign: The query window on our official airdrop portal . Please follow the guide for “Ecosystem Core Contributors” at that time.

The Path to Rewards: From Pre-Staking to Claim Day

We have designed a two-phase incentive mechanism to maximally reward our most loyal early supporters.

Phase 1: The Pre-Staking Window

This is a limited-time Alpha opportunity for our first-movers.

• Period: From 3:00 PM UTC, Sep 16th until the official TGE on Sep 18th.
• How to Participate: After checking your eligibility on the airdrop portal, you can choose to “Pre-Stake” your entire unclaimed airdrop allocation.
• Exclusive Reward: All pre-staking participants will share an early incentive prize pool of [40,000,000] $AIA. This is a direct reward for your long-term confidence shown even before TGE.

Phase 2: TGE Airdrop Day

The $AIA airdrop will be distributed on September 18th (simultaneously with our CEX listing). Your tokens will be sent directly to your eligible wallet address.

For Pre-Stakers: If you participated in Phase 1, no further action is needed. At the moment of TGE, your assets will automatically begin earning multiple rewards from our staking ecosystem, giving you a head start!

The Final Chapter is About to Begin

Trading for $AIA is just around the corner. At that time, we will announce the one and only official $AIA token contract address through our official channels.

Stay Alert! Beware of any scams and impersonations. Please only trust information published by our official channels.

• Official X (Twitter): [https://x.com/DeAgentAI]
• Official Discord: [https://discord.gg/officialdeagentai]

Share your airdrop eligibility on X, and don’t forget to tag us! The era of decentralized intelligence has arrived.

Check your eligibility now: [https://airdrop.deagent.ai/]

ステップバイステップガイド

AIを活用した予測で取引戦略を強化しませんか？

AlphaXで開催されるPredict2Win: SUI Seasonに参加して、人間の直感とAIの精度を融合させましょう。毎日のSUI価格予測シグナルとインタラクトすることで、ポイント、トークン、サプライズエアドロップを獲得できます。参加方法は以下の通りです。

🔹 ステップ1

AlphaXのウェブサイトにアクセスし、「LAUNCH NOW」をクリックしてプラットフォームに接続します。

🔹 ステップ2

ランディングページでキャンペーンルールを確認し、Suiチェーンを選択します。

🔹 ステップ3

「Connect Wallet」をクリックし、お好みのウォレット（例: OKX）を選択します。

🔹 ステップ4

ウォレットが接続されたら、ホームページにアクセスし、デイリーチェックインを行うと、通常の2倍のポイント（200pt）を獲得できます。

🔹 ステップ5

「Home > All」セクションで、利用可能な価格予測シグナルを閲覧します。いずれかのシグナルで「View」をクリックして進みます。

🔹 ステップ6

シグナルインタラクションページでは、以下の操作を行います。

• 左側には、シグナル作成時の固定価格、予測価格帯、およびローソク足チャートが表示されます。
• 右側には、他のユーザーがシグナルにどのように反応したかが表示されます。

シグナルの予測方向に対するあなたの意見を共有するには、「Agree」または「Disagree」をクリックします。

🔹 ステップ7

（任意）入力フィールドに目標価格を入力し、「Confirm」をクリックします。

🔹 ステップ8

✅ おめでとうございます！ AlphaXでのSuiベースのシグナルインタラクションが正常に完了しました。

🎁 Sui限定報酬体系

• Suiベースのインタラクションごとに、ランダムでトークンのエアドロップポップアップが表示されるチャンスがあります。
• デイリーコンプリートボーナス: その日のSuiシグナルインタラクションをすべて完了すると、2倍のポイントを獲得できます。
• 上位10名への報酬：毎日、Suiポイントの獲得数が上位10名に入ったユーザーには、2倍のポイントとトークン報酬が贈られます（24時間ごとに集計）。

💰 総報酬プール: 100,000 USDT相当のトークン

⚠️ 重要なお知らせ

AlphaXは複数のチェーン（Sui、BNB Chain、opBNB、Bitlayer）に対応していますが、このキャンペーンはSuiチェーンでのインタラクションを行うユーザーのみを対象としています。他のチェーンでのインタラクションは報酬の対象にはなりませんのでご注意ください。

🔗 Offical Links:

• Twitter
• DeAgentAI Website
• AlphaX Website

Want to empower your trading strategy with AI-powered predictions?

Join Predict2Win: SUI Season on AlphaX — where human intuition meets AI precision.

Interact with daily SUI price prediction signals to earn points, tokens, and surprise airdrops. Here’s how to get started:

🔹 Step 1

Go to the Alphax and click “LAUNCH NOW” to access the platform.

🔹 Step 2

Review the campaign rules on the landing page and select the Sui chain.

🔹 Step 3

Click “Connect Wallet” and choose your preferred wallet (e.g., OKX).

🔹 Step 4

Once your wallet is connected, head to the Home page and complete your Daily Check-in to receive double points (200 pts).

🔹 Step 5

In the Home > All section, browse through available price prediction signals. Click [View] on any one of them to proceed.

🔹 Step 6

On the signal interaction page:

• On the left, you’ll see the locked-in price at the time of signal creation, the predicted price range, and a candlestick chart.
• On the right, you’ll see how other users have interacted with the signal.

Click Agree or Disagree to share your view on the signal’s prediction direction.

🔹 Step 7

• Enter your own target price in the input field(Optional).
• click Confirm.

🔹 Step 8

✅ Congratulations! You’ve successfully completed a Sui-based signal interaction on AlphaX.

🎁 Sui-Only Rewards Structure

• Random Cash Rewards: Every Sui-based interaction gives you a chance to trigger a random token airdrop popup.
• Daily Completion Bonus: Complete all Sui signal interactions for the day to earn double points.
• Top 10 Leaderboard Rewards: The top 10 users by Sui points each day will receive double points + token rewards (settled every 24 hours).

💰 Total Reward Pool: 100,000 USDT worth of tokens

⚠️ Important Note

While AlphaX supports multiple chains (Sui, BNB Chain, opBNB, and Bitlayer), this campaign is exclusively for users interacting on the Sui chain. Interactions on other chains will not count toward rewards.

🔗 Offical Links:

• Twitter
• DeAgentAI Website
• AlphaX Website
• Discord

1. Background: The Governance Challenge for AI Agents

Artificial Intelligence (AI) Agents, particularly those powered by Large Language Models (LLMs), hold immense potential for participating in and even automating aspects of governance, especially in decentralized systems. However, deploying them reliably in such contexts faces significant hurdles:

(1) Consensus: LLMs are inherently probabilistic. For a given input sequence, an LLM calculates probability scores for potential next words, leading to a vast number of possible output sequences. While mechanisms like greedy search or beam search select a likely output (the red path in the diagram below), this selection isn’t inherently deterministic or universally agreed upon. In governance scenarios, especially those involving asset allocation or critical decisions, how do we ensure that one specific output path is the authoritative and accepted result, agreed upon by all stakeholders? Relying solely on trusted execution environments (TEEs) isn’t sufficient; the process of generating the AI’s decision requires its own form of verifiable consensus.

(2) Identity (Consistency): Even if consensus on an output is achieved, distributed systems face concurrency challenges. Multiple valid, yet potentially contradictory, decisions could theoretically be generated simultaneously for the same Agent regarding the same issue. This is analogous to the double-spending problem in blockchains, which is resolved by enforcing a single, linear chain of transactions. An AI Agent involved in governance cannot simultaneously provide contradictory directives, just as a human leader cannot credibly issue opposing orders at the same time. The Agent must exhibit a singular, consistent identity and state at any given point in time.

(3) Continuity: Human societies rely on memory for continuity. Decisions, commitments, and identities persist over time. An AI Agent participating in governance must also possess a reliable form of memory. Its past interactions, decisions, and learned state must inform its future actions consistently. An Agent that “forgets” its previous commitments or rationale loses its credibility and effectiveness, much like an elected official forgetting their campaign promises.

Consensus, Identity, and Continuity are therefore fundamental properties required for AI Agents to function reliably and trustworthily within governance frameworks, particularly in distributed environments.

2. Overview: The De(cistion)Agent Framework

The De(cistion)Agent framework (DeAgent) is proposed to address these three core challenges. It provides a structure for creating, operating, and interacting with AI Agents within distributed systems.

A DeAgent instance is defined by:

• Lobe: Represents the cognitive engine of the Agent. It encapsulates the logic for invoking one or more LLMs, processing inputs, and generating outputs. Agent creators specify the Lobe(s) to be used, potentially referencing pre-defined or custom implementations.
• Memory: Contains the Agent’s initial state (genesis memory) and its accumulated interaction history (evolving memory). This provides the basis for continuity.
• Tools: A defined set of capabilities the Agent can utilize, such as accessing external data, interacting with other systems, or performing specific actions within the distributed environment. Includes descriptions for how the Lobe can invoke them.

Creation: A DeAgent is instantiated by publishing its definition (Lobe URI, initial Memory state, Tool specifications) to a specific address or identifier within a distributed system (e.g., a blockchain mainnet, a decentralized storage network).

Inherited Properties: Crucially, a DeAgent naturally inherits the properties of its underlying distributed system. If the system guarantees immutability for published data, the Agent’s core definition becomes immutable. If the system provides strong consensus and ordering guarantees (finality), this forms the foundation for the Agent’s Identity and Continuity.

Technical Neutrality: The DeAgent framework is agnostic to specific encoding formats, publication methods, or advanced features (like native immutability) of the underlying distributed system. However, developers and communities adopting DeAgent on a specific platform should establish clear standards and specifications. The minimum requirement for the host system is that it achieves a unique, final state agreed upon by participants (i.e., it possesses inherent Consensus and Identity).

Interaction: Users interact with a DeAgent by submitting operations (e.g., transactions in a blockchain context) targeted at the Agent’s address. These operations contain the interaction payload (text, image, audio, video inputs, or references to immutable data pointers if payloads exceed size limits). Platform-specific operation standards are needed.

Execution: The DeAgent framework relies on Executors. These are nodes responsible for processing interactions. Executors can be centralized, run by multiple trusted parties, or fully decentralized. They monitor the distributed system for interactions targeting DeAgents they service, retrieve the Agent’s definition and current state (Memory), execute the interaction using the specified Lobe and Tools, and generate potential results.

Consensus and Finalization: Executors submit their results along with proofs of execution. A network of Committers (validators) then applies a consensus protocol (detailed later) to select a single canonical result for each interaction cycle, ensuring Identity. This result updates the Agent’s state (Memory) on the distributed system, establishing Continuity.

3. DeAgent Lifecycle and Roles

The DeAgent ecosystem involves several key roles:

• Agent Creator: Defines the Agent’s Lobe, initial Memory, and Tools, then publishes this definition to the distributed system, bringing the Agent into existence.
• Agent User: Interacts with the Agent by submitting queries or tasks via operations on the distributed system.
• Framework Operators: Maintain the operational integrity of the DeAgent ecosystem:
• Executors: Nodes that run the Agent’s logic (Lobe + Tools + Memory). Can range from private nodes (potentially in TEEs) to open participants.
• Compute Providers (Optional): Specialized nodes offering execution services for specific (often open-source) models, potentially forming a sub-network with its own incentive mechanisms.
• Committers: Nodes responsible for validating execution proofs submitted by Executors and achieving consensus on the canonical interaction result for each step. They select the final result (often guided by principles like minimal entropy) and commit it to the Agent’s state chain on the distributed system.

Agent Lifecycle:

(1) Creation: An Agent Creator publishes the Agent’s definition on the distributed system.

(2) Interaction Request: Users submit interaction requests targeting a specific Agent (or group of Agents). These requests might include parameters like preferred Executors (via selectors) or incentives (gas fees/tips). Requests enter an Interaction Pool (akin to a transaction mempool).

(3) State Dependency: Unlike typical transaction pools where transactions might remain valid across multiple blocks, Agent interaction requests are highly state-dependent. An Agent’s response relies heavily on its current Memory. Once the Agent’s state is updated by a finalized interaction, previous interaction requests targeting the older state become invalid and are discarded.

(4) Execution: Executors select requests from the Interaction Pool (based on factors like incentives, selectors, or internal policies). They execute the Agent’s logic using the specified Lobe, the Agent’s current Memory state, and available Tools.

(5) Candidate Submission: Executors submit their results (Response, Memory updates, Tool usage, proofs) to a Candidate Pool. Multiple Executors might process the same interaction request, leading to multiple candidate results.

(6) Consensus & Finalization: Within a defined timeframe (related to the Agent’s “tick rate” or timeout), Committers evaluate the candidate results in the pool. Using a consensus mechanism (e.g., PoS-like voting, PBFT) and potentially a selection heuristic (like the minimum entropy principle described below), they choose a single canonical result.

(7) State Update: The chosen result is committed to the distributed system, updating the Agent’s official Memory/state chain. This ensures Identity (only one result per step) and Continuity (the state evolves predictably).

(8) Death: If an Agent remains inactive (no finalized interactions) for a predetermined period, it can be considered “dead” or dormant. Future interaction requests targeting it may be ignored by Executors.

4. Lobe: The Cognitive Engine

The Lobe is the core processing unit of the Agent.

4.1 Lobe Definition

Agent Creators primarily need to specify the Lobe’s Uniform Resource Identifier (URI). This URI tells Executors how to access and run the Lobe.

• Built-in Lobes: The Executor might have optimized, native implementations referenced directly.
• Remote/Community Lobes: The URI might point to a standardized service endpoint or package developed by the community.

Lobe Inputs:

• Memory Context: Relevant portions of the Agent’s Memory (e.g., Hot Memory, relevant Longterm Memory retrieved via RAG).
• User Query: The current interaction payload from the user.
• Tool Manifest: List of available Tools and their descriptions/APIs.

Lobe Outputs:

• Memory Directives: Instructions for updating the Agent’s Memory (e.g., add to Longterm Memory).
• Response: The output generated for the User.
• Tool Usage Directives: Instructions specifying which Tools to use and with what parameters.
• Execution Proof: Verifiable evidence of the Lobe’s execution process.

Essentially, a Lobe wraps one or more foundational models (like LLMs). It preprocesses inputs (combining query, memory, tool info), invokes the model(s), post-processes the model output, and formats the final Lobe Output structure.

4.2 Lobe Consensus

Ensuring the Lobe’s execution is verifiable and deterministic (or has agreed-upon non-determinism) is crucial for overall DeAgent consensus. This requires proofs for two aspects:

1. Model Invocation/Execution Proof: Proving the underlying AI model was called correctly and produced a specific output. This is challenging.
2. Non-Model Logic Proof: Proving the correctness of the surrounding business logic within the Lobe (preprocessing, post-processing, tool handling). This is more amenable to standard techniques like Zero-Knowledge Proofs (ZKPs).

4.2.1 Model Invocation Proof Mechanisms

Closed-Source Models (Whitelisting + TLS Proofs): For proprietary models from trusted vendors (e.g., OpenAI, Anthropic, Google, Cloudflare AI), full execution proof is impossible. Instead, we rely on a whitelist approach. Executors provide proof (e.g., via ZK-TLS techniques like DECO or TLSNotary) demonstrating they securely connected to the vendor’s official API endpoint and relayed the specific query and response without tampering.

Open-Source Models (Challenges and Hybrid Approach):

• zkML: Techniques like zkSNARKs applied to machine learning models (zkML) could theoretically provide full execution proofs. However, current zkML approaches (even promising ones like zkPyTorch mentioned by Polyhedra, though practical availability was limited at the time of writing) often incur prohibitive computational overhead and latency.
• Replication Issues: Simply having multiple nodes run the same open model isn’t foolproof. Differences in hardware (e.g., CUDA SM versions), software libraries, and floating-point arithmetic can lead to slightly different outputs, breaking naive consensus.
• Proposed Hybrid Approach (Active + PoW-like Entropy Minimization): We propose a specialized compute network for open models. Participants run the models. When an interaction requires an open model, multiple participants can execute and submit their results. Instead of requiring identical outputs, we use an entropy function to select the “best” result. The participant submitting the result with the lowest calculated entropy is chosen. This incentivizes participants to produce high-quality, relevant outputs. Penalty and reward mechanisms should be integrated into this network.

4.2.2 Entropy Function for Result Selection

To objectively select among potentially valid but different model outputs (especially from open models), we use an entropy-based selection mechanism:

1. Encoding Model: Utilize a separate, highly capable encoder model (potentially a RAG-enhanced QA model) denoted as E. This model maps text sequences to dense vector embeddings: vector = E(sequence).
2. Entropy Calculation: For a given input (input) and a candidate output (output), calculate the negative dot product of their embeddings:
   Entropy = — ( E(input) ⋅ E(output) )
   (Note: Using the negative dot product means higher similarity/relevance corresponds to lower “entropy” in this context. Cosine similarity could also be used).
3. Selection: Among all candidate outputs submitted by Executors for a given interaction, the Committers select the one yielding the lowest entropy value.

Security Assumption: This mechanism relies on the assumption that it is computationally difficult for an attacker to craft a malicious or arbitrary response that also achieves the minimum entropy score for a given input, according to the chosen encoder model E. This assumption requires ongoing research and validation.

4.3 Lobe Summary

Through ZK proofs for non-model logic, TLS proofs for whitelisted APIs, and an entropy-based selection for open models, the DeAgent framework aims to establish robust consensus around the Lobe’s execution results.

5. Memory and Tools: Defining Agent Individuality

While the Lobe provides cognitive power, an Agent’s unique identity, history, and capabilities are defined by its Memory and Tools.

5.1 Memory

An Agent’s entire interaction history is immutably stored on the underlying distributed system, forming its complete Longterm Memory. However, for practical Lobe invocation, relevant parts are selected:

• Hot Memory: The most recent N interactions (or up to M tokens) are automatically included, providing immediate conversational context.
• Longterm Memory: A Retrieval-Augmented Generation (RAG) mechanism searches the Agent’s full history to find relevant past interactions based on the current query. Results exceeding a certain relevance threshold (up to a specified number of items/tokens) are included.

Consensus on Memory: Retrieving Hot Memory and verifying historical interactions (for RAG) directly from the distributed ledger is straightforward and verifiable by Committers. However, the RAG process itself (the specific algorithm and relevance scoring) is typically not subject to strict consensus verification due to complexity. We trust that Executors, incentivized to have their results selected, will employ effective RAG techniques. Committers primarily verify that the Longterm Memory snippets provided do originate from the Agent’s validated history.

5.2 Tools

Tools extend an Agent’s capabilities beyond pure text generation.

• Built-in Tools: Provided by the DeAgent framework:
• Distributed Data Query: Securely query data from the host distributed system (e.g., check account balances, read smart contract states). Verifiable by re-execution.
• Web Access: Allows the Agent to access and retrieve information from the public internet. Verified using ZK-TLS proofs for secure connection and data retrieval.
• Decision Plugin: (See details below) A critical tool enabling Agents to interact with and control aspects of the distributed system, including governance actions.
• Browser Plugin (Experimental/Restricted): For Agents running in secure, potentially TEE-backed private Executor environments, this could allow interaction with web interfaces, potentially controlling a private wallet via browser extensions. Verification is currently challenging; initial implementations might require TEE attestation and potentially recorded/streamed execution sessions. Future work aims for zk-proofs of browser automation (e.g., collaboration with projects like Playwright).
• User-Defined Tools: Creators can define custom tools, potentially requiring specific Executor capabilities or external service interactions. Verification methods depend on the tool’s nature.

Consensus on Tool Use: Committers verify the correct invocation and results of built-in tools like data queries (re-execution) and web access (ZK-TLS). For the Decision Plugin, consensus focuses on validating the intent and the eventual execution of the decision (often via MPC, see below). User-defined tools require their own specified verification mechanisms.

5.3 Decision Plugin: Enabling Agent Action and Governance

The Decision Plugin is the core mechanism for Agents to perform actions with consequences on the distributed system (e.g., transferring assets, voting in a DAO, executing a smart contract function).

When a user (or another Agent) initiates an interaction requiring a potential decision, the request must include:

• Decision ID: A unique identifier for this specific decision proposal.
• Target Object: An identifier for the object of the decision on the distributed system (e.g., a contract address, a specific asset ID).
• Action Payload: The specific operation to be potentially executed (e.g., function call data, transaction details).

The Decision Plugin exposes two primary functions callable by the Lobe:

1. introduce_decision(): (No parameters) When called, the Executor simulates the proposed action (using the Action Payload against the Target Object) and provides the Lobe with a description of the expected outcome, potential side effects, risks, or errors without actually executing it.
2. reply_decision(approval: boolean): Based on its reasoning (informed by the simulation results from introduce_decision and its internal logic/memory), the Lobe calls this function with true (approve) or false (reject).

Execution Flow:

• The Lobe uses introduce_decision to understand the proposal.
• The Lobe reasons about the decision based on its purpose, memory, and the simulation outcome.
• The Lobe calls reply_decision.
• If reply_decision(true) is called, this approval becomes part of the Lobe’s output submitted by the Executor to the Candidate Pool.
• Committers validate this approval as part of the consensus process. If the interaction containing the approval is selected as canonical, the Committers (potentially acting as an MPC group, see Section 7) are authorized to execute the actual Action Payload on the distributed system, using the Decision ID for tracking.

This plugin transforms the Agent from a passive information processor into an active participant capable of initiating verified, state-changing operations within the distributed system, forming the basis for Agent-driven governance and autonomy.

6. Agent-to-Agent (A2A) Communication Protocol

To enable complex collaboration, delegation, and emergent system behaviors, DeAgents need a mechanism to interact directly with each other. The A2A Communication Protocol leverages the underlying distributed system:

Mechanism: An A2A interaction is initiated by one Agent (the sender) submitting a standard DeAgent operation (transaction) specifically targeting another Agent’s address (the receiver).

Payload: The operation payload contains the message or query intended for the receiving Agent, potentially structured similarly to a user query, but could include specific A2A directives or context.

Processing: The interaction request enters the Interaction Pool like any other. An Executor processing the receiving Agent will fetch this A2A request. The receiving Agent’s Lobe processes the request using its own Memory and Tools.

Response & State: The receiving Agent’s execution result (response, memory updates, potential tool use including decisions or further A2A messages) is submitted to the Candidate Pool and, if selected by Committers, updates the receiving Agent’s state chain. The response part might be implicitly recorded on-chain or could trigger a reciprocal A2A message back to the original sender if designed that way.

Capabilities: A2A communication enables sophisticated patterns:

• Information Exchange: Agents querying each other for data or specialized knowledge.
• Task Delegation: One Agent requesting another Agent with specific tools or expertise to perform a task.
• Coordinated Action: Multiple Agents collaborating on a complex goal, potentially using the Decision Plugin and MPC for joint actions.
• Negotiation: Agents engaging in dialogue to reach agreements.

The A2A protocol relies on the same fundamental DeAgent principles (Consensus, Identity, Continuity) ensuring that inter-agent communication is verifiable and consistently integrated into each participating Agent’s state history.

7. Multi-Party Computation (MPC) Integration for Secure Actions

Executing decisions, especially those involving control over assets or critical system parameters (triggered via the Decision Plugin’s reply_decision(true)), requires high security and decentralization. Integrating Multi-Party Computation (MPC) provides a robust solution:

• Purpose: To allow a group of participants (typically the Committers) to collectively authorize and execute sensitive actions without any single participant ever holding the complete authority or private key.
• Mechanism: The Committers form an MPC group managing cryptographic keys associated with the Agent’s capabilities (e.g., keys for a multi-signature wallet controlled by the Agent, authorization keys for specific system functions). These keys are sharded, with each Committer holding only a share.
• Trigger: A canonical interaction result, validated through the standard DeAgent consensus process, containing an approved reply_decision(true) directive from the Agent’s Lobe.
• MPC Protocol Execution: Upon validating the approved decision, the Committers initiate a secure MPC protocol amongst themselves. They use their key shares to collectively generate the required cryptographic signature or authorization message needed to execute the Action Payload specified in the original decision request, without ever reconstructing the full private key in one place.
• Action Execution: The collectively generated signature/message is then broadcast to the distributed system to execute the intended on-chain action (e.g., submitting the signed transaction).
• Benefits:
• Enhanced Security: Eliminates single points of failure/attack; the private key is never exposed.
• Increased Decentralization: Control is distributed among the Committers, aligning with the ethos of decentralized systems.
• Trustless Execution: Enables Agents to manage assets or perform critical actions in a verifiable and secure manner, essential for Agent autonomy and governance roles.

MPC integration, particularly linked to the Decision Plugin, provides the necessary security layer for DeAgents to act as trusted custodians, managers, or governors within distributed ecosystems.

8. Application Space and Potential

By providing verifiable Consensus, Identity, and Continuity, and enabling secure action via the Decision Plugin and MPC, the DeAgent framework opens up numerous application possibilities:

Autonomous Economic Agents:

• Auctioneers: Agents managing auctions for digital assets (NFTs, etc.), providing descriptions, handling bids, and finalizing sales.
• Investment Managers: Agents managing user-delegated portfolios, analyzing markets (via Web Access Tool), making investment decisions (via Decision Plugin + MPC), and reporting performance.
• DeFi Liquidators: Providing intelligent, trustworthy, and potentially more nuanced liquidation mechanisms for decentralized finance protocols.

Governance and Coordination Agents:

• Dispute Resolvers: Agents acting as neutral arbiters in disputes, analyzing evidence (provided as input) and making binding decisions (if empowered).
• Coordinators: Facilitating complex processes involving multiple parties or resources within a decentralized organization.

Agent Interfaces:

• Interactive Platforms: Front-ends (like DApps for smart contracts) allowing users to easily discover, interact with, and monitor DeAgents (e.g., a “Live Agent” platform).
• Simulation Environments: Creating virtual worlds (cities, markets, ecosystems) where DeAgents can interact with each other and the environment, allowing for testing, research, and entertainment (Open World Simulators).

AI Agent DAOs: A paradigm shift where DAOs (Decentralized Autonomous Organizations) are partially or wholly governed by DeAgents:

• Proposal & Voting: Users or Agents submit proposals. Designated governance Agents analyze proposals, debate (via A2A), and vote using the Decision Plugin.
• Execution: Committer network (acting as an MPC group) executes the outcome of successful votes on-chain.
• Dynamic Governance: Memory allows Agents to evolve their stance based on past outcomes and DAO performance, representing different stakeholder perspectives or objective functions. The interplay between Agents with potentially different goals, constrained by the consensus mechanism, could lead to emergent, balanced governance.

DeAgent provides a foundation for building reliable, accountable, and capable AI participants within distributed systems, potentially transforming governance, finance, and social coordination online.

9. Future Work and Considerations

• zk-Browser Automation: Maturing ZK proof techniques for browser interactions to enhance the verifiability of the Browser Plugin.
• Entropy Function Security: Rigorous analysis and validation of the security assumptions behind the proposed entropy function for model output selection.
• zkML Optimization: Continued progress in zkML could eventually allow for direct, efficient proofs of open model execution, potentially replacing or augmenting the entropy mechanism.
• Scalability and Cost: Optimizing the computational overhead of proofs, consensus, and on-chain storage for large-scale DeAgent deployment.
• Ethical Frameworks: Developing clear guidelines for Agent creation, goals, and operational boundaries, especially for governance roles.

In today’s rapidly evolving AI landscape, OpenAI has proposed a five-stage evolution model: from simple chatbots to reasoners with inference capabilities, autonomous agents, innovators with creative abilities, and ultimately organizers capable of managing entire organizations. This model outlines a clear pathway from Artificial Narrow Intelligence (ANI) to Artificial General Intelligence (AGI).

However, upon closer examination of the current state of AI, it becomes evident that even the most advanced AI models are still transitioning from chatbots to reasoners. Although these models excel in specific domains, they remain fundamentally within the realm of Artificial Narrow Intelligence (ANI), lacking true autonomous learning and cross-domain applicability. This limitation stems from the probabilistic nature of neural networks. Large language models (LLMs) are essentially conditional probability models, denoted as P(y|x), where x represents the input sequence and y the output sequence. This probabilistic decision-making framework inherently conflicts with the deterministic nature of distributed systems.

Technical Challenges in AI Agent Distributed Governance

The agent stage represents a critical breakthrough toward more advanced forms of AI. However, in decentralized Web3 environments, developing AI agents capable of autonomous decision-making and execution presents three core challenges:

Consensus: The “Multiple Personalities” Dilemma

In distributed systems, traditional consensus algorithms such as Paxos and Raft are built on deterministic computation. However, when AI agents are introduced as decision-making nodes, variability arises due to the decoding processes of LLMs and the computational devices used. Even the same model running on different devices may produce divergent outcomes due to minor computational discrepancies, creating a “butterfly effect.” This raises the challenge of how participants can reach consensus on a single output.

Identity: Split Decision-Making

Another critical challenge is identity, which is essentially an extension of the state consistency problem in distributed systems to probabilistic models. This inherent uncertainty renders traditional state synchronization mechanisms ineffective. New technical solutions are needed to ensure verifiable state transitions, traceable decision processes, and consistent outputs. In simpler terms, the same AI agent might provide completely contradictory answers to the same question at the same time. This is akin to a decision-maker simultaneously saying “yes” and “no.” Without resolving this issue, such a decision-maker cannot be used in scenarios requiring rigorous decision-making.

Continuity: The Memoryless Agent

The challenge of continuity revolves around the state persistence and evolution mechanisms of AI agents. Traditional context management approaches face limitations such as memory constraints and fragmented states, resulting in the lack of a globally consistent state view, difficulties in accumulating knowledge across sessions, and the absence of rollback mechanisms. Human decision-making relies heavily on memory systems. Just as a presidential candidate who forgets their campaign promises from one day to the next would be unfit for office, AI agents must address the challenge of maintaining decision continuity and consistency.

The DeAgentAI Framework: A Decentralized Intelligent Decision Network

To address these challenges, DeAgentAI introduces an innovative framework consisting of three core modules, akin to different functional regions of the human brain:

Lobe: The “Decision-Making Center” of AI

The Lobe module resolves the consistency issues of probabilistic models in distributed environments through cutting-edge innovations:

• Entropy Minimization Decision Mechanism

• zkTLS/zkML Proof Generation

Zero-knowledge proof techniques ensure the authenticity of model invocations.

• Verifiable Computation

Guarantees the correctness of inference processes.

The Lobe acts as the AI’s prefrontal cortex, responsible for high-level decision-making. It is more than a simple AI model; it is a decision-making system fortified with multiple safeguards.

Memory: The “Memory System” of AI

The Memory module transcends the storage limitations of traditional AI systems, enabling decentralized knowledge accumulation:

• Hierarchical Storage Architecture

• State Transition Verification

Much like the human hippocampus, the Memory module is responsible for forming and storing memories. It classifies an agent’s memory into three layers:

• Initial Memory: The “genetic code” of the AI, containing fundamental knowledge and behavioral rules.

• Hot Memory: Similar to working memory in humans, it processes immediate information.

• Long-Term Memory: Stores significant historical information to guide future decisions.

Critically, these memories are converted into blockchain-based assets, ensuring their immutability and shareability.

Tools: The “Toolkit” of AI

The Tools module adopts a plugin-based architecture, supporting dynamic capability expansion and data validation. Much like humans using tools to extend their abilities, this module allows AI agents to:

• Invoke specialized tools for domain-specific problems.

• Validate on-chain and off-chain data.

• Continuously expand their capabilities through a plugin system.

By leveraging specialized toolkits and user-developed plugins, AI agents can adapt to more streamlined scenarios in vertical domains (e.g., governance, healthcare, finance), enhancing the flexibility and adaptability of decentralized intelligent decision networks.

DeAgentAI’s Lifecycle and Operating Mechanism

With these core modules in place, it is essential to understand how DeAgentAI coordinates them in practice to ensure reliable operations — akin to the birth, growth, and evolution of a living organism.

The Birth and Lifecycle of an Agent

Like DNA defining the characteristics of a living being, the “genome” of an AI agent includes:

• Lobe URI: Defines the agent’s decision model.

• Initial Memory: Establishes the agent’s foundational knowledge base.

• Tools Configuration: Equips the agent with a specific set of capabilities.

Once deployed on a decentralized network, a new agent is born. Just as humans experience birth, aging, and death, agents also have a lifecycle. If inactive for an extended period, they “hibernate,” rendering any requests to them invalid — a mechanism designed to optimize network resource utilization.

Interaction Mechanism and State Management

DeAgentAI’s interaction system draws inspiration from blockchain design while introducing unique features:

• Request Processing Workflow:

• Users initiate interactions via the agent interface.

• Requests enter an interaction pool (similar to a blockchain transaction pool).

• Executors with selection mechanisms filter requests from the pool.

• The Lobe module makes decisions using Memory context.

• State Synchronization Mechanism:

Unlike traditional blockchains, agent interactions heavily depend on their memory state. Once the state updates, pending requests become invalid, similar to how human decisions evolve with new information.

• Execution and Verification Workflow:

• Executors (some operating in TEE environments) handle user requests.

• Committers confirm results via consensus algorithms.

• Results are packaged into Memory NFTs and stored on-chain.

This design elegantly addresses the three core challenges:

• Consensus: Achieved through the network of validators.

• Identity: Ensured by producing one valid result at a time.

• Continuity: Maintained through Memory NFTs.

Practical Applications: A New Paradigm for AI Agent DAOs

A key application of the DeAgentAI framework is the AI Agent DAO, demonstrating how decentralized agents can be applied to governance:

• Proposal Initiation: By humans or AI agents.

• Decision Analysis: Using specialized decision-making tools.

• Smart Voting: Conducted by multiple AI agents based on their areas of expertise.

• Automated Execution: Final decisions executed through MPC wallets.

Like the relationship between smart contracts and dApps, DeAgentAI offers developers flexible building tools:

• Agent Interface: Simplifies user interactions.

• Customizable Tools: Supports domain-specific capabilities.

• Open Ecosystem: Encourages community-driven innovation.

This design positions DeAgentAI as not just a technical framework but as a continuously evolving ecosystem.

Future Vision: A New Paradigm for Decentralized AGI

As we look to the future of DeAgentAI, its significance transcends mere technical innovation. In the current AI landscape, both training resources and decision-making power are heavily concentrated in the hands of a few tech giants. DeAgentAI’s vision goes beyond creating individual agents; it aims to pioneer a new pathway for the development of decentralized AGI.

1. Overview

In the rapidly evolving landscape of Web3 and artificial intelligence, DeAgentAI has emerged to bridge the gap between AI models and practical applications. At its core, DeAgentAI addresses one of the most pressing challenges in the AI industry: the difficulty of deploying high-efficiency AI models in specialized scenarios. Through its innovative Proof of Insight mechanism, the platform has created a tightly coupled feedback and training process that significantly improves the accuracy and efficiency of AI models in specific use cases.

As the leading AI agent platform in Web3, DeAgentAI introduces $AIA token to power its ecosystem and create a sustainable economic model that aligns the interests of all participants. The token serves as the cornerstone of the platform’s governance, utility, and reward mechanisms, creating a robust framework for:

• Community-driven development and decision-making
• Incentivizing active participation and valuable contributions
• Supporting continuous innovation in AI agent development
• Ensuring fair distribution of ecosystem benefits
• Promoting sustainable growth through carefully designed token utility

2. Token Distribution Strategy

The $AIA token distribution is strategically designed to ensure long-term ecosystem sustainability while maintaining a strong focus on community engagement. The total token supply is distributed across five key categories:

Team and Advisor Allocation (23%)

Ensuring long-term commitment from core team members and continued platform development

Community Pool (30%)

Dedicated to rewarding active community participation, governance initiatives, and ecosystem growth

Ecosystem Fund (25%)

Reserved for protocol development, partnerships, and future ecosystem expansion

Venture Capital (14%)

Supporting strategic partnerships and securing resources for sustained growth.

Liquidity Provision (8%)

Maintaining market stability and ensuring efficient token trading

3. Token Utility and Value Proposition

3.1 Governance Rights

The $AIA token stands at the core of DeAgentAI’s governance structure, empowering holders to shape the future of the platform through direct participation in decision-making processes. Token holders can cast their votes on crucial ecosystem proposals. This governance mechanism ensures that the platform’s evolution aligns closely with community needs and preferences, creating a truly decentralized decision-making framework that benefits all stakeholders.

3.2 Platform Access and Features

Within the DeAgentAI ecosystem, $AIA tokens serve as the key to unlocking premium features and enhanced platform capabilities. Through a sophisticated token burning mechanism, holders can unlock specific agent features. This system not only provides immediate value to token holders but also introduces a natural deflationary pressure on the token supply. As users burn tokens to access advanced features, the overall supply decreases, potentially increasing the value of remaining tokens while simultaneously expanding platform utility.

3.3 Economic Incentive Model

The economic model of DeAgentAI is designed to ensure fair distribution of benefits across the ecosystem. At its foundation lies a robust buyback and burn mechanism, where ecosystem earnings are utilized to repurchase circulating $AIA tokens. Half of these repurchased tokens are burned, creating consistent deflationary pressure, while the remaining half is distributed to mining machine holders, rewarding active participants in the ecosystem.

Mining machine holders occupy a privileged position within the ecosystem, receiving priority access to token airdrops, special features, and enhanced reward multipliers. This structure incentivizes long-term participation and investment in the platform’s infrastructure.

4. Future Development and Roadmap

The future development of DeAgentAI and its $AIA token ecosystem is designed to systematically expand platform capabilities while enhancing token utility and community engagement.

The ecosystem expansion strategy centers on building a comprehensive AI agent platform that can serve diverse market needs. Following the successful launch of AlphaX, our roadmap includes the deployment of specialized agents like CorrAI for quantitative strategy configuration and MemeAI for advanced trading operations. Each new agent will be seamlessly integrated with the $AIA token ecosystem, creating additional utility and value for token holders while expanding the platform’s capabilities.

Token utility will evolve beyond its current scope through innovative applications and integrations. The platform will implement advanced feature unlocking tiers, where larger token burns will grant access to increasingly sophisticated AI capabilities. These enhancements will create new opportunities for token holders.

Community governance will undergo a gradual evolution toward complete decentralization. As the community matures, governance mechanisms will be refined based on actual usage patterns and community feedback, ensuring that the platform remains responsive to user needs while maintaining operational efficiency.

Through these strategic initiatives, DeAgentAI aims to establish itself as the premier platform for AI agent deployment in the Web3 space. The success of this vision relies on the continued engagement and support of our community, whose participation will shape the future of decentralized AI.