The machines define the real boundary of the system, so the details matter.

A microfactory like this is built from a small set of programmable fabrication nodes. A CNC cutter that reads vector paths and translates them into motion. A flatbed knitting machine that interprets stitch maps row by row. A multi-shaft loom that executes weave instructions with precise timing and tension. An embroidery rig that follows coordinate sequences. A dye station with controlled temperature, flow, and chemical ratios. Each one runs firmware that can be inspected, modified, and recompiled locally.

The important point is that these machines accept instruction sets as data, not opaque jobs from a remote service. A pattern becomes a cut path, a stitch map, a weave program. Those instructions are generated either on the designer’s workstation or inside a bounded compute node in the space. The machine executes exactly what it receives, then clears its working memory. It does not accumulate context across jobs.

Confidential computing sits right at the boundary where private input becomes machine instruction.

A designer receives measurements or a custom request. That data is encrypted in transit and only opened inside a narrow execution surface—either their local machine or a dedicated compute node inside the co-op. That node runs a specific program: take pattern state, apply measurements, output adjusted geometry. Once the output is produced, the input can be discarded. The resulting instruction set—cut file, knit map, weave plan—contains only what the machine needs. It carries no extra personal data.

This keeps the machine layer clean. The cutter never sees who the garment is for. The loom never sees a buyer profile. They only see geometry, sequences, and timing.

Open hardware matters because the designer can verify and enforce this boundary. They can inspect firmware to confirm that no additional logging or data extraction occurs. They can disable network interfaces on machines that don’t need them. They can route data physically through local connections rather than remote APIs. The hardware becomes predictable. It executes instructions and nothing else.

In more complex setups, the co-op might include local compute nodes dedicated to specific transformations. One node handles cloth simulation. Another compiles high-level pattern logic into low-level machine code. Another manages dye process optimization. These nodes can run inside secure environments where code paths are fixed and minimal. Designers send encrypted inputs, the node produces outputs, and no intermediate state is exposed outside that execution window.

For shared machines, the interface is always the same: a contract expects a token flow and a valid proof, then accepts an instruction set. The instruction set is a file or bundle of files. The machine executes it, returns a completion signal, and the contract updates state. The machine does not need to know anything about the designer beyond the fact that the inputs are valid.

Different machines expose different entry points. A loom might accept a weave program and a material token. A cutter might accept a path file and a fabrication token. A dye system might accept a batch identifier and a process profile. These entry points are precise. They define exactly what the machine expects and what it produces.

Because the hardware is open, designers can extend these entry points. They can add sensors, adjust calibration routines, or change how the machine interprets instructions. That becomes part of their practice. Two designers using the same base machine can produce very different results because they have tuned the hardware differently.

Confidential computing ensures that anything derived from private input is reduced to the minimum required for execution before it reaches the machine. Open hardware ensures that once it reaches the machine, nothing extra is extracted or retained.