> ## Documentation Index
> Fetch the complete documentation index at: https://docs.superun.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# The agent assigns work for you

> Complex work can continue in the background; keep asking in the main chat. Progress and spend stay visible; collaboration is tracked per person.

Keep building without waiting: while the main task runs, you can still send new asks. Larger work can be split into background subtasks—progress and spend stay visible.

***

## Everyday analogy

| Concept       | Analogy                                                                                                                 |
| ------------- | ----------------------------------------------------------------------------------------------------------------------- |
| **Main task** | General contractor: hears your ask, coordinates the whole renovation, and keeps you updated                             |
| **Subtask**   | Specialist crew: the contractor sends one piece (wiring, paint) to a crew in the background; they report back when done |

**Before:** often only one crew could work; you waited for them to finish before sending the next message.

**Now:** heavy work can stay with background crews while you keep talking in the main chat.

***

## What the system actually does

It may feel like “just more parallel sends,” but under the hood:

* **Splits work**: the main agent can turn complex asks into background subtasks
* **Crews run alone**: each subtask has its own progress and does not freeze the main chat
* **Reports back**: when a subtask finishes, it reports to the mainline and merges results into the project
* **Chat stays open**: while subtasks run, you can still ask new things; you may see “still generating in the background—you can keep talking”
* **Progress is visible**: e.g. “N subtasks running,” subtask tags in task status
* **Spend is clear**: subtask consumption can be reviewed
* **Collaboration stays separate**: tasks are tied to who started them; others generating show as “collaborating,” reducing accidental stops
* **Queues are explained**: when busy, items queue; when yours runs, you may see that prior work is still in the background and the queue is next

**One line:** not merely “send more messages,” but split, parallelize, report back and merge, show progress and spend—and keep multiplayer work from stepping on each other.

***

## Main task vs subtask

|                   | Main task                                                                        | Subtask                                                                     |
| ----------------- | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| **What**          | Your line with the main agent                                                    | A background crew the main agent dispatched                                 |
| **How it starts** | You send a normal ask in the input                                               | Usually not a manual “create subtask”—the main agent decides and dispatches |
| **Job**           | Understand the whole, coordinate, reply, decide whether to split, close the loop | Focus on one piece, then report to the mainline                             |
| **What you see**  | Main chat bubbles, main “generating” state                                       | “Running subtask: xxx,” subtask progress, subtask spend                     |
| **Done?**         | Main task ending ≠ everything finished                                           | Subtasks may still run; reports may not have merged yet                     |

Remember:

* **Main task** = commander + main conversation
* **Subtask** = parallel background crew

***

## When something becomes a subtask

When the ask is large, separable, and better done slowly in the background, the main agent **may** spawn subtasks so you can keep asking other things (as shown in product).

Flow in plain words:

1. You send a message (or the agent judges a piece fits background work)
2. The main agent starts a subtask
3. The subtask advances on its own; you can keep chatting / asking in the main thread
4. Subtask finishes → reports to the main chat → results merge into the project when possible
5. You can see progress in chat / task status, and subtask spend in billing

***

## What if several people send similar asks?

In shared projects, the system tries to bill and track by who started the work:

**Separate by person**\
A’s main/subtasks stay with A; B’s with B. Progress, stop, and spend stay per person so you do not stop the wrong run.

**Someone else generating → “Collaborating”**\
You can see a teammate’s work is still running.

**Similar ≠ auto-merged**\
Two people each say “make the button red” are usually two independent requests—not secretly one job.

**May use resources twice**\
Duplicate similar work can cost twice. Agree who changes what before both edit the same spot.

**Your own back-to-back asks**

* Subtasks in background, mainline free → often you can keep asking (with a parallel hint)
* Mainline still busy / queued → you may enter the queue; when it is your turn, you get an explanation

**One line:** collaboration is tracked per person; similar asks are not auto-treated as one job—coordinate first to avoid redoing the same work.

***

## Big picture

```text theme={null}
You ask
   │
   ├─ Main task (commander): understand, coordinate, reply, decide whether to split
   │
   └─ Subtask (background crew): do one piece → report → merge into the project

Also: progress visible, spend reviewable, people separated by ownership, queues explained when busy
```

***

## Value in one line

**Before:** one generating reply often meant waiting.

**Now:** heavy work runs in the background while you send the next ask and watch progress and spend—like a team that can assign work, not a counter that takes one ticket at a time.

***

## FAQ

<AccordionGroup>
  <Accordion title="Do I create subtasks myself?">
    Usually no. The main agent often dispatches them when background work fits. You keep sending normal asks in the main input.
  </Accordion>

  <Accordion title="If the main task ends, is everything done?">
    Not always. Ending the main task does not mean every subtask finished or every report merged.
  </Accordion>

  <Accordion title="Can I keep talking while a subtask runs?">
    Often yes. When the mainline is free you can still ask; the product may note background generation. If the mainline is busy or queued, you get an explanation when your turn starts.
  </Accordion>

  <Accordion title="In collaboration, could I stop someone else’s task?">
    The system tries to separate progress, stop, and spend by who started the work. Others generating show as “Collaborating,” reducing accidental stops.
  </Accordion>

  <Accordion title="Does refreshing drop subtasks?">
    Usually no. Work continues in the cloud. While parallel subtasks run, status may not be fully written back yet—refresh helps you see the latest. See [FAQ](/superun/introduction/faq).
  </Accordion>
</AccordionGroup>

## Related docs

* [Manual edit](/superun/features/manul-edit) (edit elements in preview—not the same as AI-dispatched background subtasks)
* [FAQ](/superun/introduction/faq)
* [Changelog · 08/28](/superun/changelog)