# Overview of DAPPOS DAPPOS builds low-barrier AI products that put powerful AI in everyone's hands, without the learning curve. Our flagship product, xBubble, is a low-prompt AI agent that turns simple requests into ready-to-use results. xBubble lowers the barrier by automatically coding, testing, and dispatching task-specific AI SOP solutions, so users can focus on their goals rather than manually coding skills or operating AI. # Introduction DAPPOS is a Web3 AI Operating System (OS) that intelligently researches, plans, and executes anything crypto-related. The Web3 AI OS is structured into two core layers: **the Intelligence Layer** and **the Execution Layer**. **The Intelligence Layer** establishes the cognitive foundation, powered by a scalable **Multi-Agent Framework (MAF)** with 300–400 specialized vertical agents and more than 200 integrated tools. This architecture enables broad Web3 generalization and adaptive intelligence, excelling across diverse domains—from quantitative analysis for trading strategies to marketing insights—while surpassing generalist AIs such as Perplexity in contextual reasoning and task-specific optimization. At the core of the Intelligence Layer lies **the Bubble Engine**, driven by continuous reinforcement learning (RL) models tailored for Web3. It evolves perpetually by ingesting real-time insights from sources such as X and Binance Square, enabling rapid, iterative adaptation to new knowledge. Through the Bubble task platform, users can accelerate this process by posting tweets that “force-feed” the system novel concepts; once verified, these are seamlessly integrated, resolving challenges that may have seemed unsolvable just days earlier. **The Execution Layer** complements the Intelligence Layer through DAPPOS’s proven Intent Execution Network—a stable, time-tested infrastructure that delivers institutional-grade efficiency and safety. Hardened by over 5 million users and 12 million transactions, it reliably transforms AI-generated plans into secure, on-chain interactions. Built on the Web3 AI Operating System, DAPPOS introduces **Instant dApps**—enabling users to create and deploy Web3 applications on demand through simple natural language interactions. The **Discover Page** acts as a dynamic hub, showcasing AI-generated insights and execution plans shared by the community. Users can browse, explore, and adopt strategies that align with their needs, executing them directly if desired. This experience mirrors vibe coding for websites or dashboards—where ideas transform seamlessly into deployable tools.
The User Jouney of DAPPOS Through the Web3 AI OS, DAPPOS unifies the fragmented Web3 landscape, enabling users to orchestrate complex actions through simple conversations as AI seamlessly coordinates across decentralized protocols. This one-stop system covers the entire Web3 lifecycle—from research and strategy design to autonomous execution—lowering barriers to entry and catalyzing innovation across the ecosystem. Ultimately, DAPPOS marks a paradigm shift for Web3, transforming it into an accessible frontier where anyone can engage, build, and create within the Web3 AI OS—unlocking the full potential of decentralized technologies for the advancement of human society.
# xBubble # What Is xBubble? xBubble is DAPPOS's flagship low-prompt AI product. It is designed for users who want to access cutting-edge AI productivity without becoming expert AI operators. Instead of asking every user to learn how to prompt, compare models, assemble tools, configure APIs, write Skills, manage runtime environments, and repeatedly test outputs, xBubble moves much of that operational complexity into the system. xBubble lets users complete tasks with simpler prompts by automatically building and dispatching task-specific AI agents. It turns short requests into deliverable work across image and video, websites, documents, research, automation, and scheduled solutions. #### A Product Built Around User Goals The product thesis is simple: Users state the goal.\ xBubble handles the AI operation. This does not mean removing user intent. Users still describe what they want, provide context, define preferences, and decide whether the result is useful. xBubble does not replace the user’s goal-setting role. Instead, xBubble reduces the technical and procedural burden that usually sits between a user’s goal and a usable AI result. In a normal AI workflow, a user may need to make a long chain of operational decisions: * Which model should be used? * How should the prompt be structured? * Which Skill, tool, API, or agent should be connected? * What runtime environment is needed? * How should intermediate results be checked? * What should happen when the output fails? * How should the workflow be reused next time? For technical users and AI power users, these decisions can be part of the workflow. For most users, they become friction. The more powerful AI becomes, the more users may need to understand model behavior, tool behavior, context design, and failure recovery in order to get stable results. xBubble is built to reduce that friction. #### From AI Capability to AI Operation Many AI products give users access to powerful models, but access alone is not enough. A user still has to operate the model correctly. This is where xBubble focuses. Model choice, prompt structure, Skill writing, tool selection, runtime setup, API configuration, and result testing move from users into the system wherever possible. The user still defines the task, but the system takes over more of the operational work required to complete it. In this sense, xBubble is not only a prompt interface. It is a product layer for operating AI capabilities on behalf of the user. #### Bubble Engine and Bubble Pilot At the architecture level, xBubble is built around two systems: Bubble Engine and Bubble Pilot. **Bubble Engine** Bubble Engine is the system that builds AI solutions. For a given task type, Bubble Engine can generate task-specific solution variants, test them, evaluate outputs, and turn stronger execution paths into reusable SOPs. Its role is to learn how a task should be solved, package that solution, and improve it over time as better execution paths are discovered. **Bubble Pilot** Bubble Pilot is the runtime dispatch layer. It reads a user request, identifies the task type, checks whether a suitable SOP exists, and routes the task to the best available solution. If no specialized SOP fits, the request can fall back to a more general execution path. Its role is to use the right AI solution for the user’s current request. **SOPs as the Link** SOPs connect Bubble Engine and Bubble Pilot. Bubble Engine creates and improves SOPs. Bubble Pilot selects and runs them. An SOP gives xBubble a reusable execution path for a specific type of task. When a request matches a verified SOP, the user does not need to manually configure the model, tool chain, runtime, APIs, MCPs, and execution logic. #### More Than a Generic AI Chat Interface xBubble is different from a generic AI chat interface. A generic interface gives users access to model capability, but often leaves users responsible for operating that capability. Users must decide how to prompt, which tools to connect, how to test the result, and how to recover from failure. xBubble is designed to package AI capability into task-specific workflows. The goal is to help users get closer to finished work with fewer prompts, less trial-and-error, and a lower learning curve. #### More Than a Skill Marketplace xBubble is also different from a simple marketplace of isolated tools or Skills. An xBubble SOP is not only a Skill. It can package the Skill, runtime environment, APIs, MCPs, model selection, and execution logic required for a specific task type. This matters because real AI output quality often depends not only on the prompt, but also on the surrounding environment: * Which model is selected * Which tools are available * Which APIs are connected * Which runtime environment is used * How the task is executed * How the output is evaluated * Whether the workflow has been tested for the task type By packaging these elements together, xBubble aims to reduce the number of configuration decisions that users must make themselves. #### xBubble in the DAPPOS Ecosystem In the DAPPOS ecosystem, xBubble serves as the flagship general AI productivity product. It applies DAPPOS’s AI operating system approach to everyday and professional workflows such as documents, slides, websites, images, videos, research, automation, scheduled tasks, and Bubble Code workflows. As models, coding agents, APIs, MCPs, and tool ecosystems continue to evolve, xBubble’s role is to make these capabilities easier to operate through reusable, task-specific AI solutions. xBubble is built for users who know what they want, but do not want to learn how AI is operated. AI should learn AI.\ AI should use AI.\ Users should state goals.
# Why Low-Prompt AI AI capability is improving rapidly, but usability remains a major bottleneck. The strongest AI models can already produce high-quality outputs across many domains. However, access to a powerful model does not automatically create a reliable workflow. The same model can produce excellent results for an experienced user and disappointing results for an ordinary user, depending on how the task is framed, which tools are connected, how context is supplied, how outputs are tested, and how failures are corrected. #### The Usability Gap This creates a widening usability gap. Power users can study model behavior, research tool combinations, debug failed outputs, compare different agents, build or modify Skills, configure APIs, and re-learn workflows after every model update. They can treat AI operation itself as a skill. Most users do not want to do that. They want to turn goals into usable results. They want to create a document, generate slides, build a website, produce an image or video, research a topic, automate a workflow, or create a business-facing software flow. They do not want to become model selectors, prompt engineers, tool integrators, runtime managers, API operators, and QA testers at the same time. #### Low-Prompt Does Not Mean No Intent Low-prompt AI is DAPPOS’s answer to this usability problem. Low-prompt AI does not mean the user provides no information. It means the user should not need to manually operate every layer of the AI workflow. The user still provides: * Intent * Context * Examples * Constraints * Preferences * Feedback when needed But the system should absorb more of the operational complexity required to turn that intent into a finished result. The goal is not to make prompts shorter for their own sake. The goal is to reduce the amount of AI operation users must perform before receiving a usable result. #### AI Workflows Are Becoming More Complex The need for low-prompt AI becomes clearer as AI workflows become more complex. A high-quality task may involve multiple steps: * Understanding the user’s intent * Selecting the right model or agent * Loading the right Skill or workflow * Connecting tools, APIs, MCPs, or files * Preparing the runtime environment * Executing intermediate steps * Checking whether the output matches the requirement * Revising the execution path if the result is not good enough * Packaging the final result into a usable format Even if each step is possible, asking every user to coordinate all of them creates a high learning curve. The bottleneck is no longer only model intelligence. The bottleneck is whether the user can reliably operate the surrounding workflow. #### The xBubble Inversion xBubble closes this gap by inverting the relationship: Bubble Engine does the learning.\ Bubble Pilot does the using.\ Users state the goal. In many AI products, the user learns the tool. The user discovers which prompt works, which model fails, which Skill is useful, which API is needed, and which workflow is stable. In xBubble, the system is designed to learn repeatable task patterns and convert them into SOPs. Once a task type becomes standardized, future users should not need to rediscover the same operating method from scratch. #### Why SOPs Matter SOPs are central to xBubble’s low-prompt approach. An SOP gives the system a tested execution path for a specific type of task. Instead of asking the user to configure the model, tool chain, runtime, APIs, MCPs, and execution logic manually, xBubble can route a matching request to an SOP that has already been built and tested for that kind of work. This makes low-prompt AI more than simply writing shorter prompts. The real objective is to reduce the number of operational decisions the user must make before receiving a usable result. A low-prompt AI product should therefore optimize for: * Less model selection by the user * Less prompt engineering by the user * Less manual tool configuration * Less runtime setup * Less API and MCP configuration * Less repeated testing * Less workflow rebuilding * More reusable execution paths * More stable task-specific outputs * More direct movement from user goal to usable result #### From Raw Capability to Capability Orchestration xBubble is built around this shift. As AI models continue to improve, the product challenge is moving from raw capability access to capability orchestration. Users will not only care which product has access to a strong model. They will care which product can turn models, agents, tools, Skills, APIs, MCPs, and runtimes into stable workflows that produce results with less effort. Low-prompt AI is the user experience layer for that transition. #### Who Low-Prompt AI Is For For technical users who already know how to use coding agents, build Skills, configure APIs, and debug workflows, xBubble does not need to replace their existing process. But for general users, professionals, creators, small businesses, and non-technical operators, xBubble offers a different path: use AI through task-specific SOPs instead of learning the entire AI operating process. The user states the goal.\ xBubble handles the AI operation.
# How xBubble Works xBubble is built around three components: 1. Bubble Engine 2. Bubble Pilot 3. SOP System Bubble Engine creates and optimizes SOPs. Bubble Pilot selects and runs them. SOPs are the packaged task-specific solutions that connect the two systems.
# Bubble Engine Bubble Engine is the solution factory. For a specified task, Bubble Engine uses AI coding agents to generate solution variants, build test harnesses, combine candidate models and tools, and evaluate outputs against task examples and quality criteria. The strongest route becomes a Standard Operating Procedure, or SOP: a reusable solution dispatched whenever a similar request appears, after Bubble Engine tests its versatility. # Bubble Pilot Bubble Pilot is the runtime dispatch layer. Bubble Pilot reads a trigger, identifies the task type, and checks for a matching SOP. If one fits, the user gets a task-optimized execution path. If not, Bubble Pilot can fall back to a general-purpose agent. Recurring fallback requests inform what Bubble Engine builds next. Repeated patterns become candidates for new SOPs. # SOP System An SOP is xBubble's packaged solution for a specific type of task. SOP = Skills + runtime + APIs + MCPs + model selection A Skill alone is not always enough. The result also depends on the runtime environment, the model used, the available APIs, the connected MCPs, and how the task is executed. xBubble packages these parts together so the user does not need to configure them separately. Compared with a normal Skill marketplace, xBubble's SOP system emphasizes three advantages: **Stable Performance** An SOP does not only include a Skill. It also includes the runtime environment, model choice, MCPs, and third-party APIs needed for the task. SOPs are also used within tested scopes. When a user's task matches the SOP's verified range, the output is more stable. **Easy to Use** An SOP takes the user's task description as the main input. Users do not need to choose a model, configure APIs, compare multiple Skills, or debug the execution process. Bubble Pilot selects the suitable SOP and runs it. This moves the operational burden from the user to the system. **Self-Generated SOPs** Developing a good Skill requires testing, debugging, and optimization. For non-technical users, this can be difficult and time-consuming. For many needs, Bubble Engine can help users generate specialized SOPs without requiring them to write or debug Skills themselves. SOPs can be general, or they can be narrower solutions for a specific user or company requirement.
# How xBubble SOPs Are Trained xBubble uses Bubble Engine to train and improve SOPs. The goal is to generate SOPs that can produce results matching the user's needs. Training is built around cases. Users can provide examples they consider good results, such as a previous manual output, a reference video ad, a document format, or another result they want the SOP to follow. If there are not enough examples, Bubble Engine can search for references or use AI-generated examples. After the cases are confirmed, Bubble Engine derives prompt-result pairs from them. These pairs are used to guide SOP generation and evaluation. During iteration, Bubble Engine uses coding agents to build specialized SOPs based on baseline SOPs. The generated SOP is tested, and the output is evaluated in two ways: 1. Whether the result satisfies the user's stated requirements. 2. Whether the result is close enough to the provided examples. Based on the evaluation, the coding agent revises the SOP until the result can no longer be improved meaningfully. Before an SOP is added to the system, Bubble Engine also defines its applicable scope. The goal is to make sure Bubble Pilot recommends a specialized SOP only when it is likely to perform better than a general SOP.
# Bubble Code # What Is Bubble Code? Bubble Code is xBubble's software-building mode, built on top of xBubble's SOP system. It follows the same philosophy behind xBubble: instead of asking every user to become a sophisticated vibe coder, xBubble packages complex AI workflows into task-specific SOPs. With Bubble Code, that same SOP logic is applied to software generation and software modification. The user states the business goal. Bubble Code runs the right Coding SOP.
# Why Current Coding Agents Are Still Difficult for Non-Technical Users Today's coding agents are powerful, but they still assume a certain level of technical understanding. For developers, this is not a problem. A developer can read generated code, inspect errors, decide which architecture to use, configure services, test the output, and deploy the application. For non-technical users, the experience is different. **Technical Setup** Building and launching a software project often involves domain names, servers, hosting, databases, third-party APIs, deployment environments, configuration files, and service accounts. Even if AI provides instructions, users still need to understand what each part means and how to make the right choice. **Technical Decision-Making** A coding agent may ask questions such as: Do you need an admin panel? How should order status be managed? What user roles are required? What happens when a form submission fails? How should data be stored? These questions are normal for developers, but difficult for users without a software background. **Product Requirements** A business owner may say, "I want to create an online store," but that simple sentence includes many hidden steps: product pages, product images, descriptions, customer information, order state management, fulfillment status, backend access, and future edits. The problem is not only whether AI can write code. The problem is whether ordinary users can turn a business idea into a clear, executable software workflow.
# From xBubble SOPs to Bubble Code Bubble Code is a collection of Coding SOPs and packaged AI-accessible third-party services. Together, they help users move from business intent to working software without having to manage every technical layer themselves. Bubble Code reduces the last-mile gap in three ways. **Packaged Third-Party Services** Many projects require services outside the codebase: domains, servers, cloud hosting, DNS, SMS, payments, model APIs, and other infrastructure. Users can choose trusted service providers themselves, or let AI match them with suitable providers. These service providers handle procurement, configuration, deployment, and support. Eligible services can be consumed through xBubble credits, so users do not need to manage separate technical accounts and payment processes one by one. xBubble focuses on the software-building workflow, while service providers can support the infrastructure layer.
**Scenario-Specific Application Workflows** For many business types, key technical decisions can be standardized or delegated to AI. The user can focus on business-facing questions: what they want to sell, what customer flow they need, and what basic rules should apply. **SOP Iteration** Some cases still require additional help. When a user cannot answer a technical question, or when the current SOP does not cover a specific case, a service provider or xBubble's Bubble Solution process can help refine the workflow. This is the shift from prompt-to-code to SOP-to-business.
# Coding SOPs: From Idea to Live Business Bubble Code focuses on business workflows, not demo pages. A demo page only proves that AI can generate code. A live business needs a page, a user flow, login, payment, backend records, service configuration, and a path for future updates. One important use case is Web3-enabled commerce and service sales. A user may want to sell products, digital goods, service packages, event access, consulting sessions, or community-related merchandise. Bubble Code can package the basic workflow: * Brand elements * Page structure * Product or service media and description * Wallet login * Stablecoin payment * Order records * Backend management * Launch materials The user does not start from a template. The user starts from what they want to sell. # Bubble Solution For especially complex cases, such as SOPs that require paid third-party APIs or tasks where current models are not strong enough, xBubble can also provide human-assisted solutions for enterprise customization. As AI models improve, fewer cases should require this extra assistance. # Bubble Computer Bubble Computer is xBubble's end-to-end project workspace. When Bubble Pilot detects multi-step work, it routes to Bubble Computer, where a sandbox spins up and specialized skills load on demand. Within a single run, xBubble can research a topic, draft documents, generate visual assets, verify claims, and deliver a final output. The user states the goal once. Bubble Computer handles model selection, tool routing, and step coordination. # Bubble Personal Bubble Personal is xBubble's local-environment mode. It operates across local files, browsers, apps, and schedules. It can automate website operations that need personal accounts, generate morning briefings from calendar and inbox, organize photos, or collect market data overnight. Bubble Personal uses a sandboxed execution model. Installations and system-level changes happen inside cloud containers destroyed after task completion. On the user's machine, only explicitly authorized actions execute, with heavy compute and risky operations kept in Bubble Cloud and clean results flowing back locally. # Supported Tasks xBubble runs in three modes: * Fast mode: for simple daily tasks. * Work mode: for stable, professional results using SOPs. * Code mode: for building software and business Supported task types include but not limited to: * Voice Dictation * Text to Speech * Talking Avatar * Deep Research * Slides Creation * Docs Creation * Fact Check * Scheduled Tasks * Poster Creation * Image Creation * Video Creation * Website Development # Looking Forward: Toward Near-Zero Barriers The first stage of AI coding asked: can AI write code? The next stage asks a more important question: can AI help more people launch businesses? Web3 reduces friction in login, payment, and digital ownership. xBubble reduces friction in software generation, service configuration, and business workflow creation. Service providers help complete the infrastructure layer. Coding SOPs hide unnecessary technical complexity and expose the business decisions users actually understand. This does not mean every business can be built without human judgment. It means users should not need to become software engineers before they can test a business idea. xBubble is not here to make everyone become a programmer. It is here to make software building feel closer to business building. # Security ### User autonomy In the DAPPOS execution network, each user has their own unified account. No role other than the user themselves can control or authorize any assets within the unified account. Advanced users can programmatically separate control permissions and enjoy services such as delegated execution. The team retains the authority to add or remove interoperable public chains, but the chains where abstract accounts are deployed will always remain supported. This means that even if all roles in the DAPPOS intent execution network cease to operate, users can still directly interact with public chains to control their accounts and assets. ### Decentralized Validation The execution of Custom Value-Specific tasks operates through a market mechanism, and the supervision of the execution results is a decentralized process involving execution validators in the DAPPOS Intent Execution Network. We employ a Game-theoretic equilibrium model and utilize slashing as a method to governance this POS system. Anyone can raise a challenge against the execution results of a service node. If the challenge is voted through by the execution validators, anyone can participate in the liquidation and earn the service node's collateral.
# External Audits Security always comes first at DAPPOS. We ensure public verification of our smart contract code and collaborate with top security firms for thorough validation. ### DAPPOS Audit Reports Audit reports are all open for review, showcasing our commitment to transparency. We're actively collaborating with leading security audit firms to thoroughly assess our smart contracts, reinforcing our dedication to a secure ecosystem with no vulnerability.
AuditorDateStatusAudit Link
HalbornNovember 2025Completed Token Audit
HalbornJuly 2026CompletedStaking Contract
## Audit Report PDFs ### Halborn {% file src="/files/6gbjOrBcQjyXwYNS7iQY" %} {% file src="/files/OIk3VckQjNl2lwOV9ZkA" %} # Bug Bounty Check out the official bug bounty program for DAPPOS (coming soon) # Withdraw Delay ### Withdraw Delay All service providers participating in the DAPPOS Intent Execution Network are required to undergo a 14-day delay when exiting the system. This is to ensure that all value-specific tasks participated in by the service providers have been successfully completed and have passed the period of righteous challenge. Similarly, all validators participating in staking and voting have a 14-day withdrawal delay to ensure that validators have faithfully fulfilled their responsibilities during the staking period. Validators can withdraw their staked governance tokens only after all challenges they have participated in have concluded and passed the cooldown period.
# Others # Web3 AI OS（Retired） # What Is Web3 AI OS? #### ***This product has been retired. This page is retained for historical reference only and does not describe our current product offering. Just get started with xBubble.***
Web3 AI OS is DAPPOS's crypto-native AI product for researching, planning, and executing Web3-related tasks. As one product in the DAPPOS portfolio, Web3 AI OS specializes in DAPPOS's AI operating system for crypto-native workflows. It is structured into two core layers: 1. The Intelligence Layer 2. The Execution Layer The Intelligence Layer establishes the cognitive foundation, powered by a scalable Multi-Agent Framework with 300–400 specialized vertical agents and more than 200 integrated tools. At the core of the Web3-focused Intelligence Layer lies the Bubble Engine, driven by continuous reinforcement learning models tailored for Web3. It ingests real-time insights from sources such as X and Binance Square, and incorporates user-submitted insights through the Bubble task platform. The Execution Layer complements the Intelligence Layer through DAPPOS's Intent Execution Network, which transforms AI-generated plans into secure, on-chain interactions.
# Core Features of Web3 AI OS #### ***This product has been retired. This page is retained for historical reference only and does not describe our current product offering. Just get started with xBubble.*** **Multi-Agent Framework** With 300–400 specialized vertical agents and more than 200 integrated tools, the Multi-Agent Framework delivers comprehensive Web3 generalization, covering domains such as quantitative analysis, trading strategies, and market intelligence. **Web3-Focused Bubble Engine** The Web3-focused Bubble Engine is a reinforcement learning engine for Web3 intelligence. It continuously learns from real-time sources such as X and Binance Square. Through the Bubble task platform, users can contribute new knowledge directly, accelerating integration and adaptation. **Intent Execution Network** The Intent Execution Network supports execution of AI-generated plans, transforming complex intents into secure on-chain actions.
# Generic AI vs. Web3 AI OS #### ***This product has been retired. This page is retained for historical reference only and does not describe our current product offering. Just get started with xBubble.*** \ As AI permeates every industry, **generic, one-size-fits-all models are no longer sufficient**. Web3 requires a vertical AI—one that deeply understands its domain, reasons within domain-specific constraints, and executes user intents with reliability. General-purpose AI models, such as those behind assistants like ChatGPT or Perplexity, are designed for universal applicability. They excel at tasks like summarizing articles or generating code by leveraging vast amounts of general knowledge through large language models. Yet in the specialized realm of Web3—spanning decentralized finance (DeFi), non-fungible tokens (NFTs), meme coins, and broader blockchain ecosystems—these models fall short in two critical areas: **Intelligence** and **Execution**. ## Intelligence: Generic AI's Limitations and Web3 AI OS's Superiority Intelligence in AI refers to the ability to gather, contextualize, and reason over information to produce actionable insights. Generic AI models, constrained by pre-trained corpora and general web scraping, lack the depth and adaptability required for Web3’s opaque, fast-moving environment. ### Lack of Domain-Relevant Data Sources Generic AI cannot securely or directly access user-specific, real-time blockchain data. For example, when advising on a DeFi strategy—such as optimizing recursive lending across protocols—Generic AI cannot fetch wallet balances, transaction flows, or on-chain risk metrics without external integrations, leaving users with vague, boilerplate recommendations. By contrast, Web3 AI OS integrates directly with blockchain APIs and user-authorized data. It can analyze wallet behaviors, query protocol risk exposures, and simulate yield loops in real time, producing precise and personalized strategies grounded in on-chain truth. ### Improper Weighting in Information Processing Generic AI applies uniform priors from broad training data, often misjudging Web3’s high-signal events. For instance, a meme coin’s collaboration with a major brand (e.g., Pengu’s activity with a top label) or a token’s subtle ties to Binance might be dismissed as noise, even though such signals frequently drive short-term momentum and liquidity. Similarly, project evaluations from Generic AI default to generic metrics—team backgrounds, whitepapers, technical architecture—while overlooking exchange listings, community traction, or partnership leaks that seasoned users treat as critical alpha. Web3 AI OS, powered by the continuous RL-driven **Bubble Engine**, assigns adaptive weights to Web3-specific signals. In the meme coin example, DAPPOS would flag the collaboration as a bullish trigger, cross-reference it with social sentiment, trading volume spikes, and historical meme coin precedents, then forecast potential upside. In project analysis, it would surface hidden affiliations with major exchanges as key catalysts—delivering insights aligned with how Web3 participants actually assess opportunities. ### Misunderstanding Web3 Nuances and Implicit Rules Web3 is rife with implicit rules, slang, and deceptive practices that Generic AI often misreads. A token boosted by bots or paid promotions may appear “popular” to a generic model, while emerging jargon or coded signals slip past its outdated training set—resulting in misleading outputs and overlooked red flags. Web3 AI OS embeds domain expertise directly into its agents. It filters out manipulation by detecting anomalies such as clustered wallet activity or suspicious liquidity inflows, and it continuously adapts to new slang and norms through user-submitted insights on the Bubble platform. This ensures its analyses remain current, accurate, and resistant to common Web3 pitfalls. ## Execution: From Insight to Action Execution is the critical step of turning reasoned plans into tangible outcomes—something Generic AI cannot achieve due to its advisory-only nature. Even when it produces a sound strategy, users must manually navigate wallets, DEXs, and bridges, contending with gas fees, slippage, and cross-chain complexity. Web3 AI OS closes this gap with its dedicated Execution Layer, exemplified by DAPPOS’s Intent Execution Network. Battle-tested with over 12 million transactions and 5 million users, it autonomously manages on-chain operations with institutional-grade security and reliability. A defining strength of DAPPOS is its ability to make insights instantly actionable and shareable. Through the Discover Page, users can publish AI-generated strategies and execution plans, creating a dynamic hub where the community can explore, adopt, and deploy them directly. Generic AI lacks this capability, leaving a gap between intelligence and real-world utility. Web3 AI OS completes the loop—from intelligent research and planning to seamless execution and collaborative deployment—transforming insights into value and accelerating innovation across the decentralized ecosystem. In summary, while Generic AI provides broad utility, its shortcomings in Web3-specific intelligence and execution make it insufficient for the demands of crypto. Web3 AI OS—exemplified by DAPPOS—marks the next modular evolution: specialized, adaptive, and actionable, empowering users to innovate and build without barriers.

# Intelligence Layer #### ***This product has been retired. This page is retained for historical reference only and does not describe our current product offering. Just get started with xBubble.*** # I. Core Components The Intelligence Layer of DAPPOS forms the cognitive backbone of the Web3 AI Operating System, orchestrating research, planning, and decision-making for crypto-related tasks. It is structured of two core components: the **Multi-Agent Framework (MAF)** and the **Bubble Engine**, which together enable scalable, adaptive intelligence tailored to Web3's dynamic environment. The Multi-Agent Framework (MAF) serves as the orchestration module, comprising 300–400 specialized vertical agents and over 200 integrated tools. Built on a stateful graph backbone, MAF facilitates composable autonomy through deterministic routing, subgraphs for tasks, and advanced features such as multi-agent search and tool-augmented generation. This ensures explainable, production-grade AI that excels in domain-specific reasoning and generalization across quantitative analysis, trading strategies, and market insights. Complementing MAF, the Bubble Engine acts as the adaptive learning core, powered by continuous reinforcement learning (RL) models optimized for Web3. It perpetually evolves by ingesting real-time data from sources like X and Binance Square, incorporating user-contributed insights via the Bubble task platform. Key mechanisms include Contextual Retrieval-Augmented Generation (RAG) for provenance-first data aggregation and Compound Memory for blending durable knowledge with episodic learnings, while handling misinformation and leveraging Web3 incentives for collaborative growth. Together, MAF and the Bubble Engine help DAPPOS create a synergistic system that outperforms generic AI in Web3, delivering excellent and evolving intelligence ready for the Execution Layer.
# II. Multi-Agent Framework (MAF) The Multi-Agent Framework (MAF) in DAPPOS represents a groundbreaking evolution in AI orchestration for Web3, guaranteeing explainable AI decisioning and production-grade reliability. ### Stateful Graph Backbone: The Foundation of Composable Autonomy At the core of MAF lies the **StateGraph**, a structured state schema composed of a collection of variables that forms the backbone for all operations. The StateGraph encapsulates key system elements such as messages for inter-agent communication, plans for structured workflows, artifacts (e.g., data outputs or models), UI interrupts for human oversight, final outputs, errors for robust handling, and flags for conditional logic. These variables are passed seamlessly across each state in the system, serving as the decision-making foundation for controller nodes at each stage. In MAF, each **node** represents an AI agent for a designed task. Specifically, **controller nodes** evaluate the current state to determine the next flow direction and update the state variables accordingly. The process of a user query begins with the main controller `task_planner_node`, which analyzes user intents to classify the task type—such as information gathering, strategy execution, or alpha detection—and deterministically routes it to the appropriate subgraph (search, DeFi, or opportunity).
Within each **subgraph**, specialized controller nodes handle internal flows, ensuring predictable paths that minimize variability and enhance trust in dynamic Web3 environments. This setup powers deterministic controllers and AI interrupt mechanisms, preventing errors while allowing freedom in AI decision-making. ### Subgraphs: Specialized Modules for Web3 Intelligence MAF's subgraphs are modular building blocks, each tailored to specific Web3 domains with deterministic node flows that process data efficiently. These subgraphs leverage the stateful backbone to integrate seamlessly, enabling adaptive intelligence across trading, analysis, and execution. For example: * **Search Subgraph**: This subgraph combines autonomous controllers with enhanced review cycles for continuous deepening and refinement, embodying an agentic search loop. The flow starts with `search_controller_node` that selects and parallelizes agents (e.g., `google_search_agent_node` for web data, `twitter_search_agent_node` for social sentiment, `parallel_search_coordinator_node` for multi-source queries). Outputs are merged in `merge_results_node`, filtered for relevance, and refined through an iterative enhanced review loop until confidence criteria (e.g., source diversity or accuracy scores) are met, which is checked by `enhanced_search_review_node`. The `summarize_node` then produces cited answers with frontend-friendly markers, ensuring transparency and usability.

Search Subgraph

* **DeFi Subgraph**: Centered on tool-augmented execution, this subgraph generates and validates DeFi strategies using over 200 integrated tools for precise operations like API queries or trade simulations. It begins with `fetch_market_data` to retrieve real-time blockchain metrics, followed by `strategy_generator` to create optimized plans (e.g., yield farming or liquidity provision). The `strategy_validator` closes the loop by assessing risks, simulating outcomes, and incorporating optional user choices.

DeFi Subgraph

* **Opportunity Subgraph**: This subgraph identifies high-potential Web3 opportunities by scanning markets, trends, and signals. It flows through `opportunity_search_node` for initial detection, `fetch_market_data` for validation, and an `opportunity_node` that synthesizes insights into actionable recommendations, such as emerging meme coins or protocol upgrades.

Opportunity Subgraph

### Advanced Features: Enhancing Collaboration, Execution, and Interactivity Building on the core subgraphs, MAF incorporates advanced capabilities to foster human–AI synergy and real-time adaptability. * **Multi-Agent Search**: Central to the search subgraph, this feature enables autonomous and collaborative intelligence, where a controller dynamically selects agents based on query complexity for parallel execution, boosting speed and breadth. For example, evaluating a meme coin's potential might invoke Google agents for news, Twitter agents for sentiment, and parallel custom agents for on-chain data. The enhanced review loop iterates refinements, and the summarizer outputs structured, cited responses optimized for frontend display, with HCI interrupts for real-time oversight in mission-critical actions. * **Tool-Augmented Plan Generation**: Particularly prominent in DeFi and opportunity subgraphs, this integrates structured tools to transform abstract insights into executable strategies. Validator nodes ensure safety by cross-checking against risk parameters, with optional UI interrupts for user approvals, closing the intelligence-action loop and preparing plans for seamless handover to the Execution Layer. * **Streaming and Interrupts**: To support interactive experiences, MAF streams messages during long-running tasks, keeping users informed in real-time. When user queries or provided information are insufficient for accurate analysis, the AI pauses execution to seek clarification by prompting the user with targeted questions, ensuring completeness and reliability. In essence, DAPPOS's Multi-Agent Framework redefines Web3 intelligence by combining composable autonomy with safety rails, enabling users to tackle complex tasks with unprecedented precision and adaptability. This framework not only outperforms generic AIs in domain-specific reasoning but also paves the way for collaborative, evolving ecosystems where AI and humans co-create value.
# III. Bubble Engine: Continuous RL Improvement At the core of DAPPOS's Intelligence Layer is the Bubble Engine, a Web3-focused reinforcement learning (RL) engine that drives perpetual evolution and adaptive intelligence. Powered by advanced mechanisms like **Contextual Retrieval-Augmented Generation (RAG)** and **Compound Memory**, the Bubble Engine transforms fragmented Web3 data into coherent, actionable intelligence. ### Contextual RAG: Provenance-First Intelligence Aggregation The Bubble Engine's Contextual RAG forms the backbone of its information processing, unifying diverse sources—web content, internal documents, and on/off-chain signals—into a provenance-first context layer that prioritizes traceability and reliability. This hybrid retriever combines dense (semantic) and sparse (keyword-based) techniques with domain-specific routing to orchestrate sub-queries efficiently. It deduplicates redundant results, reranks them using cross-encoders for relevance, and assembles a minimal sufficient evidence pack tailored to the query's needs. The generation process is citation-locked, producing 1]-style inline references with graceful fallbacks when evidence is limited. Dynamic budgets intelligently adjust retrieval depth and parallel agent execution based on detected uncertainty levels, optimizing for efficiency in volatile Web3 scenarios. Episodic memory captures short-term learnings from recent interactions, while long-term memory preserves confirmed facts for future recall. Looking ahead, DAPPOS sets the stage for multimodal RAG (incorporating images, videos, and audio) and graph-based extensions, enabling richer contextual intelligence that connects entities, relationships, and temporal dynamics across the blockchain landscape. ### Compound Memory: Durable and Episodic Knowledge Evolution Complementing Contextual RAG, the Bubble Engine's Compound Memory integrates durable knowledge—core, verified Web3 facts and models—with episodic learnings accumulated over time. This approach ensures the engine retains timeless domain expertise (e.g., DeFi protocols and blockchain fundamentals) while dynamically incorporating transient insights, such as real-time market shifts or user-submitted alphas. As new knowledge is verified and integrated, the memory system evolves, creating a compounding effect that enhances reasoning accuracy and personalization. ### Handling Misinformation and User Incentives To maintain integrity in Web3's deception-prone environment, the Bubble Engine employs advanced fake information handling, cross-verifying sources against on-chain data and community flags to detect and mitigate bots, pumps, or manipulated signals. Additionally, Web3 incentives motivate users to share high-fidelity insights, accelerating collective intelligence growth. In summary, the Bubble Engine redefines adaptive AI for Web3 by blending continuous RL with sophisticated retrieval and memory systems, delivering hyper-relevant, trustworthy insights that evolve in lockstep with the ecosystem.
# IV. Innovations and Future The Intelligence Layer of DAPPOS introduces transformative innovations that redefine AI's role in Web3, blending scalable orchestration with perpetual learning to deliver unparalleled intelligence. By synthesizing the **Multi-Agent Framework (MAF)** and the **Bubble Engine**, the Intelligence layer achieves composable autonomy, explainable decisioning, and adaptive reasoning—far surpassing generic AIs in handling the ecosystem's volatility and complexity. Key innovations in MAF center on its stateful graph backbone, the StateGraph, which maintains a typed state as the single source of truth for elements like messages, plans, artifacts, and UI interrupts. This foundation enables hierarchical orchestration through deterministic controllers, routing intents seamlessly to specialized subgraphs for search, DeFi, and opportunity tasks. The agentic search loop in the search subgraph, with parallel agents and enhanced review cycles, powers self-directed exploration, while tool-augmented execution in DeFi and opportunity subgraphs generates validated strategies with human-in-the-loop safeguards via HCI interrupts. Advanced features like multi-agent collaboration, streaming progress, and safety rails ensure trustworthy autonomy, fostering human–AI synergy and production-grade reliability. Complementing MAF, the Bubble Engine drives continuous reinforcement learning (RL) for rapid adaptation, ingesting real-time insights from sources like X and Binance Square. Its Contextual RAG unifies web, internal, and on/off-chain data through a hybrid retriever with domain routing, deduplication, reranking, and citation-locked generation—optimized by dynamic budgets and episodic/long-term memory. Compound Memory layers durable Web3 knowledge with bubble-driven episodic learnings, while robust misinformation handling via cross-verification and Web3 incentives for user contributions accelerate collective evolution. Looking ahead, DAPPOS envisions expanding these innovations into a fully decentralized intelligence ecosystem. Future iterations will integrate multimodal RAG for processing images, videos, and audio alongside graph-based extensions to map intricate blockchain relationships and temporal dynamics. Enhanced RL models will enable predictive simulations of market scenarios, while deeper MAF composability could support more user-defined subgraphs for custom Web3 workflows. Ultimately, this trajectory positions DAPPOS as the cornerstone of Web3's AI-native future, empowering seamless innovation, democratizing access to decentralized technologies, and catalyzing a new era of collaborative value creation across global ecosystems.
# Execution Layer #### ***This product has been retired. This page is retained for historical reference only and does not describe our current product offering. Just get started with xBubble.*** # I.Background and Problem Statement ### Problems Blockchain technology, heralded as a transformative force for decentralization, trust, and security, has experienced significant growth and innovation since its inception. The decentralized nature of blockchain ensures that no single entity has control over the entire network, thereby enhancing security and trust among participants. However, despite its potential, blockchain technology faces several limitations and challenges that impede its mass adoption. The contemporary blockchain economy is restricted to services that can be defined by mathematical formulas. For instance, Uniswap functions as a platform connecting liquidity providers and token purchasers. These liquidity providers are limited to offering services based on preset formulas, such as selling tokens at a specific rate. This restriction hampers the development of more complex and diverse services. Moreover, users encounter significant inefficiencies due to the inability to outsource tasks effectively. For example, a user desiring to sell tokens across multiple chains faces a cumbersome process in identifying service providers and often resorts to manual operations. In contrast, many Web2 tasks can be outsourced seamlessly, providing a far smoother user experience. Additionally, certain tasks remain unsolvable within the current on-chain framework. For example, the purchase of Web2 services using on-chain tokens is problematic due to the absence of permissionless trust in smart contracts. Tasks requiring time-bound execution or specific constraints are unmanageable on-chain. Nevertheless, if outcomes can be verified fairly and users accept predefined compensation, these tasks could be securely outsourced to a service provider. Furthermore, users are reluctant to approve contracts that access their accounts due to security concerns, necessitating manual confirmation of every detail, such as transaction fees, cross-chain operations, and private key management. To address these limitations, the DAPPOS Intent Execution Network emerges as a compelling solution to streamline user interactions within the blockchain ecosystem. This network connects users with service providers, enhancing the efficiency of outsourcing tasks in a decentralized environment. Analogous to real-world platforms like eBay and DoorDash, where users can communicate and collaborate with service providers efficiently, a similar level of efficiency is now attainable on-chain. DAPPOS mitigates security concerns by allowing users to delegate tasks securely to service providers. This solution not only resolves existing usability issues but also extends the capabilities of Web3 applications, enabling the creation of new services previously unattainable. For example, Ethereum smart contracts are currently limited by predefined mathematical formulas, restricting the complexity of services they can provide. An illustration of this limitation is Uniswap, where liquidity providers can only offer services based on preset formulas, without accommodating more complex requirements. DAPPOS facilitates the provision of sophisticated services akin to real-world delivery services such as DoorDash, where users do not have to worry about delivery personnel absconding with their funds. Moreover, DAPPOS enables transactions such as converting USDT to USD through services like PayPal, or using on-chain assets to subscribe to Web2 services such as OpenAI. By expanding the range of verifiable outcomes and ensuring user compensation for unmet services, DAPPOS fosters a broader array of decentralized and secure interactions.
The DAPPOS Intent Execution Network provides a decentralized framework to fulfill user intents, simplifying and securing the outsourcing of tasks. Users can specify their needs, and a network of third-party service providers can meet these intents, ensuring both security and efficiency. This innovative approach not only addresses the current limitations but also paves the way for new, complex Web3 applications, significantly enhancing the user experience within the decentralized economy. ### Introduction to Intent Intent, in the context of blockchain transactions, refers to the desired outcomes that users want to achieve, rather than specifying the exact steps needed to reach those outcomes. For instance, instead of detailing every interaction with smart contracts, nonce management, and gas payments, users can express their desired result in a straightforward manner, leaving the intricate execution details to sophisticated third parties. This approach not only simplifies user interactions but also enhances efficiency by leveraging the expertise of third-party executors. Intents can range from basic needs to broader, more complex requirements. As long as users are willing to pay a certain cost and expect a specific result, intents can cover a wide variety of demands. For example: 1. Buying BTC with 1000 USDT. 2. Receiving a specified amount of USD in a certain bank account. 3. Spending a certain amount of USDT or USD to receive the latest iPhone. In conclusion, a common definition of intents is "I want X and I’m willing to pay up to C." Intents can be considered as signed messages that allow for a set of state transitions from a given starting state. Unlike traditional transactions that specify a unique computational path, intents allow for any path that satisfies certain constraints. This flexibility enables the matching of overlapping intents, increasing gas and economic efficiency.
### Current Intent-based Systems and Their Limitations Current intent-based systems can be broadly classified into several categories based on their design and functionality: 1. Limit Orders and Auctions: Systems like CowSwap and 1inch Fusion utilize limit orders and batch auctions to match intents. These systems focus on finding the best execution prices by promoting competition among liquidity providers. However, they are often limited to specific use cases and lack the flexibility to handle more complex intents. 2. Account Abstraction (AA): Proposals like EIP 4337 introduce account abstraction, allowing users to express intents at the wallet level. This approach decouples accounts from signers, enabling custom authorization logic tailored to users' needs. However, it introduces new complexities and requires substantial changes to Ethereum’s core protocol. 3. Generalized Intent Infrastructure: Projects like Anoma and Essential aim to provide a comprehensive intent-based architecture. Anoma, for instance, utilizes a homogeneous protocol with a heterogeneous security model, allowing for decentralized counterparty discovery and solving. Essential, on the other hand, focuses on providing a modular intent layer and a new constraint-based language for more efficient intent executions. However, these projects are still under development and not accessible to users. While intent-based designs offer significant improvements over traditional transaction methods, they are not without limitations. Current solutions often face several critical issues: 1. Limited Generalizability: Due to the constraints of current validation mechanisms, intent-based systems often lack the flexibility to be applied across a wide range of decentralized applications (dApps). These systems are typically designed to solve specific problems and are not adaptable to various use cases. For example, a system optimized for limit orders may not be suitable for more complex intents such as cross-chain transactions or interactions with multiple DeFi protocols. The validation process often restricts the types of intents that can be executed, limiting the system's generalizability. 2. Restricted Solution Space: Current solutions require synchronous execution, where all transaction components must be processed within a single blockchain block, and they lack mechanisms for pre-authorization, forcing users to manually approve each transaction. The inability to handle asynchronous operations and the lack of pre-authorization severely limit the solution space of existing intent-based systems. A practical example is the use of CowSwap, which relies solely on on-chain liquidity and cannot leverage off-chain options like OTC desks or centralized exchanges, thus restricting potential solutions. 3. Efficiency and Service Quality Issues: Many intent-based systems enforce strict on-chain processes, which are inherently slow and costly. This restriction of current solutions prevents the use of more efficient or cost-effective off-chain methods. For example, the automated market maker (AMM) model requires maintaining large amounts of liquidity on-chain, which ties up significant capital and incurs high costs. Similarly, cross-chain bridges require complex security mechanisms to ensure safe transfers, which increase both the time and financial cost of transactions. Additionally, due to the inability to handle asynchronous operations, service providers often have to bear higher service costs and potential risks. In a typical e-commerce scenario, a user might want to purchase an item, with the payment and delivery being asynchronous processes, reducing the risk for the service provider. However, current solutions require synchronous execution of intents, which increases the risk exposure for service providers. As a result, services are often slow and expensive, failing to meet the efficiency expectations of users accustomed to traditional financial systems. In summary, while intent-based systems represent a significant advancement in simplifying user interactions and enhancing efficiency within the blockchain ecosystem, they still require more flexible and comprehensive solutions. Addressing these limitations will pave the way for a more user-friendly and efficient blockchain experience, thereby driving mass adoption and unlocking the full potential of decentralized applications and services.
# II. How DAPPOS Intent Execution Network Works DAPPOS intent execution network is designed to simplify and optimize the process of executing user intents on the blockchain. By leveraging the innovative Optimistic Minimum Staking (OMS) mechanism and integrating various roles within the network, DAPPOS ensures efficient and secure execution of intents
### Optimistic Minimum Staking The core of DAPPOS intent execution network is the Optimistic Minimum Staking (OMS) mechanism, an innovative solution perfectly tailored for intent-based tasks. OMS links each intent task to a predefined value and potential compensation in case of failure, allowing tasks to be executed before their outcomes are verified. In DAPPOS, intents are essentially framed as “provide C, want X, get Y when fail.” This means that if a task fails, the network employs a consensus process to penalize the responsible service provider, ensuring that either the user's task is successfully executed or the user receives the predetermined compensation. Additionally, intents within the DAPPOS network require that the success of intent task execution can be clearly and objectively determined on-chain, eliminating subjective disagreements. This ensures transparency and consistency in the evaluation of task outcomes, further strengthening the reliability of the network. The critical innovation here is the asynchronous nature of C and X in this framework. The service provider can first receive C (the resources provided) from the user and then take the necessary steps to achieve X (the desired outcome), with the assurance that if they fail, Y (the compensation) will be provided to the user. This asynchronous handling of C and X significantly expands the solution space for service providers. They are not constrained to synchronous, immediate actions but can leverage more complex, multi-step processes that might involve both on-chain and off-chain methods to fulfill the user's intent. The OMS mechanism offers significant advantages to both service providers and users. The key benefits of OMS include: 1. Generalizability of Intent Tasks: OMS supports a wide variety of intent tasks, as long as they can be validated by on-chain rules. This broad applicability allows for numerous use cases, making the network versatile and adaptable. By leveraging on-chain validation, DAPPOS ensures that the execution of intents is transparent, secure, and consistent across different scenarios. 2. Expanded Solution Space: OMS allows service providers to use any method to fulfill the user’s intent as long as the final result is achieved. For instance, if a user wants to purchase a large amount of an asset, the service provider can choose the most efficient route, whether it's using on-chain exchanges, off-chain centralized exchanges like Binance, or over-the-counter (OTC) desks. This flexibility significantly broadens the range of possible solutions, enabling service providers to find the most cost-effective and timely methods. 3. Enhanced Capital Efficiency: Service providers only need to stake a minimal amount of collateral relative to the total value of ongoing intent tasks, and they can take user’s C(the resources provided) first and execute the intent later. This reduces the capital burden on service providers and allows them to utilize their funds more efficiently. They can freely deploy and utilize their working capital as long as they can fulfill the user’s intent. 4. Guaranteed Execution Speed: Execution speed is a critical component of the DAPPOS network, ensured through a predefined parameter within each intent. If a task is not completed within the specified time frame, it is automatically deemed a failure, and the user is compensated. This time-bound approach ensures that users are not left waiting indefinitely for their intents to be executed. It also incentivizes service providers to prioritize timely execution, knowing that delays will result in penalties and loss of collateral. 5. Scalability and Security: The OMS system ensures that tasks are either completed successfully or the users are compensated adequately. This model guarantees that the network can handle a wide variety of tasks without compromising security. By focusing on the final outcome and using a robust consensus mechanism to validate task completion, DAPPOS maintains a high level of security while supporting scalable operations. The system's high tolerance for verification time and low-risk exposure ensure that tasks can be verified efficiently and securely, promoting a resilient and scalable network. The OMS mechanism aligns the interests of service providers and users, fostering a reliable and efficient ecosystem. By ensuring that tasks are either completed successfully or compensated appropriately, OMS establishes a robust framework for intent execution, driving the adoption of intent-based interactions within the blockchain space. ### Participants in Intent Execution Network Before diving into the detailed workflow of the DAPPOS intent execution network, it is essential to introduce the three primary participants within the network:
**Service Provider** The service provider is the entity responsible for executing the user's intent. Service providers must stake collateral to take on tasks within the network, and the total value of the tasks they accept cannot exceed a certain proportion of their collateral. When a user's task is successfully completed and validated by the network, the reduction in the current total value of the service provider's tasks is acknowledged by other network participants, allowing the service provider to accept new tasks. **Execution Validator** Execution validators play a crucial role in verifying whether a user's intent has been successfully executed. These validators must stake a significant amount of tokens as collateral within the network. By continuously participating in verification tasks, execution validators earn token rewards. If they fail to provide timely validation results or if they submit incorrect validation outcomes, they face penalties. Their role is vital to maintaining the integrity and accuracy of the network's operations. **Matcher** Matchers are advanced execution validators with additional responsibilities. Besides verifying the execution results, matchers are also tasked with pairing and matching users with suitable service providers. This dual role requires matchers to stake even more assets within the network. Each service provider must select one or more matchers upon registration. Matchers ensure that the network operates smoothly by facilitating the interaction between users and service providers, enhancing the efficiency and reliability of the intent execution process.
These three roles—service providers, execution validators, and matchers—form the backbone of the DAPPOS intent execution network. Each participant plays a distinct and crucial part in ensuring that user intents are executed efficiently, accurately, and securely. ### Workflow of Intent Execution Network The DAPPOS intent execution network operates through a structured workflow, consisting of three main phases: Counterparty matching, execution, and verification. **Phase One: Counterparty Matching** When a user defines their intent, they can query any matcher within the network. The matcher will return execution quotes from the connected service providers for the specified intent. Once the user selects the most optimal quote, the intent deal is finalized. The user then only needs to monitor the success of their task; if it fails, they will receive compensation. For convenience, DAPPOS has developed a series of intent task frameworks. When users interact with partner infrastructure or dApps of DAPPOS, their intents are automatically generated by the intent task frameworks. Users can then view quotes from various service providers within the dApp and select the most appealing option. **Phase Two: Execution** After the intent deal is finalized, the service provider will receive C(what user provides for the intent), and take responsibility for fulfilling the X(what user wants in the intent). DAPPOS Intent Execution Network does not care about how the service provider completes the intent task; it only cares about whether the result is successfully achieved. Unlike many other intent-related projects where intent solvers are limited to on-chain solutions, DAPPOS allows service providers to choose from a broader range of solutions. This flexibility may offer users better options. **Phase Three: Verification** Service providers can proactively report the completion of their tasks. If they do not, execution validators will verify the success of the intent after the specified time within the intent. If the task is detected as failed, execution validators can issue a challenge to the network. All execution validators will then vote according to a Delegated Proof of Stake (DPOS) mechanism to reach a consensus. If the consensus determines that the intent task has failed, the service provider's collateral will be used to compensate the user and reward the challenger. If the consensus confirms that the intent task was successfully executed, the challenger will be penalized. If the task is successful, which means that nobody issues any challenge about the success, the corresponding task value for the service provider will be released. Through these phases, DAPPOS ensures a seamless, efficient, and user-centric process for executing intents. The structured workflow not only simplifies user interactions but also maintains the network's integrity and reliability.
# III. Intent Task Frameworks ### Intent-centric dApp Interaction The intent-centric dApp interaction framework revolutionizes real-time engagement with decentralized applications by supporting a seamless blend of contract calls from users’ contract-based wallets and asset bridging, even when arbitrary steps and dependencies are involved. This framework simplifies and automates the vast majority of dApp interaction tasks, traditionally executed manually. It is already live and trusted by top-tier dApps such as GMX, Benqi, and QuickSwap. To further streamline this interaction, the DAPPOS unified account has been integrated into the framework. This officially sanctioned account system allows users to effortlessly manage their assets across various blockchains. By mirroring the ease of centralized exchanges while maintaining a decentralized structure, it enhances user experience by enabling asset management across any dApp integrated with the DAPPOS. The unified account not only supports asset usage in these dApps but also facilitates fee payments with all mainstream tokens, significantly simplifying the blockchain experience. This integration is designed to provide a unified, frictionless user experience, where the account system is inherently compatible with intent execution, ensuring smooth and efficient authorization for service providers. ### Intent Assets Intent Assets are a new type of asset launched by DAPPOS. Intent assets offer high yields while remaining readily usable on-chain at any time. Whether users want to withdraw Intent Assets to a native asset on an exchange or use them on-chain to buy new MEME coins, participate in lending, or stake, they can do so directly without long wait times or suffering high slippage. The first batch of Intent Assets includes intentBTC, intentETH, and intentUSD. #### Scenarios Scenario 1: User intends to redeem yield-generating assets and exchange them for USDT Without DAPPOS, if you wanted to redeem your yield-bearing assets (e.g., xxETH), you would typically have to choose between using a DEX or redeeming through the project's official website. If you opt to exchange directly on a DEX, you might encounter issues like insufficient liquidity, high slippage, and significant losses. Redeeming through the official website often requires a waiting period of about seven days, which can be problematic in urgent situations. Additionally, after redemption, you would still need to manually sell ETH to exchange it for USDT. With DAPPOS, if you hold intentETH, you can directly use it as ETH on a DAPPOS-supported DEX to exchange for USDT with a single click. The liquidity pool used for this exchange is the regular ETH-USDT pool with high liquidity and low slippage. Scenario 2:User intends to buy $XXX token on xxL2 chain, but has no funds on xxL2. Without DAPPOS, even a seemingly simple task like this might require considerable planning. For example: * Fund Allocation: Deciding which chain’s funds would be more convenient to use for this task; some funds might still be locked in other protocols, requiring withdrawal. * Conversion: If your funds exist primarily in other chains or in non-ETH forms, how do you convert them to ETH? If you lack sufficient gas for the conversion, how do you obtain the gas? * Cross-Chain Method: Should you use an on-chain cross-chain protocol, or transfer ETH to an exchange and then withdraw it to the xxL2 chain? With DAPPOS, if you hold intentETH, you can go to a DAPPOS-supported DEX on xxL2 to buy tokens. You’ll find that using intentETH to buy tokens feels just like using regular ETH. Moreover, you won’t need to plan various operational steps, allowing you to use and allocate your on-chain assets more flexibly. For example, you no longer need to leave funds on each L1 or L2 just in case for gas; simply holding Intent Assets will satisfy your cross-chain interaction needs. In summary, when users hold intentETH, using it in non-yield scenarios feels identical to using native ETH, with the added benefit of earning passive income.
#### How Intent Asset works As shown in the diagram, when a user has the intent to "directly use Intent Assets in a specific scenario," they can do so with a single click. Behind the scenes, the user is providing Intent Assets as input to the DAPPOS Intent Execution Network and assigning the settlement task to the network’s service providers, expecting a specific result. The complexity of various on-chain operations involved in the actual use of Intent Assets is handled by the service providers within the DAPPOS network. When users hold Intent Assets, the yield generation tasks are also performed by the service providers within the Intent Execution Network. The underlying yield of Intent Assets comes from yield-bearing assets like LRT/Pendle PT (e.g., wstETH, sUSDe, sDAI, stBBTC), and the Intent Assets held by users can be seen as certificates. Theoretically, without the help of DAPPOS Intent Execution Network, users could choose to move assets across different chains themselves and seek ways to earn yields. However, in practice, users often do not choose to operate on their own but instead opt for the DAPPOS Intent Execution Network because: * Users want a straightforward process: In current blockchain interactions, completing an operation usually requires thinking through many intermediate steps. By using the Intent Execution Network, regardless of how complex the task's process is, as long as the result can be clearly verified, users can simply confirm it with a single click, letting professional service providers execute the task. * The Intent Execution Network enables institutional-level cost efficiency for ordinary users: Ordinary users usually cannot compete with professional service providers in terms of cost and efficiency. In the DAPPOS network, competition among service providers drives prices down to the optimal level, benefiting users. This enables ordinary users to access institutional-grade costs and speeds. * The Intent Execution Network enhances the security of Intent Assets: Due to the OMS mechanism, when a service provider takes on a user’s task to "use Intent Assets"， the user’s assets are already secured: either the task is successfully completed, or the user receives a pre-determined compensation. In essence, users are transferring the risks associated with redeeming assets to service providers who are better equipped to handle those risks. ### Intent EX The Intent EX framework within DAPPOS is designed to handle a wide range of asset exchange tasks, offering unmatched flexibility and efficiency. This framework allows service providers to utilize a diverse array of solutions to fulfill user intents related to spot trading, catering to both large and small orders. By leveraging both on-chain and off-chain strategies, service providers can optimize execution to achieve the best possible outcomes for users.
# How-to Guides（Archived） Archived # I.Web3 AI OS Quick Start Welcome to the Quick Start guide for DAPPOS's Web3 AI Operating System (OS). This guide walks you through getting started quickly. Whether you're researching DeFi opportunities, executing trades, or building Instant dApps, follow these steps to dive in.
Step 1: Log In To begin, navigate to the DAPPOS product page() and locate the login button in the top-right corner of the interface. * Recommended: Use a Web3 Wallet – Connect your preferred Web3 wallet (e.g., Binance Wallet, OKX Wallet, MetaMask) for full access to blockchain interactions * Alternative: Email Login – Sign in with email for quick access. However, this limits functionality—blockchain-related features, such as asset transfers or on-chain simulations, will not be supported. For the complete experience, we strongly recommend using a Web3 wallet to unlock the full potential of our Web3 AI OS. Step 2: Enter Invitation Code (Test Phase Exclusive) If you're accessing Web3 AI OS during the internal test phase, you'll be prompted to enter an invitation code. Simply input your provided code in the designated field and proceed. If you don't have a code, reach out to our team or check community channels for opportunities to contribute and gain early access. Step 3: Input Your Prompt At the heart of the Web3 AI OS is the conversation interface. In the central dialog box, type your natural language prompt to engage the system. For example: "Analyze the latest meme coin trends on Solana and suggest a trading strategy."
You can customize your interaction using the following product features of Web3 AI OS: Mode Selection Modes guide the AI's processing tendency for your prompt. You can select only one mode per interaction, influencing how the Multi-Agent Framework handles your request. Choose from the dropdown near the prompt input. * Auto (Default): The AI intelligently analyzes your prompt and responds dynamically, balancing research, planning, and execution based on context. Ideal for general queries where you want adaptive intelligence without specific constraints. * Analyze: Directs the AI toward deeper, more time-intensive searches and reasoning. Use this for research-heavy tasks, such as evaluating a project's fundamentals, cross-referencing on-chain data with social sentiment, or simulating DeFi yield strategies. * Plan: Guides the AI to analyze and generate executable plans, transforming intents into actionable on-chain steps. Perfect for complex tasks requiring implementation, such as deploying an Instant dApp or automating a trading loop. * Light: Prompts the AI for quick, concise results with minimal response time. Great for simple tasks like rapid fact-checks or basic queries, ensuring fast responses without extensive computation. TAG Addition Enhance your prompt by adding one or more tags from the available options. Current tags include: * Bubble: Unlock enhanced intelligence with the premium Bubble Engine for smarter, more adaptive results * Connected Opportunity: Instructs the AI to proactively identify executable money-making opportunities related to your prompt, such as buying tokens, opening contracts, or launching memes. * Marketing: Ideal for project teams and KOLs when crafting marketing materials. Quick Buttons For convenience, especially for new users, utilize the shortcut buttons below the prompt area to access pre-built functionalities: * Inquiry: Triggers common quick-query prompts, such as "My Trading Position" or "My Balances" This helps with fast information retrieval using our integrated tools. * Transfer: Quickly deposit or withdraw assets to/from your DAPPOS Wallet. * Play: Offers built-in example prompts tailored for beginners. * Fast Trading: For straightforward buy/sell needs, jump directly to the DAPPOS IntentEX. Use Cases This section explores key use cases, demonstrating how to harness DAPPOS for research, strategy, and deployment. Each example includes recommended modes, tags, and prompt suggestions to optimize results. Generating Analysis Reports DAPPOS excels at producing in-depth reports on Web3 topics, drawing on real-time blockchain data, social sentiment, and domain expertise to provide insights that generic AIs often miss—such as adaptive weighting of high-signal events or detection of manipulative practices. Users can request analyses on projects, sectors (e.g., DeFi, NFT, RWA), KOLs, or broader market trends, resulting in structured reports with quantitative metrics, risk assessments, and actionable recommendations. How to Use: * Select the Analyze mode to enable deeper searches, longer reasoning chains, and comprehensive data integration via the MAF. * Input a prompt in the dialog box, such as: "Compare $LINK with $XRP, analyze which one has more potential?" Complex DeFi Interactions Navigating DeFi can be intricate, but DAPPOS simplifies it by generating personalized strategies based on your prompt, wallet balances, and on-chain situations. Unlike generic AIs that offer vague advice without real-time data access, DAPPOS simulates yield loops, assesses protocol risks, and crafts executable plans through the Intent Execution Network—enabling one-click deployment with institutional-grade safety. How to Use: * Choose the Plan mode to focus on generating and outlining execution schemes, transforming your intent into secure on-chain steps. * Describe your strategy in the prompt, e.g.: * Review the generated plan, which includes step-by-step actions, simulations, and safeguards. Click Execute for autonomous completion via the Execution Layer—no manual approvals needed for routine interactions. \
Launching Meme Tokens Meme coins thrive on virality and timing, and DAPPOS streamlines their creation by designing tokens based on user-specified themes or AI-identified hotspots. The DAPPOS AI detects emerging trends, slang, and momentum signals that generic models overlook, then generates essentials like tickers, tokenomics, and deployment plans. How to Use: * Plan mode is recommended for dynamic generation and execution focus. * Prompt examples: "Create a meme based on the news that Justin Sun sold WLFI." * Click the execution Button for implementation.
Marketing Materials Writing DAPPOS empowers project teams, KOLs, and marketers to craft promotional content with ease.
How to Use: * Add the Marketing tag. Analyze Mode is recommended to use. * Input your prompt with the core content idea, e.g.: "Compared to BTC, why ETH is more worth buying" . The AI will automatically expand this into complete marketing materials.
Instant dApp Generation Instant dApps represent a core innovation in DAPPOS, allowing the Web3 AI OS to rapidly generate deployable Web3 applications based on AI-designed execution plans. These on-demand dApps, created through simple natural language interactions, mirror vibe coding—transforming ideas into functional tools without coding expertise. Unlike generic AIs limited to suggestions, DAPPOS integrates the Intelligence Layer for plan optimization and the Execution Layer for secure deployment, enabling seamless coordination across decentralized protocols.
Instant dApps serve two primary roles: 1. Facilitating User Execution: Through an intuitive dApp UI, they simplify operations for the current user, such as inputting necessary parameters for DeFi actions (e.g., loan amounts, collateral ratios, or yield thresholds). This streamlines complex tasks like recursive lending or token swaps, with built-in simulations and safeguards. 2. Enabling Community Reuse: Shared via the Discover Page, these dApps allow other users to browse, adopt, and reproduce the same execution schemes. This dynamic hub fosters collaboration, where community members can explore AI-generated strategies, customize them, and execute directly—lowering barriers and accelerating innovation. How to Use: * Use Plan mode to emphasize generating executable plans that culminate in Instant dApp creation, or Auto mode for flexible ideation. #Opportunity tag is also recommended. * Interact with the Instant dApps with UI just like normal dApps. * You can publish the dialogue to the Discover Page to share the instant dApps with other users. # II.Bubble Tasks Publishing Posts with #BubbleUp for the Bubble Engine To contribute directly to the Bubble Engine's knowledge base, users can publish posts on platforms like X (formerly Twitter) or Binance Square. By including the #BubbleUp tag, these posts become eligible for ingestion within the system. This process "force-feeds" the engine with fresh, Web3-specific data, helping it adapt to opaque, fast-moving environments where generic AIs falter—such as detecting deceptive practices or weighting high-signal events like partnership leaks. By publishing Bubble posts, you actively shape the Intelligence Layer, making DAPPOS more resilient to Web3's implicit rules and new concepts. BubbleUp Task Platform The Bubble Task Platform is currently in internal beta testing, which offers a structured ecosystem for collaborative contributions to DAPPOS AI’s intelligence. It also introduces incentive mechanisms to reward users for completing bubble tasks. Regarding the quality of information, the platform implements a reward and punishment mechanism: false statements will be penalized, while high-quality information will be rewarded. If you're interested in participating in Bubble activities, please join the DAPPOS community channels to get the latest news.
# External Audits (Retired) Security always comes first at DAPPOS. We ensure public verification of our smart contract code and collaborate with top security firms for thorough validation. ### DAPPOS Audit Reports Audit reports are all open for review, showcasing our commitment to transparency. We're actively collaborating with leading security audit firms to thoroughly assess our smart contracts, reinforcing our dedication to a secure ecosystem with no vulnerability.
AuditorDateStatusAudit Link
CertiKAugust 2023CompletedCertiK
Secure 3August 2023CompletedGithub
Secure 3August 2023CompletedGithub
Trail of BitsAugust 2023CompletedGithub
SlowMistOctober 2023CompletedGithub
BlockSecJune 2024CompletedGithub
HalbornNovember 2024CompletedHalborn
## Audit Report PDFs ### CertiK {% file src="/files/dCuNdlwyDyk0wfLXQhfp" %} ### Secure3 {% file src="/files/01FNzH3eO6z0ElL3CUF5" %} {% file src="/files/yrKeETMOfN6sYhzTQhcy" %} ### Trail of Bits {% file src="/files/d8rHIfFJdKXqozH7e6hs" %} ### SlowMist {% file src="/files/9MiO8iHUD4vB3ia6OSDp" %} ### BlockSec {% file src="/files/H8pNgE1mJfgMXPsqDwNX" %} ### Halborn {% file src="/files/z1V6tnDDhLz8NZ4oEYwR" %} {% file src="/files/qKl68tIAR5u9gPfaspof" %} # Support For any issues, questions, comments, feedback or concerns, please join the [***discord***](https://discord.gg/Gu2jD9tREf)