§5.4 Two Problems of Factory Engineering
The factories examined in this chapter differ substantially in scale, organization, and purpose. They also place engineering structure in different parts of production. The commercial systems in §5.3 devote substantial engineering structure to arranging how production proceeds: supplying context, routing work, controlling tool access and permissions, coordinating people and agents, arranging review, and deciding what may be admitted. DocAble has production machinery as well, but much of its explicit structure represents properties of the software being produced and establishes whether successive realizations preserve them.
The comparison also exposed a constraint that becomes more important as production accelerates: the capacity to produce changes and the capacity to supervise and verify them need not grow together. Process design therefore includes the allocation of scarce supervisory capacity, not only the organization of realization.
The distinction recalls the two techniques with which this chapter began (Figure 5.1-1). Process design determines how production proceeds. Tolerance determines what variation in the resulting product is acceptable. Both are problems of factory engineering. The cases make visible how differently an agentic software factory can distribute its effort between them.
5.4.1 Process Design and Tolerance
DocAble's emphasis on tolerance was partly a consequence of the problem that produced it. Accessibility supplied external requirements, including legal obligations, that the resulting documents had to satisfy. The project was also a side effort run by one engineer. There was little organizational process to design, and neither time nor appetite to inspect every implementation decision made by coding agents. The practical objective was therefore to encode consequential requirements precisely enough that agents could change the system freely while the resulting software continued to satisfy them. At the time, this struck me as the obvious way to build an agentic software factory. Having now compared it with commercial factories, I can see that it was specifically the obvious way for an "organization" with one human engineer and no spare humans to supervise the agents.
Commercial factories operate under different conditions. Their agents work inside large engineering organizations, where work must move among people and agents, organizational knowledge must reach the right work, authority must be bounded, tools must be exposed safely, and changes must eventually enter systems maintained by many people. Their public descriptions consequently place substantial emphasis on process design. The difference is where the visible engineering structure is concentrated.
Tolerance is present in these factories, but generally less explicit and less tightly represented. Tests, static checks, simulators, benchmarks, and policy predicates all bound selected properties of acceptable realizations. They are genuine tolerance mechanisms. But much of the engineering intent described in the public accounts remains in natural-language instructions, skills, policy corpora, knowledge graphs, or human review. These channels can make an agent better informed and improve the probability that it interprets the intent correctly, but they do not themselves provide a machine-checkable boundary around acceptable realizations. The fabricator still has to interpret the instruction, and another act of interpretation may be required to decide whether the result satisfied it.
Information available to an agent is not the same thing as control available to an engineer.
DocAble's approach to tolerance, however, is distinctive. MAGE represents selected consequential properties explicitly and uses Alignment to maintain correspondence between those representations and the realized system. Tests, property-based testing, static analysis, measurements, and other evidence mechanisms can participate in establishing those properties, but the tolerance is the represented engineering obligation rather than any particular checking technique. This permits tighter tolerances than instructions or isolated checks alone: the factory can represent what must remain true, identify the realization freedom left open, independently establish whether the resulting system remains within those bounds, and make failure consequential for admission.
The representations used by the factory also become part of its maintenance burden. GitLab, Cloudflare, and Shopify all describe machinery for keeping instructions, documentation, or other inherited context current. Externalizing engineering knowledge therefore does not eliminate the cost of exercising that knowledge repeatedly; it exchanges some of that repeated judgment for the carrying cost of production structure. Whether that exchange pays depends on how widely the structure is reused and how expensive it is to keep accurate.
The distinction matters because process design and tolerance respond differently to improvements in the fabricator. Process design often encodes assumptions about how production must proceed: how work is decomposed, what information is supplied, which tools are available, and where supervision occurs. Those assumptions can change as the fabricator and its interfaces improve. Tolerances describe properties of the product that production must preserve. A more capable fabricator may require a different process — or much less process — without changing the memory bound, security boundary, accessibility requirement, or deployment constraint that the resulting system must satisfy.
That difference also helps locate MAGE within the larger problem of factory engineering. MAGE concentrates primarily on the tolerance side of the factory. Process design remains part of the production system, but MAGE does not attempt to prescribe a general process for agentic software development. The distinction is therefore not between factories that have tolerances and factories that do not. It is between different ways of representing tolerances, establishing them, and making them consequential in production.
5.4.2 The Engineer in the Factory
In both aspects of factory engineering, human engineers use their judgment to decide what the production system should carry. Process design requires decisions about decomposition, information, authority, tools, review, and admission. Tolerance requires decisions about which properties are consequential, how they should be represented, and what evidence should establish them. These structures allow judgment exercised once to shape subsequent production rather than requiring the same judgment to be exercised again for every realization. The industrial cases show the leverage directly: one policy, skill, verifier, or shared representation can govern a class of later work.
Why not simply delegate that judgment to a sufficiently capable agent? Organizations have long delegated consequential judgment to people, but they do so partly through incentives and accountability: people can be trained, rewarded, promoted, disciplined, fired, held professionally responsible, or subjected to legal sanction.11. James G. March and Herbert A. Simon, Organizations (Wiley, 1958). Codex and Kimi and Claude do not desire to do good work, pursue promotion, fear firing, or face jail time for what they produce. Instructions, context, and process can shape their behavior, but they cannot reproduce these organizational mechanisms for delegating consequential judgment. Greater capability does not remove this difference. The human engineer therefore remains responsible for deciding which decisions may safely remain with the agent and which require stronger control through the production system.
Tolerance provides one way to preserve that control without specifying realization completely. A memory model need not specify the implementation that satisfies the memory bound, nor must a deployment model determine the internal structure of every service. The engineer identifies the consequential property and the evidence required for it; the agent retains the remaining degrees of freedom. Process design can similarly constrain where and how the agent works. In either case, the engineer's task is to decide which judgments the factory must carry forward and which may be supplied by the fabricator during realization.
5.4.3 Factories Inside and Outside the Organization
The cases also differ in who supplies the factory. DocAble and several systems in §5.3 are substantially internal production systems: the organization engineering the software also engineers much of the factory through which agents participate in its production. Other systems move toward a factory in a box: a reusable production system supplied to organizations whose software, requirements, and engineering knowledge the factory provider does not own.
Every software factory must join productive capability to organization-specific engineering intent. An internal factory can build that connection directly into its representations, processes, controls, and evidence mechanisms because the organization owns both the production system and the engineering knowledge it must carry. A factory in a box must solve the same problem across an organizational boundary.
The provider can supply agents, orchestration, context-delivery machinery, execution environments, permissions, evidence infrastructure, and generic controls. It cannot know in advance which properties of a customer's software are consequential, which variation is acceptable, or what evidence should establish that an obligation has been satisfied. The customer must supply that engineering knowledge, and the factory must provide means for making it consequential in production. The external factory therefore makes an existing integration problem harder: organization-specific intent must enter a generic production system without returning every consequential judgment to human inspection of the resulting implementation.
This remains an open design space. A factory in a box might provide richer means of designing the production process, richer means of representing and enforcing product tolerances, or both. Improvements in the underlying agents may also change which parts of the factory are worth carrying. The important point for the cases in this chapter is narrower: productive capacity and engineering control need not come from the same place, and an agentic factory must somehow join them.
Works Cited
- March, James G., and Herbert A. Simon. Organizations. Wiley, 1958.