Garnet

Cut the cable. It keeps working.

Garnet is a private AI system that runs under your own roof, on hardware we maintain. It can be taken fully off the network — not throttled, not sandboxed, disconnected — and it carries on answering, because nothing it does needed the outside.

An ethernet cable lying unplugged on a desk beside an empty port on a matte black equipment panel.
Airgapped is a supported configuration here, not a marketing word. One switch, and the model loses its route out.

Generated geometry · scroll to walk it

Make it, keep it, and know where it stops.

Three rooms, one continuous pass. Every object in them was produced as a mesh by this system — loaded as geometry, lit with the rig the photographs use, and moved through by scrolling.

Three rooms, one pass

01 — where a thing is made

The Forge

Generation is the loud part and the least interesting. The furnace runs on your own machine, the anvil is where the output gets hit until it is the shape you asked for, and neither step leaves the building. What you are looking at was made by the machine this page describes — these are its meshes, not a stock scene.

02 — where it is kept

The Library

Everything the system has read stays where you put it. Documents are ingested, chunked and embedded on the machine, and an answer arrives with the page it came from attached. The shelf is the honest metaphor: retrieval is not memory, it is knowing exactly where you filed something.

03 — where it stops

The Vault

The door is the product. Every outward or irreversible action queues for a human, the gate grants nothing by default, and the audit trail is written whether or not anyone reads it. A system that can act on your behalf is only worth having if you can show exactly where it cannot.

The airgap

One switch, and the work has no route out

A heavy industrial toggle switch on a metal panel, thrown to the off position.

Most “private” AI means a different company's server with a better contract. This is the other kind: the network can be cut at the machine, and the system is built to notice and carry on.

It is enforced, not promised

Airgap mode is a firewall rule dropping outbound traffic at the machine itself — not a preference inside an application that the next thing you install could ignore. While we are still maintaining the machine it keeps one deliberate exception, the management path we reach it on; that path is removed at handover, and on a delivered build there is nothing left to except.

The software knows

The Application reads the airgap state and shows it for as long as it is on. Anything that would have needed the outside says so plainly, rather than hanging or failing in a way you have to interpret.

The work is unaffected

Chat, documents, search across your own material, generation and code all run on the machine. Cutting the network does not degrade them, because none of them was reaching out to begin with.

And what stops

A wall-mounted patch panel photographed square on, most ports empty.

Web search, fetching a page, and pulling new models or updates. Those need the outside by definition. You turn the airgap off to do them, deliberately, and turn it back on.

The Application

One program, not a stack you assemble

Garnet is a desktop application that opens on the machine. Everything below is a surface inside it, sharing the same models, the same documents and the same approvals.

Garnet's work surface: tabs for Decisions, Autonomy Gate and Collaboration above a prompt reading ask the box to build, with one decision waiting.
The Application, on the machine it runs on.

Talk to it

Chat, with your own models

A full chat workspace against models running on your machine — switch between them, compare them, keep the thread. Nothing is metered, and nothing is sent anywhere to be answered.

Make things

A production studio, not a toy

Images, video, 3D and audio, generated locally: stills, motion and image-to-video, mesh generation, music and speech. The same card that answers your questions renders the work.

Write code

It can build

A coding surface with an agent that reads the repository, proposes changes and runs them past you. It works on the code already on the machine, not on a copy someone else is holding.

Know things

Your material, indexed

Documents ingested, chunked, embedded and searchable with their sources shown. Contracts, case files, correspondence, drawings — the things that were never going to be pasted into a public chat box.

Run the work

Agents that ask permission

Standing agents handle recurring work and queue anything outward for a person. Decisions require a cryptographically verified operator identity, and the request is frozen by a digest checked at the moment you decide — a ticket altered after you were shown it cannot be approved.

Watch it

Nothing is hidden from you

Model manager, engine monitor, benchmarks and system health are part of the application. You can see which models are loaded, what they cost in memory, and what the machine is doing now.

The Garnet autonomy gate, disarmed: switches for Publish, Deploy, Spend and Outreach all off, with the master switch off beneath them.

Control

It asks before it acts

Agents can do a great deal on their own. What they cannot do is anything outward or irreversible without a person saying yes: publishing, deploying, spending, or sending mail. Four switches, and they start off.

Decisions queue where you will see them, require a cryptographically verified operator identity, and are written to an audit trail. This is the screen as it ships, not a concept.

The machine

Delivered, installed, yours

A single workstation-class machine with a high-end GPU, specified to the work you actually do and built before it ships. It arrives, it is installed where you want it, and it stays. No tenancy, no region to choose, no per-token bill.

We don't publish part lists — ours or yours. The specification is part of the conversation about what you need it to handle.

A matte black workstation tower standing on a concrete floor in the corner of a warm office.

In build · Garnet Law

The same machine, for a law firm.

A separate application sharing the same hardware: matters, privileged documents, discovery and correspondence, with citations shown and privilege enforced. Offline by architecture — the shell ships with no network plugins and no updater.

It is not finished and we are not selling it yet. There are no deployments and no customers, and the screens we can show you use synthetic matters.

Before you ask

What we don't do

Published here rather than left for a call.

We don't sell a download

There is no public build to install this afternoon. A Garnet is specified, built and handed over, which takes time and is the reason it fits.

Airgapped costs you things

With the network cut there is no web search, no fetching a page and no pulling new models. That is the trade, and we would rather you knew it before buying than discovered it after.

We don't pretend it's finished

Parts of the system are in daily use and parts are still being built. We will tell you which is which for the things you care about, before money changes hands.

We don't publish our internals

You won't find our infrastructure on this website. If you need that depth for due diligence, ask, and we will take you through it properly.