OneTapAI

Task Overview
Dashboard
Logs of task being performed
Task prompt and features
Analytics

Inspiration

What if sending an email, scheduling a task, or fetching data didn’t require opening multiple apps and repeating the same steps again and again?

In real life, even a “simple” task like:

checking the weather,
applying for a job,
typing an email,
sending a scheduled message etc.

can take 5–10 manual steps.

We felt this could be made more efficient.

We realized - Humans think in intent, but systems work in steps. That gap is where time, effort, and productivity are lost. So we asked a simple question: “What if intent itself could be executable?”

That idea became OneTapAI.

What it does

OneTap AI converts natural language into a single secure, executable link.

You simply describe what you want: “Send me today’s weather after 1 minute.”

And the system understands you, breaks the task into structured steps, assigns those steps to intelligent agents and generates a link. Clicking the link executes the entire workflow automatically.

OneTapAI turns “what you want” into “what gets done” - instantly.

We designed the system like a team of intelligent workers (AI agents):

A Controller Agent understands the user’s request.
It converts the request into a task graph (DAG).
Each task is handled by a specialized agent.
The system generates a token-based execution link.

This is technically explained in the next section.

How we built it

We built OneTapAI as a distributed multi-agent system. At the core, we use a Controller–Worker architecture:

A Controller Agent (powered by GLM 5.1) understands user intent and converts it into a structured workflow.
This workflow is represented as a Directed Acyclic Graph (DAG), where each node is a task.
Each task is handled by a specialized Worker Agent, such as:

API Agent (for API calls)
Communication Agent (emails/messages)
Scheduler Agent (timed execution)
Data Agent (information processing)

In our model, we have used:

FastAPI for backend API handling
Redis for fast state tracking
MongoDB for persistent storage
Playwright for automation
Secure tokens (JWT/AES) for execution links
Task orchestration engine for DAG execution
Logging system to track real-time execution

When a user clicks the generated link, the system validates the token, executes tasks in the correct order, tracks progress in real-time and returns the final result.

We treat user intent as a compilable unit, similar to how code is compiled into executable programs. Each component was built to simulate a real-world distributed system, ensuring modularity, scalability and clear separation of responsibilities.

Challenges we ran into

1. Converting Intent to Structure - Natural language is ambiguous. Mapping it into a clear execution plan required designing a reliable pipeline that converts said task to a precise workflow.

2. Task Dependency Management - Ensuring tasks run in the correct order without conflicts was tricky but solved using DAG-based execution logic. Designing and managing DAG execution was a major challenge.

3. Making It Actually Work (Not Just a Concept) - Many systems simulate automation, but we focused on real execution, with real APIs, real scheduling, and real outputs.

4. Multi-agent Coordination - Managing communication between multiple agents while maintaining consistency and state was a complex system design challenge.