All chapters
  1. Start hereA software factory, from first principles
  2. Primitive · 1A factory, before AI: input, transformation, check, output
  3. Primitive · 2From repetition to a pattern: what stays, what varies, what to leave alone
  4. Primitive · 3The specification as an executable contract
  5. Primitive · 4Build the smallest factory: four stations, two specs, one manifest
  6. Primitive · 5Assembly stations: typed contracts, owners and failure handling
  7. Primitive · 6AI enters the factory: what a model adds, and what stays deterministic
  8. WatchAlgo · 7The WatchAlgo production story: what the repository shows
  9. WatchAlgo · 8A problem as a production unit: the files one unit must contain
  10. WatchAlgo · 9Station by station: description, solution, implementations, visualization
  11. WatchAlgo · 10The visualizer factory: from algorithm state to renderable steps
  12. WatchAlgo · 11Three flavors and three languages: two different contracts
  13. WatchAlgo · 12Looping over a large backlog: scheduling, limits and a failed-case queue
  14. WatchAlgo · 13Long-running agent execution: context, checkpoints and token limits
  15. WatchAlgo · 14Evidence of correctness: tests the producer cannot talk its way past
  16. WatchAlgo · 15The factory learning loop: defects change the pattern, not only the unit
  17. Enterprise · 16Classify the enterprise demand before choosing a pattern
  18. Enterprise · 17Reference enterprise patterns and their variation points
  19. Enterprise · 18Platform foundations: golden paths, templates, registries and catalogs
  20. Enterprise · 19Pattern versus configuration versus business logic
  21. Enterprise · 20Insurance factory, part 1: building the intake contract
  22. Enterprise · 21Insurance factory, part 2: building the underwriting workflow
  23. Enterprise · 22Insurance factory, part 3: trust and observability built in
  24. Enterprise · 23Data and integration engineering: contracts that survive change
  25. Enterprise · 24The CI/CD and deployment factory: from pull request to production
  26. Enterprise · 25Enterprise governance: owners, approved patterns and provenance
  27. Enterprise · 26Scaling safely: many teams, many agents, one set of boundaries
  28. Operations · 27Factory quality engineering: measuring accepted output, not activity
  29. Operations · 28Failure and recovery scenarios: what breaks a factory, and what restores it
  30. Operations · 29The landscape: which tool for which job, read from its own documentation
  31. Operations · 30Design an enterprise software factory: the blueprint and the rollout
  32. ReferenceSources and verification
  33. ReferenceGlossary
  34. AboutAbout this site
Reference

Glossary

Every term this site uses, each with what it is, what it is not, and where it shows up in the examples.

Every term this site uses, in one place. Each card opens the same drill-down as the underlined phrases in the text: one line, what it is, what it is not, and how it shows up in the examples.

Three sentences hold the words apart. A software factory turns a reusable engineering pattern and an explicit product specification into independently tested software artifacts through governed, repeatable assembly stations. A self-report of "done" is not evidence; a test the producer did not write is. And, in the insurance example: the model recommends; a person decides.

Acceptance checkA check written from the specification, run by something other than the producer, that a product must pass before it is called done.Acceptance contractThe part of a specification that says how the product will be judged (criteria, examples and the checks they become), agreed before the work starts.Agent frameworkA library for building programs in which a model's output chooses part of the control flow: which tool next, which branch, when to stop.Agent loopAn agent or station that repeats the same attempt, edit or tool call without making progress, and never crashes.Agent traceThe connected record of what one agent run did: each request, event and log line, tied together by one identifier so the run can be followed end to end.Agentic case managementA reference pattern for a case that stays open while an agent gathers evidence with tools from several sources and writes a recommendation, ending in a person's decision.AmbiguityA statement in a specification that two competent readers can interpret differently, so whoever meets it first makes an invisible decision.Animation phaseA short label naming the stage of the algorithm a state belongs to, such as init, find, union or return.API contractThe written description of what a service accepts and returns at one boundary: routes, fields, types, error responses and required headers.Approved patternA pattern version the platform team released and the review roles accepted, recorded in a list the factory reads before it starts.ArchetypeA named starting shape for a project or unit from which new instances are created by filling a few fields.Architecture reviewA review, by people outside the team that designed it, of whether a factory design meets written rules: owners, evidence, boundaries, gates, release and governance.Artifact registryThe store where built, versioned artifacts (packages, images, generated contracts) live, each retrievable by version and content digest, never changed in place.Artifact signingProducing a signature over an artifact's digest (or over a statement about it) so anyone can check the bytes are the ones a known identity signed.ArtifactA persisted, versioned output of a station with a content hash, which later stations and reviewers consume instead of a transcript.Assembly lineThe ordered set of stations a unit passes through, with a handoff of artifacts between each.Assembly stationA responsibility with declared inputs, outputs, a validator and an owner, staffed by code, an agent, a person or a mix.AttestationA signed statement about an artifact, identified by its digest, made by a party a verifier chooses to trust; provenance is the most common kind.Audit fieldA field written on every request record or event so a later reader can reconstruct who did what, when, and under which version.Audit recordA durable, append-only entry written for every request, accepted or refused, saying who asked for what, on which case, and what happened.Author reportA statement about a case study that comes from the person who built it and that no file shows in full; it is quoted as a report, never as a measurement.BacklogThe set of units the factory still has to build, ideally computed from what exists rather than kept by hand.Backward compatibleA schema change is backward compatible when readers using the new schema can still read everything written under the old one.Batch / ETLA reference pattern that extracts, transforms and loads data on a schedule, with checkpoints and data-quality checks between steps and reruns by date.Blast radiusThe set of products, consumers and approvals that one change to a shared component reaches: who must rebuild, re-test and sign.BottleneckThe station with the slowest pace per accepted unit, counting rework; it sets the ceiling on throughput.Brittle abstractionA shared mechanism that works for the cases it was designed from and fails, often silently, as soon as a product needs something it cannot express.BrokerAn intermediary who sends a commercial property quote request for a client to the insurer; in the series the request arrives as an email and intake turns it into a submission.Build graphA directed graph with no cycles in which an arrow from one station to another means the second cannot start until the first has finished.Building vs operatingThe split between a factory run that builds a product (code, tests, a rollout manifest) and a runtime run in which the built product acts on real cases.Business-rule moduleThe code that makes one product's decisions, owned and reviewed by its domain team, called by the pattern through a seam and never contained in it.Byte-identicalTwo files are byte-identical when every byte is the same, which you check by comparing their content hashes.CanarySending a small share of real traffic to a new build for a fixed window and comparing its error rate with a threshold before promoting further.Change data captureTurning each committed change in a database into an event, by reading the database's own change log rather than asking the application to publish.CheckpointA record, written outside the worker, of which units are finished and with which artifact hashes, saved after each completed unit and before risky steps.CI pipelineA fixed sequence of builds and checks that runs automatically on every change to a repository and reports pass or fail.CI systemA product or project that runs a pipeline of dependent jobs when something happens in a repository, records the result, and can gate merges and releases.Coding agentA program that reads a repository, edits files and runs commands in a loop driven by a model.CompactionShortening a long conversation by replacing its earlier part with a summary, so a worker that is running out of context room can continue.Concurrency limitA cap on how many workers act at the same time against a shared resource such as an account, a database or a review team.ConfigurationData a product spec supplies at the pattern's extension points: route paths, role names, field types, timeouts, thresholds.Content hashA short fixed-length value computed from the exact bytes of a file or document; any change to the bytes gives a different value.Context windowThe amount of text a model can consider at one time: instructions, spec, files it has read and the conversation so far.Contract testingChecking, before release, that each side of a boundary sends and accepts messages matching a shared contract, without starting the whole system.ConveyorWhatever moves a unit of work and its artifacts from one station to the next: a function call, a queue, a scheduler reading a database.Cost per accepted unitAll spend in a period, every attempt including failed and abandoned ones, every reviewer hour and later escapes, divided by the units accepted in that period.Cross-language checkA factory check that runs every language implementation on the shared fixtures and compares the results with each other and with the expected values.CRUD portalA reference pattern in which people create, read, update and delete records through a user interface over one owned database.Cycle timeThe time from the moment the first station starts on a unit to the moment its artifact is accepted.Database migrationA versioned script that changes a database's structure, run in order and recorded, so every environment reaches the same schema the same way.DeduplicationChoosing the key that says two tasks or two units are the same work, and refusing the second one.Defect taxonomyA short, fixed list of classes that every recorded defect is sorted into, so counts per class show where the line leaks.DefectA property of an artifact that violates its specification or fails one of its checks.Definition of doneThe complete list of conditions under which a product may be called finished: checks passed, artifact and evidence recorded, required people signed.Demand intakeThe step that receives a request, classifies it on a fixed set of dimensions, records what is unknown, assigns a risk tier, and only then picks a pattern.Deterministic stationA station whose output is fully determined by its input: validation, rendering from templates, compiling, static analysis, running tests, writing a manifest.DeterministicA step is deterministic when the same input always gives the same output.Differential testingRunning two independent implementations on the same inputs and treating every difference in output as a defect in one of them.Discovery questionA question asked of the people who own a demand, chosen so that its answer is a decision that changes the design, not a preference.Document intakeA reference pattern that turns emails, forms or files into validated records, where retrieval or a model may help read the input and a draft is reviewed before it becomes a record.Domain teamThe team that owns one business area and its products: the product spec, the business-rule module and the decision to release.Durable executionA started process runs to completion even if the machine running it fails, because each step's result is recorded and replayed or resumed elsewhere.Durable recordRows for every run, task and attempt, written before and after each piece of work, with hashes and pointers to immutable artifacts.Environment configurationEvery value that differs between the places a product runs: hostnames, credentials, the address of a real provider.Environment promotionMoving one build, identified by its digest, from development to staging to production after the checks for each step pass.Escaped defectA defect discovered after acceptance, by a later check, a reviewer, a user or production; the rate is escapes per accepted unit.Event-driven workflowA reference pattern in which each step reacts to an event and emits the next, so versioned event schemas carry the process between services.Eventual consistencyThe property that two parts of a system will agree after a delay, not at every instant.Evidence captureStoring, for every build that moves, which build it was, from which inputs, which checks ran with which result, who approved and what the canary saw.Evidence matrixA table with one row per claim and three columns: what the files show, what the author reports, and what this site proposes for teaching.Exception processThe governed way to let one product depart from a rule, with a reason, a compensating check, an approving role and an expiry date, recorded where it can be counted.Executable exampleAn example in a specification that the factory turns into a test without a person rewriting it.Extension pointA place the pattern declares by name where each product must supply its own configuration or code; the factory refuses a spec that leaves one empty.Factory pipelineThe pipeline that runs on changes to the factory (a pattern version, a station, a spec) and checks that the factory still produces correct products.Factory runOne identified execution of the factory that builds a product or a batch, with its task state, attempts, costs, lineage and resume points.Factory topologyThe picture of a whole factory line: where work comes from, what coordinates it, which stations run in which order, how acceptance and checkpoints work, and how output reaches readers.Failed-case queueA separate list of units that used up their attempts, each with its failure evidence, owned by a person who decides what happens next.Fake dependencyA stand-in for an outside system that the tests control, so they can reproduce its answers and its failures without the real thing.First-pass yieldThe share of units, or attempts, that pass a station's check on their first attempt, without rework.Flaky testA test whose result changes between runs with no change to the code under test, usually because of timing, order or an outside dependency.FlavorOne narrative variant of a unit: the same problem, algorithm and constraints, told in a different voice with different names and images.Golden caseAn input with an agreed correct outcome, owned by the domain team, that every version of the product must handle correctly before release.Golden pathA bundled, supported workflow for a common job, offered with a template and documentation, that most teams follow because it is the easiest route.GuardrailA control that limits what an agent's output can cause, whatever the output says.HallucinationOn this site, output from a model that is wrong and carries no sign of doubt: code that fails cases it claims to pass, a citation that does not exist, an expected value nobody computed.Headless modeRunning a coding agent from a script or CI with a prompt and flags, no interactive session, and machine-readable output.Human gateA point in a flow where work waits until a person with the authority for it decides, with a role check, a queue and a record of the decision.Human reviewA named person checking an artifact against stated criteria and recording a verdict, for what code cannot judge.IdempotencyA property of an operation: running it again with the same input changes nothing beyond the first run.Infrastructure as codeDescribing environments (networks, databases, queues, permissions, runtime settings) in versioned files that a tool applies, instead of configuring them by hand.Intake agentThe agent at the front door of the insurer's service that reads a broker's email and writes a draft submission for the broker or a validation step to confirm.Intake endpointThe one route a broker calls to hand in a submission; it authenticates, checks the role, validates the body and stores the submission once.Integration serviceA reference pattern that puts one contract-first API in front of other systems, with an adapter per external system, mappings and contract tests.Internal developer platformThe common name for the collection of shared engineering capabilities an organization offers its own developers through portals, templates, APIs and command-line tools.InvariantA part of the work that is the same for every request of one kind, so it is written once, versioned and owned by one team.Irreversible writeA side effect outside the factory's own artifacts, such as a record in a partner system, a message, an email or a dropped column, that no rollback removes.Item dependencyA declared rule that one work item cannot be produced, or cannot be accepted, until another item is done.Language implementationThe solution of a unit written in one programming language, expected to behave exactly like the unit's other implementations.Lead timeThe time from the moment a specification is accepted to the moment a deployable artifact exists.Least privilegeEvery principal, person or workload, holds only the permissions its job needs, and nothing it might need someday.Legacy adapterA component that translates between an older system's formats and behavior and the contract a new service expects, so the new service never depends on the old system's quirks.Little's lawIn any stable system, the average number of units inside equals the rate at which they leave times the average time each spends inside.MaintainerThe named team or role that owns a product after release: it answers pages, approves changes and receives the defects the factory records.Malicious dependencyA library, plugin or tool, new or a changed version, that runs harmful code when the factory builds or runs a product.ManifestA machine-readable receipt for one artifact: which inputs produced it (by hash), which files it consists of (by hash), which checks ran and what they found.Maturity levelOne of four stages a factory reaches for one kind of product, entered only when named evidence exists: repeatable, verified, governed, learning.Measured qualityA statement about an artifact that names which checks ran, on which input, with what result, so anyone can repeat it.Merge conflictTwo changes made in parallel touch the same lines or files, so they cannot be combined automatically, or combine into something wrong.Metamorphic testA test that changes the input in a known way and checks that the output changes in the matching known way, without knowing either output.Model outageCalls to the model fail, time out or are refused for all workers, from an outage, throttling or an account usage limit.Modernization adapterA reference pattern that records what a legacy system actually does, rebuilds behind the same contract, and replays recorded traffic against the new code to compare outputs.MonorepoOne version-controlled repository holding many products and their shared libraries, built with one build graph.Non-determinismThe property of a step whose output can differ between runs on the same input, as a language model's can.Non-functional requirementA requirement about how well the product works (speed, reliability, security, observability, cost) rather than what it does.Observed evidenceA statement backed by an artifact on disk, cited by path and commit so anyone with the repository can open it and check.Partial artifactA station's output left incomplete by an interruption, or written without the record that says it is complete.Pattern registryThe place where every pattern version is recorded with its owner, what it applies to, its approved dependencies, its migrations and its deprecation date.Pattern versionThe identifier of one released state of a pattern, recorded in every manifest built from it, so any artifact traces back to the exact templates, validators and station graph that produced it.PatternA versioned, reusable reference solution: structure, interfaces, conventions, constraints and the station graph every product of its kind shares.Paved roadThe same idea as a golden path: the well-supported way to do a common job, easy enough that teams choose it.Persistent artifactA station's output stored outside the worker's memory, immutable and addressed by its hash, so a later process can find, check and reuse it.PII maskingReplacing personal data with a stand-in before a record leaves the place where the real value is needed.PilotThe first product built by the factory for real use, chosen because it fits a pattern, has a baseline to compare with, can be released reversibly and keeps every consequential decision with a person.Platform engineeringThe discipline of building and running the shared services every team uses (templates, builds, registries, configuration, a catalog) as a product for the organization's own engineers.Platform teamThe team that builds and runs the shared capabilities other teams use: templates, registry, catalog, the factory's runtime and the shared patterns.Policy as codeWriting an organizational rule as data or code that a program evaluates on every change, instead of as a paragraph someone must remember.PolyrepoA layout where each product, and often each shared library, has its own repository, connected by published versions and integration contracts.PR gateThe set of independent checks that must pass before a pull request may merge into the main branch.Premature abstractionMerging two things into one shared mechanism before you know they change for the same reasons, which often deletes the place a rule should live.Product specificationThe variable business requirements for one product: intent, actors, data, behavior, constraints, examples and a definition of done.Production unitOne finished item a factory can register, build, check and publish on its own, kept together with a fixed list of parts.Project generatorA tool that creates a new project's starting files from a template and a few answers.Prompt injectionText inside data the factory or an agent reads, a spec, a pull request, a document or a retrieved passage, that tries to change what the agent does.Property testA test that checks a rule about the output on many inputs, without computing the right answer itself.ProvenanceA record of which builder made an artifact, from which source and parameters, in which run, identified by the artifact's digest.Quality gateA condition checked independently of the producer that decides whether a station's output may move to the next station or ship.Queue timeThe time a unit spends waiting for a free worker, a reviewer or an approval, inside lead or cycle time.QueueAn ordered list of tasks ready to be claimed, each with a status such as pending, running, done or failed.QuotaA budget per tenant on a shared resource over a period, such as model usage per day, runner minutes per hour or runs in flight.Randomized testA test whose inputs come from a seeded random generator, so it reaches cases nobody wrote down and still runs the same way every time.Rate limitA cap on how many requests may arrive per unit of time, enforced by the provider or by the factory before requests leave.RecommendationThe underwriting agent's written proposal for a case, with reasons, cited rules, missing items and a stated confidence, always marked as needing a human decision.ReconciliationThe work of tracing every figure for the same thing to what it counts and where it comes from, and explaining each difference instead of picking one number.Reduced motionAn operating-system setting a reader turns on to ask for less non-essential motion; web pages detect it with the CSS media feature prefers-reduced-motion.Reference blueprintA written design of an entire software factory: its components, who owns each, the evidence each leaves, and how they connect.Reference patternA reusable, versioned solution for one recurring kind of enterprise product: fixed structure, declared variation points, the stations that build it, the gates that accept it, and its known risks.Regression caseA fixture that captures a defect once found, so the same defect cannot pass again unnoticed.ReplayRunning recorded inputs through a system again and getting the same outputs, byte for byte, so a failure can be reproduced and a fix proven.Repository templateA concrete starting repository (folders, build file, CI configuration, a catalog descriptor) that a new product is created from.ReproducibilityThe property that running the same procedure on the same inputs gives the same artifact, byte for byte, so a run can be trusted by someone who did not watch it.ResumeContinuing an interrupted run by reading what is finished, re-verifying each finished artifact, skipping it, and doing the rest.Reusable operationA procedure that takes a written request as data, produces the artifact by fixed steps, checks it and records what happened, so it can run again on the next request.Rework causeThe reason an artifact was sent back, recorded with the rework: which check failed, at which station, and which input or instruction let the defect in.Rework rateThe share of attempts, or of units, sent back to a station because its check failed; a report must say which.ReworkSending work back to the station that produced it, or to the author of its input, because a check found a defect, together with the evidence of what failed.Risk tierA label set at demand intake, from the harm a defect could cause, that decides how many gates and approvals a product needs.RollbackSwitching production back to the previous build that was known to work, usually automatically when a canary crosses its threshold.SandboxAn execution environment that limits which files a worker process can write, which hosts it can reach and which commands it can run.SBOMA software bill of materials: a machine-readable list of the components and dependencies inside an artifact.ScaffoldThe set of starting files a generator creates for a new unit or project from templates, before anyone changes them.Schema driftThe gradual divergence of real data from its intended shape, as fields move, appear, disappear or change type while consumers keep working.Schema evolutionChanging a data format over time while records and messages written in the older format remain readable.Schema validationChecking a request body against a declared description of its fields (types, required, ranges, allowed values, patterns) before any product code sees it.Scoped credentialA credential that grants only what one task needs, for one target, for a short time, instead of broad standing access.SeamA place in the pattern's code where product-specific behavior plugs in, with a fixed contract on both sides.Selective regressionRunning the tests that exercise the changed component in each affected product, plus the contract tests of every consumer of its output, instead of every test of every product.Self-reportA worker's own statement about its output, such as 'done', 'all tests pass' or 'verified', which costs nothing to produce and proves nothing.Semantic equivalenceTwo implementations are semantically equivalent when they give the same result for every input the specification allows, whatever their code looks like.Semantic stationA station whose work is interpreting variable business logic written for people and turning it into a new artifact, the only kind of station where this site recommends a model.Semantic versioningA convention (Semantic Versioning 2.0.0) in which MAJOR rises for an incompatible change, MINOR for a compatible addition and PATCH for a compatible fix; a released version is never modified.Service virtualizationA stand-in that runs as a separate service, answers over the network like the real one, and replays recorded or configured behavior, including latency and errors.Session limitA cap set by a provider or an account on how much one session, or every session on the account, may use in a period.Shared fixtureOne file of inputs and expected outputs that every implementation reads, so all languages are judged on exactly the same cases.Shared-state lockA mechanism that lets only one worker change a piece of shared state at a time: a file lock, a database lease, a merge queue on a branch.SLOA target for a service's behavior stated as a measurable level over a period, such as the share of requests answered without a server error over 30 days.Software catalogThe system of record for every product: its owner, the pattern and version it pins, and its relationships to other products.Software factoryA production system that turns a reusable pattern and an explicit product specification into independently tested, versioned artifacts through governed, repeatable stations.Software product lineA family of software products built from a shared, managed set of core assets in a prescribed way (SEI definition, read 2026-11-20).Source of truthThe one copy that decides when two copies of the same information disagree; every other copy is derived from it or checked against it.Spec compilerThe first station of every run: it validates the spec's structure and meaning against the pattern, and turns each unknown into a question with an owner instead of a guess.Spec validationChecking a specification with code before any station runs: required fields, types, identifiers, choices inside the pattern's allowed set, examples consistent with the declared parameters.Stale patternA template, validator or instruction file that units are still built against, or were built against, after the rules moved on.Stand-inA class that plays the model in this site's examples by returning canned outputs in a fixed order, with no model call, no network and no key.State traceAn ordered list of states recorded while an algorithm runs on one input, one state per interesting step; the renderer draws them one after another.Station contractThe written promise of one station: inputs, outputs, validator, owner, dependencies, failure handling, and the rule that separates a retry from rework.Station mapA table that matches each station to its real module, who or what does the work, the check that accepts its output, and a status of observed, partly observed or unknown.Station ownerThe named person or team accountable for a station: its contract, its validator, and the queue of work it refused.Step invariantA condition that must hold at every state of a trace, not only at the end; a state that breaks it cannot be one the algorithm really passed through.SubmissionThe broker's quote request turned into a JSON record with typed fields; 63 fields in the series scenario, about ten carried in the examples.Takt timeAvailable time divided by the number of units required; every station must finish an accepted unit faster than this for the line to keep up.Teaching reconstructionAn architecture, toy, simulator or station map this site builds to teach, labelled every time so it is never mistaken for a description of WatchAlgo.TemplateA concrete file with named placeholders that a program fills with values to produce a new file, the same way every time.Tenant boundaryThe enforced separation of one tenant's data, runs, artifacts and credentials from another's, so a mistake or compromise in one stays there.Test fixtureA fixed input kept with the code, so the same case runs the same way every time a test uses it.Test oracleThe source of truth a test compares against: known outputs, a slow implementation that is easy to trust, or a rule every right answer obeys.Test tierA group of checks that cost about the same and ask the same kind of question, run in order from cheap to expensive.ThroughputThe number of accepted units the line delivers per hour or per day; attempts and generated files do not count.Token budgetA limit on how much model usage one unit or one run may consume before the factory stops spending on it.TransformationThe step of a factory that turns the input into a candidate product; it can be swapped, so the definition of good must live outside it.UnderwriterThe person at the insurer who decides whether to offer cover and on what terms; on this site, a principal holding the underwriter role.Underwriting agentThe run-time agent inside the insurer's service that gathers evidence with read tools, applies the rules and writes a recommendation for an underwriter.Unit contractThe written statement of which files, fields and declared variants one production unit must have, and which check enforces each rule.Unit folderA directory that holds every file of one production unit, named by a strict id pattern so scripts can find units and ignore everything else.Unknowns registerThe list of discovery questions with no answer yet, each with an owning role and the station or release step it blocks.UtilizationThe share of a station's available worker time spent working: busy minutes divided by workers times elapsed minutes.Validation errorA refusal of a request that names each field that broke the contract and the rule it broke, so the caller can fix all of them in one pass.Value slotA small template placed after a code line and filled from the current state's variables while the highlighted line is near it.Variation pointA place the pattern declares where each request supplies its own value, with a rule for what values are accepted.WatchAlgoThe author's algorithm-learning product, whose content folder holds one folder per algorithm problem with a problem, a solution and a visualization file.WIP limitA rule that a new unit enters the line only when the number of units inside is below a cap.Work in progressThe number of units that have entered the line and are not finished: running, waiting between stations, or in rework.Work itemOne deliverable that the factory schedules, produces and accepts as a whole; it is the thing that moves through stations and gets retried or escalated.WorkcellA short-lived execution environment for one station attempt: one checkout, a credential scoped to one target and one run, sandboxed tools, resource limits and only the context that task needs.Workflow engineA service that runs a process whose steps and order the application defines, records each step, retries failures and waits for timers or people.Workflow transitionA permitted move of a case from one named state to the next, listed in the product spec and checked by code on every move.

Each term is explained in full on one page and used everywhere else. Statements about standards, open-source projects and products were read in their own documentation on 2026-11-20; the sources are listed on Sources. For the design decisions these terms support, see the Blueprint.