The run page

Follow an agent’s work live, answer its questions, step in when you want to, and read exactly what it changed. Every run has its own page in the web app. It streams the transcript, pins everything that waits on you, and keeps the diff, the cost and the audit trail after the run ends. To start runs and find them, see Start and track runs.

Available when your administrator enables runs.

What you can do with it

Approve from your phone. A run asks “Merge to main?”. You tap the answer in Slack, and the run carries on and finishes.
Correct course mid-run. You see the agent start on the wrong module. Type “Use the v2 client, not v1” and press Interrupt. The agent reads it before its next step.
Pick up where it stopped. A run finished but missed one case. Press Continue, write “Also handle empty input”, and a new run starts with the same conversation and a copy of the files.

See it end to end: Review every pull request and Triage alerts from your tools.

Walkthrough: a run from question to review

The run works. You open the run page from Runs. The transcript streams the agent’s messages and tool calls. The header pill shows the time left.
It asks. The agent asks “Merge to main?” with two buttons. The badge changes to Waiting on you, the question is pinned in Needs you, and it shows on Home and in Slack.
You answer from Slack. You press the button in the Slack message. The first answer claims the question, so nobody else can answer it twice. The run continues.
It finishes. The status changes to succeeded, and the page says how the run ended in plain words.
You review. Open the Changes tab to read the diff of every file the agent touched, Costs to see what the run spent on models and compute, and Audit to see every request it made.

How it works

The page

Header. The run title (select it to rename), the deputy and mission or “Ad-hoc run”, Prompt to read the task, the status badge, how it was triggered (manual, schedule, webhook, API or MCP), the runtime, the start time and the run id. A live run also has Take over, the time-left pill and Cancel run. A finished run has Continue.
Secrets hidden. When Marshal hid a credential from what the run printed, a badge such as 2 secrets were hidden sits next to the status. Red means the run printed a value Marshal injected, so rotate it. See Output redaction.
Pull request chips. When the run opens, merges, closes or reopens a pull request, a chip such as acme/api#482 open appears next to the run id. It shows the pull request’s state and links to GitHub. See Pull request impact.
Transcript. The agent’s messages and tool calls as they happen. While you read an older part, Jump to live takes you back to the end. Download log saves the transcript.
Live line. Under the transcript of a live run, one line says what the agent is doing right now, such as Running · npm test, Thinking or Writing, with how long it has been at it and the run’s token count. While a question waits on you, it reads Waiting for you.
Turn times. Each turn of the conversation shows how long it took. The turn in progress counts up every second and pauses while the run waits on a person. Times follow when the agent did the work, so they read the same when you leave the page and come back.
Needs you. A pinned stack of everything that waits on a person: questions, review requests and denied calls, oldest first. Each item is also marked in the transcript.
Shell drawer. A shell of your own in the run’s space, next to the agent’s. Open it with Shell while the environment is up.

The page refreshes every 4 seconds while the run is live.

The badge can say more than the raw status:

Badge	When
Waiting on you / Waiting on `<name>`	A question is open, and it says whose answer is needed.
Needs input	The run ended because nobody answered its question. Continue carries the answer.
Ended, not finished	The agent stopped without saying it was done. Continue picks up where it stopped. Filter the Runs page with Ended to list these runs.
Out of memory	The environment ran out of memory. A larger compute size fixes it.

The tabs

Tab	Shows
Details	The run’s facts, and the chain it belongs to (“continued by”, “continues”).
Preview	A live view of an app the run serves on a port. A question can point you here.
Changes	The git diff of the workspace, with the count of changed files.
Ports	Ports the run has open.
Blocked	Calls that policy denied.
Resources	CPU, memory and disk, as on a space.
Costs	What this run alone spent, not the whole chain. The total and its LLM and compute split come first, then a Compute card with CPU, Memory and Disk, then the model spend. See Billed compute cost.
Audit	The audit events for the run’s space.

A parked or finished run keeps Details, Changes, Costs and Audit. Changes are saved when the run parks or finishes, so you can always read them. The transcript is stored after the run ends and does not expire.

Read the conversation

Agent messages, your replies, the Last said strip, and the notices and answered questions in the transcript render as GitHub-flavoured markdown, so a report reads like a document, not like source.

Text. Headings, lists, task lists, tables, quotes, emphasis and inline code.
Code. Fenced code is highlighted for its language, labelled with that language, and has a copy button that copies exactly what is inside the fence.
Diffs. A diff fence colours added and removed lines.
JSON. A json fence is pretty-printed.
Diagrams. A mermaid fence is drawn as a diagram, with its source one click away.
Links. Links open in a new tab. When the link text differs from the address, the host shows beside it.
Images. An image shows as a card that names its host. It loads only when you click it.
HTML. Raw HTML shows as text. It never runs.

Long messages fold behind Show more. Replies you write render the same way, so a pasted stack trace or a fenced snippet reads well on both sides.

Read the output

The Output panel renders prose output the same way: the report a run returns, and any multi-line text value inside structured output. Single-line values stay as they are. Show raw and the copy button always give you the exact stored output.

Talk to a running agent

Use the reply box under the transcript.

Send queues your message. The agent reads it when it finishes the step it is on.
Interrupt asks the agent to stop sooner and read your message first. A command that is already running keeps going.

Press Ctrl+Enter (Cmd+Enter on a Mac) to send. A message can be up to 1 MiB. Each message shows a status chip, such as queued or interrupt relayed, and a queued message has Interrupt now.

While a question is open, the reply box shows the question, and your answer goes to the agent. While someone has taken over, that person sends the messages.

From the CLI: marshal deputies message <run-id> <text> queues a message, and --interrupt sends it with an interrupt.

Answer a question

A question shows in Needs you on the run page, on Home, in Slack if your Slack account is linked, and to a connected AI client through the inbox_answer tool. Answer in the web or with a Slack button. The first person to answer claims it.

A question can have buttons, a free-text answer, links and a live preview. Marshal opens the preview itself, never through a link the agent supplies.

The people asked can answer, and so can org owners and admins. If nobody answers for a while, the run parks and frees its CPU and memory. See Timeouts and parking.

Take over

Take over puts you in charge of a live run.

Press Take over in the header and add a reason if you like.
Press Take over now. The agent stops at its next step and waits. It is not canceled, and its clock stops while you hold it. The status becomes engaged.
Work in the shell drawer, which opens for you, and the reply box.
Press Hand back. The agent continues.

The first window is 30 minutes. Each extension adds up to 1 hour, to at most 4 hours in total. When the window ends, the run is handed back.

On an ad-hoc run, the person who started it can take over. On a deputy run, the deputy’s owner scope decides: the owning person, a member of the owning team, or an admin for an org deputy. To take over a parked run, use Wake to look first.

From the CLI, marshal deputies engage <engagement-id> opens a shell in the run’s space for a takeover.

Continue a finished run

Continue on a finished run starts a new run from it. Write an instruction, such as “Keep going, but also update the docs”. The new run:

keeps the same agent conversation
gets a copy of the previous working tree, when it is still kept
has its own run id and links back to the original, which does not change
inherits the title

The conversation is kept for 30 days after the run ends. A chain can be continued by hand up to 10 times. A run that was already continued shows “Continued by <id>” with a link. See Retention and archive for how long the files are kept.

To continue, you need the right to act on the run, to read the space it ran in, and to use the manifest. Every attempt is recorded in the audit log. If the button reads Can’t continue, see Help with runs and deputies.

Cancel

Cancel run works on any unfinished run. The run is marked canceled and its environment is removed. Anyone who can see the run can cancel it.


marshal runs cancel <run-id>

Try it

Start a run that asks you something:


marshal run --manifest <your-manifest> --task "Propose a README change and ask me before you write it"

Open it from Runs, answer in Needs you, then read the Changes tab.