---
title: "Move a step to AI"
url: https://services.dev/docs/operate/line
captured: [operate-line.txt]
---
# Move a step to AI

URL: https://services.dev/docs/operate/line

> A line answers one question, where a person still changes the work, and moves between its rungs on the record. A step moves down when the evidence clears a bar scaled to what a miss costs, slice by slice and tied to the model that earned it, and moves back up on its own. A reserved act never moves, and what it learns from still does.

A line answers one question: where does a person still change the work? [The rungs](https://services.dev/docs/people.md#the-rungs) are the places a person can stand at a step. This page is how a step moves between them: on evidence the record holds, scaled to what a miss costs, and back up the week the evidence breaks.

## Every move, and what sends it back

| From → to | What it frees | What the buyer waits for | What moves it back up |
|---|---|---|---|
| every job → a sample | the act on each job the sample skips | nothing: a sampled job ships first | a week over the bar, or an upheld send-back on a job no person saw |
| → flagged, and a sample of the rest | the sample's acts on jobs the review passed | the flagged jobs, while a person reads them | the same |
| → flagged only | every act on a job the review passes | the flagged jobs | an upheld send-back on a job the review passed |
| → AI alone | every act at the step | nothing | the first upheld send-back |
| reserved | nothing: the line is how the Service meets licensing by design | the person's act, every time | it never moved |

Inside the sample rung, the share halves each week the sampled send-backs stay under 2%, as [a sample that falls](https://services.dev/docs/people/sample.md) runs it. That weekly rule moves the share. The bar below moves the step off the rung, so a sample can halve every week and still wait for its evidence.

## The bar scales with the stakes

`human.evidence` names the bar. `check` sets `'high'` on every step that acknowledges a clock, and prints it:

| Bar | For a miss that | Jobs a person saw at this rung | Over | Upper 95% bound on changes | Also |
|---|---|---|---|---|---|
| `'standard'`, the default | the next week catches | 100 | 14 days | under 5%: one change in 100 clears it, two need 124 | — |
| `'high'` | misses a date | 1,000 | 182 days | under 0.5%: one change in 1,000 clears it, two need 1,258 | — |
| `'critical'` | no one can undo | 1,000 | 182 days | under 0.5% | a holdout, with no upheld send-back on a job AI shipped alone |

An object of your own, `{ jobs, days, under, holdout }`, sets any other bar. `by: [...]` names the slices the bar is checked in, by the same predicate [`hold --where`](https://services.dev/docs/operate/incidents.md#the-four-controls) takes, so each slice clears or holds on its own.

## The lines that are ready

```bash
npx services.dev line --all --live
```

```txt title="magic values: none"
api.lawyer · live · 16 Nov · every step a person is still on, ranked by what moving it frees a month
  step              rung                         evidence, against its bar                      ready  frees a month
  docket-watch.ack  a watcher on every ack in 7d  1,206 jobs · 182 days · 0 changes · ≤0.25% of 0.5%  now    $763.80
  reserved          7 acts on 5 Services keep their person whatever the count says · line <service> shows what moves under each
  apply             npx services.dev line apply docket-watch
```

```bash
curl https://api.lawyer/owner/line -H "authorization: Bearer $OWNER"
```

```json title="200 · magic values: none"
{
  "object": "list",
  "data": [{
    "object": "line",
    "step": "docket-watch.ack",
    "rung": "always",
    "next": { "rung": "sample", "human": { "sample": "25%", "floor": "5%", "by": "watcher", "evidence": "high" } },
    "evidence": { "bar": "high", "jobs": 1206, "days": 182, "changes": 0, "upper": 0.0025, "under": 0.005, "model": "claude-x@2026-05-20" },
    "ready_at": "2026-11-16",
    "frees_usd_month": 763.80
  }],
  "reserved": 7
}
```

api.lawyer's docket watch clears the high bar. A watcher acknowledges every date inside its last week, and in 26 weeks never changed the AI's read:

```bash
npx services.dev line docket-watch --live
```

```txt title="magic values: none"
Docket Watch · ack · watcher · an open act: rules.ts says acknowledging a date is a delivery act
  rung      a watcher on every ack inside 7 days of a date
  bar       high, as check sets it for a step that acknowledges a clock: 1,000 jobs over 182 days, upper bound under 0.5%
  evidence  1,206 acks over 26 weeks · the watcher changed the AI's read on 0 · upper bound 0.25% · check pinned to claude-x@2026-05-20 throughout
  ready     line.ready · the next rung is a sample that falls · $3,618.00 back over the 26 weeks at its 25% start, $4,582.80 at its 5% floor
  proposes  services/docket-watch.ts
            −   deliver: { check: 'ai', ack: { by: 'watcher', when: job => job.clocks.inside('7d') } },
            +   human: { sample: '25%', floor: '5%', by: 'watcher', evidence: 'high' },
            +   deliver: { check: 'ai' },
  apply     npx services.dev line apply docket-watch writes the change; deploy --live ships it with this evidence in its notes
```

A move down is a change to your file, so it ships through a deploy with its evidence in the version's notes. A move back up needs no deploy: the step goes back a rung for new jobs and records `line.reverted`.

Checked by office, the same step is ready in one slice and held in another, and a slice no job has reached starts at the top rung:

```bash
npx services.dev line docket-watch --by office --live
```

```txt title="magic values: none"
Docket Watch · ack · the high bar, slice by slice · evidence: { bar: 'high', by: ['office'] }
  office              acks   changes  upper   the bar
  USPTO               1,066  0        0.28%   ready
  PCT national phase    140  0        2.1%    held · 140 of the 1,000 jobs it needs
  EPO                     0  —        —       none yet · its first job starts at the top rung, line.reverted { because: 'slice_new' }
  proposes  the sample for USPTO acks only · a watcher stays on every PCT and EPO ack
```

## When the model changes

A line's evidence belongs to the model that earned it. A deploy that changes an AI step's model, brief or lenses carries the evidence forward only when the newest eval shows no lens finding fewer grounds. Otherwise each line that moved on it goes back one rung for new jobs, with `line.reverted { because: 'model_changed' }`. The 13:55 deploy that [ended an incident](https://services.dev/docs/operate/incidents.md#lift-it-without-going-back) carried its lines on `evl_3Lq7`:

```bash
npx services.dev deploy --live   # 30 Nov: docket-watch.check pinned to claude-x@2026-11-26
```

```txt title="magic values: none"
api.lawyer · 2026-11-30.1 · sha256:0c5d9e27a1f84b63… · tested 11 minutes ago
  checks  plan, stripe, model, domain and the live suite · 0 failed
  lines   docket-watch.ack moved on evidence earned on claude-x@2026-05-20 · evl_3Lr1 against 2026-11-30.1: 0 dates missed of 412, as on live · the evidence carries forward
✓ live    2026-11-30.1 · version.live
```

## What moves under a reserved act

The person stays, and the work around them improves. Each change an attorney makes becomes an eval label and a lens proposal, so the next version drafts closer to what they sign:

```bash
npx services.dev line trademark-response --live
```

```txt title="magic values: none"
Trademark Office Action Response · respond · attorney · reserved by rules.ts to bar admission
  rung      the attorney signs every response · the line never moves
  changes   attorneys changed the AI's draft on 23 of 412 (5.6%) · each change is an eval label: evals create --label attorney-changes
  lenses    the changes proposed 1 lens, genericness · it shipped in 2026-11-02.1
  act time  p50 18m in August → 11m in November · the attorney's $175.00 is unchanged: flat pay is earned on the act
```

## What buyers see when a line moves

A job's line is pinned to its [version](https://services.dev/docs/operate/versions.md#what-a-version-pins), so a move reaches new orders only. The Service's Site and Docs reprint who does the work on the next deploy, and a subscription hears `line.moved` before its next mint.

## Holdouts

`human: { holdout: '10%' }` ships a random share of a line's jobs the way the next rung down would, with a person checking each after delivery, so the evidence includes what buyers do with the AI's work alone. A defect a holdout finds is redone at no charge before the buyer acts on it. `check` refuses a holdout on a reserved act. Holdouts run on [Team](https://services.dev/docs/money/plans.md#team).

## Controls

| Call (CLI) | API | Event | On the console | Plan |
|---|---|---|---|---|
| `line <service> [--all] [--by <field>]` | `GET /owner/line?service=` | `line.ready` | `/console/line` | [Launch](https://services.dev/docs/money/plans.md#launch) |
| `line apply <service>` | `POST /owner/line/:service/apply` | `line.moved` | `/console/line` | [Launch](https://services.dev/docs/money/plans.md#launch) |

---

- Up: [Run your Service](https://services.dev/docs/operate.md)
- Previous: [Quality](https://services.dev/docs/operate/quality.md)
- Next: [Pool health](https://services.dev/docs/operate/pool-health.md)