The thesis.

The process was built to ration judgment

A refund waits for a supervisor. A record correction waits for someone to pick up the ticket. An exception waits for the one person who knows that exception. None of these are difficult decisions. They sit in the process because when it was written, putting a person in front of the step was the only way to be sure the step was allowed.

That is how most large operations are built, and for a long time there was no alternative. Judgment was scarce and expensive, so the process rationed it.

Judgment is not scarce anymore, and it gets cheaper every quarter. A process built to ration it does not improve when it stops being scarce. The queues stay, the approvals stay, and a model ends up somewhere in the middle producing a faster draft for a person to sign off at the old speed. The draft is quicker. The wait is not.

Why the person is still in the path

Getting anything out of this means rebuilding the process rather than decorating it, and the process cannot be rebuilt while the company's judgment exists only in people's heads. The policy document is four years old. The rule that actually applies lives with a team lead who has never written it down. The precedent that settles the case was set in a thread nobody can find.

So the work splits in two. Make what the company knows findable, so it can be cited and checked. Then hand execution to something that consults that knowledge before it acts. Loom is the first part. Weaver is the second. The sandbox governs what it can touch. Loom governs whether it should.

Why it has to run on your ground

What gets encoded here is the company itself: its processes, its customers, the accumulated knowledge that separates it from a competitor with identical headcount. Send that to a model somebody else owns, on hardware nobody can inspect, in a jurisdiction a vendor picked, and you spend the next twenty years renting back what your company knows.

That is the visible cost. The one that matters more is what does not happen. A rented model is a service anyone can buy, so nothing done with it accumulates anywhere the company can reach. The vendor improves it on their own schedule, every competitor receives the same improvement on the same morning, and three years of an operation running through it leave a company roughly where one that started yesterday would be.

On its own ground those three years do something instead. The deployment produces a record of how the work is actually done, that record makes the next version of the system more specific to this company and no other, and what the company owns gets harder to copy each year rather than easier. In the first year the two options look similar. They do not stay similar.

Sovereign inference is the answer to that, and plenty of enterprises buy it on its own long before they build anything on top of it. We own the models, the serving and the deployment rather than reselling an API, so the whole stack runs disconnected, on the client's GPUs, behind their firewall, with every request logged locally.

The mill and the motor

Electricity did not make factories faster, at least not at first. It made them possible to lay out differently. A nineteenth century mill ran off a single engine, with belts and driveshafts carrying power across the floor. Every machine had to sit where the power could reach it, so the building was arranged around the engine rather than around the work. Once each machine could have its own motor, that constraint disappeared and the floor could finally be organised around what was being made.

Enterprises are arranged around the approval the way those mills were arranged around the driveshaft. Every process bends toward the point where a person can be inserted to confirm it. Take that out and work stops travelling to wherever judgment happens to be sitting, and the operation can be shaped around the work itself.

Where it stands today

Aural is the part of this that already runs. Voice and WhatsApp agents with human teams behind them, at contact centre volume, in production. It runs as a managed service by default, and when a customer needs it inside their own network it runs on the stack described above. Those on-prem deployments are where the stack already runs on a customer's hardware, in production.

Loom is in its first deployment. Weaver is being built against it.

We are self-funded, deliberately small, and building this in India, where a large share of the world's operations already runs and where the problem is at its largest and least forgiving. Infrastructure that holds up here holds up anywhere.

The infrastructure is the work.