A small, design-forward studio casting AI-native tools for the Mac, the iPhone, and the open browser. We treat software the way master craftsmen treat metal — with patience, precision, and the conviction that the object should outlive the trend.
Most software today is liquid — endlessly poured, infinitely reshaped, optimized for the next quarter. We work the other way around. Every product leaves the foundry as a finished thing, with weight, with edges, with a particular grain.
Our tools are built one at a time, in small batches, by a team that fits in a single room. We choose our commissions carefully and refuse most of them.
Software has weight, even when invisible. Latency, error states, the defaults we choose, the way a button responds — these are tactile decisions, in the interface and underneath it. We never ship a tool that feels weightless.
A single hot key that does what three menus did is not less work — it is more. We spend the engineering hours upstream so that our users spend zero downstream. The same trade governs every layer: the schema, the prompt, the API surface, the type system.
We bet on rhythms longer than the launch calendar. Frameworks, schemas, type systems, motion language — chosen so that two years from now the work still reads as deliberate, not nostalgic.
We work across five practices — each with its own grain. Sometimes a single project moves through all five; usually it lives in one. We never staff up beyond what fits in one room.
Web applications end-to-end — frontend, backend, database, deploy. The kind that hold up after the launch post fades and the third user starts pushing edges the founder didn't think to cover.
Swift, SwiftUI, the platform conventions taken seriously. We build iOS pieces the way Apple's own teams do — keyboard-first, Dynamic Type ready, opinionated about what the OS is for.
APIs, queues, jobs, observability. We design backends to survive their own success — boring where it counts, instrumented from day one, and operable by a small team without a war room.
Multi-step tool use, evals, fallbacks, human checkpoints. We build agents the way a foreman runs a shop floor — explicit handoffs, audit trails, and the right cost ceiling. Most of the work is the scaffolding around the model.
Tokens, primitives, documentation, motion language. We design systems the way a foundry treats its casting molds — built once with care, so that the team shipping next year still reads them as sharp.
A short, written contract. We agree on the problem, the scope, and what is explicitly out of scope. Always shorter than you'd expect.
The first working artifact, rough but real. Always interactive, never a deck. We'd rather show you a clumsy v0 than a polished mockup.
Iteration in tight loops with a small group of real users. We track decisions, not features. Most of the value lives in this phase.
The piece ships with a versioned, signed manual. We're available for one round of post-launch refinement, then we stay out of the way.
If you have a piece of software that needs to exist — particular, built once and built right — we'd like to hear about it.