Use Lookout
Subagents
The agent can hand parts of a task to subagents that report back, waiting for them or working on while they run.
A subagent is a second agent that the agent starts for part of a task. It gets a brief the agent writes, does that work on its own, and reports back. The agent decides when one helps, and you can ask for them: "Use subagents to review each package."
A subagent lives inside its chat. For work that needs a chat of its own (its own worktree, machine or model, or work that outlasts the conversation), one of your agents starts a whole chat instead.
A subagent:
Waited on or not
Every subagent is the same kind of run, with the same row, the same chat of its own and the same controls. The one difference is whether the agent waits for it:
| The agent | While the subagent works | Its report |
|---|---|---|
| Waits for it | The agent's turn holds until it reports back | Is the result of that step |
| Doesn't wait (a background task) | The agent keeps working, or ends its turn | Arrives when it finishes |
A message you steer into the chat while the agent waits for a subagent ends the wait, not the subagent: the agent reads your message within moments, and the subagent goes on as one it doesn't wait for. A message queued for the next turn leaves the wait as it is.
When a subagent the agent didn't wait for finishes, the chat shows Subagent finished (or Subagent failed) and its report goes to the agent: at its next step if it's working, or in a turn of its own if the chat is idle. The agent then tells you what came back.
A subagent can ask the agent a question its brief didn't settle and keep working meanwhile: its row says Asks a question until the agent reads it, and the chat shows the question, its choices and the agent's answer where the agent read it. One the agent was waiting for moves to the background, so the agent is free to answer.
Its model and effort
A subagent runs on the chat's model and effort, the ones the chat has when it starts (an effort you changed while the chat's turn ran counts). To put subagents on another model, ask for it in the chat by the name the model menu in the message box shows, with an effort if you want one, such as high. The agent picks a model only when you ask. It can choose from the models your account runs now, the ones that menu lists. A model that can't run now (signed out, not on your plan, its plan used up, its provider failing or rate limiting it) isn't started: the agent hears why, in the words Continue on uses, when Lookout tries that model again, and which models run now, and tells you. Once that time has passed, the subagent starts, and its request is the one that tries the model. One exception: a subagent the agent doesn't wait for, on a model whose plan is used up or whose provider Lookout is waiting out, starts and waits for it without sending anything, then goes on by itself. The agent hears that it can start one that way. When its provider is signed out or doesn't offer it and another provider serves the same model, it runs there instead, unless that provider is billed per token, such as an API key: then the agent hears the exact model to ask for and tells you, and it runs there only when you ask (When a model can't run). Another effort alone works too: "Run it on low effort."
The effort goes to the nearest level the model has. A model chosen without an effort takes the chat's, the same way switching models in the message box keeps it. A subagent that is still running keeps its model: a follow-up the agent sends it can't move it to another.
A subagent started without a model or effort follows the chat. While it runs, a change of the chat's effort reaches it at its next request, moved to the nearest level its model has; a change of the chat's model waits until it next waits or parks, since moving a running subagent would throw away its cache. Each time it runs again (the agent continues it, you continue it from its row or its chat, it goes on after a plan wait or a restart), it takes the chat's model and effort as they are then, so switching the chat's model moves its subagents along at their next run. Its own conversation says where the model changed, the way a chat's does. A subagent you put on a model or effort keeps it every time it runs again, until you ask for another, or for the chat's ("same as yours"), which makes it follow again.
To change the default, open Settings › Chat › Subagents: Subagent model is Same as the parent unless you pick one, with its effort on the slider under the models. A project can have its own in its settings, Subagents: Use the default follows Settings. What you ask for in the chat wins over both.
Agents without asking, in the same group, is how many agents one turn may start before a card asks you: its subagents, and the chats an agent starts or steers. The turn waits for your answer, even one that started while you were away, such as an agent's turn another chat's message started, and its chat shows that it needs you until you answer. Allow for this request lets the turn start as many as it wants; Stop starts the ones that fit, and for the rest of that turn the agent starts no more past your number, with no second card. The next turn asks again. A workflow run that wants more asks too. It is Unlimited unless you pick a number: Unlimited never asks, however many agents a turn, a Multitask chat or a workflow run starts.
A chat can also have a number of its own, one for everything it starts: its subagents, the chats its agent starts or steers, and its workflow runs. Run and allow on a workflow's launch confirm raises it to that run's size; when Agents without asking is higher, the higher number counts. While a chat's own number differs from Agents without asking (either may be Unlimited), the orchestration menu in its composer shows Use the default with your setting beside it. Choosing it puts the chat back on Agents without asking.
A subagent on another model spends that model's plan, and Usage counts it there. If that model fails while the subagent works, the subagent stops: it doesn't move to the chat's model on its own. Continue picks it up when the model is back, and its chevron continues it on another.
A subagent on the chat's model and effort says nothing about it at rest. One on another model shows that model and effort on its row and in the sidebar; hover it to see what the parent runs and why it differs. Its opened chat names its model and effort either way, where a chat shows its model.
Follow a subagent
Each subagent is one row in the chat: a mark, its title, what it is doing in plain words, and how long it has run. The subagents the agent starts together share one block, in the order the agent asked for them; past six, the first five show and a last line reads 7 more with a chevron: click it to show the rest in the block, and again to fold them. A workflow's phase in a block shows six of its subagents, then Show all 12 with the open arrow, which opens the workflow's page.
Click a row to open it in place: its report, the files it changed by name, and a line that counts its steps, such as 17 files read, 13 commands, 21 searches. Click that line for its steps in order, such as Read store.ts, Looked through 6 files or Ran 3 commands, the one it is on last. Its commands, what they printed and every result are in its chat: Open. To see what the agent asked of it, choose Show the brief in the row's ⋯.
Hover a row (or move to it with the keyboard) for its stop square while it works, Open, and ⋯ for Show the brief, Copy report, Copy id, Continue and Stop, each where it applies. On a touch screen or in a narrow window, ⋯ shows all the time.
While subagents work, they also show under the chat's row in the sidebar (an agent's main chat: under the agent), the newest step's first, the ones of one step in the order the agent asked for them, one that needs you before them. Past three, a row says how many more are working, such as 2 more working: click it to list them all in place, and Show less to fold them back; the list stays open for that chat until you fold it or quit Lookout. One that waits out a spent plan stays there on a hollow ring. One that ends shows its mark a moment and leaves, so a long chat's row stays one line plus what runs now. Their rows sit one step further in than the chat's, in quieter ink, and the working mark is on the row doing the work: while a subagent's row works under it, the chat's row shows none, and once the chat's own turn has ended it reads as any finished chat does.
Nothing under the message box repeats them. Scrolled away from their rows, open a subagent at work from its line in the sidebar, or press ⌥⌘↓ for the one that needs you, else the latest at work.
Every subagent of the chat keeps its row in the chat where it started: one that ends, waits or is cut off changes its mark and its line, never its place. In a chat with an agent, they also nest under the agent's row while they run. Search's Work filter (⌘K, then ⌘] twice) lists a chat's subagents by day, the ones that ended included.
Click a row's Open, or its row in the sidebar, to open that subagent.
Open a subagent as a chat
Click Open on its row, or click its row in the sidebar. The run fills the main pane as a chat of its own, and the top bar shows the path back up through the chat that started it to the agent or chat at the top: the brief first, then every step as it happens, a web search its model's provider runs included. Its steps open as the chat's do: an edit to its diff, a command to its output. An older run that didn't keep them says Diff not kept for this run or Output not kept for this run instead. The top bar's last step names it, with its mark and how long it has run; its message box reads Message this subagent, and while it works the send button is its stop square. Click the chat's name in the top bar, or press ⌥⌘↑, to go back up: the chat opens where its row was, and the row glows once. ⌥⌘← and ⌥⌘→ step to the subagents beside it; Esc leaves the page as it is. The run keeps its own address, so leaving the chat, reloading or following a link opens it again with every step it took.
While a subagent runs, you can message it from there. It reads your message at its next step, in its own context, never the agent's. If a plan limit cuts it off before that step, the message is kept: it reads it once when it continues.
Stop a subagent
Continue a subagent
A subagent cut off before it finished keeps its whole context, as its last request carried it: by a spent plan, a provider failure, a restart, its time limit or Stop. Its row says why it stopped, such as Stopped or Stopped by a restart, and when a spent plan resets. A lost connection doesn't cut it: it shows Waiting for the network, its parent is told it waits rather than failed, and it goes on by itself on the same model once the network answers, with the time it waited not counted against its time limit.
What a subagent keeps to continue from stays for 7 days after its last step, and goes once its chat is archived or deleted. Continuing one after that says it kept nothing to continue from (the agent is told to start a new subagent), and its transcript still opens. A subagent still running, or one in a workflow that is still going, keeps it.
A subagent the agent doesn't wait for, cut off by a spent plan, a provider that keeps failing or a lost connection to it, waits instead and continues on its own once its plan answers again: its row says when it goes on, such as Goes on at 4:37 PM, the time its plan resets (hover it for the model it waits for), and its chat's row shows a clock in place of its dot (it lists under Running, never Needs you). It goes on from where it stopped, on the same model. When the wait is half an hour or longer, the agent hears of it once for that plan: which subagent, its model, why it waits and until when, and the call that continues it now on another model that is open. It is woken for it once per plan limit; another subagent waiting on the same limit, and a workflow agent the plan floor holds, ride along its next turn instead. Nothing is asked of it: it moves the subagent only when the work can't wait, and otherwise leaves it waiting and hears again when it finishes. A workflow agent's wait reaches the chat whose agent launched the run the same way. In a chat with fallback models (or one set to wait at a spent plan), it goes on on the first of them that is open, in order (the chat's own model first, then its fallback models), at once if one is open, else on the first to open; a plan that reopens within a minute or two is waited out, not skipped. Such a move doesn't stick: each time it runs again, and at a later request once an earlier model is open again, it goes back to the first open one, and one started while the chat's own model is spent starts there. One that follows the chat follows a switch of the chat's model while it waits: it goes on at once on the new model, or waits for that model's plan if it is spent too. Continue on, on its row and in its opened chat, moves it now to a model a subagent can run now (the chat's fallback models first; a model whose provider is failing, whose plan is used up on the account the chat uses, that runs in chats only, or that refused subagents lately, isn't offered, and Lookout refuses one that closed meanwhile with why), from where it stopped. Retry now, beside it on its row, in its row's ⋯ and in its opened chat, tries once at once on the same model; if the plan still says no, it waits again until the new reset the provider gives, and it never moves to another model unless you pick one. Stop waiting in its opened chat, or Stop in its row's ⋯, leaves it interrupted, for Continue later. Signing in another account of that provider (or a plan that reopens early) wakes every subagent, workflow agent and chat waiting on it at once: they go on one per answer, and each one still waiting reads In line: its plan has room instead of the old reset. A wait gives up after a day without an answer.
A subagent the agent doesn't wait for that Lookout's restart cut off, with nothing to continue it, starts a turn in its idle chat, so the agent hears about it and can continue it. Any other subagent cut off by a plan limit, a sign-in or a lost connection, and one whose wait you stopped, doesn't start a turn in an idle chat: the agent hears about it with your next message. Until it is continued, its row keeps a still mark and Continue. Editing an earlier message removes the subagents that the turns after it started and that have ended.
Multitask
With Multitask on in Agent mode, the agent sends substantial requests to subagents it doesn't wait for, instead of working on them in the chat. It starts one subagent per request as a rule, and several only for parts that are independent of each other; a quick request it still answers itself. You can keep asking while they work. Reports arrive as each one finishes, and the agent puts them together when several make one answer. Modes shows how to turn Multitask on and off.