Tasks

A task is one unit of work owned by a single coding agent - typically one pull request. Each task has a prompt, a chosen backend and model, the machine it runs on (Remote, your computer, or a box you added), a spend ceiling, and a lifecycle you can follow on the Tasks page. There is no time limit to set; see Lifecycle for how long a run can go.

Starting oneアンカーリンクをコピー

The Tasks header keeps one New task button, with a machine picker beside it once you have somewhere other than Remote to run (This computer, or a machine you added). The repository, the coding agent and the model are all chosen in the message box (on a phone, the coding agent is set under Settings > Code > Coding agent). The coding-agent picker lists all six assistants with the ones that need provisioning or a credential of yours marked, and picking one sets your account default: it also applies to scheduled tasks and to the autonomous loop, never to a task already running. Models and credits at the foot of that menu opens Settings > Code > Coding agent, where a Kiro or Cursor row reading "needs your credential" takes its key. Each new task gets its own conversation the moment you press enter, so New task really is empty.

A request that names a repository ("In acme/api: add a health check") runs in that repository rather than the one selected in the picker, and Foxl asks which one when it cannot tell. A named repository that is not connected to your account is never used, and Foxl says so.

The composer's + menu holds two more things:

• Add images - attach up to four images to a message (pasting or dropping them works too), such as a screenshot of a bug. The chat's model reads them with your request; a coding agent it starts gets the task the model writes, not the pictures. If the chosen model cannot read images, Foxl says so instead of answering without them.
• Plan first - off by default; while it is on, a Plan first chip beside the + turns it off again. The coding agent reads the repository and writes a plan without changing any files or opening a pull request. The plan appears in the task's conversation with Approve plan, which has the same agent implement it and open the pull request; until then the task is listed as Plan ready and waits in Needs you as "Plan needs your approval", whose card opens the task. After 14 days it moves to Done, where opening it still offers Approve plan. It works for Claude Code tasks on Remote: a task that would run another agent, or run on one of your own machines, is refused rather than started without a plan.

On a phone (the iPhone and Android apps, and a phone's browser), the message bar is the same capsule as Foxl Agent's: +, Message and the microphone, growing a line at a time as you type, with Send once there is something to send. It carries no chips: the repository and the model are rows of the +, each naming the current pick and opening the same picker; inside a task the Repository row names the task's repository. Plan first, while on, is the checked row in the +. The iPad and a computer keep the chips. When a new task on a phone names two to four of your repositories and none of them is the selected one, Foxl asks "Which repository should this run in?" before anything is sent: tap one or type its name, or choose Both (All of them) to send it as written and let Foxl place the work. Until the task appears, its conversation says at the top which repository it runs in ("In my-app").

How many tasks can run at once is set by your account's limits; see Budgets and tiers.

The task listアンカーリンクをコピー

The sidebar's first row, New task, opens an empty composer from any Code page, and your tasks are listed under Recent tasks below the pages, with the number of unread notifications from tasks waiting on an answer from you beside the heading. From inside a task, Escape, the back arrow or the task counts at the top of the page return to the list on a computer, and the Tasks tab or Back does on a phone.

The Tasks list groups your tasks into Needs you, Working and Done. Groups fold and stay folded. Clear on Done hides every finished task from the list on this device, with Undo, and Show N cleared brings them back; they stay in Work and in your task history. Cancelled runs fold into one line at the end of Done. A Needs you row has the same dismiss as its card in Work. A task started from an issue is named after the issue, and each row says which agent ran it. A running task is timed from the start of its current run, so time it spent waiting for a plan approval does not make the agent look slow.

In the desktop app and in a browser with a mouse, the list works from the keyboard while the caret stays in the message box:

If Foxl asks a question instead of starting the task you typed, the question is in Needs you; an answer or an error shows a notice with Open.

On a phone (the iPhone and Android apps and a phone's browser), the Tasks tab lists what you handed off in the same three groups, one line each; a finished task's line is what its coding agent says it did. Open a task and its conversation reads like a chat, with one card at the end when the next move is yours: the pull request with a look at the change and Merge, or a reply such as Fix it or Try again. The changes, the terminal, the pull request on GitHub, Stop and Retry are in the task's ... menu. A failing check Foxl is already fixing shows as Working on its pull request's row rather than as a task of its own.

Lifecycleアンカーリンクをコピー

A task moves through these states:

merged, failed, and cancelled are terminal. A task in review whose agent is still running can be resumed in place on Claude Code, Codex or Kiro. Once the agent has exited, only a Claude Code task comes back: from review it can be resumed, and from review, failed or cancelled it can be reconnected, which reuses the checkout while its machine is still up and otherwise clones the task's pushed branch back and picks up Claude Code's conversation. Work that was never pushed does not survive the machine being recycled, except a Claude Code terminal pane's uncommitted changes on a private repository, which are saved to that repository while it is open and put back on reconnect - see Resume from review. Retry is different: it starts a new task on a fresh clone and pays for the run again, so Foxl never takes it for you.

A task runs until it finishes, you stop it, or it reaches its budget. There is no time limit to set: a task you hand off may run for up to about 7 hours 20 minutes (AgentCore's 8-hour limit for one run, less the time kept for delivering the work), at which point the agent is asked to commit and push what it has. A long run keeps working when AgentCore ends its live connection (it does every hour), and the task reconnects to it. A run that shows no activity for an hour (no output and no model calls, usually because it is waiting for an approval nobody will give) is stopped the same way. The same maximum applies to a task on This computer. A cloud task whose connection to Foxl drops in the middle of a run stays running for up to 15 minutes in case it finishes and reports; if it does not, it is marked failed with the reason on the task, and its compute is charged. A repository's setup script, when it has one, runs first and its time comes out of that maximum (see GitHub). While a task runs, its header shows when it started and what it has cost so far. A task whose machine was recycled with nothing to show, or a review that nobody answered for 14 days, is moved to cancelled with a note saying which of the two it was; a pull request it opened is untouched.

A task that did not finish says why its coding agent stopped - out of credits, Task budget reached (with where to raise it), too many requests at once, the maximum run time, a setup script that failed, or the CLI's exit code - and keeps the last lines the agent printed. It also says what the run left: the pushed branch or "Nothing was pushed", and what it cost in model and compute. A finished task's card at the end of its conversation says what the run cost and how long it took, on a phone too, and Time split shows how long the agent worked and how long the task waited for plan approval, your answer or a review. A Kiro or Cursor task's cost reads "+ Kiro model use" (or Cursor) beside it, because that vendor bills its model use to your own account. Retry runs the task again on the same coding agent with the instructions it started with, and its button names that agent (for example Retry with Codex). A task started with Plan first is retried with Plan first again: it writes a new plan, changes no files and waits for Approve plan. A Plan-first task started before mid-October 2026 still retries as an ordinary task, because nothing recorded the choice for it.

A follow-up you send in the conversation of a task that has finished ("now also fix the header") does not rerun the task. Foxl asks whether to start a new task with your follow-up, because a new task starts from the default branch without the finished task's unmerged changes; Reconnect on a Claude Code task still continues it on the same workspace. A follow-up on a merged task starts as new work.

Subtasks and Task Documentsアンカーリンクをコピー

When the orchestrator plans multi-PR work, the Task Document holds the checkboxes and each checkbox is a subtask. Subtasks have their own status (pending, running, review, done, failed, cancelled) and the plan completes when every subtask reaches a terminal state.

A step is never started twice: while its agent is running or its pull request is open, a second start (from the autonomous loop and a message of yours at the same moment, for example) is refused and the plan keeps the first agent. A failed or cancelled step can be started again, and a retry stays on the plan: the step shows the retry running, and it is checked off when the retry's pull request merges, as it is when a pull request Foxl fixed after its checks failed merges.

Live terminalアンカーリンクをコピー

Each agent runs a real coding CLI inside a PTY, so while a task is running its terminal streams genuine output - colors, spinners, and syntax highlighting included. On a wide screen a task keeps its conversation on the left and a panel on the right with two tabs: Terminal, and Changes - the task's plan and its pull request review (checks, changed files, line comments, Request changes and Merge). A running task opens on its terminal and a finished one on its changes; press the tab that is showing to close the panel, and it stays closed until you open one again. In a narrow window the header's Conversation | Terminal | Changes switch shows one at a time, and a running task's Terminal carries a live dot; on a phone, Terminal and Changes are rows of the task's ... menu. A tab appears only when it has something to show: a task you open after its run has ended has no Terminal (no saved output is replayed), and a task that has not pushed, has no pull request and has no plan has no Changes.

A Claude Code task on Remote that was started from a prompt takes messages while it works: a line typed in its terminal, or a follow-up passed on to it, reaches the agent at its next tool call and shows in the terminal as a [user] line. When an agent cannot take input - it is wrapping up, or it is a run that does not read its terminal - what you type is not delivered, and the pane says so; send it as a follow-up when the run ends.

Changes before the pull request. As soon as a task pushes its foxl/<id> branch, Changes shows that branch compared with the repository's default branch - the files, their diffs and a link to the comparison on GitHub - and reads it again each time the task pushes. A task running on this computer shows its copy of the repository instead, including changes it has not committed yet and new files it has not added, while it runs. While the agent is still on the run, each file has Discard, which asks it in the task's conversation to put that file back as it is on the default branch and keep the rest of its work; nothing is changed until the agent does it. A finished task's changes are read-only: ask for a follow-up in the conversation instead. Once the task opens its pull request, Changes shows the pull request review. Decisions waiting on the task - a red build, requested changes, a merge Foxl could not make - appear in its conversation, above a card saying the task was merged, is ready for your review, did not finish, or was cancelled, with its pull request, Resume (a Claude Code task in review) or Retry.

The pane carries the agent's output and nothing else: the header above it names the task's repository, coding agent and start time beside its status, links its pull request by number (and its issue), holds one alert slot and the view switch, and if a reconnect fails or a keystroke does not reach the agent, that is said in a strip over the pane that goes away once the condition does. Task actions in the header holds Reset session, Check out locally (in the Foxl desktop app with Where Foxl Code runs set to This computer, once the task has a branch - see On your own computer), Resume (in review: Claude Code tasks, or any task whose agent is still running), Open on computer... (continue the task on your own computer; see On your own computer), Mark done, Mark failed, Retry, Cancel and Delete, each where the task's status allows it. Deleting a task removes its history from Foxl's servers too: its event log, its last terminal screen and its chat thread.

When a task is waiting on your answer to a question, its status pill reads Waiting on your answer instead of Running, and its icon in the sidebar's task list turns orange with a message mark. When Foxl started the task itself (a red build's fix, a scheduled run, a plan step, a merge train or an issue), the instructions it wrote appear as Foxl's message under Foxl's instructions for the agent, not as your own.

Discuss in a channel... in the same menu shares the task into a workspace channel you are in. The channel gets a card for it, and the agent's questions, its pull request, a merge, a failed run, failed checks and requested changes are posted under that card as they happen, without ringing anyone's phone. Teammates answer under the card with Reply, and you read the thread in the task's Discussion tab, where you can answer the agent's open question with one of its options or with any reply, or send a reply on to the agent as a follow-up. Only you can answer or instruct the agent. The channel sees the task's title, repository and status, the pull request and the agent's questions (except one asking for a credential or a destructive step), never your prompt, the terminal or logs. Stop sharing ends the updates and leaves what was posted.

The Files page has a Tasks shelf with the checkout each coding agent edited, readable while its machine is still up (a recycled task's checkout shows as gone; its pushed branch is on GitHub), and a Computer shelf for a task that ran on your own machine.

Tasks that ran on your own computerアンカーリンクをコピー

A task can also run on your machine instead of in Foxl's cloud, once Where Foxl Code runs is set to This computer. Those are listed separately, under On this computer (only while that setting is chosen), because they are a different kind of thing: they have no cloud budget, no CI verdict and no reviewer round, and they live on that machine rather than in your Foxl account. Each row carries the assistant that ran it, the goal, the repository and how long ago, and opens the task's own page: the live terminal you can type into, the status, the branch, a Stop button, and the pull request link in its header once there is one. Rows open while the task is still running - that page is the only place the agent's output exists.

The group only appears where a Foxl desktop is reachable - so not on the web with your machine asleep. See On your own computer.