A workflow in the back seat, nagging your agent through every step.

searching: {
  on: {
    'search.results': {
      target: 'summarizing',
      // A clarification of the transition, read while choosing. No instructions here.
      description: 'That was the last query.',
      …
    },
  },
},

summarizing: {
  // A clarification of the state, read while choosing. No instructions here.
  description: 'Every query has been answered; the sub-task needs a written finding.',
  // Handed to the agent on arrival, told the context and which visit this is.
  instructions: ({ visit }) =>
    visit === 'first'
      ? 'Write a finding that answers `data.subQuestion` from the hits you gathered, …'
      : 'Conclude on `data.subQuestion`: write the finding, say that nothing supports an answer, or resume the search.',
},

type LeadEvent =
  | { type: 'brief.submit'; question: string; output: { rounds: number; budget: string } }
  …

briefing: {
  on: {
    'brief.submit': {
      target: 'planning',
      schema: z.object({ question: z.string().min(10) }),
      // The effect: how many rounds the question warrants, judged from the question, not set by the agent.
      effect: ({ event }) => judgeMaxRounds(event.question),
      // event.output is what the effect returned. The actions keep the part the run needs later.
      actions: assign({
        question: ({ event }) => event.question,
        maxRounds: ({ event }) => event.output.rounds,
      }),
    },
  },
},

planning: {
  // The landing state's data: the budget from context on every visit, and once, from the effect, why it is what it is.
  data: ({ context, event }) => ({
    round: context.round + 1,
    maxRounds: context.maxRounds,
    ...(event?.type === 'brief.submit' && { budget: event.output.budget }),
  }),
  …
},

import { researchTask } from './research-task.ts'   // a machine of its own: the subagent's workflow

// The roster: the machines this workflow can spawn, each under the name its spawns and collections use.
actors: { researchTask },

…

researching: {
  …
  // Spawned on arrival, as an entry action.
  entry: spawnChild('researchTask', {
    id: ({ context }) => `task-${context.round}-${context.dispatched}`,
    // For the agent: what this subagent was sent for, read out on the call that spawns it.
    about: ({ context }) => context.current?.subQuestion ?? '(no sub-question)',
    // For the subagent: the context its own workflow starts with. Nothing else of the parent's reaches it.
    input: ({ context }) => ({ subQuestion: context.current?.subQuestion ?? '', question: context.question }),
  }),
  on: {
    // The next sub-task: re-enter, and spawn again.
    'task.next': { guard: hasPending, target: 'researching', reenter: true, actions: assign(takeTask) },
    // Held until every subagent spawned here has settled. What enters the parent's context is the workflow's call.
    'research.review': {
      guard: queueDrained,
      target: 'reviewing',
      actions: collectChildren('researching', 'researchTask', assign(({ context, event }) => {
        const findings = [...context.findings]
        for (const site of event.settled)
          for (const child of site.children) {
            const report = child.status === 'done' ? asReport(child.output) : null
            …
            findings.push({ actorId: child.actorId, subQuestion: report.subQuestion, sources: report.sources })
          }
        return { findings, … }
      })),
    },
  },
},

import { backseat, RejectedEvent } from 'backseat-ai'

'finding.submit': {
  target: 'complete',
  description: 'The sub-question is answered.',
  schema: z.object({ summary: z.string().min(80), sources: z.array(source).min(1) }),
  // The sources are checked at the source: a run once accepted a citation its own title called "page 404'd".
  // Only a page the server says is gone is refused; any other status, and any failure to reach it, passes,
  // since a page that blocks bots is not a page that is gone. Some servers answer HEAD with 404 and GET with the
  // page, so a HEAD that says gone is confirmed with a GET.
  effect: async ({ event }) => {
    const statusOf = (url: string, method: 'HEAD' | 'GET') =>
      fetch(url, { method, signal: AbortSignal.timeout(10_000) }).then(
        (res) => (res.body?.cancel(), res.status),
        () => 0,
      )
    const gone = await Promise.all(
      event.sources.map(async ({ url }) => {
        const head = await statusOf(url, 'HEAD')
        const status = head === 404 || head === 410 ? await statusOf(url, 'GET') : head
        return status === 404 || status === 410
          ? `${url} is gone (HTTP ${status}). Cite the page you read instead, or drop it and say what rested on it.`
          : null
      }),
    )
    const reasons = gone.filter((reason) => reason !== null)
    if (reasons.length > 0) throw new RejectedEvent(reasons.join('\n'))
  },
  actions: assign({ summary: ({ event }) => event.summary, sources: ({ event }) => event.sources }),
},