Background tasks let you push a running command - or an entire subagent - off the main thread so your session stays live while the work continues. A slow build or an independent research job no longer blocks the conversation. Start it, keep working, and collect the result when it’s done. Suppose you kick off a full end-to-end suite that takes ten minutes. Instead of sitting on your hands, send it to the background and keep editing. 100xprompt runs it alongside you and reports back the moment it finishes.

​
How the two tracks work

Your session always has one foreground track - the thing you’re actively watching. Anything that doesn’t need your attention right now moves to a background track that runs in parallel. Background work keeps executing, keeps capturing output, and reports back when it’s ready, without blocking the conversation.
There are two kinds of background work, and they combine freely:

Background commands

Send a running shell command - a build, a watcher, a dev server, a long test matrix - to the background so the session keeps moving.

Background subagents

Launch specialized subagents that work autonomously and in parallel, then hand their results back when each one finishes.

​
Send a command to the background

A long command doesn’t have to hold your session hostage. Press Ctrl+B while it’s running and it moves to the background: the process keeps going, its output is still captured, and your prompt is free again.
1

Kick off a long job

Ask 100xprompt to run something slow - a full build, an end-to-end suite, or a dev server.
npm run build && npm run test:e2e
2

Send it to the background

Press Ctrl+B while it’s running. The command detaches and keeps executing; you’re returned to the prompt immediately.
3

Keep working

Continue the conversation - edit code, ask questions, start other work. The backgrounded job runs alongside you.
4

Check back when you're ready

Open the background tasks view (press Ctrl+B again when nothing is actively running) to see what’s still going, how long it’s taken, and the output each task has captured.
A running-task indicator shows how many background shells are live (for example, “2 shells”), so you always know work is in flight even while you focus on something else.

​
Run subagents in parallel

The biggest speedup comes from fanning out. Suppose you need to research three libraries, migrate four directories, or audit each package. These pieces don’t depend on each other, so 100xprompt launches a subagent for each and runs them all at once instead of one after another. Each subagent is a fresh, self-contained worker with its own focus: you brief it, it does the work, and it returns a single result.
Because the subagents run in parallel, three tasks that would take fifteen minutes end to end finish in roughly the time of the slowest one. You stay in control the whole time - reviewing, steering, and picking up each result as it lands.
Foreground vs. background is a judgment call 100xprompt makes for you. If it needs a subagent’s answer before it can continue, it runs that subagent in the foreground and waits. If the work is genuinely independent, it backgrounds it so nothing stalls. You can always ask for one or the other explicitly - for example, “run those three in parallel.”

​
Check status and read output

Background work is never a black box. At any point, 100xprompt can check a task’s status and read its output - the partial output captured so far while it’s running, or the complete result once it’s done. Nothing to babysit: you, or 100xprompt on your behalf, pull the current state when you want it.

Status

Where the task is in its lifecycle, how long it’s run, and whether output is available yet.

Output

The captured output - streaming and partial while running, full and final once complete.

Timing

Start time, end time, and total duration for every task, so you know what’s slow.

​
Track the lifecycle

Every background task - command or subagent - moves through the same four-state lifecycle. There’s no polling loop to manage; the status reflects reality whenever you look.
StatusWhat it meansWhat you can do
RunningThe task is actively executing in the background.Read the partial output captured so far, keep working, or stop it.
CompletedThe task finished cleanly (a command exited successfully, or a subagent returned its result).Read the full, final output and act on it.
FailedThe task ended with an error or a non-zero exit code.Read the output and error to diagnose what went wrong.
AbortedYou stopped the task before it finished.Nothing further runs; the captured output up to that point is still available.

​
Stop a task

Started something you no longer need? Stop it. Open the background tasks view and stop any running task - the process halts, its status becomes aborted, and whatever output it captured up to that point stays readable. Finished, failed, and aborted tasks can be cleared out when you want a clean list.
Stopping a task ends the underlying work immediately. If a background command was mid-write (a build emitting artifacts, for example), stop it the same way you’d cancel that command in your own terminal - check that it left things in a state you’re happy with.

​
Let completions come to you

You don’t have to sit and watch. When background work finishes, 100xprompt brings it back to your attention:
  • A notification confirms when a task moves to the background and when tasks are cleared.
  • The running-task indicator shows the live count of background shells, and drops as they finish.
  • The background tasks view always reflects current status, duration, and captured output for everything you’ve launched.
  • For subagents, the completed result flows back into the conversation so 100xprompt can read it and continue - synthesizing several parallel results into one coherent answer for you.
The pattern that pays off: start the slow, independent work early, keep the fast interactive work in the foreground, and let completions come to you. That’s how a single session does the work of several.

​
Tips & limits

Wait when you need the result to decide your next move. Background it when it’s long-running and independent - a build you’ll check later, a dev server that should just stay up, or a test matrix that doesn’t block your next edit.
When the work splits into pieces that don’t depend on each other. Independent research, per-directory migrations, or separate audits are ideal. Tell 100xprompt to “run these in parallel” and it fans them out into background subagents at once.
Yes. Background tasks keep executing and keep capturing output while you continue the conversation. You collect the results whenever you’re ready.
Independent implementation work can be run in an isolated worktree so its edits never touch your main working tree until you’ve reviewed them - useful when fanning out changes in parallel.
  • Scheduling: run tasks automatically on a clock instead of on demand.
  • Workflows: chain background steps and parallel work into repeatable recipes.
  • Agents: the specialized subagents you fan out across independent work.

Scheduling

Go beyond on-demand background work - have 100xprompt run tasks automatically on a schedule.

Workflows

Chain background steps and parallel work into repeatable, multi-step workflows.

Agents

Meet the specialized subagents you can fan out across independent work.