> ## Documentation Index
> Fetch the complete documentation index at: https://docs.thread.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Milestones and verification

> Milestones are plain-English customer outcomes confirmed by an agent or a human, and the required ones are the gate for advancing a stage.

Every stage in a Motion carries a list of **milestones** — the customer outcomes that stage exists to produce, written in plain English: "Sending domain authenticated", "Admin has invited the team", "First report scheduled". Milestones are what the account's stage panel tracks, what the customer sees in their [portal](/customer-portal/overview), and what gates the advance to the next stage.

<Frame>
  <img src="https://mintcdn.com/threadsolutionsinc/zrnqSMRcQ5MGUbqN/images/screenshots/motions/stage-panel.png?fit=max&auto=format&n=zrnqSMRcQ5MGUbqN&q=85&s=8deea0cfb830a4b48406c2cf6babf949" alt="An account in a Motion's Setup stage: milestone rows with required, agent, and manual tags, Run checks, agent-cited evidence, and the Advance button disabled at 2 of 3 required met" width="3200" height="2000" data-path="images/screenshots/motions/stage-panel.png" />
</Frame>

There is no separate exit-criteria layer to maintain. The milestone list is the single source of truth: the ones you flag as required *are* the gate.

## Two ways a milestone gets confirmed

Each milestone is confirmed in exactly one of two modes, chosen with a toggle in the stage editor:

**Agent** — an AI verifies the outcome by reading your connected systems. You write one plain-English check ("what should the agent confirm?"), and the agent answers it by calling the account's connected **read-only** tools — your CRM, Google Workspace, Slack, and the rest of your [integrations](/integrations/overview). The check is grounded: the agent has to cite what it actually found, and it can only ever confirm a milestone — it never un-confirms one that has already been met.

**Manual** — a human marks it. Use this for outcomes that live outside anything Thread can read: a signed-off kickoff call, an in-product metric from a system that isn't connected, a judgment call.

<Note>
  No faking: if an agent-confirmed milestone can't actually be verified — because no connected tool can see that outcome — Thread shows you the honest gap ("No connected tool for the agent to verify with yet — connect one or use Manual") instead of a false green. The stage editor flags this at authoring time, keyed on which read tools your org actually has connected.
</Note>

## When checks run

Agent checks run two ways:

* **Automatically** — Thread sweeps active accounts on a schedule and re-runs the checks for each account's current stage.
* **On demand** — the account's stage panel has a **Run checks** button that runs the live agentic check immediately for that stage's agent-confirmed milestones. Use it after a customer tells you they've finished something, or to sanity-check a new Motion without waiting for the sweep.

Either way, a confirmation is only written when the agent found real evidence in a connected system. A confirmed milestone shows what the check consulted, so you can see *why* it's green.

Manual milestones are marked directly on the milestone row in the account's stage panel.

## The required flag is the stage-advance gate

Each milestone has a **Required to advance** toggle. That flag is the entire gating model:

* The stage panel shows the gate as a running count — "3 of 4 required met".
* Non-required milestones are still tracked and still visible to you and the customer; they just don't block the advance.
* A stage with no required milestones gates on nothing — the advance is available whenever you judge it right.

When the last required milestone on the current stage confirms, the runtime **proposes** the stage advance to a human. An item lands in the [Inbox](/inbox/overview) saying the account is ready to advance, and the stage panel's **Advance** button goes live. A person reviews and confirms; nothing advances automatically. See [Motions overview](/motions/overview) for the full advance flow.

## Authoring milestones

In the Motion editor, open a stage and add milestones to its list:

<Steps>
  <Step title="Write the outcome">
    One plain-English line, phrased as the customer outcome — this is the label you, your team, and the customer will all see.
  </Step>

  <Step title="Choose Agent or Manual">
    Agent mode adds a check field: describe what the agent should confirm, in plain English. If your org has no connected read tool that could answer it, the editor shows the honest-gap notice so you can connect one or switch the milestone to Manual.
  </Step>

  <Step title="Set Required to advance">
    Flag the milestones that define "done" for this stage. Everything else is progress color.
  </Step>
</Steps>

If you [AI-draft a Motion](/motions/build-your-motion), the builder generates the milestone list for each stage from your source material and tags each one as agent-verifiable or manual based on what Thread can actually check — you review and adjust the same list in the same editor.

<Tip>
  Keep required milestones few and load-bearing. They are the definition of stage-done, so each one should be an outcome you would genuinely refuse to advance without. Track the nice-to-haves as non-required milestones instead.
</Tip>

## What the customer sees

Milestones flow to the [customer portal](/customer-portal/overview) grouped by stage — the same outcomes, the same confirmations, in customer-facing language. Confirming a milestone isn't just internal bookkeeping; it's how the customer knows the program is moving.