Manifesto
The Operator Stack.
Software you own, on infrastructure you control, with language models treated as electricity. Here is what SaaS got wrong, what self-hosting alone got wrong, and the three-layer stack we built instead.
Solutions Factory is built on a single claim: large language models are infrastructure, not a product feature. They are electricity. Once you treat them that way, the terms on which you buy, run, and own business software have to change. This is the argument for why, and for what we built in place of the alternatives.
Self-hosted business infrastructure, with language models treated as electricity. Your data stays yours. Your agents run on a runtime you control. Your inference is a metered utility you can read line by line. The software you buy from Solutions Factory is software you actually own.
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 is indexed to your headcount rather than to the value the software delivers. 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 independently verify. Leaving is a migration project, and everyone involved knows it. The friction is not an accident. It 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 requires 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 detonate its own cash flow, so it cannot. That is why the lane stays open far longer than it feels like it should, and that 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. Twenty, EspoCRM, n8n, and a long shelf of others give you software that runs on your own machine with your records in your own database. For anyone who cared about sovereignty, good options have existed for years.
But self-hosting alone stopped at sovereignty. It handed you the data and the deployment and then left the manual work precisely 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 — self-hosted, agent-driven, with inference you control — had no occupant. That overlap is the whole company.
What the Operator Stack adds
The Operator Stack is three layers, and you own 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 instead of corrupting your data quietly. Their spend is capped by the runtime before the bill arrives, not audited after. Their health is observable. And anything that reaches out to the world stops for your confirmation first. APG is the discipline that makes "AI agent" an operational fact rather than a demo that breaks in 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. Solutions Factory DMC, where eight agents carry a destination-management company from a raw inquiry to an audited brief, 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 run inference as a utility. The model is electricity, so we sell it the way an electric company does. Solutions Factory buys Anthropic capacity wholesale and meters it to your appliance at a transparent retail rate, itemized the way a power bill is: the wholesale 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 you pay nobody for inference. Three tiers, and one config line moves you between them.
That is the entire 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 nothing in it phones home.
The pattern is already here
This is not a bet against the market. It 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 own instead of rent.
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, ownable 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 displacement 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 show you the wholesale rate next to our margin, and we will leave the door open for you to route around us entirely and bring your own key or your own GPU.
Your data stays yours. Your costs decouple from your headcount. Your software is software you own.
Where to start
Four products carry the thesis: APG, the runtime appliance; Solutions Factory CRM; Solutions Factory DMC; and SF Foundry, which builds, deploys and operates agents straight into your own APG appliance when you would rather have it built than build it. You own the deployment; we own the delivery. And inference comes three ways: metered through us, on your own key, or sovereign on your own GPU. Own the stack. Read the bill. Keep the data.