The Operator Stack.

Solutions Factory rests on one claim: large language models are infrastructure. They are electricity. Once you treat them that way, the terms on which you buy, run and hold business software have to change. This is the argument for why, and for what we built in place of the alternatives.

Your data stays yours. Your agents run on a runtime you control. Your inference is a metered utility you can read line by line.

What SaaS got wrong

SaaS solved real problems. It took provisioning, updates and access off the customer's plate, and for fifteen years that was a fair trade. The trouble is not the delivery model. The trouble is the pricing model that funded it, which hardened into three habits that no longer serve the people paying.

The first is per-seat, per-month pricing. The bill follows your headcount, whatever value you get from the software. Hire a person and the bill goes up, whether or not that person ever opens the tool. For a growing team that is a tax on growth, paid to a vendor whose costs did not move when you hired.

The second is treating your data as the thing that keeps you. Your records live on the vendor's servers. Export is a feature you hope works on the day you need it. Deletion is a promise you cannot verify. Leaving is a migration project, and everyone involved knows it. The friction is the retention strategy.

The third arrived with the language models. The moment the models became useful, the incumbents gated them behind the most expensive plan and metered them per credit, with a line on the invoice you cannot itemize. The technology that should have lowered the cost of the work became the reason the plan went up.

None of this needs bad intent. It is the gravity of a business that has to grow per-seat revenue every quarter. An incumbent that switched to a flat fee and a local model would break its own cash flow, so it cannot. That is why the lane stays open longer than it should, and it is the lane we walked into.

What self-hosting alone got wrong

The open-source, self-hosted world answered the data-hostage problem, and answered it well. For anyone who cared about sovereignty, good options have existed for years: software that runs on your own machine with your records in your own database.

But self-hosting alone stopped at sovereignty. It handed you the data and the deployment and left the manual work exactly where it was. The self-hosted CRM still waits for a human to type into it. The self-hosted automation tool still needs an engineer to wire each step. A filing cabinet you host yourself is still a filing cabinet: private, yours and entirely manual.

So the map has a hole in it. Cloud SaaS has the agents and holds your data. Self-hosted open source has your data and no agents. The overlap, software that is self-hosted, driven by agents and running on inference you control, was close to empty when we started. It is filling now, and that overlap is the whole company.

What the Operator Stack adds

The Operator Stack is three layers, and you run all three.

At the base is APG, the Agents Proving Ground. It is the agent runtime, and it runs on your infrastructure. Agents are bound to a registry that is the single record of what exists. Their output is validated at every boundary, so a bad response fails loudly and never corrupts your data quietly. The runtime caps their spend before the bill arrives. Their health is observable. Anything that reaches out to the world stops for your confirmation first. APG is the discipline that turns “AI agent” into an operational fact that survives its second week.

In the middle are the products that run on APG. Solutions Factory CRM, where four agents keep the pipeline complete so no rep is typing into a form at 5pm on a Friday. Drengur, where eight agents carry a travel designer from a raw client email to a checked, client-ready itinerary, with the money handled in exact integer units and confidentiality intact. Both are self-hosted. Both keep your data local. Both run their agents on the APG appliance you control, under the same ceilings and gates.

At the top is inference, and this is where Solutions Factory does something the rest of self-hosting does not. We are building inference as a utility. The model is electricity, so we will sell it the way an electric company does. When our managed tier opens (it is coming soon), we will buy the capacity, meter what you draw and show our margin as a line on the bill, itemized the way a power bill is: the rate, our margin and your line total, each on its own line. If you would rather bring your own key, you bring it, and we charge for the software alone. If you would rather run a local model on your own GPU, you run it, and no inference bill reaches you from us or from a model provider. Three tiers, and one config line moves you between them.

That is the whole stack. A runtime you run, products that run on it, and inference you can read on an itemized bill. Nothing in it is rented out from under you, and your persistent data never passes through us.

The pattern is already here

This is a reading of where the market has already started to go. A widening shelf of self-hosted tools has displaced its SaaS incumbent by handing people the same software to run themselves.

Penpot took on design-tool lock-in. Cal.com did it for scheduling. Plausible did it for analytics, cookieless and light. Mattermost did it for team chat, Listmonk for mailing lists, Excalidraw for whiteboarding, Vaultwarden for password vaults, Coolify for deployment itself and Outline for the team wiki. Different categories, one pattern: the self-hosted version quietly wins the operators who were tired of renting.

What that shelf is missing is the agent layer. Every tool on it still waits for a human to do the work. The Operator Stack is the same pattern with agents added on top and inference treated as the utility it has become. The thesis is alive elsewhere. We are pointing it at the work itself.

The pledge

We will not charge you per seat. We will not hold your data as the reason you stay. We will not bury the cost of inference inside a plan you cannot itemize. We will buy the capacity, meter what you draw and show our margin as a line on the bill, and we will leave the door open for you to route around us and bring your own key or your own GPU.

Your data stays yours. Your costs decouple from your headcount. The software runs on your machines.

Where to start

Three products carry the thesis: APG, the runtime appliance; Solutions Factory CRM; and Drengur. Our delivery service is how we build for clients. It builds, deploys and operates agents straight into your own APG appliance when you would rather have it built than build it. You hold the deployment and we answer for the delivery. Inference comes three ways: on your own key, sovereign on your own GPU, or metered through us once that tier opens.