Most AI case studies come from software companies
Which is a problem, because a software company adopting AI proves very little to a plumber, a hauler, a landscaper or a fleet owner. They already had engineers. They already had clean data. They were never the hard case.
We are the hard case. Thirteen trucks, crews who clock in on their phones, a shop, a dispatch board and a real payroll. Everything below runs on Viktor, in production, in a business where being wrong costs a route, a customer or a paycheck.
Seven areas of the business
Dispatch
Next-day route plans built every morning against crew availability, time-off and clock-ins — then graded afterwards against what the dispatcher actually chose.
Fleet
A maintenance layer that reads fault codes, service history and oil analysis per vehicle and produces work orders instead of alerts.
Payroll
A nightly audit of the whole path from clock-in to paycheck — tips, overtime, missing punches, incomplete shifts.
Customer messaging
Outbound customer texts drafted, checked against a policy gate, and held for a human to send. Nothing reaches a customer unreviewed.
Cash & receipts
Receipt photos read from a Slack channel into structured cost data, and a 72-hour cash turn-in tracker that chases its own exceptions.
Crew performance
Revenue-per-hour and revenue-per-opportunity scoreboards, published to the team on a schedule, with strict rules about which numbers a crew is allowed to see.
Executive reporting
Daily revenue forecasting with accuracy tracked against actuals, monthly close-outs, and an owner dashboard.
The first agent was never the hard part
The whole industry markets the same promise: deploy your first AI agent in fifteen minutes. Fine. The first one was never the problem.
The problem is the fortieth — who runs them, who notices when one quietly breaks, who retires the one nobody needed, and who stops the whole estate from becoming a pile of scripts with no owner.
That's what an operator is for. You don't build an agent, you ask for one, and describing it is the deployment step. Then the work that proves itself gets pushed down the compute tiers — starting on frontier reasoning while the shape is still unknown, ending up on our own hardware once it isn't. Unit cost falls as usage rises instead of climbing with it.
We didn't pick a tool. We hired something.
We went looking for automation and kept hitting the same wall: every platform wanted us to know the answer first. Draw the flow, define the trigger, map the fields. That's fine if your problem holds still. Ours changes by the route.
Viktor was the first one where describing the problem in plain language was the whole build step. Not a prompt box bolted onto a workflow tool — an operator that reads our systems, writes the code, runs it on a schedule, and remembers why it did it that way the next time we ask.
Three things made it stick, and they're the same three we'd tell any operator to test for:
- 01It keeps context. It knows our territory, our trucks, who's allowed to see what, and which numbers come from which system. Every agent it stands up inherits that on day one instead of being told again.
- 02It's not stuck in a browser tab. Slack, our own hardware, a Windows workstation, the phone system — it goes where the work already is.
- 03What it learns becomes a file, not a subscription. Every capability is written down. That's why work can move off it onto our own machines later without a rebuild.
A sentence, not a sprint
Here is the actual mechanic, because "instant" is easy to say and worth nothing unspecified. We run more than one kind of agent, and the operator stands up all of them the same way — by being asked.
Hermes — the resident on our own hardware
A persistent agent living on our DGX Spark, no cloud bill per task and no presence in front of the crew. It takes long or repetitive jobs the operator hands down to it. Standing one up is a request in a chat window, not a deployment ticket.
NemoClaw — the one with hands
A local vision model that looks at a Windows screen and operates the software directly. Every operator has two or three systems with no usable API and no chance of getting one. This is how those still get automated — the agent uses the same screen a person would, driven by a model running in our building.
The handoff
This is the part we think gets underrated. A job usually starts on the operator with the best available reasoning, because we don't yet know what shape it is. Once the shape is known, the capability is written down as a file — and that file moves to Hermes, on our own GPU, for a fraction of the cost. Nothing is rebuilt. It's the same instructions, running somewhere cheaper.
So the pitch we keep hearing — your first agent in fifteen minutes — isn't the bar we're measuring against anymore. Ours sounds like "spin up an agent on the shop machine that does these three things", and the deploy is the sentence. The fifteen minutes was never the cost. Owning forty of them afterwards is.
An operator selling to operators
- →A working reference account in the hardest category. Not a pilot, not a demo tenant. The business runs on it daily.
- →Implementation, not resale. We install and operate it for other home services businesses — the segment that buys software late and keeps it forever.
- →A recorded content library. Two seasons of long-form conversations built from the actual build threads — not marketing written after the fact.
- →Hardware credibility. We run local inference on our own NVIDIA hardware alongside frontier models, so we can speak to cost architecture honestly rather than pretending everything belongs in the cloud.
What we won't claim
Instant to stand up is not instant to be right. A useful agent takes a few rounds of correction, and those rounds need somebody inside the business who can say what "right" looks like.
We also keep a human gate on the way out. Anything that reaches a customer, an employee or a bank account waits for a person. That's a deliberate design choice, and we'd rather say it here than have a prospect discover it and think it was hidden.
The seven things we have it run
Each one started as a problem in our own business before it became something we'd install for anyone else.