A runtime walkthrough · Updated 2026-10-02

Factory

Factory turns an approved software goal into something Emre can try. An AI engineering lead decides the next steps, builders make changes, and a different model checks each build. The conversation assistant, Hermes, examines the evidence and brings Emre the result or a decision that needs him.

Start here / one concrete request

“Add a CSV export to Harbor for completed tasks in a chosen date range. Show the task title and completion date, integrate it locally, and give me a working demo.”

Harbor is a fictional task app. This synthetic example follows one approved goal; public release is a separate decision. Emre supplies the purpose, product choices, required access, and authorization. Factory owns investigation, engineering, review, and proof; Hermes handles the owner conversation.

A useful result

A file that opens in a spreadsheet, containing the right completed tasks, plus a working local demo and a delivery record identifying the job's changes.

From request to result

What happens next

  1. Approve the job

    Emre sends the Harbor request to his conversation assistant, Hermes, over Telegram. Hermes saves his words and presents the proposed job for approval. Emre approves that specific job, and Factory starts engineering. The lead now knows what the export must contain and that public release needs a separate decision.

    What moves forward

    Hermes gives Factory the goal, its boundaries, and Emre's approval.

    How this step works

    A campaign is the saved record of one software goal. Telegram approval uses the campaign's own button or scoped command, so the system can identify exactly which job Emre approved. Installing or starting the services does not activate a proposal. Model-generated feedback cannot create owner approval. This example includes local integration in its approved scope; publishing remains a separate decision.

  2. Decide what to build

    The AI engineering lead reads the approved goal and inspects how Harbor already stores tasks and dates. It gives a builder a focused brief: add the export and show that it includes completed tasks in the selected range while excluding open tasks and other dates. That makes success concrete enough to build and check.

    What moves forward

    The lead sends the builder a brief and the project facts needed to carry it out.

    How this step works

    Factory starts fresh lead sessions with project instructions, a compact working map, and relevant new evidence. The map explains what is known and what to do next; it can change as the work reveals facts. Sol through Codex or Opus through Droid supplies the lead. Straightforward work goes directly to implementation. An important factual uncertainty can receive a small research step first, normally assessed by the lead without a separate reviewer. The execution adapter checks subscription access and applicable quota; unavailable capacity leaves work waiting.

  3. Build the export

    The builder works in a separate copy of Harbor, adds the export control, and creates the CSV download. It tries the feature with synthetic tasks and reports what appeared in the file. The original project stays available while this proposed change is examined, so the reviewer receives something it can actually run and inspect.

    What moves forward

    The builder passes the changed working copy and its observations to the reviewer.

    How this step works

    Git calls the separate working copy a worktree. Factory creates a branch for the step and preserves relevant non-private unfinished source work in the starting baseline without resetting the original copy. The eventual delivery must include the campaign's changes rather than unrelated baseline work. Worker reports include surprises and dead ends. Factory checks declared private-file changes after the run and discards a candidate if it detects them. This detects changes, not silent reads. A successful process exit alone does not show that the export is correct.

  4. Check it with another model

    A reviewer using a different model checks the builder's working copy. It independently tries Harbor's export, including a task on the date boundary, an open task, and a title containing a comma. It fixes ordinary defects within the brief or explains a larger problem to the lead. The lead then has another model's observations to judge.

    What moves forward

    The reviewer returns the revised export and its observations to the lead.

    How this step works

    Factory rejects a builder and reviewer using the same underlying model. Review starts after the builder and can examine partial work even if the builder run failed. The reviewer is instructed to exercise the requested behavior before relying on the builder's explanation and derive expected results from the contract and source data. Changes needing a new design or unrequested dependency return to the lead. A finished review is process evidence; the lead still owns judgment against the full goal.

  5. Try the complete feature

    The lead tries Harbor as a user: choose dates, press export, open the file, and compare its rows with the right tasks. If the experience is wrong, it orders another focused correction. Once the result meets the goal, it brings the approved changes into the local project and records what was delivered, ready for Hermes to assess.

    What moves forward

    The lead gives Hermes the result, the delivered changes, and evidence from the full user path.

    How this step works

    Worker results wake a fresh lead session. The original owner goal stays authoritative through revisions. Independent steps can run in parallel; within one build step, review follows the builder. A step needing an unresolved decision waits while independent work can continue. The lead rechecks private-file changes before integration and includes only intended campaign changes. Local integration is permitted in this example; public release is not. Delivered commits carry a campaign reference. Recording completion does not deploy the product or guarantee acceptance.

  6. Show the result

    The conversation assistant, Hermes, checks whether the evidence supports the Harbor request. It can inspect the CSV rather than simply trust a success report. Missing proof or a weak result goes back to the lead for more work. When the evidence supports completion, Hermes sends Emre the outcome over Telegram so he can inspect it.

    What moves forward

    Hermes sends Emre the result or returns a specific problem to the lead.

    How this step works

    Hermes selects relevant reports, changes, text outputs, and images. It has no terminal or editor, so the lead must obtain missing observations. Its silent engineering feedback returns to the same approved campaign, remains separate from owner input, and grants no new permission. Genuine product direction, taste, access, or authorization decisions can reach Emre. With preview setup separately approved, Hermes can include a protected link to a selected evidence file or static demo. The link requires the configured owner's email sign-in, expires within two hours, and depends on the host staying online; it is not a production release.

  7. Learn from the owner's experience

    Emre tries Harbor's export and can rate the delivery from 1 to 10 with a reason. Factory looks back at how that job was handled, using his feedback to identify a useful improvement. For example, a correct CSV that is hard to find could expose a delivery problem. Any proposed change to Factory returns to Emre for approval.

    What moves forward

    Emre's rating guides a review that may produce a new improvement proposal.

    How this step works

    The delivery record connects the goal to the campaign's commits and completion reports. Hermes relays the owner's original score and words; it does not infer a rating from apparent satisfaction. Each rating schedules a retrospective, a look back through the campaign's prompts, reports, timing, and execution evidence. It may propose a focused Factory improvement but cannot activate a new campaign itself. Whether this mechanism measurably improves future deliveries remains unproven.

The system behind the story

Every piece has a job

Open a piece for its role, or a technology for the choice and tradeoff.

PeopleEmre

The owner: defines the desired outcome, authorizes actions, tries the result, and supplies feedback.

SoftwareHermes

The conversational interface and outcome judge: handles Telegram, preserves original replies, and challenges selected evidence before presenting it.

SoftwareFactory service

The coordinator: keeps job state, starts sessions, notices finished work, and resumes campaigns when new information arrives.

RecordsCampaign record

The durable record of one goal: approval, working map, worker results, questions, and delivery evidence.

SoftwareOrchestrator

The AI engineering lead: plans the next useful step and owns the whole result. Configured routes use Sol through Codex or Opus through Droid.

SoftwareBuilder

The worker: implements one narrow brief in a separate working copy of the target project.

SoftwareReviewer

A different underlying model: independently exercises the requested behavior and can fix defects in the builder's working copy.

SoftwareModel Runtime

The execution adapter: selects the configured vendor command, checks subscription access and applicable quota, and records the run.

Why these technologies?

TypeScript and Node
The job
Run the background control service that coordinates campaigns and worker processes.
Why this choice
This is the implemented control layer; it uses Node's built-in SQLite rather than requiring runtime npm packages.
The tradeoff
The local host and supported Node version must be available. Coordination code can preserve workflow facts, while useful-product judgment remains a model responsibility.
SQLite
The job
Keep campaigns, owner inputs, events, and run state in a local durable database.
Why this choice
Transactions and recorded request identities let the service recover and avoid repeating successful engineering effects when requests are retried.
The tradeoff
Stored state survives service restarts; it does not keep an offline host operating or guarantee sound model judgment.
Python and vendor command-line tools
The job
Connect configured model seats to subscription-backed tools, with access checks, applicable quota checks, and execution records.
Why this choice
A central registry owns model identity and command details. Current builder choices include Gemini Flash, SWE-2, Grok, and GLM; builds require a different-model reviewer.
The tradeoff
Login failures, changing vendor tools, or exhausted allowances can block work. Metered seats require the configured 10% reserve in live short windows; unlimited-marked seats bypass quota queries. No paid API fallback is selected, but vendor account billing settings are separate.
Git worktrees
The job
Give each step a separate working copy for implementation and review, then identify the campaign's delivered changes.
Why this choice
Candidates can be examined without resetting unrelated source work, and delivered commits carry a campaign reference.
The tradeoff
The lead must integrate only intended changes and respect release authorization. Private-file change detection can discard a candidate; a working copy is not a read-isolation guarantee.
Hermes and Telegram
The job
Handle the owner conversation, approval controls, original replies, and delivery of selected outcomes.
Why this choice
Communication is separate from engineering, allowing Hermes to return unsupported claims and routine engineering questions for refinement.
The tradeoff
Hermes cannot run the product itself. If it is unavailable, communication waits while independent engineering can continue. An interrupted Telegram send can produce a duplicate retry.
Cloudflare Quick Tunnels
The job
Provide protected temporary web links to selected evidence files or static demos after preview setup is approved.
Why this choice
The implemented preview path lets the owner inspect supported artifacts without a manual upload or a production release.
The tradeoff
Viewing requires the configured owner's email sign-in. Links expire within two hours and need the host online; they are not persistent production hosting.
macOS launchd
The job
Supervise the Factory and Hermes background services.
Why this choice
Both services are configured to stay running, and durable recovery can reconcile work after a restart.
The tradeoff
The current operating setup depends on a macOS host staying available, awake, and connected. Service supervision does not establish that a particular campaign produced a useful result.

Keep the boundary clear

What exists, and what comes next

Build and review workflow implemented

Implemented today

  • Factory keeps a saved job record, requires specific campaign approval, and resumes work when results or owner replies arrive.
  • Builders make changes and different-model reviewers check them. Research can return directly to the engineering lead.
  • The execution adapter uses configured subscription tools, checks access and applicable quota, and selects no paid API fallback.
  • Hermes examines selected evidence, returns inadequate work to the same job, and presents supported outcomes. Delivery records identify the campaign's changes.
  • Protected temporary previews, owner ratings, and reviews that can propose Factory improvements are implemented.
  • Service records document an owner reply reaching engineering on October 1, 2026, and owner-confirmed viewing of image, video, and static previews on October 2.
Limits of the current system
  • Reliable delivery of useful whole products with very little owner attention remains unproven.
  • The lead, reviewer, and Hermes can misjudge work. A successful run, finished review, or completion record does not establish product quality by itself.
  • Private-file protection detects changes; it does not prove that private information was never read.
  • This walkthrough checks source and reads deployment records, including a checkout with local uncommitted changes. It does not establish today's service health or vendor capacity. Communication and preview demonstrations are recorded observations; no new live check was performed for this page.

Next, not yet established

  • The proposed direction is to complete an approved whole software goal with very little owner attention.
  • Voice and photo brief handling was listed as deferred work. Current owner decision routing accepts original text.

Say it back

The version to remember

Factory is my internal system for turning an approved software goal into something I can try. An AI lead breaks the work into focused steps. Builders make candidate changes, and a different model reviews each build. The lead checks the full result; Hermes challenges the evidence and brings me the outcome or a real decision. The job record survives interruptions. The machinery exists; reliable whole-product delivery with very little of my attention still has to be demonstrated.

Founder questions

Check your understanding

What is Factory actually producing?

An authorized software outcome and evidence that it behaves as requested, tied to a specific goal and delivery record. Plans, reports, and finished worker processes are intermediate evidence.

Who decides whether the work is good enough?

The orchestrator owns engineering judgment. A different model independently exercises each build, and Hermes challenges selected evidence before presentation. The owner tries and rates the delivery. These checks add perspectives; they do not guarantee correctness.

Does one approval let it do everything?

Approval activates the scoped goal. Product direction, required access, new spending, and release actions follow the owner's actual authorization. Hermes feedback cannot create approval or expand that scope.

What happens when work or communication fails?

Factory preserves the campaign and reconciles run evidence after restart. Unavailable routes leave work waiting; failed lead sessions retry and prefer another eligible lead. Hermes retains conversation obligations separately, so communication failures need not repeat engineering effects.

Why use several models and subscription tools?

A different underlying model is required for build and review, providing an independently exercised check of the candidate. Configured vendor routes use subscription access and applicable quota checks. This creates an inspectable execution route while depending on those tools and allowances; no general model-superiority claim is established.

Can I inspect the result before public release?

Yes. The system can return evidence and, with preview setup approved, a protected temporary file or static-demo link. Previews expire and depend on the host. A production release needs its own authorization and execution.

Is it autonomous and proven?

It can coordinate and resume work without a continuous human engineering session. Communication and preview delivery have documented demonstrations. Consistently useful whole-product delivery with minimal owner attention remains unproven, and its private-file checks do not establish read isolation.