LOOM is an AI-native relationship and project intelligence system. It holds the companies, the people, the deals in motion and the quiet ones — and it reads back, in ninety seconds, what a founder would otherwise reconstruct from four applications and memory.
Every system of this kind fails the same way: it asks you to move your work into it. LOOM does the opposite. The files stay where they are. The notes stay where they are. The mail stays where it is. LOOM holds the pointers and the intelligence — what a thing is, who it involves, what moved, what is owed — and links out to the rest.
A project room shows the folder in place. LOOM never copies a document and never becomes a second place to look for one.
Deep links from the room to the vault. The writing lives in the tool built for writing; LOOM knows which pages belong to which project.
Mail, calendar, messages. LOOM records that an exchange took place and what it meant — not a second copy of the exchange.
The rule is enforced, not aspired to: if a feature would duplicate something Box, Obsidian or a mail client already does well, it is not built. It is linked.
A founder does not have a pipeline. They have several companies, each with projects, each with people who wear more than one hat, and a history of contact that explains why any of it exists.
Each one answers a single question. Installed as an app on desktop and phone. The test a project room has to pass: a partner who has never seen the deal understands it in ninety seconds.
The whole portfolio in one reading — every company, what has moved since you last looked, weighted pipeline, what is waiting on you. Filters by stage, and by whose work it is, so a growing book stays readable.
Status and the summarised timeline, stakeholders with their roles, the Box folder in place, the linked notes, the open loops. Past a couple of dozen entries the history sinks into a well and scrolls within itself, so the room stays a room.
One entity at a time: its context, the projects running beneath it, the people around it, its files and notes. The view a founder needs when the question is about the venture rather than the deal.
How you met, every role this person holds, the projects they touch, the history of contact, and their immediate neighbourhood in the network. Contacts import from a vCard rather than being typed twice.
The weave itself, in three dimensions: people, projects, organisations and companies as nodes, typed relationships as edges. Take hold of a node and the page tells you why it matters.
For the owner alone: data health, a visibility sweep, the audit log, system vitals, the partner directory — and view-as, which renders the app exactly as a given partner would see it. Permissions you can check are permissions you can trust.
Alongside them: a ⌘K command palette that reaches anything by name, full editing of every record, a guided tour for a first-time partner, and an installable progressive web app on both desktop and phone.
Nothing writes to a project table directly. Every channel drops a plain-text note into a single inbox; an AI filer — running under the owner's own session, with the owner's own guardrails — turns that note into interactions, loop movements, or an explicit "no development here".
A one-line command from any AI coding or writing session posts what just happened — a document sent, a scope change drafted, an answer awaited — and LOOM files it into the right project itself. No form, no picking a project from a list.
A great deal of real project traffic happens in messages. LOOM reads the desktop client's own local store on the owner's Mac — never the protocol, never a linked device, never a send. Chats are mapped to a project or a company one click at a time, with the assistant suggesting matches from names alone.
A project can name the folders where its work lands. Each hour LOOM notices what is new there — filenames, sizes, dates — and drops a note. It never opens a file, never copies one, and never looks in a folder nobody invited it into.
One authenticated endpoint takes free text and an optional project hint, so a phone shortcut, a script or a future mail pipeline all write through the same reviewed path rather than each inventing its own.
LOOM is conversational by design, not as a bolted-on chat box. Three routes in, all of them governed by the same permissions as the screens.
A system that holds candid notes about real people has exactly one hard requirement: the permission model must be impossible to talk your way past. In LOOM the rule lives in the data layer, so every route — the app, the assistant, the connector, a script — meets the same wall.
Nothing is visible without a grant. Access is per project and per level — read or edit — and enforced by row-level security on every table, not by a hidden button.
Sensitive records carry a visibility flag. A partner sees a summarised timeline of the work they are part of; the founder's private judgement of a negotiation is not in the same room.
Sign in with a passkey, a password, or an emailed link — the link deliberately kept as the recovery path. Every partner's session is their own.
The permission rules are tested from a real client as four different people — owner, a partner with read, a partner with edit, and a stranger — on every change. Dozens of assertions, run as a gate, because a policy nobody tests is a policy nobody has.
Who did what, and especially who was granted what. Permission changes are the events worth being able to reconstruct a year later.
The administrative key that can bypass every rule is a private build channel and is never in the application's path. What the app can do, it can only do as you.
Most of the decisions worth showing are the ones that closed a door. Each of these is enforced in the code, not stated as a value.
Everything below is specified and scoped — and deliberately unbuilt until the layer under it is proven. The shape of each is fixed; the date is not.
Incoming mail matched to the people and projects it concerns, summarised into the timeline, with the raw thread staying owner-only. A draft queue where each card carries the recipient, the project context, the conversation so far, the proposed reply and the reasoning behind it — edit, approve, and it sends in thread, sixty seconds later, logged automatically. The mail client is never opened.
The network becomes an instrument rather than a picture: the system proposes edges from what it has just read — she introduced you to him; add it? — and one tap confirms. A weekly strategic pass reads the whole portfolio for new leads, positioning and what is going quiet, and leaves a brief on the Command Deck.
LOOM was not commissioned, specified by a committee, or assembled from a template. It was conceived at Ateliersavant as the answer to a question the studio had about its own work — how a founder running several companies at once holds all of it in view — and then built, adversarially reviewed, and run in earnest.
The surface you are reading is part of the system, not a poster for it. The page is a warm bone vellum with a grain; nothing floats on it. Cards rise out of the material and press back into it under the finger, lit by a single raking light from the upper left. There are no borders anywhere, no glass, no gradients pretending to be depth — only light and shadow written as alpha, so the same surface holds in daylight and at night. Containers take an asymmetric radius, because a stamped corner reads as manufactured and this should read as made.
The figure turning at the top of this page is the system's instrument: several sources driving one circular plate, their ripples interfering into standing ridges. It is not a waveform display and not an ornament — it is how LOOM shows it is alive. The small marks beside each section are the same instrument with its clock stopped, each one caught at a different instant. When this interface needs a shape, it takes one from the instrument rather than inventing a second language.
Built on Supabase, Cloudflare and Claude, over Box, Obsidian and the mail and calendar a working studio already runs on. Written with Claude Code, under a plan whose locked decisions are held in the repository beside the code.