---
title: "What Does the Future Production Line Look Like? Full-Inspection Vision, Patrol Agents, and an On-Prem 27B LLM in One Discrete-Manufacturing Plant"
date: 2026-09-05
description: "A live manufacturing plant: frame-by-frame vision inspection, three-a-day patrol agents, and a 27B on-prem LLM — the first unsupervised night shift, 2026-09-05."
category: "Industrial AI"
tags:
  - "computer vision"
  - "industrial inspection"
  - "AI agents"
  - "local LLM"
  - "vLLM"
  - "manufacturing"
verifiedHardware: "LineWatch patrol system on two live production lines at a discrete-manufacturing plant (production run Aug–Sep 2026) · on-prem machine-room workstation with a single RTX 4090D 24GB serving a Qwen-family 27B model, 4-bit quantized, via vLLM"
keyTakeaways:
  - "The system in one sentence: two production lines inspected frame-by-frame by computer vision (30 channels, no sampling), measurement data auto-flowing hourly into a central database, a patrol agent running three shifts a day (day patrol, overnight dispatch, morning reconciliation) that scores each line 0–100 with a defect ledger and delivers a PDF to the manager's phone — and on the evening of 2026-09-05, a test agent stood its first fully unsupervised overnight shift: eight rounds, one per hour, through the night."
  - "The brain lives inside the plant, and it is small on purpose: a Qwen-family 27B-parameter open-weights model, 4-bit quantized, on one RTX 4090D 24GB under vLLM, handles all three text roles — summarizer, event judge, alert triage — with zero process data leaving the factory. The working discovery: what the small model lacked was not reasoning but plant-specific common sense, fixed not with a bigger model but with ~1.2K-word one-page role manuals. On the night of 2026-09-05 the judge scored 5/5 (including one correct 'uncertain'), triage stress test 5/5, and automated number-fidelity checks against real patrol JSON found zero fabricated numbers."
  - "The economics of the architecture: adding a new agent is a job description, not an integration project; response speed moves from days (sampling era) to hours (dashboard era) to minutes (agent era); and the whole digital layer is run by one person plus agent colleagues — adding a production line is approximately adding a config, replicating a factory approximately replicating the stack."
measuredOn: 2026-09-05
faq:
  - q: "What is LineWatch?"
    a: "The working codename of the intelligent patrol system covered in this series — a computer-vision surface-inspection and agent-patrol stack running since August 2026 on two live production lines at a real discrete-manufacturing plant. The codename describes the function, not the owner. It is not a vendor product or a pilot slide deck: the patrol agent has been filing scored reports three times a day, and on 2026-09-05 its sibling test agent ran the first unsupervised overnight research shift. The plant is identified only as a manufacturing plant; the operator and client are not named."
  - q: "Why run the LLM on-premises instead of calling a cloud model?"
    a: "Industrial process data is a red line — cloud models are kept outside the factory gate. The working answer is to move the brain inside instead: a Qwen-family 27B-parameter open-weights model, 4-bit quantized, served by vLLM on a single 24GB consumer GPU (RTX 4090D class) on a workstation in the line machine room. Summaries, event judging and alert triage all complete locally; no process data leaves the building."
  - q: "Can a small local model really judge production events reliably?"
    a: "Not out of the box — and the fix was not a bigger model. The 27B lacked plant-specific common sense (what a cron timing gap looks like, that a dashboard red light is display-layer lag, which scores it must never compute itself). Each text role got a one-page manual of roughly 1.2K words as its system prompt, iterated through three documented rounds. On the night of 2026-09-05: event judge 5/5 cases correct including one honest 'uncertain', alert triage 5/5 under stress testing (real faults not downgraded, orphan alerts kept independent, device alerts exempt), and zero fabricated numbers in automated per-number comparison against real patrol JSON."
  - q: "What did the first unsupervised night shift actually do?"
    a: "Dispatched on the evening of 2026-09-05 after gate conditions cleared, the test agent ran one round of controlled measurement on both lines every hour on the hour — eight rounds over eight hours, through the night — then handed its results to the morning patrol for reconciliation. Unattended sentinel checks reported to the manager's phone minutes after launch under a 'must send, silence is the alarm' contract. The rehearsal earlier that evening (18:09–19:15, five gates, all passed) is Episode 1 of this series."
  - q: "Is it safe to let agents loose on live production lines?"
    a: "Every collection action in the system is permanently read-only, hard-coded. Exactly one write action exists in the entire system — dispatching research — and it is gated: line reachable, container up, database fresh within 60 minutes, at least one line producing. The test agent has entry conditions (unsafe, no entry), a yield mechanism (if someone is already there, it exits), a canary self-check (invalid data means the round alarms instead of measuring), and a ledger (every dispatch is logged)."
  - q: "What is the three-way model comparison the plant is running?"
    a: "A same-question bake-off started on the night of 2026-09-05: a cloud LLM versus the local 27B with its role manual versus the local 27B with no manual, all answering from the same patrol dataset, results due the next morning. The stated selection philosophy: not which model is smarter, but which one errs less and more stably."
---
On the evening of 2026-09-05, at a discrete-manufacturing plant, a test agent clocked in for its first fully unsupervised overnight shift: eight rounds of controlled measurement on two live production lines, one round every hour on the hour, running through the night, with results reconciled into the morning report on the manager's phone. The lines it watched are inspected frame-by-frame by computer vision — 30 channels, no sampling, no blinking, no shift end — and whatever deserves a human's attention gets its annotation written by a Qwen-family 27B-parameter model, 4-bit quantized, running on a single RTX 4090D 24GB in the plant's machine room under vLLM: not one byte of process data leaves the factory. This dispatch is the anchor map of that system — the one-piece picture of what runs, what is measured, and what it costs to operate. The episodes that follow carry the field record: [the dress rehearsal before the first night shift](/posts/2026-09-05-machines-keep-the-watch-ep1-first-night-shift/), [the one second of the evening that contained no AI at all](/posts/2026-09-05-machines-keep-the-watch-ep2-190000-no-ai/), [the night the hardest paper came back blank twice](/posts/2026-09-11-machines-keep-the-watch-ep3-blank-paper-exam/), and [the bill for the plant's one AI call](/posts/2026-09-12-machines-keep-the-watch-ep4-the-bill/).

One sentence frames the whole architecture, borrowed from the operator: **machines keep the night watch, AI builds the clocks, humans set the time.**

## What is actually running

The LineWatch intelligent patrol system, as it stood on 2026-09-05 (two live production lines at a discrete-manufacturing plant, production run August–September 2026, all timestamps in this series are local plant time):

| Layer | What it is | Status on 2026-09-05 |
|---|---|---|
| Eyes | Computer-vision inline inspection, every frame checked, real-time data | In production daily |
| Nerves | Four industrial PCs plus the dev machine, encrypted internal network, star topology, bidirectional | Fully interconnected |
| Memory | Central unified database, hourly incremental flow (watermark + dedup) | Running every hour |
| Reflexes | Equipment health dashboard (minute-level) and data-platform dashboard (pipeline control room) | Standing services |
| Brain | Agents: two already on the job, more on the drawing board | **First night shift this evening** |
| Delivery | Scored PDF report + short bulletin, straight to a phone | Every patrol, without fail |

The vision layer deserves its own emphasis: it is not a camera that samples. Every frame of product on both lines is seen — 30 channels scanned frame-by-frame, 365 days a year. Data is no longer "samples that were collected"; it is a river that flows.

## From sampling to seeing everything

Quality inspection used to work like this: a senior operator stands beside the line, pulls a few pieces from a batch, measures them offline, aggregates statistics afterwards. Anomalies are discovered in units of "batches"; reactions happen in units of "days." The essence of sampling is **inferring the batch from the sample** — information after the fact, offline, probabilistic.

These lines work like this: computer vision inspects inline, every frame of product image is seen, 30 channels scan frame-by-frame, all year, no sampling, no blinking, no shift end.

The jump from sampling to full inspection is not "checking more" — it is a qualitative change in what information is: **quality information moves from after-the-fact inference to direct reading of the process.** Quality is no longer verified after the fact; it is watched as it happens.

But seeing is only the first step, and most factories stop there: each inspection instrument is an island, data lies on its own disk, and "real-time" dies at the machine-room door. This factory finished building the road — hourly incremental flow into one central database, watermark plus dedup, so data neither repeats nor drops — which is what makes everything below possible. The operator's formulation is exact: real IoT is not connecting devices to some cloud; it is **every machine can be found, asked, and entrusted** — eyes grown onto nerves, nerves connected to the brain.

## The roster: agents already on the payroll

Once the data converges, the agents take their posts. This is not roadmap material — it is the headcount list as of 2026-09-05:

**The patrol agent** — three shifts a day, every day: a full day-shift inspection (including the day's spec-change deep scan), the overnight dispatch that launches the night research, and the morning harvest that reconciles it and files the morning report. Every shift produces, per line, a lab-report-style PDF: a 0–100 score, highlights, a problem ledger, an AI-written running summary — plus one merged bulletin to the phone, roughly 5 minutes from line to pocket. That same afternoon, the patrol caught a real process event with no human on site: line one scored 90 (deduction: an early-afternoon spec change with a 25-minute detection gap), line two scored 100.

**The test agent** — first night shift on the evening of 2026-09-05. Every hour on the hour it runs one round of controlled measurement on the live lines — eight rounds across eight hours — verifying exactly the thing no offline benchmark can: **the production line's own consistency, measured with the line's own data**. It has entry conditions (unsafe, no entry), a yield mechanism (if a human is already working there, it stands down), a canary self-check (invalid data alarms instead of measuring garbage), and a ledger (every dispatch is on the record).

The future job descriptions are already queued: an equipment doctor (predictive maintenance), a quality intelligence officer (sigma-drift early warning), a changeover advisor (optimal windows), a data steward (pipeline self-healing), a rhythm coach (throughput optimization).

> **Adding a new agent is no longer an integration project. It is a job description.** That is the real dividend of interconnection: the cost of intelligence drops from "engineering" to "writing."

The whole loop fits on one canvas, and the operator reads it in three acts — the unstaffed workshop, the machine-room brain, the human pocket — along a single path: ① every frame inspected → ② data auto-flows → ③ the agent patrols → ④ AI annotates → ⑤ report in the pocket → ⑥ human ruling, fed back as new rules and new cases.

## Why does the LLM have to live inside the plant?

Because industrial process data is a red line, and the cloud stops at the factory gate. The plant's answer is not to negotiate the red line but to move the brain inside it: a Qwen-family open-weights model with 27B parameters, 4-bit quantized, served by [vLLM](https://github.com/vllm-project/vllm) on a single 24GB consumer GPU (RTX 4090D class) on a workstation in the production machine room. All three text roles — summarizer, event judge, alert triage — run locally.

The key discovery of the deployment is worth quoting precisely, because it inverts the usual scaling instinct: **the small model was not missing reasoning power; it was missing this factory's common sense** — what a cron timing gap looks like, that a dashboard red light is display-layer lag rather than a fresh fault, which scores it is absolutely not allowed to compute itself. The fix was not a bigger model. It was a one-page manual of roughly 1.2K words per role, written as the system prompt, handing the model the plant's own common sense.

The manuals iterate, and the iteration is the story. Three documented rounds on 2026-09-05 alone:

| Round | Failure observed | Manual amendment | Retest result |
|---|---|---|---|
| 1 | The judge hard-guessed "collection interrupted" on an event with insufficient evidence | "Insufficient evidence → rule uncertain" | Rules "uncertain" and hands back a human follow-up path — correct |
| 2 | Triage opened an independent case for a dashboard red light | "Dashboard red = display-layer lag, check before opening a case" | Correctly merges into the existing case |
| 3 | Stress test: an orphan alert merged into an already-closed case | A boundary rule for closed-case handling | 5/5 correct under retest |

The same night's battle report, from the operator's late-night test log of 2026-09-05: the event judge ruled 5 of 5 cases correctly — including one where the correct ruling was "uncertain," which the model issued instead of guessing; the alert triage passed a 5/5 stress test (a real fault was not falsely downgraded, an orphan alert stayed an independent case, a device alert was correctly exempt); and an automated number-fidelity check that compares every number the model writes against the real patrol JSON found zero fabricated numbers. For an industrial text role, that last number matters more than fluency: a summary that invents a score is worse than no summary.

One comparison is still open as of this writing: a three-way, same-question bake-off — cloud LLM versus local 27B with manual versus local 27B with no manual, all answering from the same patrol data — was launched on the night of 2026-09-05 with results due the next morning. The plant's stated selection philosophy for that test: **not which model is smarter, but which one errs less, and more stably.**

## Days, hours, minutes

Stack the three layers — frame-perfect vision, hourly data convergence, automatic analysis — and you get the thing manufacturing has chased for half a century: real-time advanced process quality and process control. Its essence is a three-stage jump in response speed:

- Sampling era: anomaly found, in **days**;
- Dashboard era: anomaly seen, in **hours**;
- Agent era: anomaly understood and accompanied by a recommendation, in **minutes**.

The loop closes in three stages, each with its own guardrail: data → report → human decision (running today); data → recommendation → human approval (the overnight research is the first controlled action, and the system's only write entry point); data → controlled execution (every inch of new permission arrives with an inch of new guardrail). In manufacturing, the distance from data to action is itself competitiveness — **a week late is an incident; an hour early is an adjustment; a minute-level response is immunity.**

When inspection is real-time, data converges, and analysis is automatic, the production model itself becomes programmable: quality shifts from verified to controlled; process tuning shifts from experience-driven iteration to nightly controlled experiments — the test agent runs them for you all night; and the night shift shifts from "the unsupervised hours" to "the precisely measured hours."

## One person's fleet

The most striking detail of the picture is the headcount. The entire digital layer — vision pipelines, converging databases, dashboards, two agents, a local LLM with its manuals — is operated by **one person** and their agent colleagues. Not built by headcount; grown by architecture. And it replicates by construction: adding a production line is approximately adding a config; duplicating a factory is approximately duplicating the stack.

That may be the new organizational physics of AI-era manufacturing: **headcount stays flat while capability grows in units of agents.** The human's job description is the one thing that does not commoditize — set the standards, make the rulings, set the clocks.

## Tonight, and where the record continues

On the evening of 2026-09-05 the first overnight employee clocked in: hourly rounds, eight of them, first full overnight report due the next morning. The machine room is quiet — one workstation, a few steady indicator lights. But if you could see the data, you would see a loop starting to turn: **machines produce data, data feeds intelligence, intelligence returns to the machines.**

The episodes that follow carry the evidence:

- [Episode 1 — No One on the Line Tonight](/posts/2026-09-05-machines-keep-the-watch-ep1-first-night-shift/): the 18:09–19:15 dress rehearsal, five gates, all passed unattended, with the timestamped verification table.
- [Episode 2 — 19:00:00 Sharp, and No AI in That Second](/posts/2026-09-05-machines-keep-the-watch-ep2-190000-no-ai/): the division of labor between deterministic code and AI, and why run-time reliability never depends on the model.
- [Episode 3 — The Hardest Paper Came Back Blank Twice](/posts/2026-09-11-machines-keep-the-watch-ep3-blank-paper-exam/): the on-prem 27B's two blank papers on the changeover-daily exam, the config race behind them, and the three-way verdict that kept code, cloud and local each in their seat.
- [Episode 4 — The Whole Factory Had One AI Call](/posts/2026-09-12-machines-keep-the-watch-ep4-the-bill/): the token audit that found one LLM call point in thirty days, priced its agent harness at ~97% door fee, and rebuilt it same-model to ~2K the same day.
- [Episode 5 — The Staircase](/posts/2026-09-13-machines-keep-the-watch-ep5-the-staircase/): every job in the plant on four steps, the word "need" retired, the industrial-agent purchase case taken apart component by component — and the ruling that kept both lanes running.
- [Episode 6 — The Audit Came Home](/posts/2026-09-12-machines-keep-the-watch-ep6-the-compaction/): the same audit turned on the operator's own desk — ~1.8B tokens in thirty days, ~95% of it re-reads — and the compaction cure that costs detail memory.

### A small dictionary

*Full inspection: computer-vision frame-by-frame detection replacing human sampling · Agent: a software employee that autonomously holds down a class of job, with duties, permissions and a reporting line · Test agent: an agent that executes controlled experiments on the live production line · Watermark: the progress mark of incremental sync, data neither repeated nor dropped · Sentinel: an unattended scheduled checker under a "must send" contract — silence is the alarm · Single write entry point: exactly one approved "action" permission exists in the whole system; everything else is read-only forever.*

## Sources and method

First-party: the operator's same-day Chinese-language field records of 2026-09-05 (the patrol reports, the rehearsal log with timestamps, the LLM test log) — assembled into English with AI assistance under human editorial direction, with every fact and number carried over unchanged from those records. Deliberately absent, by disclosure policy: anything that identifies the plant, its industry, its operator or its network (addresses, hostnames, internal paths, credentials, service ports). The measured numbers are registered in the [/data/ ledger](/data/).

*[All episodes](/series/machines-keep-the-watch/) — Machines Keep the Watch, a field-record series. Episode 1: [the dress rehearsal](/posts/2026-09-05-machines-keep-the-watch-ep1-first-night-shift/) · Episode 2: [the second without AI](/posts/2026-09-05-machines-keep-the-watch-ep2-190000-no-ai/) · Episode 3: [the blank-paper exam](/posts/2026-09-11-machines-keep-the-watch-ep3-blank-paper-exam/) · Episode 4: [the bill](/posts/2026-09-12-machines-keep-the-watch-ep4-the-bill/) · Episode 5: [the staircase](/posts/2026-09-13-machines-keep-the-watch-ep5-the-staircase/) · Episode 6: [the compaction](/posts/2026-09-12-machines-keep-the-watch-ep6-the-compaction/).*