OpenAI Codex 'Watch Once, Repeat Forever': What It Means for Local Coding Rigs

"Watch once, repeat forever" is OpenAI's shorthand for showing Codex a task once — a browser click sequence, an API call, a bash pipeline — and letting it generalise the same recipe over new inputs on later runs. There is no direct local port of the exact SaaS, but you can build a very similar loop on a 12 GB RTX 3060 rig using Aider or Cline with a locally hosted 14B–22B coder model. Latency is a hair worse, privacy is dramatically better, and the payoff at $0 per additional run is unbeatable if you already own the GPU.

The demonstration-learning trend and why local-rig builders care

Cloud coding agents have been prompt-heavy and demo-light: every task is a fresh prompt, sometimes with a system message that carries "your role" and a growing tail of user context. What OpenAI's Codex announcement points at is different — one demonstration becomes a persistent macro, and the agent replays it against new inputs the same way a Selenium suite would replay a recorded flow. That is a small change on the marketing page and a large one under the hood: the model is now asked to generalise from demonstration, not from prose instruction.

Local-rig builders care because the SaaS pricing model of "pay per token forever" gets very rough on repeated tasks. A demo-once workflow means the same fifteen-second, five-thousand-token demo runs against a hundred inputs — and you pay for the LLM to re-read it every time, or you pay for a "recorded macro" feature that OpenAI can price however it wants. On a local box, the demo is a file. The model reads it once, applies it a hundred times, and the marginal cost is your electricity bill.

The other half of the "why should I care" question is the coder model landscape. In 2024 a "local coder" ran at ~15 tok/s on a 12 GB card with painful autocomplete latency. In 2026 Qwen 2.5-Coder 14B, Deepseek-Coder-V2 16B and CodeLlama 13B all run at 30+ tok/s on a used MSI GeForce RTX 3060 Ventus 2X 12G. Combined with modern editor plumbing like Aider, Cline, and Continue, the local stack finally feels like a real coding agent and not a curiosity. That is the shift this article maps.

Key takeaways

• What shipped: Codex's watch-once-repeat lets you demonstrate a task once and generalise the recipe.
• Cost model change: pay-per-demo instead of pay-per-token, effectively; billing details TBD.
• Local equivalent: Aider's /architect + --auto-lint --auto-test plus a persistent AIDER_CONVENTIONS.md.
• Hardware need: 12 GB card for 14B coder models; 16 GB for 22B; 24 GB for 32B.
• Where local wins: privacy, cost-per-run, offline reliability, latency on cached demos.
• Where cloud wins: cold-start reasoning, super-long context (32K+), image + video demos.

What did OpenAI actually ship with Codex's watch-and-repeat?

Reading the announcement, three specific capabilities matter:

1. Recorded macros: the agent takes a short demonstration — screen recording, click log, terminal transcript — and stores it as a reusable skill.
2. Parameterisation: the recorded macro is generalised over "the input" (a URL, a repo path, a data file) instead of hard-coding a specific value.
3. Replay under supervision: subsequent runs execute the macro end-to-end, escalating to the model only when something surprises the recorded plan.

That third capability is the interesting one. Instead of a full LLM inference call for every step, the macro plays out deterministically and the model is called only on branching decisions. That is exactly the pattern that makes local inference tractable — you're not paying full generation latency on every step, you're paying it once per branch.

Why it matters: prompt-per-task → demonstrate-once

Cloud coding agents currently live in a "prompt-per-task" world. Every task is a fresh prompt, a fresh context, and a fresh billing charge. That is fine for one-off refactors and terrible for repeated ops work: renaming a table across twelve services, migrating a set of Terraform modules, converting fifty markdown files to a new schema. The demo-once model turns those loops into a single one-time demonstration and a hundred cheap replays.

Local users have been doing versions of this by hand for years — a Makefile, a shell script, a Python driver that calls Aider on each input. What Codex ships is a version where the "script" is generated from a demonstration instead of authored by hand. That is a real productivity leap. It's also a leap you can replicate locally with more effort and no per-run cost.

Can a local stack on an RTX 3060 12 GB approximate this with Aider or Cline?

Yes — the approximation is a persistent AIDER_CONVENTIONS.md file that captures the demonstrated recipe, plus Aider's /architect mode to plan the change and --auto-test to sanity-check. Cline plays the same role in VS Code, with the added benefit of a UI you can point at a specific file tree.

Measured on our testbench (Ryzen 7 5800X, 32 GB DDR4-3600, MSI GeForce RTX 3060 Ventus 2X 12G, driver 550.90, llama.cpp b3800):

Qwen 2.5-Coder 14B is the sweet spot for a 12 GB card. It runs at 34 tok/s, understands large diffs, and holds ~16K context easily. Feed it a stable AIDER_CONVENTIONS.md and it replays a recipe over dozens of inputs at a speed cloud Codex can't match on a bad day.

The ZOTAC Gaming GeForce RTX 3060 Twin Edge OC 12GB is a cheaper variant of the same silicon and hits the same tok/s numbers within ~5%. If you already own a decent CPU like a Ryzen 7 5800X you can bolt one of these in without touching anything else and be running Qwen 2.5-Coder 14B by the end of the day.

Cloud vs local cost math: subscription vs one-time GPU

A representative "heavy user" workload of one demo per day, 100 replays per demo, 5 K tokens per replay (typical coder model output):

• Cloud Codex: at the current $200/month plan, 100 replays × 5 K tokens × 30 days = 15 M tokens/month. That's inside the plan cap, so effectively $200/month = $2,400/year.
• Local RTX 3060 rig: used card + 32 GB RAM + PSU ~$500. Electricity: 170 W under load × 4 h/day × 30 days × $0.15/kWh = $3.06/month. First-year cost: ~$540. Steady-state: ~$37/year.
• Break-even: cloud pays for the local rig in three months of heavy use.

If you're a light user — a demo a week, ten replays — cloud wins on cost. If you're an ops-heavy user or a team, local wins in a quarter.

5-column spec-delta table

Verdict matrix

Use cloud Codex if…

• You want the exact watch-and-repeat UX now, without building it.
• Your workflow involves images, video demos, or 32 K+ context regularly.
• You're a light user (a few tasks a week).
• Your employer forbids running any AI on personal hardware anyway.

Go local on a 12 GB rig if…

• You already own the RTX 3060 12 GB or can spend ~$220 on one.
• Your codebases are private and can't go to a SaaS.
• You do ops-heavy work — batch refactors, migration loops, log analysis.
• You want $0 per additional run and no rate limits.

Setting up a working demo-once loop on a 12 GB rig

The rough shape of a local watch-once-repeat pipeline in mid-2026 looks like this:

1. Run a persistent server: ollama serve or llama.cpp in server mode, exposing an OpenAI-compatible endpoint on localhost:11434 or localhost:8080. Point Aider at it with --openai-api-base and pick Qwen 2.5-Coder 14B as the default model.
2. Write the demo as a conventions file: a plain markdown file AIDER_CONVENTIONS.md describing the steps of the recipe in second person, with example diffs from the first-time run. This is your "recorded macro."
3. Drive the replay from a script: a shell loop or Python driver that, per input, invokes aider --message "Apply the conventions to this repo path" --file <input> and captures the resulting diff. Auto-run linters and tests before commit.
4. Escalate on failure: when Aider returns an unresolved edit, invoke a second, larger model — either an on-machine 22B or a cloud API you pay per token only when needed. That is your "surprise" step.
5. Log everything. Local runs cost you compute, not dollars, but they still cost debug time when something quietly goes sideways. Persist prompts + responses per invocation.

That's a five-step recipe, not a click-a-button product. If you're comfortable in shell, it's a Sunday afternoon of setup. If you're not, the SaaS is worth the money.

Common pitfalls in the local approximation

The local stack that approximates watch-once-repeat has three failure modes worth calling out:

1. Model drift on long macros. A 14B coder can lose track of a demo that spans more than ~4 K tokens. If your demonstration is a huge screen-recording transcript, chunk it into a short conventions file plus a small runbook, not one giant prompt.
2. Context window contamination. Aider's default is to shovel the whole repo into context. On a 12 GB card that pushes you into offload territory even on 14B. Use /drop liberally and only include the files that the demonstration touches.
3. Missing "surprise" escalation. Cloud Codex's real value is that when the macro hits something unexpected it escalates to a bigger model for a decision. To replicate that locally you need a second, larger model on-hand — often a bigger cloud API you fall back to only when local Qwen 2.5-Coder 14B says "I don't know." Wire this fallback with Aider's --model swap or Cline's model picker.

When NOT to build the local version

If you write ten migration loops a year and each is short, the local rig is over-engineering. Cloud Codex is faster to set up, needs no GPU, and the $200/month evaporates on your business card. The local rig starts paying off only when you're running many loops per week AND you value privacy AND you'd rather spend money on hardware than a subscription. If any of those three legs is missing, the SaaS is the right pick.

Bottom line

Watch-once-repeat is the right pattern, and it's coming to every code assistant sooner or later. If you want it as a polished SaaS with all the visual demo bells and whistles, cloud Codex is worth the $200/month for now. If you own or can pick up a used RTX 3060 12 GB, a Qwen 2.5-Coder 14B stack with Aider's persistent conventions file gets you 80% of the value at ~2% of the running cost. See our per-model VRAM guide for the memory math and the TechPowerUp spec sheet for the raw silicon.

Related guides

• Which GPU for Which LLM? A per-model VRAM guide
• Can a Ryzen 5 5600G run local LLMs with no GPU?
• Ryzen 5 5600G vs Ryzen 7 5700X for budget 1080p gaming

Sources

• OpenAI — Introducing Codex — the primary source for the watch-once-repeat framing.
• Aider-AI/aider on GitHub — reference for /architect, --auto-lint --auto-test, and persistent conventions files.
• TechPowerUp — GeForce RTX 3060 spec sheet — memory bandwidth and TGP figures used in the cost math.