AGENTS | GDN

She builds her agents as bounded functions running on her own machines. Each one has a defined input surface and a defined output surface. Nothing more. A pattern agent reads CC0 files, transforms geometry, emits new pattern states. A fitting agent reads encrypted measurements inside a narrow execution surface, emits adjusted geometry, and discards the input. A compilation agent takes geometry and emits machine instructions.

Each agent sits in a specific layer.

Some agents operate entirely in the commons. They only touch open pattern data. Their outputs can move outward immediately.

Some agents operate entirely in the confidential layer. They only touch encrypted inputs and produce results that never enter the commons unless explicitly transformed.

The separation is structural. It’s defined by where the data lives and how it enters the function.

All of this runs on her hardware. Local compute boxes, open boards, storage she maintains. The models, weights, datasets, and prompts exist there. When an agent runs, it reads from those sources and writes back to them or to a defined output. There is no default path outward.

She then composes these agents into a workflow.

A pattern state enters.
A variation agent produces candidates.
A selection step filters them.
A compilation agent converts one into machine instructions.
A fabrication node receives those instructions and executes them.

Tokens move through this sequence as triggers. When a token arrives at a step, that step executes. When the step completes, the token is consumed or transformed. The agents do not decide timing. The flow of tokens defines when each function runs.

Inside a microfactory co-op, her agents connect to shared machine nodes.

A loom node exposes an input surface for weave instructions.
A cutter node exposes an input surface for path files.
Her agents send the correct instruction sets into those surfaces when the required tokens are present.

The machines execute and return outputs. The agents receive those outputs and continue the sequence.

Her agents remain distinct. They are not absorbed into a shared system. They are programs she brings into the space, connects to available nodes, and runs.

Identity sits on top of this, not inside it.

She signs selected outputs with specific keys. One key for one thread of work. Another key for another. The same agent outputs can be anchored under different keys depending on how she wants them to appear. The agents carry the process. The keys place certain results.

Because the agents and data stay with her, she can shift identities without moving anything else.

A new key starts signing outputs. The underlying agents keep running. The workflows remain intact.

Nothing needs to be transferred or rebuilt.

Her storefront reflects this structure.

It shows pattern states from the commons.
It shows garment references tied to specific outputs.
It exposes entry points where tokens can enter workflows.

When a buyer interacts, they route tokens and encrypted inputs into her system. The agents process those inputs. The output returns. The storefront is just the surface where this connection happens.

What she gains is a stable internal system that does not depend on external models, external data pools, or external execution surfaces.

Her agents operate within clearly defined domains.
Her data remains in place.
Her workflows evolve by rearranging functions and flows.

Everything stays aligned because each part only touches what it is meant to touch.

digitalax.xyz