Skip to content

The software factory

The output of a thousand engineers. The accountability of one.

The factory is our internal build system: a pipeline of AI agents and automated checks that turns a written spec into reviewed, tested pull requests, with an engineer approving every merge. It is why our engagements take less calendar time and cost less money.

Book a callHow it runs

How it runs

Five stops on one loop. One of them is a person.

How the factory runs A racetrack with five stops, one lap per ticket, clockwise. Your request enters at Specify, where it becomes a written spec. Build: agents build in parallel, each in an isolated sandbox, with tests written alongside the code. Review: 33 gates and 14 review agents, plus linting and tests, for up to three rounds. Merge: an engineer reviews every pull request that reaches it, the one human gate; approval merges, releases and closes the ticket. Learn: what the merge taught becomes a rule for the next ticket. In the middle sits the written spec: acceptance criteria, plan ledger, risk definitions, cost projections, gap analysis and more; every stop reconciles its work against it before the next begins. The written spec acceptance criteria, plan ledger, risk definitions, cost projections, gap analysis, and more every stop reconciles its work against it next ticket your request 1Specify Your request becomes a written spec 2Build Agents build in parallel, each in an isolated sandbox, tests with the code 3Review 33 gates and 14 review agents, plus linting and tests, up to three rounds 4Merge Engineer review, the one human gate 5Learn What the merge taught becomes a rule
One lap per ticket, top to bottom. Dotted lines: every stop reconciles its work against the written spec before the next begins. The filled stop is the human gate.

  1. 1Specify

    Your request becomes a written spec before any code is written: acceptance criteria, plan ledger, risk definitions, cost projections, gap analysis and more. Every later stop reconciles its work against it.

  2. 2Build

    Agents build the plan in parallel, each in its own isolated sandbox, so one agent's work cannot touch another's and nothing runs outside it. Tests are written alongside the code, and the result opens as a draft pull request.

  3. 3Review

    33 gates and 14 review agents read every pull request, on top of linting and the test suite: code review, an audit against the plan, a risk audit and more. All must pass; what fails is fixed and only the gates whose inputs changed run again. Three rounds at most.

  4. 4Merge

    An engineer reads every pull request that reaches this point: the one human gate. Approval merges, releases and closes the ticket.

  5. 5Learn

    What the merge and production taught becomes a rule the next ticket is built under, so each lap starts from a better spec than the last.

One day, counted

October 7, 2026. An ordinary working day. Every figure comes from the agent transcripts, one count per API response, priced at the vendor's published list prices.

We publish the day in full, with the orchestration overhead that most per-task figures leave out, because a number you cannot audit is not a number.

October 7, 2026, 00:05 to 19:55

Pull requests merged
73
Between 00:05 and 19:55, America/New York.
Cost of the day
$1,252.55
Every agent session, at API list prices.
Cost per merged pull request
$15.89
Orchestration included. Direct work alone: $7.21 average, $4.29 median.
Model calls
8,740
Unique API responses across three model tiers.
Tokens processed
1.9B
96.3% of input served from cache; 7.2M output.

Pull requests merged, by hour

Columns for each local hour from 00:00 to 23:00. Peak of 10 merges at 15:00; no merges after 19:00.051000:00 — 9 merged0001:00 — 7 merged02:00 — 5 merged03:00 — 1 merged0304:00 — 3 merged05:00 — 3 merged06:00 — 3 merged0607:00 — 2 merged08:00 — 3 merged09:00 — 1 merged0910:00 — 1 merged11:00 — 5 merged12:00 — 2 merged1213:00 — 8 merged14:00 — 4 merged15:00 — 10 merged101516:00 — 3 merged17:00 — 0 merged18:00 — 0 merged1819:00 — 3 merged20:00 — 0 merged21:00 — 0 merged2122:00 — 0 merged23:00 — 0 merged
Merges per hour on October 7, 2026
HourMerged
00:009
01:007
02:005
03:001
04:003
05:003
06:003
07:002
08:003
09:001
10:001
11:005
12:002
13:008
14:004
15:0010
16:003
17:000
18:000
19:003
20:000
21:000
22:000
23:000

Where the day's spend went

Sessions are attributed by the worktree branch they ran in, or by the pull request a reviewer prompt names. Sessions in the main checkout steer the merges and belong to no single pull request.

Direct work on the 73 merged pull requests
$526.3142.0%
Orchestration sessions in the main checkout
$626.9250.1%
Work on pull requests merged on later days
$92.367.4%
Plan audits
$6.940.6%

Half the spend is orchestration: the sessions that plan, dispatch and review, which belong to no single pull request. That is why the cost per merge with orchestration included is $15.89 while direct work is $7.21 mean and $4.29 median.

How it was counted

  1. 1Source: the coding agent's session transcripts for the main checkout and every linked worktree, read on 2026-10-14. One count per API response.
  2. 2Attribution: a worktree session belongs to the pull request whose branch it ran on; sessions in the main checkout are orchestration and belong to no single pull request.
  3. 3Prices: the vendor's published API list prices, applied per call to the tier that answered it. A subscription plan bills differently, so this measures volume, not an invoice. Priced this way, the figures reproduce the agent's own running cost within 3% across 1,803 sessions.

The day in detail

The same October 7, 2026, opened up: which model did the work hour by hour, what each tier handled, and what every one of the 73 pull requests cost to merge.

  • Frontier model
  • Large model
  • Mid-size model

Input tokens per hour, by model

Uncached input, cache writes and cache reads together. Almost all of it is cache reads.

Input tokens per hour, by modelStacked columns for each local hour, split by model tier. Peak at 06:00 with 150,894,074 tokens.0M50M100M150M200M00:00 — Frontier model 51,328,376, Large model 58,787,737, Mid-size model 3,456,4130001:00 — Frontier model 45,408,923, Large model 61,443,060, Mid-size model 5,404,85102:00 — Frontier model 42,530,970, Large model 19,407,272, Mid-size model 3,540,22703:00 — Frontier model 21,570,581, Large model 2,146,302, Mid-size model 9,621,0440304:00 — Frontier model 24,114,437, Large model 18,424,762, Mid-size model 16,754,91705:00 — Frontier model 18,467,177, Large model 7,230,300, Mid-size model 3,242,72906:00 — Frontier model 121,945,058, Large model 26,371,267, Mid-size model 2,577,7490607:00 — Frontier model 58,655,385, Large model 3,279,203, Mid-size model 008:00 — Frontier model 40,617,552, Large model 2,085,575, Mid-size model 009:00 — Frontier model 108,248,291, Large model 4,638,841, Mid-size model 12,988,8240910:00 — Frontier model 57,634,113, Large model 9,674,872, Mid-size model 50,513,66411:00 — Frontier model 57,717,883, Large model 12,823,034, Mid-size model 13,926,98812:00 — Frontier model 48,482,921, Large model 27,081,714, Mid-size model 24,891,9131213:00 — Frontier model 45,312,655, Large model 10,930,957, Mid-size model 12,754,50714:00 — Frontier model 44,680,513, Large model 45,152,513, Mid-size model 18,215,41515:00 — Frontier model 76,212,103, Large model 42,714,865, Mid-size model 01516:00 — Frontier model 49,814,478, Large model 8,444,964, Mid-size model 017:00 — Frontier model 77,132,728, Large model 1,184,730, Mid-size model 018:00 — Frontier model 57,297,206, Large model 10,580,211, Mid-size model 1,797,3531819:00 — Frontier model 23,498,332, Large model 4,122,079, Mid-size model 020:00 — Frontier model 23,906,318, Large model 6,228,454, Mid-size model 3,680,12721:00 — Frontier model 32,270,945, Large model 52,412,035, Mid-size model 4,843,1912122:00 — Frontier model 23,509,646, Large model 27,374,308, Mid-size model 1,945,75923:00 — Frontier model 36,373,739, Large model 20,608,177, Mid-size model 0
Input tokens per hour, by model
HourFrontier modelLarge modelMid-size model
00:0051,328,37658,787,7373,456,413
01:0045,408,92361,443,0605,404,851
02:0042,530,97019,407,2723,540,227
03:0021,570,5812,146,3029,621,044
04:0024,114,43718,424,76216,754,917
05:0018,467,1777,230,3003,242,729
06:00121,945,05826,371,2672,577,749
07:0058,655,3853,279,2030
08:0040,617,5522,085,5750
09:00108,248,2914,638,84112,988,824
10:0057,634,1139,674,87250,513,664
11:0057,717,88312,823,03413,926,988
12:0048,482,92127,081,71424,891,913
13:0045,312,65510,930,95712,754,507
14:0044,680,51345,152,51318,215,415
15:0076,212,10342,714,8650
16:0049,814,4788,444,9640
17:0077,132,7281,184,7300
18:0057,297,20610,580,2111,797,353
19:0023,498,3324,122,0790
20:0023,906,3186,228,4543,680,127
21:0032,270,94552,412,0354,843,191
22:0023,509,64627,374,3081,945,759
23:0036,373,73920,608,1770

Output tokens per hour, by model

Generated tokens, thinking included. The frontier and large models did nearly all the writing.

Output tokens per hour, by modelStacked columns for each local hour, split by model tier. Peak at 06:00 with 596,496 tokens.0K200K400K600K00:00 — Frontier model 268,278, Large model 161,250, Mid-size model 6620001:00 — Frontier model 106,015, Large model 395,387, Mid-size model 1,43602:00 — Frontier model 100,765, Large model 219,082, Mid-size model 68003:00 — Frontier model 29,680, Large model 43,930, Mid-size model 6,8190304:00 — Frontier model 23,216, Large model 389,582, Mid-size model 1,80805:00 — Frontier model 18,854, Large model 9,240, Mid-size model 63406:00 — Frontier model 160,699, Large model 434,322, Mid-size model 1,4750607:00 — Frontier model 57,456, Large model 71,258, Mid-size model 008:00 — Frontier model 45,190, Large model 44,538, Mid-size model 009:00 — Frontier model 169,054, Large model 81,326, Mid-size model 1,3200910:00 — Frontier model 53,987, Large model 193,968, Mid-size model 6,87711:00 — Frontier model 145,756, Large model 251,924, Mid-size model 3,57312:00 — Frontier model 130,515, Large model 407,735, Mid-size model 2,9281213:00 — Frontier model 158,044, Large model 132,955, Mid-size model 3,27914:00 — Frontier model 219,259, Large model 224,426, Mid-size model 2,32515:00 — Frontier model 266,400, Large model 228,438, Mid-size model 01516:00 — Frontier model 103,881, Large model 34,039, Mid-size model 017:00 — Frontier model 194,801, Large model 7,905, Mid-size model 018:00 — Frontier model 180,202, Large model 141,738, Mid-size model 5181819:00 — Frontier model 33,740, Large model 1,940, Mid-size model 020:00 — Frontier model 149,425, Large model 18,538, Mid-size model 42121:00 — Frontier model 206,931, Large model 309,272, Mid-size model 7062122:00 — Frontier model 112,483, Large model 140,297, Mid-size model 40523:00 — Frontier model 111,701, Large model 168,703, Mid-size model 0
Output tokens per hour, by model
HourFrontier modelLarge modelMid-size model
00:00268,278161,250662
01:00106,015395,3871,436
02:00100,765219,082680
03:0029,68043,9306,819
04:0023,216389,5821,808
05:0018,8549,240634
06:00160,699434,3221,475
07:0057,45671,2580
08:0045,19044,5380
09:00169,05481,3261,320
10:0053,987193,9686,877
11:00145,756251,9243,573
12:00130,515407,7352,928
13:00158,044132,9553,279
14:00219,259224,4262,325
15:00266,400228,4380
16:00103,88134,0390
17:00194,8017,9050
18:00180,202141,738518
19:0033,7401,9400
20:00149,42518,538421
21:00206,931309,272706
22:00112,483140,297405
23:00111,701168,7030

By model tier

Frontier model
2,738 calls
Uncached input
60,670
Cache writes
12,897,284
Cache reads
1,173,772,376
Output
3,046,332
of which thinking
1,215,873
Large model
4,630 calls
Uncached input
9,366
Cache writes
45,577,952
Cache reads
437,559,914
Output
4,111,793
of which thinking
1,580,087
Mid-size model
1,372 calls
Uncached input
2,766
Cache writes
9,805,039
Cache reads
180,347,866
Output
35,866
of which thinking
3,484

Three tiers were in use: a frontier model for the hardest reasoning, a large model for most implementation and review, and a mid-size model for small tasks. Every call was priced at the vendor's published list prices for the tier that answered it.

The 73 pull requests, by cost on the day

Each bar is split by model tier. Six pull requests merged just after midnight were built on earlier days, so they show their earlier spend instead. Titles are not published; the number and ticket are enough to audit against the repository.

  • Frontier model
  • Large model
  • Mid-size model
  1. #132 PAI-212$45.99
  2. #59 PAI-16$45.23
  3. #90 PAI-210$32.14
  4. #144 PAI-278$24.61
  5. #153 PAI-193$23.91
  6. #119 PAI-265$21.62
  7. #165 PAI-285$20.93
  8. #157 PAI-213$20.84
  9. #60 PAI-51$20.72
  10. #136 PAI-35$17.53
  11. #80 PAI-206$15.95
  12. #160 PAI-282$13.67
  13. #83 PAI-209$9.86
  14. #139 PAI-279$9.57
  15. #118 PAI-263$9.52
  16. #97 PAI-220$9.18
  17. #92 PAI-244$7.88
  18. #173 PAI-299$7.25
  19. #158 PAI-214$7.23
  20. #135 PAI-212$6.15
Show the other 53 pull requests
  1. #91 PAI-246$6.14
  2. #142 PAI-35$6.03
  3. #172 PAI-298$5.97
  4. #138 PAI-208$5.90
  5. #88 PAI-240$5.88
  6. #131 PAI-275$5.86
  7. #169 PAI-286$5.83
  8. #143 PAI-280$5.79
  9. #117 PAI-262$5.72
  10. #128 PAI-211$5.26
  11. #121 PAI-264$5.02
  12. #124 PAI-268$4.75
  13. #140 PAI-35$4.72
  14. #156 PAI-195$4.50
  15. #129 PAI-274$4.44
  16. #120 PAI-266$4.42
  17. #74 PAI-190$4.29
  18. #174 PAI-284$4.26
  19. #130 PAI-273$4.18
  20. #141 PAI-35$4.18
  21. #149 PAI-282$3.74
  22. #164 PAI-201$3.73
  23. #84 PAI-34$3.55
  24. #137 PAI-244$3.53
  25. #108 PAI-253$3.48
  26. #72 PAI-189$3.20
  27. #155 PAI-200$2.84
  28. #98 PAI-219$2.76
  29. #150 PAI-251$2.73
  30. #152 PAI-282$2.69
  31. #134 PAI-277$2.42
  32. #168 PAI-294$2.42
  33. #123 PAI-267$2.17
  34. #145 PAI-245$2.13
  35. #122 PAI-269$2.07
  36. #126 PAI-271$1.84
  37. #127 PAI-272$1.84
  38. #86 PAI-241$1.61
  39. #125 PAI-270$1.59
  40. #87 PAI-243$1.44
  41. #82 PAI-207$1.06
  42. #58 PAI-15$0.31
  43. #161 PAI-199$0.24
  44. #89 PAI-216built on earlier days · $5.02 lifetime
  45. #93 PAI-248built on earlier days · $18.74 lifetime
  46. #94 PAI-217built on earlier days · $2.77 lifetime
  47. #95 PAI-247built on earlier days · $2.93 lifetime
  48. #96 PAI-218built on earlier days · $6.23 lifetime
  49. #112 PAI-255built on earlier days · $9.89 lifetime
  50. #154 PAI-194built on earlier days · $0.00 lifetime
  51. #159 PAI-196built on earlier days · $0.00 lifetime
  52. #167 PAI-198built on earlier days · $0.00 lifetime
  53. #170 PAI-202built on earlier days · $0.00 lifetime
Cost on the day for each merged pull request, split by model tier, with lifetime cost and session count
PRTicketMergedCost, dayFrontierLargeMid-sizeCost, lifetimeSessions
#132PAI-21210:48$45.99$27.54$8.32$10.13$54.8912
#59PAI-1606:31$45.23$18.43$24.91$1.89$65.8531
#90PAI-21011:06$32.14$25.85$6.29$0.00$36.1515
#144PAI-27813:31$24.61$15.37$9.24$0.00$24.6113
#153PAI-19314:58$23.91$7.46$16.45$0.00$23.911
#119PAI-26502:19$21.62$13.29$8.33$0.00$21.6217
#165PAI-28515:35$20.93$13.67$7.26$0.00$20.9311
#157PAI-21315:05$20.84$2.75$18.09$0.00$20.8421
#60PAI-5107:05$20.72$0.00$20.72$0.00$29.2627
#136PAI-3512:08$17.53$2.22$12.31$3.01$17.5321
#80PAI-20605:10$15.95$0.00$15.95$0.00$30.8629
#160PAI-28215:09$13.67$8.68$4.99$0.00$13.6712
#83PAI-20907:48$9.86$5.53$4.33$0.00$13.1212
#139PAI-27913:30$9.57$4.35$5.22$0.00$9.5710
#118PAI-26300:13$9.52$7.40$2.12$0.00$12.075
#97PAI-22000:05$9.18$9.18$0.00$0.00$19.329
#92PAI-24411:06$7.88$2.67$3.16$2.06$11.1411
#173PAI-29919:54$7.25$0.98$6.27$0.00$7.2512
#158PAI-21415:25$7.23$2.14$5.10$0.00$7.238
#135PAI-21211:21$6.15$1.72$4.19$0.24$6.157
#91PAI-24611:06$6.14$1.48$4.48$0.17$10.8613
#142PAI-3514:46$6.03$0.00$6.03$0.00$6.036
#172PAI-29819:55$5.97$2.35$3.62$0.00$5.979
#138PAI-20813:29$5.90$0.00$5.90$0.00$5.906
#88PAI-24008:33$5.88$0.00$5.88$0.00$10.8617
#131PAI-27505:25$5.86$0.00$5.86$0.00$5.8610
#169PAI-28616:20$5.83$3.36$2.47$0.00$5.836
#143PAI-28012:19$5.79$2.92$2.87$0.00$5.797
#117PAI-26200:55$5.72$0.00$5.72$0.00$10.599
#128PAI-21105:12$5.26$0.00$4.80$0.46$5.267
#121PAI-26401:23$5.02$2.98$2.04$0.00$5.025
#124PAI-26802:52$4.75$0.00$4.75$0.00$4.758
#140PAI-3513:31$4.72$0.00$4.72$0.00$4.726
#156PAI-19515:11$4.50$0.00$4.50$0.00$4.506
#129PAI-27404:40$4.44$0.00$4.44$0.00$4.447
#120PAI-26602:17$4.42$0.00$4.42$0.00$4.428
#74PAI-19001:51$4.29$0.00$4.29$0.00$13.1521
#174PAI-28419:53$4.26$0.00$4.26$0.00$4.267
#130PAI-27304:50$4.18$0.00$4.18$0.00$4.186
#141PAI-3514:46$4.18$0.00$4.18$0.00$4.186
#149PAI-28213:33$3.74$0.31$3.43$0.00$3.747
#164PAI-20115:25$3.73$0.00$3.73$0.00$3.736
#84PAI-3404:00$3.55$0.00$3.55$0.00$7.2612
#137PAI-24411:43$3.53$0.00$3.53$0.00$3.536
#108PAI-25301:21$3.48$0.00$3.48$0.00$24.1825
#72PAI-18901:22$3.20$0.00$3.20$0.00$21.5736
#155PAI-20015:22$2.84$0.00$2.84$0.00$2.846
#98PAI-21901:09$2.76$0.00$2.76$0.00$5.9611
#150PAI-25113:54$2.73$0.00$2.73$0.00$2.735
#152PAI-28213:55$2.69$0.00$2.69$0.00$2.695
#134PAI-27709:52$2.42$0.00$2.42$0.00$2.425
#168PAI-29416:20$2.42$0.68$1.75$0.00$2.426
#123PAI-26702:36$2.17$0.00$2.17$0.00$2.174
#145PAI-24513:32$2.13$0.00$2.13$0.00$2.135
#122PAI-26901:56$2.07$0.00$2.07$0.00$2.074
#126PAI-27102:43$1.84$0.00$1.84$0.00$1.844
#127PAI-27206:19$1.84$0.00$1.84$0.00$1.844
#86PAI-24108:05$1.61$0.00$1.61$0.00$4.687
#125PAI-27006:24$1.59$0.00$1.59$0.00$1.594
#87PAI-24308:24$1.44$0.00$1.44$0.00$4.127
#82PAI-20703:01$1.06$0.00$1.06$0.00$10.9513
#58PAI-1501:01$0.31$0.00$0.31$0.00$7.829
#161PAI-19915:09$0.24$0.24$0.00$0.00$0.241
#89PAI-21600:05$0.00$0.00$0.00$0.00$5.027
#93PAI-24800:27$0.00$0.00$0.00$0.00$18.7429
#94PAI-21700:05$0.00$0.00$0.00$0.00$2.775
#95PAI-24700:05$0.00$0.00$0.00$0.00$2.935
#96PAI-21800:05$0.00$0.00$0.00$0.00$6.236
#112PAI-25500:27$0.00$0.00$0.00$0.00$9.8913
#154PAI-19414:58$0.00$0.00$0.00$0.00$0.000
#159PAI-19615:21$0.00$0.00$0.00$0.00$0.000
#167PAI-19815:31$0.00$0.00$0.00$0.00$0.000
#170PAI-20216:19$0.00$0.00$0.00$0.00$0.000

What the factory enforces

These are not guidelines. The pipeline does not let work through without them.

  • Spec-Driven

    Every task starts from written acceptance criteria. If it cannot be specified, it is not ready to build.

  • Parallel Agents

    Independent tasks are implemented concurrently by agents working in isolated branches, which is where most of the speed comes from.

  • Tests on Every Task

    A task is not complete without tests that exercise its acceptance criteria. The factory enforces this, not a checklist.

  • Human Review Gate

    Every pull request is reviewed by an engineer before it merges. Agents propose; people are accountable.

  • Full Audit Trail

    Specs, plans, diffs, test runs and reviews are linked, so you can see why any line of code exists.

  • Continuous Delivery

    CI/CD, preview environments and monitoring are part of the pipeline from the first commit.

What it means for your project

Three claims, each with its number. All three come from the measured day above, not from a projection.

Faster
73
pull requests merged in one day
Parallel implementation and automated checks compress the parts of delivery that usually wait on a single engineer's calendar. On 2026-10-07, 73 pull requests merged on our own codebase between 00:05 and 19:55.
Cheaper
$15.89
per merged pull request, orchestration included
Senior time goes to specs, architecture and review instead of boilerplate. The day's spend on these 73 merges and the orchestration around them, divided by 73, at API list prices. Work on pull requests that merged on later days is left out; the whole day divided by 73 is $17.16.
Auditable
8,740
model calls, each one counted and priced
Written specs, tests on every task and a full audit trail make scope, progress and quality visible rather than reported. Every call on the day is attributed to a pull request or to orchestration, and the pricing reproduces the agent's own running cost within 3%.
A dark river running through a forest, the water still enough to hold the trees

See the factory on your project

Bring a problem. We will scope it into a spec and tell you what the factory can and cannot do with it.

Book a callWhat we build

Questions about the factory

What it is, what it is not, what working together is like, and what you own at the end.

Something not covered? Ask directly.

Our internal build system: a pipeline of AI agents and automated checks that turns a written spec into reviewed, tested pull requests, with an engineer approving every merge. It is how we build our own software, and what we bring to client work.

Not today. It is the way we work, and the reason our engagements run faster and cost less than a conventional agency's. If that changes we will say so here.

Agents write most of the implementation and tests. Engineers write the specs, make the architecture decisions and review every pull request. Nothing merges without a human approving it.

Written acceptance criteria before building, tests enforced on every task, automated checks on every pull request and an engineer reviewing every merge. The pipeline makes the shortcuts hard to take.

Yes. Every task links its spec, plan, diff, test run and review. You can trace any change back to the requirement that produced it.

Anything that can be specified and tested: greenfield builds, integrations, feature work on existing codebases, and taking a prototype to production. It is less useful for open-ended exploration, which we do the ordinary way.

It is strongest in TypeScript and the modern web stack, and it is designed to operate on existing repositories. We assess first and tell you where it will and will not help.

Work starts with a written spec, so you know what you are getting before we build it. Work happens in a repository you own, releases land on a predictable cadence, and you get a plain-language summary of what shipped and what is next.

You do, from the first commit, in a repository you control. Nothing is held back at the end of an engagement.

Either a handoff to your team with documentation and runbooks, or an ongoing engineering retainer. We will recommend one based on your situation rather than defaulting to the retainer.

Get a written estimate from your spec

Tell us what you are building and where it is today. We reply within a few business days with questions, or with a scope and a price.