Field noteNov 19, 20266 min read1 source

Making OpenClaw CI faster and 95% cheaper

In one minute

OpenClaw engineer Vincent Koc describes a broad CI cleanup that coincided with 86.5% fewer weekly runner-hours and a 95.5% drop in the estimated value of sponsored compute. The figures are not a controlled before-and-after test, but the account offers concrete ways to remove redundant checks, reuse setup and balance cost against feedback time.

What changed: Vincent Koc details OpenClaw’s CI overhaul, reporting 86.5% fewer runner-hours and a 95.5% reduction in estimated compute value, alongside the changes behind the savings.

What happened

In a November 17, 2026 essay and technical appendix, Koc says OpenClaw’s coding agents were producing code, tests, jobs and retries faster than its checks could validate changes. The team set out to reduce compute use without making useful work take longer. About 89% of OpenClaw’s code is TypeScript, where the work began, though Koc says several principles apply across languages. GitHub Actions coordinates the jobs; Blacksmith supplied runners, and boat.dev was used more recently. GitHub also supported the project with donated CI runners and an Enterprise plan. Blacksmith sponsored the runner capacity, so the dollar values are estimates at published prices, not amounts OpenClaw paid.

Across all repositories on the Blacksmith account, runner-hours fell from 158,546 in September 17–23 to 21,395 in November 6–13, 2026. Jobs fell from 1,482,257 to 301,413. The source calculates an 86.5% reduction in runner-hours, a 79.7% reduction in jobs and a 95.5% reduction in estimated compute value, from about $1.27 million to $57,324 per 30 days at published prices. The weeks were not equivalent workloads: indexed commits in the main repository were about 44% lower in the comparison period, and that repository’s activity is not a like-for-like measure of all account usage.

The changes Koc describes start with removing work that does not need to run. The team audited tests against the behavior they were meant to protect, consolidating duplicates while preserving independent regression checks. A test-line budget made growth visible: the earlier guard asked contributors to offset added lines or justify a higher ceiling; by November 13, changes could add 400 net test lines without an allocation record, while larger additions needed a recorded justification. Koc also reports that, between September 28 and November 13, core test files fell by 417,906 lines net. This was not all attributed to one cleanup, and implementation grew during the same interval.

The workflow was split by the kind of answer a change needed. Pull requests run selected tests and other checks before merge; pushes to main retain smaller regression and protocol guards; broader scheduled validation checks a named main revision and supports release qualification. Koc says full release checks should not be confused with checks required for each change. Other measures described include selecting tests based on the diff, reusing caches and workers, packing shards, and delaying work that a superseding push is likely to cancel. The article also shows a trade-off in one paired job covering the same 240 test files: a 16-class runner cost $0.672 and took 20m 51s, while a 32-class runner cost $1.152 and took 17m 54s. Both runs shared a known failure.

What the archive adds

New Runtime’s earlier coverage of a 68% inference-cost reduction discussed workload-aware request handling, not CI. Koc’s account is a new event in a related cost-optimization conversation: its subject is engineering checks, and its reported reductions are qualified by changing workload and sponsored capacity.

Trend signal

This does not yet fit a pattern New Runtime tracks. The account is useful evidence that teams can change CI economics through workflow and test-suite design, but it does not establish a general trend or show that cheaper verification improves delivery outcomes. Koc explicitly distinguishes compute reductions from the still-unestablished effect on pull-request-to-merge time.

Why now

Koc says the team faced a hard deadline to reduce compute needs as agents generated more code and tests, creating more jobs and retries. That pressure makes the distinction between faster runners and less unnecessary work consequential: buying execution speed cannot fix repeated setup or checks that do not add useful protection. The account was published after a September-to-November comparison period and presents the process as a set of changes rather than a single intervention.

Why it matters

Teams adopting coding agents can inherit a verification bill that grows alongside code production. This case makes clear why CI optimization cannot be reduced to choosing a cheaper runner: fewer jobs may reduce cost while also reducing useful coverage, and slower machines can increase the time people and dependent agents wait. The practical objective is to remove redundant work while keeping checks tied to real behavior contracts.

The measurements also illustrate why engineering teams should track several outcomes at once. Runner-hours and estimated compute value show resource use; they do not demonstrate that changes reached production sooner or that software quality stayed constant. Comparing equivalent jobs, checking retained tests against plausible regressions, and tracking review and merge time would give a team a stronger basis for deciding whether a change is worthwhile. OpenClaw’s figures are a useful case, not a forecast for another repository.

Limits and uncertainty

The two account-wide weeks had different workloads, and activity in one repository was lower in the later comparison. The sponsored-compute estimates use Blacksmith’s published prices; they are not OpenClaw’s actual bill. A paired runner comparison covered one job and both runs shared a known failure, so it does not establish a fleetwide cost or speed result. Koc says the reduction in estimated compute value is measured, while an improvement in pull-request-to-merge time is not established in this account. The reported test-line changes also do not measure test effectiveness or prove that coverage was preserved across the repository.

Skill to build now

Audit one expensive CI path this week. For each check, write down the behavior contract it protects and identify a plausible defect that should make it fail. Consolidate only when another check demonstrably owns the same contract; keep independent regression guards. Then compare the same job before and after any change, recording runtime and estimated cost together. If test selection from a diff is uncertain, keep the full suite for that change rather than treating a smaller run as proof.

Reader takeaway

OpenClaw’s headline reduction is not a controlled estimate of savings another team can expect. The transferable lesson is to remove unnecessary work before optimizing the machines that run it—and to protect the contracts that matter while doing so. Measure cost and feedback time together, and do not mistake fewer test lines or lower compute use for proof of faster, safer delivery.

Evidence / sources

  1. 1vincent.build/openclaw-ci-cost-reduction
All Field Notes

Next reads

Read next

Open the graph
  1. 01topicGithubExplore the github topic hub.
  2. 02archiveField NotesOpen the latest editorial analysis.
  3. 03sourcesSourcesSee the original sources this archive cites.
Who read this page?Machine requests, hidden until opened

Loading the privacy-safe route aggregate...

Open the JSON contract