We Rent the Model. We Own the Logic.

People ask me what keeps me up at night. Lately it is the success of our AI employees.

At Vendasta our AI employees answer phones, book appointments and talk to customers for small businesses. Those businesses' livelihoods run through our systems. Every one of those employees runs on a model we do not own and cannot freeze.

That is what keeps me up. It is also the biggest opportunity we have. So I wrote my team a plan.

The ground moves

We chose to be model agnostic. We do not build or host our own models. That is a strength and an exposure.

Models change for many reasons. A provider retires one, changes its infrastructure or updates its guardrails. A model goes down and we fail over to a backup. A partner picks a different one. Each time, the prompt we tuned so carefully is standing on air.

It does not break loudly. There is no error and no red light. The receptionist asks for a phone number a beat too late, or books the wrong service, or misses the upsell. Multiply that across thousands of businesses and real customers get a worse experience. You find out from churn while the dashboard stays green.

And the ground moves even when nothing changes. A model is not deterministic. The same prompt on the same day can return different answers, because production serving batches your request with whoever else is on the wire. Drift is the weather. We are engineering for weather that never stops.

The comfortable story is wrong

We pressure-tested this before betting a roadmap on it. Three reassuring beliefs did not hold up.

"Less compute only makes it slower." Under load, the same prompt at temperature zero can return different answers depending on what else is batched with it.

"The model only changes when the version changes." Providers compress models, tweak hidden safety layers and re-route traffic, with no version bump.

"An upgrade is always better." Better on average is not better on your task. Researchers who tracked one major model through a few months of updates in 2023 watched its accuracy on a simple maths task collapse.

The major providers now retire models on roughly a yearly cycle. There is no button that safely re-tunes an old prompt for a new model.

The prompt is not the asset

We have thousands of prompts. We treated them like crown jewels. That instinct was backwards.

A prompt is scaffolding. It is calligraphy tuned to one model's quirks, a contract with one vendor. When the model changes the contract is void, even though not one word moved. The library we thought was an asset is a liability that grows every time the frontier moves.

Capture the logic

Under every prompt sits something that does not depend on the model at all. The business logic: what the employee is trying to do and what good looks like. I call it the Logic Layer. It has four parts.

1. Job to be done. The outcome in plain language. "When a visitor shows buying intent, capture a name and one way to reach them, create a contact and tell them a person will follow up."
2. Success criteria. What done well means, written as checks. "Asks for consent before saving a contact." "Never promises a specific callback time."
3. Examples. Real conversations paired with what the employee should have done.
4. Corrections. Every mistake, turned into a durable rule.

The model becomes the runtime. The logic is the source code. We compile the logic into whatever prompt the current model needs. The prompt becomes a build artifact: generated, never hand-edited, thrown away and regenerated for the next model.

Edit the logic, never the prompt.

Corrections compound

This is what people really mean when they ask for self-improving prompts. Every thumbs-down, every missed lead and every time a person steps in becomes a candidate correction. Someone reviews it, and it folds into the logic. The next compile includes it automatically, whichever model we compile for.

Now picture that across every vertical we serve. How a groomer handles a de-matting question. How a dentist handles an after-hours emergency. How a law firm handles a consult request. That operating knowledge compounds, and a competitor starting today does not have it.

The model resets to zero on every swap. The business logic never does.

Validate all the time

If the model is non-deterministic, testing only when the version changes is like checking the weather once a year. So we run two loops.

In line. The success criteria run as automated checks inside the employee's own process, on live output. Cheap, fast and always on.

Regression. On every compile (a model change, a failover or an accepted correction) we run the full set of golden tests with a locked-down model as judge. Only what passes ships. Every regression goes to a person.

Manual QA across thousands of prompts is impossible. Always-on validation catches a silent break in minutes instead of in a churn report months later.

Pinning a model is a tactic

For the highest-stakes flows we can buy dedicated capacity and pin a version. That is a good tactic. It does nothing to make the logic portable or self-improving. We are trying to get the hole dug correctly, whichever shovel is in our hand.

AI does the work. Humans orchestrate. Here that means people write the intent and approve the corrections. Machines compile the prompts, run the checks and grade the tests.

The model is a rental. The logic is ours, and it gets smarter every week.

We rent the model. We own the logic.