DAPPOS launches xBubble: An AI agent that learns and uses AI for you

xBubble allows users to complete specific tasks with simpler prompts by automatically building and dispatching task-specific AI agents.

Today, DAPPOS is launching xBubble, a low-prompt AI agent designed for users who want results, not prompt-tuning sessions.

With xBubble, users can turn short requests into deliverable work across creating image/video, websites, documents, and scheduled solutions, without testing models, assembling tools, building solutions, or vibe coding skills themselves.

xBubble is built around two core systems: Bubble Engine, which generates and tests task-specific SOPs that can be executed by AI agents, and Bubble Pilot, which reads a user’s request and dispatches it to the best available AI solution.

“Powerful AI no longer requires users to learn AI,” said the DAPPOS team. “xBubble inverts the relationship. We have AI learn AI, and we have AI use AI, so users don’t have to. The system evolves faster than any user can, and leverages AI more effectively than they can.”

Why low-prompt AI

AI capability is improving rapidly, and access is no longer the constraint. But as models grow more powerful, the gap between users who know how to operate AI and users who don’t is widening, not closing. The same model that produces professional results for power users often returns disappointing output for everyone else — and the gap compounds with every model release.

Closing that gap takes real work. Power users study how each model behaves across different task types, research which combinations of tools and skills chain together for a given workflow, and run repeated debugging cycles before outputs become reliable. They build internal playbooks of what works on which task, and re-learn the operating manual every time a new model launches — the know-how rarely transfers cleanly to the next release.

The bottleneck has shifted from model capability to model usability. The question is no longer only whether AI can complete a task. The question is whether ordinary users can reliably turn their goals into the right AI solution.

xBubble is designed to close that gap by inverting the relationship. Instead of users learning AI, xBubble has AI learn AI. Instead of users figuring out how to use AI, xBubble has AI use AI on their behalf. Bubble Engine does the learning. Bubble Pilot does the using. Users only state the goal.

The low-prompt approach

Dispatch task-specific AI solutions

Most AI products give users a blank box and a set of powerful tools. The user has to decide which model fits the task, which tools to chain, how to format the output, and how to recover when the result misses — and to re-learn that decision tree every time a new model arrives.

xBubble takes a different approach. It gives users a dispatch layer.

A short request is not sent to a general AI agent, but passed to a specified agent who can best understand and execute it. Bubble Pilot reads the user’s intent, identifies the task type, and routes the request to a solution that Bubble Engine has already built and tested.

This is what xBubble means by low-prompt AI. The goal is not to remove user intent. Users still describe what they want. The goal is to remove the burden of operating AI. Model choice, prompt structure, skills writing, tool selection and result testing move from users into the system.

Bubble Engine: A system that builds AI solutions for users

Bubble Engine is the part of xBubble that learns AI on the user’s behalf. It is the solution factory behind the system.

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 an SOP (Standard Operating Procedure): a reusable solution that can be dispatched whenever a similar request appears.

Instead of relying on a fixed prompt template, Bubble Engine can generate task logic, test different execution paths and revise the solution for specified tasks. Bubble Engine will also test how versatile the SOP is before publishing it into xBubble’s dispatch layer.

This changes the unit of progress. A generic AI agent takes time and effort to deliver reliable results. xBubble starts from solutions that have already been designed for specific task types.

Bubble pilot: AI for using AI

Bubble Pilot is the part of xBubble that uses AI on the user’s behalf. It is the runtime dispatch layer that turns Bubble Engine’s solutions into delivered results.

It reads a short user trigger, identifies the task type, checks whether a matching SOP exists, and routes the request to the best available solution. If a specialized SOP fits, the user gets a task-optimized execution path. If no specialized SOP fits cleanly, Pilot falls back to a general-purpose agent so the user can still complete the task.

The user-facing change is simple. The work of choosing the right model, tool, and solution moves out of the user’s head and into the system.

The user states the goal. Bubble Pilot picks the path. Bubble Engine has already built the path.

Over time, recurring fallback requests can also inform what Bubble Engine builds next. When users repeatedly ask for a task that does not yet have a specialized SOP, that pattern becomes a candidate for solution generation and testing. Each new SOP expands what Bubble Pilot can dispatch. Each dispatch decision gives the system more signal about where low-prompt execution is most useful.

Available today

xBubble launches as a complete AI agent product, not a single-feature preview. It ships with 10+ core capabilities organized into two modes with multiple running environments that mirror how users actually work with AI.

Bubble computer

Bubble Computer is xBubble’s end-to-end project workspace. It unifies xBubble’s full capability stack into a single execution path, so a request that spans research, writing, design, and verification ships as one project rather than as a stitched-together chain of sessions. When Bubble Pilot detects multi-step work, it routes the request to Bubble Computer, where a sandbox spins up, specialized skills load on demand, and the project runs end-to-end without the user managing intermediate steps.

Within a single Computer 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, skill loading, and step coordination. The deliverable is the work product, not a conversation about one.

Bubble Personal

Bubble Personal is xBubble’s local-environment mode. It brings cloud AI home as a secure solution for work that requires access to a user’s own machine, operating across local files, browsers, apps, and schedules. Bubble Personal can automate website operations that need personal accounts, generate morning briefings from a user’s calendar and inbox, organize thousands of photos, or collect market data into a user’s drive overnight.

Bubble Personal runs on a sandboxed execution model. Installations, downloads, and system-level changes happen inside cloud containers and are destroyed once the task completes. On the user’s machine, only explicitly authorized actions execute, with no software installs or environment modifications. Heavy compute and risky operations stay in Bubble Cloud, and clean results flow back to the local workspace, giving users cloud-scale capability without local-environment risk.

Supported tasks

xBubble has two modes: fast and work. Fast mode is designed for simple daily tasks like research while work mode uses SOPs to deliver stable and professional results. Currently, we have supported the following task type:

• Voice Dictation: captures spoken input and turns it into clean text
• Text to Speech: reads xBubble’s responses aloud in natural voices
• Talking Avatar: generates visual content with style, format, and output structure handled by the system
• Deep Research
• Slides Creation
• Docs Creation
• Fact Check
• Scheduled Tasks
• Poster Creation
• Image Creation
• Video Creation
• Website Development

Built for results, save hours spent on learning AI

xBubble is built for users who know what they want but do not want to learn how AI is operated or spend time on multiple rounds of conversations with AI.

The core product thesis behind xBubble is simple: AI should learn AI. AI should use AI. Users just need to state goals.

Bubble Engine handles the learning. It studies how models behave, tests which tools and skills chain together, and builds reusable execution paths. Bubble Pilot handles the using. It reads each request and dispatches it to the right path. Users ask for outcomes and receive results.

Looking forward

DAPPOS will continue to improve Bubble Engine’s ability to build AI solutions for more complicated tasks. This leads to better performance for more tasks. As more SOPs are built by Bubble Engine, xBubble can also route more requests away from generic agents and toward task-optimized execution, making performance better with less response time.

The goal is simple: users should spend less time operating AI and more time using the results.

About DAPPOS

DAPPOS is an artificial intelligence company focused on building low-barrier AI products for general users and professionals. The company has secured over $20 million in funding from leading investors, including Polychain, Binance Labs, Sequoia China, IDG Capital, and OKX Ventures.

Learn more: https://medium.com/@dappos.com