Skip to main contentSkip to navigation
Doctrine · position paper

The shipyard must remember. An operating doctrine for AI-native shipbuilding.

The argument: a vessel is a coupled physical system whose consequences do not respect the boundaries of the departments that build it, and the build process is part of the technical system rather than an administrative wrapper around it. What follows is the architecture that claim implies, the seven ordinary events it has to survive, and the questions it must decline to answer. It is written to be disagreed with.

Every case runs against a synthetic concept vessel in Veldarium’s code, and nowhere else.

I A ship is not a document set

A ship is a coupled physical system. Mass is displaced water; power is heat; a bracket moved three centimeters is a cable route, an access panel and a maintenance procedure. That is why naval architecture exists, and it was true for a century before anyone drew a ship on a screen.

What changed is that the record of the ship fragmented. A modern program holds its vessel in a product-lifecycle system, a CAD environment, a planning tool, a materials system, a quality system and several thousand documents, each authoritative for something and silent about everything else. Each is correct. The ship is the thing that spans them, and nothing in that stack is responsible for the span.

So the span becomes a person, who holds in their head or a spreadsheet the relationship between a drawing revision and the work packages planned against it. That has built every ship ever built. It does not scale past the relationships one person can hold, and it does not survive that person leaving.

The claim of this paper is narrow: those relationships are data, they are currently not data, and almost everything people want from artificial intelligence in shipbuilding is downstream of making them data.

The order matters. A reasoning system over a fragmented record inherits the fragmentation silently, because a language model asked about a relationship nobody recorded does not return nothing.

II The failure mode is competence

The expensive errors in shipbuilding are rarely careless. They are individually correct decisions, taken by competent people, against different versions of the same vessel.

An electrical engineer sizes a generator against the load list they were given. A thermal engineer sizes a cooling branch against the heat load they were given. A planner sequences a block against the drawing revision they were given. A buyer orders against the bill of materials they were given. Each is right. The four inputs were snapshots taken at four different times, and the change that moved all four arrived between the second and the third.

Nobody did anything wrong, which is why it keeps happening. The defect is structural: nothing represented that the four decisions were about the same object and had to share one basis. A meeting is not the remedy; it resolves the relationships the people in the room think of, and the ones that cause trouble belong to a discipline nobody knew to invite.

III What AI-native cannot mean

Not a language model over the document stack. A model that reads documents can say what a document says. It cannot say that the document was superseded eleven days ago by a change whose scope nobody recorded, because that fact lives in the relationship between documents.

Not autonomy. The consequential decisions in shipbuilding are judgements of acceptable risk by people accountable for them: a configuration release, an inspection disposition, a safety release, a start of work. Automating the accountability away makes a wrong answer arrive faster, with nobody attached.

Not a digital twin, if the twin is a rendering. A three-dimensional model that cannot say which revision governs the object you point at, what evidence supports its state, or what would change if it moved is a visualization of geometry, the part that was already well represented.

Not optimization. A yard is rarely constrained by the quality of its plan. It is constrained by qualified capacity, material that has not arrived, a hold nobody has cleared and rework it did not predict. An optimizer over a plan that omits those produces a better plan for a yard that does not exist.

What is left is a claim about representation: the industrial system should be built so that its own consequences are computable, and so that the computation can say when it does not know.

IV The properties the system must have

Six properties. The marker on each is this company’s own maturity, not an aspiration: two building, three exploratory and one target.

  1. 01

    A machine-readable vessel

    Building

    Requirements, systems, zones, components, materials, suppliers, revisions, work packages, inspections and as-built state exist as connected objects, each able to answer what depends on it.

  2. 02

    Evidence-bound build state

    Building

    Which source controls, which revision applies, what conflicts and what remains unknown are fields on a record. The public proof demonstrates the narrower three-valued readiness and human-authority contract.

  3. 03

    AI-assisted engineering

    Exploratory

    Agents surface dependency impact, configuration conflict, change propagation and supplier constraint to the engineer deciding. They surface evidence; they never hold engineering authority.

  4. 04

    Production-aware design

    Exploratory

    Fabrication, inspection, rework, material problems and supplier performance reach the next engineering decision as records rather than recollection.

  5. 05

    Human + robotic execution

    Target

    People stay responsible for consequential decisions and craft. Inspection, scanning, measurement and material movement become increasingly machine-assisted.

  6. 06

    Lessons carried from hull to hull

    Exploratory

    Each decision is checked later against what happened, and a dependency the model missed comes back to an engineer as a question to review. That check runs today on synthetic decisions only. Whether it compounds across real programs has not been shown.

V Seven ordinary events, walked through

The same architecture as mechanism: ordinary events that happen in every yard, each walked along one fixed chain from the object it touches to what physically moves. The chain does not change between cases, because a module substitution and a failed weld inspection answering the same eight questions is the claim.

  1. 01

    A module is swapped for a higher-power variant

    Building

    An approved sensor module goes out of production and the vendor offers its successor. It fits the same footprint, it is a better instrument, and the substitution is approved on those two facts.

    Object
    The module, as an installed position on the vessel rather than a line on a purchase order: one addressable thing with a variant, an envelope and a set of declared interfaces.
    Governing revision
    The drawing revision that governs the position, and the configuration the vessel is approved to carry. The successor is a different variant, so the position is now described by a revision that does not govern it.
    Dependency
    The declared interfaces the position holds: electrical demand, thermal load, mounting, mass and center of gravity, network and software identity. Each is an edge to a domain owned by a different discipline.
    Evidence
    What exists: the vendor datasheet and the approval of the substitution. What does not exist yet: a generator margin result, a cooling result and a stability result computed against the new figure.
    Authority
    Electrical load stays with the electrical authority, thermal with thermal, stability with naval architecture, configuration release with configuration control. No reasoning layer resizes a generator or accepts a stability result.
    Computed consequence
    The change propagates along declared interfaces into energy, thermal and platform, and then out of the vessel’s engineering domains altogether into production sequence and maintenance burden. That is ten hops from a swap nobody thought was structural.
    Human decision
    Each named discipline dispositions its own domain. The configuration authority releases the new variant only once every one of them has answered.
    Physical action
    Cable is pulled to a different size, a cooling branch is re-cut, the block is re-weighed, and the maintenance plan the vessel carries for its service life is rewritten. Or the substitution is declined, and the original module is bought ahead.

    What the system must not concludeThe system may not report the position as approved because a substitution was approved. Until the dependent domains have answered, the configuration state is not established. That is not the same as rejected, and it resolves by computing the answers rather than by re-approving the swap.

    Where this is implemented, and what fails if it drifts
    Demonstrates
    A machine-readable vessel
    Implemented by
    apps/web/src/lib/shipbuilding/vessel-intelligence.ts
    Guarded by
    apps/web/src/lib/shipbuilding/__tests__/cascade-path.test.ts
  2. 02

    An engineering change lands on work already released

    Building

    A configuration change supersedes the drawing revision a work package was planned against. The crew is on shift. The package read READY an hour ago.

    Object
    The work package, and the objects the change model declares it reaches. Not every object in the zone, and not every object anyone is worried about.
    Governing revision
    The superseding revision becomes the governing one for the objects inside the change’s declared scope. Objects outside it keep the revision they had.
    Dependency
    The propagation model states which objects are known-affected, which are known-not-affected, and which cannot be assessed. All three are answers; only the first two are conclusions.
    Evidence
    Records captured against the superseded revision describe an object under a basis that no longer governs. They are retained with their capture date, authority and the reason they stopped governing. They are never deleted or rewritten.
    Authority
    Configuration control owns which revision governs. Quality owns whether an observation is accepted. The planner or supervisor owns whether work starts. None of those moves because a change was issued.
    Computed consequence
    The gates whose evidence lost its basis become CANNOT ESTABLISH, never open, because losing the ability to establish a claim is not learning the claim is false. The package itself, still released at the superseded revision, is NOT READY: its configuration gate is known open until it is re-released at the governing one.
    Human decision
    A named person re-baselines the affected records or sends someone to capture new ones, and re-releases the package. Objects the model marked not-affected are left alone.
    Physical action
    Either the crew keeps working on the part of the package the change never reached, or the work stops before steel is cut against a revision that no longer governs.

    What the system must not concludeThe system may not invalidate everything nearby to be safe. Conservative explosion stands crews down for guessed reasons and is its own failure mode; an unmodelled relation is not a licence to invalidate. It also may not report an unknown gate as open, because that sends a crew to fix something that may already be correct.

    Where this is implemented, and what fails if it drifts
    Demonstrates
    Evidence-bound build state
    Implemented by
    apps/web/src/lib/shipbuilding/change-propagation.ts
    Guarded by
    apps/web/src/lib/shipbuilding/__tests__/readiness.test.ts
  3. 03

    A qualified source stops being qualified

    Exploratory

    A source that has been shipping for months fails a surveillance audit, or lets a process certification lapse. Nothing on the shop floor looks different that morning.

    Object
    The source, as a record with a qualification state, and the requirements that record is the qualified answer for.
    Governing revision
    The qualification state that governs today, and the date the evidence behind it stopped being current.
    Dependency
    Every requirement whose only qualified source is this one. That set is the actual exposure, and it is usually smaller than the panic and larger than the purchase order.
    Evidence
    The audit finding, the certificate and its expiry, and the material already received under the qualification that held when it was received.
    Authority
    Supplier quality owns the qualification state. Procurement owns sourcing. Engineering owns whether an alternative is acceptable. A reasoning layer surfaces the constraint and the candidate responses; it approves no substitution and releases no material.
    Computed consequence
    Requirements covered only by this source lose their qualified coverage. Material already received keeps the qualification it was received under. Expiry reaches forward to new work, never backward into a record that was valid when it was captured.
    Human decision
    Supplier quality dispositions the finding. Procurement and engineering decide together whether to qualify an alternative, hold, or accept a deviation with its own named approver.
    Physical action
    Purchase orders stop, or a second source enters qualification, or the program accepts a longer lead time. The steel already in the yard does not change state because the audit failed.

    What the system must not concludeThe system may not treat a lapsed qualification as a defect in the material already delivered. Those are different claims about different objects at different times, and collapsing them scraps good material to protect a claim nobody made.

    Where this is implemented, and what fails if it drifts
    Demonstrates
    AI-assisted engineering
    Implemented by
    apps/web/src/lib/shipbuilding/supplier-qualification.ts
    Guarded by
    apps/web/src/lib/shipbuilding/__tests__/supplier-qualification.test.ts
  4. 04

    A dimensional inspection fails, and the fix invalidates the measurement

    Exploratory

    A scan comes back outside tolerance. A nonconformance is raised and the board dispositions it to rework.

    Object
    The physical subject that was measured, the finding raised against it, and the hold the finding places on acceptance.
    Governing revision
    The acceptance plan that governs, and the hold points inside it. Each hold point names the measurement classes that can close it. A dimensional read never closes a pressure test, however many dimensional reads exist.
    Dependency
    The work that cannot be accepted while the hold stands, and the downstream operations sequenced behind that acceptance.
    Evidence
    Every observation captured before the disposition. A decision to rework is a decision to change the physical thing, so those records describe an object that no longer exists.
    Authority
    Quality owns acceptance. The Material Review Board is the only authority that may take use-as-is, which is precisely why it is the only disposition that closes without new measurement. Scrap holds permanently.
    Computed consequence
    Clearing the hold requires an accepted observation of the subject captured AFTER the disposition timestamp. Any accepted observation would not do, because it would accept the thing that was just rejected.
    Human decision
    The inspector accepts or rejects the re-verification. The rework path does not lower the evidence bar; it raises the capture date.
    Physical action
    The part is reworked and re-measured, or repaired under a named disposition, or scrapped. Downstream work stays sequenced behind an acceptance that has not happened.

    What the system must not concludeThe system may not let the original measurement close the hold it triggered, and may not let a satisfied hold point stand in for an unsatisfied one. Acceptance is a property of the whole plan, not of the most recent good result.

    Where this is implemented, and what fails if it drifts
    Demonstrates
    Production-aware design
    Implemented by
    apps/web/src/lib/shipbuilding/nonconformance.ts
    Guarded by
    apps/web/src/lib/shipbuilding/__tests__/nonconformance-consequence.test.ts
  5. 05

    The instrument measures. The instrument does not accept

    Target

    A calibrated sensor returns a reading inside tolerance. Nothing is wrong, and nothing about the result is surprising.

    Object
    The measurement, and separately the instrument that produced it, each with its own identity, because a record about a part and a record about a head are different populations.
    Governing revision
    The calibration that was valid when the reading was captured, and the acceptance criteria in force for that subject at that time.
    Dependency
    Whether a second, independent read exists. Two reads off one head are two records and one observation: a single miscalibrated instrument agrees with itself perfectly.
    Evidence
    The reading, its method, its instrument, its operator, its time, and the requirement it is offered against. A reading with no claim attached is not evidence of anything in particular.
    Authority
    The instrument establishes a measured value. It does not establish acceptance. An authorized inspector does, and no model score substitutes for the measurement.
    Computed consequence
    The observation counts toward sufficiency only if it is accepted AND about the subject the plan governs. A rejected measurement is real evidence that does not satisfy an acceptance threshold.
    Human decision
    The inspector accepts or rejects. A second read off the same head adds a record and no confidence; only a read from an independent instrument does.
    Physical action
    The hold point closes and the next operation is released, or a second independent read is taken before anything moves.

    What the system must not concludeA sensor never self-accepts, and agreement is not independence. A monitor reading the work it watched, or two reads off one head, establishes a measured value and nothing more.

    Where this is implemented, and what fails if it drifts
    Demonstrates
    Human + robotic execution
    Implemented by
    apps/web/src/lib/shipbuilding/sensor-evidence.ts
    Guarded by
    apps/web/src/lib/shipbuilding/__tests__/sensor-evidence.test.ts
  6. 06

    The qualified cell is qualified for something else

    Building

    A requirement arrives specifying a different alloy. The welding class is qualified, staffed, and sitting idle.

    Object
    The capability class, and the process-and-material pair the arriving requirement actually needs.
    Governing revision
    The procedure qualification record, which is per process and per material. Class-level status is not the answer to a requirement-level question.
    Dependency
    Whether any qualified class covers this requirement at all. The question has three answers, because "not assessed" is not "not covered".
    Evidence
    The qualification records that exist, and the specific one that does not: a procedure qualified for the arriving alloy.
    Authority
    Welding engineering owns procedure qualification. Production owns the schedule. Neither can borrow the other’s answer.
    Computed consequence
    The class is unqualified for this work rather than busy with other work. Those are different shortages: admissibility outranks throughput, because capacity that may not lawfully do the work is not slow capacity, and adding a shift does not retire it.
    Human decision
    Welding engineering qualifies the procedure, or the requirement is re-sourced, or the material is changed. A planner cannot decide this by moving the schedule.
    Physical action
    A qualification coupon is welded and tested before any production weld is made, or the work goes somewhere that already holds the procedure.

    What the system must not concludeThe system may not read an unassessed requirement as a missing capability. Not knowing is checked first, because the most expensive mistake available is industrializing against capacity the program may already have.

    Where this is implemented, and what fails if it drifts
    Demonstrates
    A machine-readable vessel
    Implemented by
    apps/web/src/lib/shipbuilding/industrial-loop.ts
    Guarded by
    apps/web/src/lib/shipbuilding/__tests__/industrial-loop.test.ts
  7. 07

    The machine is released, and the capacity it adds is not established

    Exploratory

    A cell completes commissioning, passes its site acceptance test, and a named supervisor releases it into the plan. It is, finally, capacity.

    Object
    The asset, in a lifecycle state the schedule is allowed to plan against. Most of the eleven states do not qualify.
    Governing revision
    The release record, and the named person on it. Ordered, delivered, installed and commissioned are each a different state, and none of them is this one.
    Dependency
    The capability class the asset was proposed against, and the constraint that class was binding on.
    Evidence
    Acceptance test results, safety validation, operator authorizations, calibration. Enough to release the machine. Not enough to say what it adds.
    Authority
    Production releases the asset. Nobody has measured its contribution, and no authority can supply a number by deciding one.
    Computed consequence
    The asset counts as schedulable. How much executable capacity it adds is NOT ESTABLISHED. The throughput model carries scenarios that move a whole class’s inputs, and none of them is a measured contribution from one machine.
    Human decision
    The program either plans conservatively against the class and measures the delta over the next hulls, or it commits to a number it does not have.
    Physical action
    Work is scheduled through the cell. Whether the program’s throughput actually moved is a question the next hull answers, and only if someone instrumented this one to ask it.

    What the system must not concludeThe system may not print a capacity delta it did not compute. This is the case where the honest output is a boundary rather than a figure, and where the claim that industrial memory compounds across hulls stays an ambition. Nothing here demonstrates it.

    Where this is implemented, and what fails if it drifts
    Demonstrates
    Lessons carried from hull to hull
    Implemented by
    apps/web/src/lib/shipbuilding/capacity-intervention.ts
    Guarded by
    apps/web/src/lib/shipbuilding/__tests__/capacity-intervention.test.ts

VI What the architecture must refuse

Every case above carries a refusal, and the refusals are load-bearing: a system that always returns an answer cannot tell an answer it computed from one it invented.

Ordinary software collapses three states into two. A gate can be established, citing a record; known open, because a record says no; or cannot establish, because there is no record or the record lost the basis it was captured under. The last two have different remedies: one sends a crew to fix something, the other sends someone to find a record. A red light that cannot tell them apart sends the wrong person, with total confidence.

That is the answer to the objection about putting a model near this work. The question is not whether a model is sometimes wrong, but whether the system can represent "I do not have the evidence for this" and prevents the model from resolving that state with a confident sentence. Abstention has to be a first-class output, not a prompt instruction.

The second refusal is authority. A recommendation is not a decision, and software that absorbs a decision without absorbing its accountability has removed something the industrial system needed.

VII The industrial base is inside the boundary

Treat the yard as the system and its suppliers as the environment, and the software models the yard beautifully and is surprised four times a year.

The binding constraint is often not inside the shipyard: a forging capacity three tiers down, a single qualified source for a casting, a long-lead item ordered against a schedule that has since moved, a process qualification that covers the last hull’s alloy and not this one’s.

So capacity is not a count of machines. It is what survives qualification, availability, first-pass yield and staffing, and capital is judged by the constraint it retires rather than by its size. The last two cases carry both points as mechanism: a qualified cell that may not take the work, and a released machine whose contribution nobody has measured.

VIII What would show this is wrong

A position that cannot name its own falsifier is an opinion. Five findings would materially undermine this one, each with what would have to be measured to know.

The relationships are not representable. The claim assumes dependency, applicability and evidence can be captured as typed structure across the domains a vessel spans. If the relationships that matter are irreducibly tacit, the architecture captures the easy half and leaves the expensive half where it was. Measured by: on a real program, the share of release decisions whose governing relationships could be captured as records, and what the reviewers say the rest depended on.

Capture costs more than coordination saves. Declaring interfaces is work done early, by the people with the least slack. A yard that spends more on declaration than it recovers in avoided rework has bought a worse process with better documentation. Measured by: hours spent declaring and mapping against rework hours avoided on the same work, both against a baseline set first.

Abstention is operationally unusable. A system that often returns "cannot establish" may simply be ignored, at which point it has added a step and made things worse. Measured by: how often it abstains, and whether those abstentions were resolvable.

Authority stays with people only on paper. A release authority who approves every recommendation unread has handed the decision over in practice. Measured by: how often recommendations are held or returned for evidence, and whether those returns were right.

The compounding never appears. The most ambitious claim here is that evidence from one hull makes the next one cheaper. It is an ambition, labeled as one, and nothing Veldarium has built demonstrates it. What exists is the bookkeeping it would need: decisions checked against what happened afterwards, on synthetic records. Measured by: time and rework on several real hulls built under the same governed record, against hulls built without it. Nobody has designed that measurement yet.

Scope

What this paper does not establish.

Every case above is a mechanism Veldarium’s code implements against a synthetic concept vessel, VS-001, and nothing else. Veldarium operates no yard, holds no program, has qualified no source and has connected no model of any provider. The cases describe how the architecture behaves, not work anybody has done.

  • That any of it runs anywhere but against a synthetic vessel in Veldarium’s code.
  • That a model of any provider has been connected to it, or evaluated on it.
  • That industrial memory compounds across hulls. The last case exists to mark that ambition as unproven.
  • That a yard, supplier or program has adopted, reviewed or endorsed any of it.
ConceptPosition paper
Disagree with something specific

The useful reply is the one that names the case.

If a case above is wrong about how the work happens in a real yard, that is worth more than agreement with the thesis. Say which case, and how it really goes.