Jobs

A job is one conversation that ran: the prompt, the steps it took, the result, and the trace. A scene collects many jobs over time, since every prompt, refresh, and scheduled run is one. The scene's cells show the latest state; the job log shows how it got there.

A job does the work and waits when it needs someone

you ask for something
→ the agent replies, may make a plan
→ it works through the plan
→ some steps wait on someone:
  you         an OK, an answer, a login
  a teammate  their answer
  a customer  their email reply
  the clock   9:00 tomorrow
→ once they're in, the work goes on
→ every step done, the job is done

Nothing runs while a step waits, and you can close the app. The plan stays in the job, and the server carries on when the answer comes.

A plan can wait days for a reply

Say what should happen later and the agent writes the plan now. "When Mike replies, ask Moritz for feedback, draft my answer and let me approve it" becomes four steps: wait for Mike's email, ask Moritz, draft the answer, hold it for you. The job waits on Mike, then on Moritz, then on you, and sends nothing until you approve.

While it waits, the job shows what is coming up. Each step sits under when it happens (Now, When Mike writes, Tomorrow) next to the person it reaches or waits for, and the step being waited on counts down to its deadline. A message the plan will send shows its words before it goes, and once it is drafted you can edit it right there before you approve.

A wait can have a window. Give the plan something to do when nothing comes, like "if he hasn't answered by Friday, tell me", and that branch runs instead. To change a plan while it waits, say so: "make the thank-you shorter" replaces the waiting plan with a new one, and nothing of the old one runs.

A write waits for your approval

When a step writes, to a database or an external service or a system of record, the job stops and asks. You see the exact diff and approve, reject, or modify it before the write commits. Each step goes pending → ready → running → waiting (on a person, a device, or an event) → completed, failed, or cancelled, and the changes stream in real time. Approvals covers the gate.

What a job records

  • The prompt that started it
  • Every tool call the agent made, with name, inputs, outputs, duration, cost
  • Every pause and how it was answered
  • The final response or artifact
  • A permalink that anyone with access can open

The team discusses a job, and the agent acts when asked

Everyone in the scene can write in a job. Tag @agent and it acts on your message. Tag a teammate and they get a push; the agent does nothing. Tag nobody: in a job you started by asking the agent, it acts on every message. In a job you started by writing to a teammate, it waits to be asked.

Each message shows who wrote it. Writing to teammates is free. Asking the agent runs a metered turn with the usual approval gates.

A job can start without a person

A job starts with a prompt, typed or scheduled or fired by an event: a webhook, a calendar trigger, another scene's output. From there it runs like any other, pauses included.

The trace covers debugging, sharing, and audit

When a job goes wrong, the trace shows which tool call failed and with what input. When a colleague asks what happened, the permalink shows them the same trace instead of screenshots. And every write is recorded with who, when, and why. Audit covers what gets logged where.

Jobs can run without a scene

One-off queries and ad-hoc tasks run as jobs too, with the same trace and the same permalink, just no persistent surface.

What's next

Updated 2026-10-17