Delegating a task

Added · Last updated
Prerequisites

The actor has a piece of work that can be finished: there is an outcome they want now, and they will know when they have it. They have judged that handing it to an agent is worth more than doing it themselves. That judgement happens before this sequence, and no pattern here makes it. The sources the agent should work from exist, and the actor can point to them.

The actor has a piece of work that can be finished and wants it done now, with the sources it should be done from at hand. The walk leaves a result the actor can stand behind without having made it, and it is walked once for each task. The run can happen while the actor watches or while they are away, and several steps differ between the two.

Other sequences lead here: the encounter, where an open request becomes the prompt, and learning, where a newcomer’s starting content is generated from what they say they want.

Work that has no point of completion, because it comes back on a schedule or whenever something happens, is delegating standing work, which uses this walk for each of its runs. A task that waits on an event, such as telling the actor when a price drops, can be finished but leaves the actor’s attention with no known time of return, so it borrows that sequence’s steps for watching and ending.

Handing the work over

  1. Write the request — Prompt

    Help the actor turn what they want into a request the agent can act on, in their own words and without special syntax. Ask only for what this task is missing, and leave standing preferences until early use gives the agent a reason to ask. Keep the request so the actor can edit it, reuse it, or make it a template.

  2. Give the agent what the task needs

    Both act on the request, and neither comes first: a source may need access before it can be attached, and access to act is not needed until the agent starts.

    In any order:

    • Attach the sources to work from — Reference material

      Let the actor attach files, mentions, and connected sources inside the request, so the agent works from their sources rather than from general knowledge. Show what is attached and let the actor remove it. Citations later point back to these sources, as set up in calibrating reliance.

    • Ask for the access the task needs — Permissions · optional

      Where the task reaches something the actor controls outside the artifact, such as a calendar or a mailbox, ask for it at the point it is needed, with its purpose. Say whether the grant ends with the task or stays for later ones. Skip this where everything the task needs is attached or already inside the artifact.

  3. Hand the goal to an agent — Agent

    The actor can state the goal but not the procedure, so an agent decides how to reach it. Decide whether the agent works in a focused view, inline, or in the background, and keep how much it may do on its own easy to find; the limits themselves are set in governing autonomy. The work now happens while the actor is not watching, so the agent owes an account of it, which the next steps provide.

Following work out of sight

Applies when: The run has started and the actor is elsewhere, nearby for a few minutes or away until morning. The agent owes the account promised when it took the work on.

  1. Show the work as it happens — Live presentation · optional

    Show the output as it forms, so the actor can read ahead, judge early, and stop the run with the stop designed in the encounter. Skip this for a run nobody watches by design, such as an overnight run; the status and the record cover it.

  2. Keep the run's status visible at a glance — Status feedback

    Show the status on the place the work already has, the session or the item the agent was given, as the work of a person would show there: whether the run is still on task, what it has produced so far, and which way its measures are moving. When a measure moves in a worrying direction, the status becomes an interruption, graded in attention and tempo.

  3. Show the reasoning — Transparent reasoning

    Show how the agent is working, in the form that fits who is watching: a running account beside the live output when the actor watches, and explanations attached to the record when nobody did. Reasoning that looks thorough invites the actor to stop reading it, and the friction that keeps them judging is added in calibrating reliance.

  4. Keep a lasting record — Activity log

    Record each event with who acted, what they did, what it applied to, and when, and let the actor narrow the record down. This is the account the agent owed when it took the work on, and part of what memory and continuity keeps across sessions.

Receiving the result

Applies when: The run has finished and something substantial has arrived: text, a draft, or a set of changes. The actor's job is now to judge rather than make. Accepting all of it takes no effort, while checking it takes time in proportion to its length.

  1. Present the result for judgement — Generated content

    Let the actor rate the result, take parts of it, and trace each part to the source it came from, so they can stand behind a result they did not make. Proposing what to do next with the result is decided in assistance escalation.

  2. Decide where the result goes

    Decide for each result. A short answer that is read once stays in the reply and needs neither.

    One or more of:

    • Show the result as a set of changes — Change review

      When the result changes something that already exists and matters, show what was there and what would replace it, and let the actor accept it in parts. Show enough of what surrounds it to judge the change, since the actor did not write it and did not watch the work. The set of changes is also what an approval in governing autonomy acts on.

    • Move the result out of the conversation — Extraction

      When the result matters more than the conversation that produced it, give it its own name, link, and versions, so it no longer depends on the conversation. Decide what the conversation keeps, so it still reads afterwards as a record of what happened.

Correcting the result

Applies when: The result is not right: close but wrong in a way the actor can name, or wrong in a way they can only reject. Each correction works on the result wherever the previous step put it.

  1. Choose how to correct it

    Choose for each problem, not once for the whole system, since all of these are needed. A third option, making the change directly, leads out of this sequence into making changes.

    One or more of:

    • Say what to change — Instructed revision

      Let the actor say what is wrong, such as shorter, warmer, or only this part, so the result changes without being remade or the request rewritten. Let the actor limit a change to one part, so the parts that were already right stay as they are.

    • Ask for another attempt — Regeneration

      Let the actor ask for another answer to the same request: the whole, a part, or several versions side by side to compare. A new attempt replaces the previous one, and the way back to it is the undo in making changes.

  2. Make a repeated correction a standing instruction — Standing instructions

    When the actor gives the same correction for the third time, offer to make it an instruction for every later task. Either side can notice the repetition: the actor promotes the correction, or the agent counts the repeats and proposes the instruction. The editor for it uses the form parts of making changes, with its set of fields left open.

Leaves: The task is done: the actor has a result they corrected by judging rather than writing, and corrections that recurred have become standing instructions. The actor has shaped a result they never wrote, so it is unclear who authored it and who answers for its details. A task the actor finds themselves handing over again and again is made standing in delegating standing work.