Request

The record

81 days, 536 commits

None of the above arrived finished. It was built in the open, one commit at a time, and most of what makes it trustworthy today came from something going wrong first. What follows is not the marketing version: every milestone has a date and a commit behind it.

Commits

536

Days of build

81

Products on the line

6

Agents in the pipeline

8+2 UI

Harness

19.2k LOC

Decision records

22

Nine eras

A green marker means the machine learned something new. An amber one means a human deliberately took capability back. The amber ones matter more — they are the moments the factory chose to be slower in order to be trusted.

1. 12–14 June3 days · 49 commits

   IThe first run

   From an empty repository to a line that deploys on its own.

   The first commit was not code — it was the architecture. A token budget and cost accounting sat in the harness skeleton from day one, not bolted on after the first surprising invoice. That detail shaped everything after it: the factory knew what it cost before it knew how to work.

   • 12 Jun

     Initial commit — the architecture. A flat orchestrator-worker pattern, with a deterministic orchestrator in code instead of an improvising model.

   • 13 Jun

     A harness with a token budget and cost capture. The single choke point every model call passes through.

   • 13 Jun

     The quality chain. Analyst → Developer → Review → Security → Tester. Halt on failure, and handoffs by file rather than by conversation.

   • 13 Jun

     The first real run failed. Agents span to their turn limit without finishing. The toolkit was showing them tools they were not allowed to use, so they kept trying them. The fix was to restrict which tools are visible, not merely which are permitted.

   • 14 Jun

     Model tiering. A cheap, a mid and a frontier model by role. Never the expensive one for everything.

   • 14 Jun

     A context engine. Agents receive the project's own documentation instead of searching blind.

   • 14 Jun

     Cross-issue learning. The factory remembers finished work, reusable components and its own failures.

   • 14 Jun

     Always-on. A task moved in the tracker starts the line by itself. From here the factory runs, rather than gets run.

   • 14 Jun

     Then fifteen commits about deployment: timeouts, tooling inside the sandbox, environment injection, rebasing on resume. The last mile cost more work than the entire pipeline.

   Unlocked

   Request → spec → code → review → tests → staging → production, with no human in the middle. On one project, and without brakes.

2. 15–16 June2 days · 13 commits

   IIBrakes, and a bill for €8.92

   The day the factory got approval gates and learned not to loop.

   One task failed its tests three times in a row. Each time the developer agent tried to repair the implementation; after three rounds the bill was €8.92 and the credits ran out. The conclusion was not to improve the retry loop. It was to delete it.

   • 15 Jun

     Human approval gates. A production deploy needs an explicit approval from every team member. No agent can trigger one.

   • 15 Jun

     Authenticated webhooks and run locks. Concurrent runs stop overwriting each other's state.

   • 15 Jun

     A cost estimate before development. The work is sized S/M/L/XL and the harness derives the expected tokens and euros from it.

   • 16 Jun

     The end of the test fix loop. Failing tests stop the line for human review. The code-review loop stayed — cheaper, and a higher return.

   • 16 Jun

     The factory remembers failures. What broke, at which gate and why, is visible to future runs on similar work.

   • 16 Jun

     One gate, two meanings. The same approval state covers signing off the spec before development and signing off before production.

   Unlocked — a human decision

   The factory lost the ability to spend money unobserved. You approve the specification before the first expensive token is spent.

3. 3–4 July2 days · 4 commits

   IIITaste and memory

   Four commits carrying thirteen tasks. The factory stopped being blind to design.

   A dedicated role appeared between analysis and development — the UI Architect. Not to make things pretty, but because a design decision taken in passing while writing code is a design decision taken by accident. At the same time the context engine stopped behaving like a vacuum cleaner and started behaving like a librarian.

   • 3 Jul

     UI Architect and design context. A project's design system — colour, spacing, components, UX conventions — is extracted from the repository and stored. The agent reads it instead of inventing it.

   • 4 Jul

     Structural summaries instead of whole files. The most relevant files in full, the rest as structure. The tokens saved are visible in the context itself.

   • 4 Jul

     Prompt caching. The static agent definition goes first and the task last, so the expensive part of the prompt can be reused. Cache hit rate is measured on every call.

   • 4 Jul

     A circuit breaker. Three identical failures on similar work within a week block the next attempt. The factory stops walking into the same wall on its own.

   • 4 Jul

     Semantic search over past work, and adaptive budget calibration from history — which can only tighten a budget, never loosen it.

   • 4 Jul

     A design knowledge base. 161 product categories, 85 styles, 74 typographic pairings, 99 UX guidelines. The harness retrieves candidates at zero token cost; the agent chooses between them.

   Unlocked

   The output stopped looking generated. And the cost of a task started falling without the quality falling with it.

4. 11–15 July5 days · 61 commits

   IVOne standard for the whole portfolio

   The Golden Stack. Five products, five different technologies, one migration.

   The largest single leap in this history, and the least AI-flavoured thing in it. Five products ran on five different stacks, so every task needed different context, different scripts, different tests. The decision: one stack for everything, a feature freeze, five waves, big bang. In four days every project was unified and back in production.

   • 11 Jul

     A lint gate inside the sandbox. Zero tokens, and it catches exactly what an expensive model would otherwise be spent on.

   • 11 Jul

     A cost report. Spend per project and per agent, estimate against actual, cache hit rate.

   • 12 Jul

     The Golden Stack as a canonical standard. Machine-readable version pins and a compliance checker alongside the prose.

   • 12 Jul

     The standard is injected into prompts. It is not a document sitting on a disk; it is an input to every decision the agents make.

   • 12 Jul

     A monthly upgrade watch. When a pinned technology ships a major version, a task opens by itself. Every project moves together, or none does.

   • 13 Jul

     Tooling travels with the repository. Every device — desktop, phone, web session — sees the same pinned version.

   • 15 Jul

     Migration complete. All five projects on one stack, in production, behind CI quality gates.

   • 15 Jul

     Stale documentation is a bug. Because it goes straight into an agent's prompt as truth.

   Unlocked

   A new project joins with a single command instead of a week of integration. The factory stopped being a tool for one product and became a line.

5. 16–17 July2 days · 35 commits

   VIndependence and rules

   The factory stopped depending on a single model vendor — and got a security baseline.

   In one day a layer appeared that separates what has to be done from who does it. Any role can run on a different vendor's model, with the same permissions and the same accounting. Quality is not settled by an AI referee but by measured outcome: did the build pass, did review pass, what did it cost, how long did it take.

   • 16 Jul

     A runner contract. Budget and cost accounting sit above every vendor and cannot be bypassed by swapping the model underneath.

   • 16 Jul

     Second and third vendor adapters, behind the same permission layer as the first.

   • 16 Jul

     A quality scorecard and leaderboard. Plain scoring, no AI referee. Historical quality, cost and speed per vendor.

   • 16 Jul

     This website joined as the sixth project. From here the factory builds its own site through its own line.

   • 17 Jul

     One security baseline for every project and for the factory itself. The Security Auditor receives it as a checklist and fails a change that breaks a mandatory rule.

   • 17 Jul

     Five product rules. Dark only, mobile first, findability, English first, store readiness — mandatory for every current and future project.

   Unlocked

   If one model provider gets expensive or goes down, the line keeps running. Security and the product minimum are not checked at the end; they are inputs to the brief.

6. 20–23 July4 days · 42 commits

   VISight, taste and human memory

   The first time the factory looked at what it had made.

   Until this point UI was judged blind — from a written spec, without a single pixel. Visual defects were found by hand, late. Three things arrived together: verification against the live staging URL, a visual check of real screenshots, and, most importantly, a place for a human to deposit knowledge that exists nowhere in the code.

   • 20 Jul

     Staging verification. After deployment the line walks the real URL, takes screenshots, runs tests against it and attaches the evidence to the task.

   • 22 Jul

     Visual QA. Mobile at 390px and desktop at 1280px, checked for defects. Explicitly a guardian of intent, not a judge of beauty — there is no AI rubric for aesthetics.

   • 22 Jul

     A two-mode UI Architect. Extend mode for incremental work, where novelty is a bug; define mode for a new page, where a design thesis and an anti-generic check are required.

   • 22 Jul

     A brain for human knowledge. A person writes a note; agents retrieve it with a tool. Agents may read it, never write it.

   • 22 Jul

     An art director and a direction pack. A project's design direction as a document that gets parsed and fed into the line.

   • 23 Jul

     And the reality of operations: the machine's memory ceiling went from 512 MB to 2.5 GB, because the old limit had been killing runs outright.

   Unlocked

   “It works” stopped being a claim by an agent and became a screenshot and a green test against a live address. Knowledge only a human holds finally has somewhere to go.

7. 25 July – 2 August9 days · 129 commits

   VIIThe shop window, and a key for the customer

   The densest stretch in the whole history — and the first time a customer got a key.

   The factory built itself as a product. The desktop site is a single screen of nine acts with a live 3D scene; a phone gets a document built from the same content, written once. Then came the change that alters the relationship with a customer: a portal with a login, a dashboard, live task status and visible spend.

   • 25 Jul

     A cinematic hero. Shader cores, a 2,400-particle field, a hand-rolled bloom — and a frame-rate watchdog that degrades one way only, so a struggling phone simplifies the scene and never flickers back.

   • 25 Jul

     A capability gate. The shell is chosen by viewport and input device, not by graphics card. The server always renders the document, so the content survives even where the 3D cannot.

   • 28 Jul

     The Analog Core landing. Nine acts, one source of content for both desktop and phone.

   • 28 Jul

     Live data, projects, ideas, a model arena. The site stopped being a brochure and became a window into a running line.

   • 29 Jul

     Analytics with consent, sitemap, legal layer, plus a four-step project wizard.

   • 30 Jul

     A small commit that says a lot: unsubstantiated vendor claims were deleted from the arena because they were not backed by measurement.

   • 31 Jul

     Security rules and a prototype generation pipeline.

   • 1 Aug

     The customer portal. Sign-in, activation, dashboard, admin panel, approval functions, security rules and indexes.

   • 2 Aug

     The line syncs task state into the portal. A customer can see what is happening to their request without having to ask.

   Unlocked — a human decision

   Transparency became a feature instead of a promise. You get an account, live status, visible spend, and the approval.

8. 3–7 August5 days · 108 commits

   VIIIMeasurement instead of opinion

   The factory started running experiments on itself.

   The old context engine pre-packed context. The new one inverts it: a minimal core plus tools the agent uses to pull exactly what it needs, at the moment it needs it. No tokens spent on context nobody read. On top sits the layer that turns this into science rather than opinion — feature flags, telemetry, and a mandatory classification of every failure. Was it bad context, or bad judgement?

   • 3 Aug

     A lean core and just-in-time retrieval. The agent decides what to pull; the server verifies it is allowed to have it.

   • 3 Aug

     Failure attribution. Every failure is classified — context missing, wrong or ignored, against reasoning, implementation or test error.

   • 3 Aug

     Feature flags and telemetry. One field switches the whole engine back to the previous version. 130 tests cover it.

   • 4 Aug

     Model choice in the admin interface. Vendor and budget mode per project, set through a screen instead of in code, with a leaderboard of historical quality, cost and speed.

   • 4 Aug

     One source of truth for project configuration. The pipeline reads it live, with a cache and a fallback.

   • 4 Aug

     Verification that a pull request is genuinely merged before a production deploy runs.

   • 5 Aug

     Cost per run. Run and loop counts, and a token spend indicator inside the customer dashboard.

   • 7 Aug

     This page. And a single shared header across every screen the factory owns.

   Unlocked

   The factory can measure whether a new version of its own brain beats the last one — and roll it back with a single switch when it does not.

9. 8–31 August24 days · 95 commits

   IXThe Analyst learns to think

   A four-turn process, corpus distillation, and the end of pre-packed context.

   The Analyst agent was rewritten from scratch. Instead of receiving a wall of context it might not need, it now follows a structured four-turn process: scope identification, codebase exploration, memory retrieval, then synthesis. At the end of every run, a distiller compresses the work into a corpus record worth keeping — so the next Analyst learns from the last one.

   • 8 Aug

     Provider Health Check. A manual smoke test of all registered providers from the admin UI — nine models tested, results stored with history.

   • 11 Aug

     Process page. An interactive visualization of the entire pipeline, with collapsible phases and mode/provider filters.

   • 14 Aug

     Self-service onboarding. A four-step wizard that lets a new project join the factory without touching code.

   • 17 Aug

     n8n installed. The automation layer for the growth loop — n8n.tokenwise.sk live with nginx, SSL, and daily backups to GCS.

   • 17 Aug

     MDX blog infrastructure. Weekly AI articles now deploy through the same pipeline as code.

   • 20 Aug

     Context Engine V0. The Planner was removed; a minimal core plus JIT retrieval replaced pre-packed context. The Analyst now decides what to pull.

   • 20 Aug

     Four-turn Analyst. A structured process: scope → exploration → memory → synthesis. 130 tests cover the new engine.

   • 24 Aug

     Analyst context restoration. An audit found most of V0 was dead in production. Fixed in one wave — project briefs, retrieval traces, and spec validation now work.

   • 24 Aug

     Corpus distillation. One Haiku call at the end of each run turns the work into a structured record — approach summary, lessons, what to avoid. €0.02 per call.

   • 25 Aug

     Audit pages. Native Next.js pages replaced iframe embeds for pipeline audit reports.

   • 31 Aug

     Measurement layer. O-series optimizations: founder comments filter, provider telemetry, budget mechanisms unified across all paths.

   • 31 Aug

     Social media publishing. GTM Wave 4: direct Meta Graph API calls from the pipeline. Articles with growth:article label auto-post to Facebook and Instagram after production deploy.

   Unlocked

   The Analyst stopped being a reader of walls and became a thinker with a process. Every run leaves behind knowledge the next one can use.

Five more eras

1 September – 9 October 2026. Another 39 days and 387 commits across the factory and this website. The figures above belong to the first nine eras; the line kept moving.

1. 1–7 September7 days · 96 commits

   XA receipt for every step

   The bill stopped being a total and became a trail.

   Knowing what a run cost was no longer enough. The next question was where the money went, what the agent actually read, and which decision sent the work around again. The measurement layer moved down to individual calls and operations. Even a run that died halfway through had to leave a receipt.

   • 1 Sep

     Model choice by role. The process page gained an agent grid. The Analyst, Developer and Reviewer no longer had to inherit one project-wide choice.

   • 2 Sep

     Local models joined the line. A local provider can run a role, with a fallback when it is unavailable. A specification can be started from the command line and kept for the next phase.

   • 2 Sep

     One record per model call. Tokens, context size, retries and cost share a run identity. The accounting can be reconciled against the calls that produced it.

   • 4 Sep

     The work between model calls became visible. Sandbox commands, tool results, Git operations, pull requests, deployment and social publishing gained timed spans.

   • 4 Sep

     Cost per correct output. Gate verdicts became quality measurements, so a cheap failed run could no longer win simply by being cheap.

   • 5 Sep

     Decisions left a trace. Retries, budget stops, skipped phases, provider fallbacks and circuit-breaker blocks are recorded with their reasons.

   • 5 Sep

     Context has a journey. The factory records what was retrieved, how the context grew, and which retrieved passages appeared in the output.

   • 6–7 Sep

     A monitoring page and weekly product audits. The telemetry got a place to be read. UX, logging and the context engine got a recurring inspection rather than waiting for a complaint.

   Unlocked

   A slow or expensive run can be followed back to the call, the tool and the decision that made it so. The factory gained evidence for where to improve next.

2. 8–18 September11 days · 67 commits

   XIStop writing the whole app

   The prototype became an assembly job. The model lost its tools.

   The first prototype line asked a Developer to build an application from a brief. It was slow, and the baseline was blunt: three attempts, no live prototypes. More instructions and more turns did not solve the underlying problem. The next version took the code-writing job away. Tested patterns belonged to the template; the model's job was to choose and fill them.

   • 8 Sep

     The first running-prototype pipeline. A brief enters through the wizard, moves to the build machine and gets a deadline. A watchdog watches stuck work; a daily reaper removes expired demos.

   • 9 Sep

     The public entry got boundaries. Abuse controls, safer email rendering and ownership checks were added around the anonymous wizard and prototype adoption.

   • 11–12 Sep

     More guidance was not enough. Pre-built components, progress tracking and a larger turn allowance were tried. The assembly-line redesign recorded the failed baseline rather than hiding it.

   • 12 Sep

     A crashed run still has a bill. Usage captured before a stream failure is retained. The real failing gate is recorded instead of labelling every failure a build error.

   • 14 Sep

     Assembly replaced generation. The template supplies its schema. One model call writes the copy; deterministic code composes the configuration at zero token cost.

   • 14 Sep

     No tools means no tools. The content role cannot edit files or run commands. The restriction is enforced by the harness, rather than left as a sentence in its prompt.

   • 15 Sep

     The Golden demo finally had an address. The earlier claim that it was live met a 404. A real deployer and Firebase configuration replaced the claim, and the template repository became public.

   • 17 Sep

     A name chosen by the customer. Prototypes gained readable /newapp/ addresses instead of a separate Firebase site for every idea.

   • 18 Sep

     The template became the contract. It publishes the patterns it can actually render. The model chooses their composition; the customer keeps the brief, palette and language. Duplicate pattern lists and the extra wizard steps were removed.

   Unlocked — a human decision

   The prototype line stopped paying a model to recreate infrastructure it already owned. Its creative freedom narrowed to a brief, a composition and the words inside tested components.

3. 19–29 September11 days · 67 commits

   XIIA demo with an owner

   Working data, three free changes, and a boundary around customer code.

   A prototype that looks finished but cannot save a record is a picture. The next stretch made the patterns work, opened the demos to visitors and gave their creators a route to keep them. At the same time the factory drew a harder boundary: customer applications moved away from the portal's origin, and private records stopped being public by accident.

   • 19 Sep

     The patterns started doing the work. The template gained a working data layer, languages it actually renders and contact messages that reach the project's tracker. The wizard offers those languages from the template itself.

   • 20–21 Sep

     Choose a model, not just a vendor. Agent settings became model-based. The content role can switch providers through the same resolver as the rest of the line.

   • 21 Sep

     Ideas became live demos. The catalog shows running prototypes and their fourteen-day deadline. An adopted prototype moves onto the projects grid.

   • 24 Sep

     Three free issues. Demo projects gained their own pipeline mode, per-issue token cap and merge guard. Their code lives on a demo branch; the free allowance is settled against completed work.

   • 24 Sep

     A separate origin for prototypes. Customer apps moved to apps.tokenwise.sk. Old addresses redirect, while customer code no longer shares the portal's browser session.

   • 24 Sep

     Fifteen palettes, and a way to refresh. The wizard previews colour pairs. Existing prototypes can receive template improvements without losing their own configuration.

   • 25–28 Sep

     Private means private. Prototype records became readable by their creators rather than the internet. Activation tokens and customer records received the same ownership boundary.

   • 25–28 Sep

     A real bill in the shop window. The landing console shows the last prototype's measured cost. AI hero images and the site's header reached the prototypes, with eleven refreshed by 28 September.

   • 29 Sep

     Credits beyond the free allowance. The wallet, checkout, webhook and refunds were exercised in Stripe test mode. That was evidence for the payment flow, not a claim that live payments had launched.

   • 29 Sep

     The site had to match the line. A funnel audit followed the calls to action through to credits. Landing copy returned to the product with human approval gates; the prototype route got its own explanation.

   Unlocked — a human decision

   A visitor can try a running idea, a creator can keep it and request changes, and the portal has a boundary around it. The free line gained limits before it gained a price.

4. 30 September – 4 October5 days · 86 commits

   XIIIThe line reaches the founder's desk

   Personal coding sessions became supervised work, with production as the finish line.

   The factory already knew how to run on a server. Now it learned to coordinate Claude and Codex sessions on the founder's own machine. A task in Linear could reach a local session, ask for a decision, recover its state and continue through review. Finishing a conversation was not enough: completion had to be tied to the merged change and its deployment.

   • 30 Sep

     Legal research gained a second source. Law Expert combined court sources and compared legal similarity. A separate repair made statute-section searches reach Supreme Court decisions.

   • 1 Oct

     A demo became each visitor's own workspace. Signed-in visitors get separate data. The prototype owner has a contact card and inbox, with email forwarded only after the owner's address is verified.

   • 1 Oct

     Model experiments in pairs. An experiment runner compares model sets on the same briefs. It was deployed and dry-run checked; a paid comparison was still to come.

   • 1 Oct

     Pictures joined the publishing line. Generated article images are prepared before web and social publication and appear in sharing previews.

   • 2 Oct

     A supervisor for local Claude and Codex. Linear tasks reach personal sessions through a relay. A dashboard shows the runs, queue, permission requests and subscription limits.

   • 2 Oct

     Production became the completion test. The supervisor checks that the task's change was merged and deployed. Notifications mark production, queue and quota milestones instead of every intermediate step.

   • 2 Oct

     Replies without copied identifiers. The founder can answer a decision in Linear in plain text. Contact leads gained an automatic reply path of their own.

   • 3–4 Oct

     The applications got their own receipts. CV Matcher gained its verified job library and completed import; Reading Diary gained book lookup and required quizzes. Their delivery records include tests against the published prototypes.

   • 3–4 Oct

     Two ways to give the brief. The landing gained an A/B test between the wizard and a scripted chat. The chat asks the same questions, previews the palette and lets the visitor review the answers.

   • 3–4 Oct

     One workspace for founder operations. Local agents and company state came together in admin. A voice COO backend was activated too, with real-device and mailbox acceptance still left to verify.

   Unlocked

   The founder can send work from the tracker to a personal coding session and follow it through to production. The local tools joined the line's accountability, rather than ending at a finished chat.

5. 5–9 October5 days · 71 commits

   XIVDone means a page and a receipt

   Less automatic work. Stronger proof for the work that reaches a customer.

   The next defects lived after the model had finished: a button with nowhere to go, a green build serving old HTML, a live prototype with no ready email. The repair followed the whole handoff instead of declaring success at the build. In the same week, automatic discovery of new work was switched off. The line got stricter about what it delivers and more restrained about what it starts.

   • 7 Oct

     Links became part of composition. Landing links are checked before a build. A closing call to action must lead to a real chapter, not an anchor invented by the model.

   • 7 Oct

     A model override the pipeline actually reads. The resolver gained per-prototype overrides across the roles it runs. Only the reader was deployed; the customer selector and its write endpoint remained unfinished.

   • 8 Oct

     Automatic work discovery stopped. Idle local agents no longer invent their next task. Reusable scheduled templates remain available for work the founder has chosen.

   • 8 Oct

     Build once, test those bytes. The prototype browser gate reuses the production export instead of building again. Publication requires smoke evidence from that same artifact.

   • 8 Oct

     Fewer checks, with current proof. CI selects tests and deployment targets from the change. A merge still needs verification of the current head and base; an old green run does not count.

   • 8 Oct

     Failed work stayed in the cost report. Recorded failed costs are shown alongside successful ones. Missing measurements are labelled incomplete or unavailable, rather than invented as zero.

   • 8 Oct

     Semantic memory returned to a local provider. Local embeddings restored retrieval. Exhausted-credit calls gained a bounded cooldown instead of repeatedly asking an empty account.

   • 8 Oct

     The creator can rewrite the words. Text editing gained instructions, previews and measured cost. A creator's publish reserves one credit, settles it after success and returns it on failure.

   • 8 Oct

     Bad copy gets feedback before another attempt. The template validates the actual production content, including nested records and every declared language. Repairs stay within the original budget; exhausted attempts fall back to a clearly labelled concept presentation.

   • 8–9 Oct

     The handoff reached the customer email. Assets upload before HTML, the live address must match the expected artifact, and a saved email snapshot is retried safely. Four missing ready notifications were recovered without rebuilding; provider receipts confirmed acceptance, not arrival in an inbox.

   • 9 Oct

     A customer query exposed a search that only seemed to work. Law Expert's section filters, Slovak word forms and search coverage were repaired. The repaired adapter found 204 results for the reported query against live court sources. The stronger research model came after retrieval was fixed.

   Unlocked — a human decision

   A completed build is only one step. The line now asks whether the intended page is live, whether its buttons lead somewhere, and whether the email provider accepted the handoff — while keeping the limits of that proof visible.

The next chapter — 12 October 2026

9–12 October 2026. Another 179 commits dated in this interval: 76 in the factory and 103 in this website, after the revisions covered above. Template history supports the story and stays outside this count. This is a snapshot of four calendar days, including the unfinished day of 12 October.

1. 9–12 October4 days · 179 commits

   XVA smaller line, a clearer bill

   One way to start. Measured tokens to change it. A release still has to reach the page.

   The next changes removed choices that had become accidental: a visitor still landing in the old wizard, a customer buying an abstract credit, a release testing work the same tree had already passed. The factory became more explicit about what starts a job, what the customer pays for, and which version actually goes live.

   • 9 Oct

     The chat became the front door. Every start-a-project button now opens the same scripted conversation. The wizard-versus-chat experiment closed; its stored results stayed frozen, and a new counter follows the chat alone. The chat's meter keeps model tokens at zero until a model actually runs.

   • 9 Oct

     One prototype build at a time by default. The factory gained a shared queue: a lock on each prototype had never limited how many different prototypes could build together. Duplicate requests are refused, and waiting work remains recoverable after a restart. This is a capacity guard, not evidence of a completed conference load test.

   • 10 Oct

     A green quality gate did not mean a release. An earlier main run passed the website's quality gate, failed other required jobs and skipped deployment. CI now reuses a successful pull request's tested tree instead of repeating its tests on main. The production build and deployment still have to succeed.

   • 10 Oct

     Terms that actually open. The missing terms page was added, the privacy notice names the company and its processors, and registration asks for consent. The project chat gained an explicit AI notice. These are delivered pages and controls, not a claim that legal review is complete.

   • 11 Oct

     Tokens replaced credits. The website gained a token wallet, a purchase window and prices calculated by the server. The change flow reserves tokens, settles recorded usage on completion and releases the reservation after a terminal failure. The pricing page is live; that alone does not establish a successful live payment or revenue.

   • 11 Oct

     A task can name its engine and its starting state. The founder's new-task chat can choose Claude or Codex and Backlog or Prioritized. A release guard also learned to update a branch that falls behind main and wait for fresh proof. Staging deploys the merged target branch, after the old feature checkout could omit newer work.

   • 11 Oct

     The template moved ahead of its public demo. Listings and owner contact fields were followed by an optional map and a repair for a map worker that loaded HTML instead of map data. Those changes are in template history. The public Golden demo still names an older revision; a template commit is not proof that every existing prototype was refreshed.

   • 12 Oct

     Model recommendations stopped being a cage. The founder's agent settings moved to the leaderboard. Each role can choose across the available model catalogue, with the recommended tier marked rather than enforced as the only choice. The local-model restriction for autonomous projects remains.

   Unlocked — a human decision

   The customer has one route into the factory and a bill expressed in tokens. The founder can choose how a task starts. The lesson from the release failures stays the same: tested code, deployed code and a page a visitor can read are separate pieces of evidence.

The next chapter — 16 October 2026

Snapshot taken on 16 October 2026, after the revisions covered on 12 October. Another 106 unique commits became reachable from main: 54 in the factory and 52 in this website, including 52 merge commits. Fifteen were dated 11 October and entered main later; the other 91 were dated 12–15 October. Five template commits support the story and stay outside this count. Earlier totals remain frozen. Commits count history, not delivered features.

1. 11–16 October · snapshot106 newly covered commits

   XVIApproval enters the queue

   Preparing a repair, approving its revision and delivering it became separate steps.

   The factory had learned to stop at a pull request. It now needed a reliable way to collect the founder's decisions, combine approved work and prove what reached production. That machinery advanced, but it also exposed its own unfinished handoffs. A closed release and a prepared repair still could not stand in for a changed public page.

   • 11–12 Oct

     The shop window and its measurements changed together. Changes authored on 11 October and merged on 12 October made projects and ideas live catalogs with creator and owner names. Exposure counts gained source buckets and excluded browsers where the founder had signed in. The process map gained an interactive model-cost illustration; its estimates are a demonstration, not measured production bills or a model benchmark.

   • 12 Oct

     A review became inventory for a release. Factory work gained an approval queue for a specific pull-request revision. Approval queues that revision for integration; it does not authorize the source worker to merge or deploy. The release planner then needed a repair of its own: pagination had used an option unavailable in the installed GitHub CLI. Explicit page fetching replaced it.

   • 12 Oct

     Audits made the gaps visible. The published journey review recorded keyboard focus escaping dialogs and sign-in errors disappearing without an explanation. A separate operational review tracked checkout failures. These reports are diagnostic evidence, not implemented repairs. Publishing the previous Record chapter, its timeline and its social posts also produced separate delivery receipts.

   • 13 Oct

     The release clock moved into code. A deterministic timer and checkpointed runner replaced the scheduled coding session that coordinated releases. The runner checks approval against the exact revision, remembers failed integration trees and returns bounded rework to the owning session. It can resume interrupted releases without planning the same sources twice. No reduction in cost or failure rate is established by that implementation alone.

   • 14 Oct

     The founder's pending decisions became visible. The admin overview had counted waiting questions while missing paused pull requests awaiting a decision. Its deployed update now includes those revisions, their links and approve-or-defer controls. The public website revision was checked against the successful production deployment, rather than inferred from a merged pull request.

   • 14–15 Oct

     Reliability findings became factory repairs. The VM's verified revision includes durable work records before webhook acknowledgment, locks that an obsolete worker cannot refresh or delete, and explicit project scope on memory reads. Missing scope can see shared notes, not another project's private notes. Production defers when the lock store is unavailable. Loopback webhook binding and dependency updates also merged. This verifies the running revision; it does not certify that every failure mode was exercised in production or that a firewall script was executed.

   • 14–16 Oct

     The template moved ahead of the public demo. Golden main gained security headers and dependency updates on 14 October. The published demo still identifies the 12 October template revision. The newer security configuration is repository work, not evidence that those headers protect the current demo or every existing application.

   • 16 Oct

     Prepared repairs still wait at the gate. Checkout, dialog focus, sign-in feedback and analytics-consent repairs remain open draft pull requests at this snapshot. The website's 14 and 15 October integration pull requests closed without merging; neither delivered those drafts. Reusing the verified Hosting artifact and reporting blocked releases remain backlog work. The honest finish line is still the exact live revision, followed by its own checks.

   Unlocked — a human decision

   The factory can hold a reviewed revision for a consolidated release and show the founder what awaits a decision. Its history now distinguishes source repairs, verified running revisions, draft fixes and backlog work. This chapter, image and caption drafts are prepared together; their public delivery and later social publication require separate verification.

The next chapter — 23 October 2026

Snapshot taken on 23 October 2026, after the source revisions covered in the 16 October chapter. The factory and website added 76 non-merge commits: 29 factory and 47 website. Another 87 merge commits are recorded separately and excluded from that figure; six non-merge template commits support the story and are also excluded. The 76 commits are dated 14–19 October and entered main later. They include documentation, not 76 delivered improvements. All earlier chapters and totals stay frozen.

1. 14–23 October · snapshot76 new non-merge commits

   XVIIThe staging line moves ahead

   Main kept changing. Production held its place. Staging still needed proof.

   The repairs waiting at the last chapter's gate began to arrive. Then the factory deliberately separated its source line from production for a week of autonomous work. That made the next distinction unavoidable: merging into a staging line does not mean a staging site was delivered, and a longer interval without a PC intervention does not prove the factory kept releasing throughout it.

   • 17 Oct

     Several drafts became delivered website changes. The checkout configuration, keyboard-focus traps, visible sign-in errors and analytics-consent gate merged on 17 October. Those revisions are included in the current public website baseline, verified independently of main. The previous Record chapter and its image arrived in the same release. A repaired checkout configuration still does not establish a successful payment; publication of a chapter does not establish its later social posts.

   • 17–18 Oct

     Time away from the PC became a visible measurement. The founder workspace gained a timer tied to recorded PC interventions. The public version first appeared beside the call to action, then moved into the live console as an hour meter on 18 October. Missing measurements render as dashes. The meter describes time since a recorded intervention, not uninterrupted worker uptime, completed work or freedom from phone decisions.

   • 18 Oct

     A failed release gained a place in the ledger. The previous chapter's backlog item for release-failure notices became a delivered admin ledger and a deduplicated notification path. Earlier integration pull requests had closed without merging; their existence never delivered the repairs. The new path makes blocked outcomes visible, but a push accepted by its provider is still not proof that the founder read it. Reusing the tested Hosting artifact remains backlog work.

   • 18–19 Oct

     Main became the staging line while production froze. The release policy stopped automatic production delivery for the autonomous week. Website main gained an isolated staging deployment job on 19 October, with separate configuration, inert scheduled jobs and guards against production services. Recurring-template scheduling was also separated from queue reconciliation in source. At this snapshot the public website and factory VM still identify their 18 October revisions. These later merges are not production deliveries, and the staging workflow alone does not prove that staging is live.

   • 18–19 Oct

     The analyst's handoff became more explicit in source. Factory main gained typed outcomes for a specification, a clarification or invalid output, so an empty clarification cannot pass as a specification. Later merges added a deterministic specification gate, confirmation of the remote spec commit, shared filesystem tooling for non-Claude runners and explicit retrieval status with a minimum relevance threshold. The verified production VM predates these changes; no production quality or cost improvement is inferred from their merge.

   • 18–19 Oct

     Preparation was recorded without calling it recovery or compliance. Recovery tooling added WAL-safe SQLite backups, encrypted configuration bundles and offline checks. Activation, independent key custody and real recovery drills remain acceptance work. Privacy-rights and processor-review packets also merged; they are research and procedures, not legal sign-off. The context audit removed dead code, while its remaining context-size and measurement findings stayed findings.

   • 19–23 Oct

     Golden's source advanced beyond the public demo. Stable landing-section IDs and validated call-to-action destinations merged on 19 October. On 23 October, the inbox repair merged: a failed mark-read write keeps the unread state and exposes a retry. The repair's source commit is dated 19 October; its merge date is later. The public Golden demo still names the older 12 October template revision. No existing application refresh or live inbox outcome is claimed.

   • 23 Oct

     The autonomous week met an external release stop. Existing release checks report that jobs could not start because of an Actions billing or spending-limit problem; the message does not identify which account condition caused it. Staging delivery remains unverified. A proposed week review records further operational limits, but remains a draft. The portal voice-connection repair, unavailable-quality handling and fuller billing attribution also remain draft pull requests. An approval queue and a green source history cannot substitute for a release that actually ran.

   Unlocked — a human decision

   The factory has a clearer boundary between source progress and public delivery. Some earlier drafts reached the website; newer safety gates, recovery procedures and staging machinery remain ahead of production. This chapter, timeline and caption drafts are prepared together for founder approval. Their release and any later social publication will need their own evidence.

Eleven turning points

Ordered by impact rather than by date. Each one changed what the factory can do, not how it looks.

1. 0112–13 June

   Budget and cost accounting were in the skeleton from day one

   Not bolted on after the first surprising invoice. Every model call passes through one place that counts tokens and euros — and that still holds now that several vendors are in play.

2. 0215–16 June

   Human gates, and the deletion of an expensive retry loop

   After a task burned €8.92 on three failed repair attempts, the factory stopped trying again. Failing tests halt the line and call a person. A production deploy needs an explicit approval.

3. 0312–15 July

   One standard for the whole portfolio

   Five products, five stacks, one four-day migration. Since then, onboarding a new product is a single command rather than a week of integration. The biggest throughput gain in the history.

4. 0414 June

   Always-on — the line runs itself

   A task changes state and the pipeline starts without anyone pressing anything. This is the difference between a tool and a line.

5. 0516 July

   Independence from a single model vendor

   Any role can run on a different provider, with identical permissions and identical accounting. Quality is settled by measured outcome, not by an AI referee.

6. 0620–22 July

   The factory learned to look

   Staging verification walks the live address and files the evidence. Visual QA checks mobile and desktop screenshots. “It works” stopped being an agent's opinion.

7. 071–2 August

   The customer portal and live task status

   Your own account, the stage your request is in, and what it has consumed. Transparency as a feature rather than a promise.

8. 083–4 July

   A UI Architect as its own role

   Design stopped being a by-product of writing code. The project's design system is read from the repository instead of reinvented on every task.

9. 0914 June · 22 July

   Memory — first the machine's, then the human's

   The factory learns from finished work, reused components and its own failures. Since July it also has a place for the knowledge that will never be in the code.

10. 103–5 August

    An engine that can prove it improved

    Agents pull context on demand, every failure is classified by cause, and every change to the engine can be measured and reverted with one switch.

11. 1120–24 August

    The Analyst learned to think in turns

    A four-turn structured process replaced the wall-of-context approach. Scope first, then exploration, then memory, then synthesis — and a distiller that turns every run into a lesson for the next one.