The lab / Stormforge
Stormforge.
The lab behind the work.
Local first, by design.
A multi-node GPU lab I build and operate myself. Everything Tinkerworks does runs here, on hardware I own, with no cloud model in the daily loop. This page describes how it is put together, by concept rather than by part number.
The stack, top to bottom
Seven layers, one direction of trust.
- L1
Intent
Issues, designs, and approvals. The work queue humans and agents share.
Every run starts from something a person asked for, and ends at a gate a person controls.
- L2
Contracts
Each task states its inputs, its expected outputs, and the limits of its authority.
An agent can only be judged against an expectation that was written down first.
- L3
Harness
The runtime around a model: the loop, the tools, the identity, the budget, the stop conditions.
The model reasons. The harness decides what that reasoning is allowed to touch.
- L4
Agents & skills
Roles such as Architect, Developer, and Validator, each loading packaged skills for the job in front of it.
Skills keep procedure out of prompts, so it can be versioned, reviewed, and reused.
- L5
Gateway
A single door to inference. Agents ask for a capability tier; the gateway picks the model and fails over.
Models change monthly. Agents shouldn’t have to.
- L6
Inference
Local models across a mix of GPU nodes, each placed where its size and speed fit the tier.
Running my own models exposes the constraints a hosted API hides: memory, latency, contention.
- L7
Platform
Kubernetes reconciled from Git, sealed secrets, a private certificate authority, and an overlay network.
The cluster’s desired state is a pull request, so infrastructure gets the same review as code.
Underneath every layer, Git is the memory: decision records, task contracts, and the run ledger all live in repositories, not in a model’s context window.
Design rules
How the lab is meant to behave.
Each rule came from something that broke, or almost did.
Local first.
Daily work runs on my own hardware. Cloud models are a deliberate exception, never the default path.
Route by capability.
Agents request a tier, such as agentic, coding, or fast. Which model answers is a gateway decision, so models can be swapped without touching an agent.
Git is the memory.
State, decisions, and contracts live in repositories. If it isn’t committed, the system doesn’t know it.
Controls are structural.
Identities, repository rules, and read-only validation credentials enforce boundaries. An instruction in a prompt is a request, not a control.
Gated and sequential.
Work moves one approved step at a time. A blocked task waits for a human rather than improvising around the gap.
Document just in time.
Decisions are written when they are made, from what was observed. No speculative documentation for systems that don’t exist yet.
Honest status
What works.
What’s still being built.
Running
- The governed pipeline, through independent validationAgents design, plan, and build; a separate validator checks the repository.
- GitOps deliveryThe cluster reconciles itself from Git.
- A single inference gatewayCapability tiers with failover between nodes.
- Encrypted offsite backupHigh-value data leaves the house, encrypted before it goes.
In progress
- Scoped identities for every roleThe Developer identity is implemented; the rest follow.
- A consolidated controllerAutomating post-merge handoffs between roles.
- ObservabilityDashboards for the pipeline and the fleet, as the first end-to-end feature built by the pipeline itself.
What runs on it