Reliable Software, Adjustable Oversight
The 2% Problem
I used to invest in a lot of software for trucking logistics companies, and one thing that always struck me was the difficulty that these platforms had with automating actual logistics networks.
Here's what that looks like in practice. You have a load that needs to move from Kansas City to Omaha, Nebraska — it's a pretty well-worn route, it's not that far. A shipper wants to move a container from A to B, so they go to a freight forwarder who then, on the other side of the marketplace, reaches out to carriers — the truckers running that route — to see who has capacity. The freight forwarder's job should be pretty easy to automate: reach out to a bunch of truckers, see who is doing that route, and whether or not they can take the load.
And theoretically, it is easy. But in practice, it never gets fully automated because there is a 2–3% chance that something goes wrong — the truck breaks down, the driver is late, the dock isn't ready to support the truck because they're late, or a fee needs to be renegotiated. Any one of a dozen things. And because that 2–3% exists, you keep 20 humans in the middle of a process that is 98% deterministic.
Every software company that's tried to solve logistics has hit this wall. The easy part is easy, and the hard part isn't even that hard — it's just unpredictable enough that you can't write a rule for every edge case. So you staff it with people instead, and those people spend the vast majority of their day doing work that could have been handled automatically.
We call this the 2% problem, and it isn't unique to logistics.
Every Business Has These Flows
Almost every single organization, every single company, has processes that run daily — sometimes many times a day — that require a little bit of human judgment, but not that much. Things like triaging your inbox, routing a customer conversation to the right sales rep, moving a new ticket to the right customer service representative, reconciling an invoice against a purchase order, or following up with a lead after a demo.
There are dozens and dozens of these. None of them are complex, they're just repetitive. And because each one has its own small 2% — the edge case, the ambiguity, the thing that doesn't fit the template — they stay manual. Humans sit in the middle of these flows all day, every day.
Now, there is a world in which the average person goes to Claude every time and says "Hey, I want you to do xyz," but the reality is you don't need that. An AI model shouldn't be trying to interpret from a markdown file every single time how to do something again and again when you need a lot of determinism in the system. You want it to check your Gmail the same way every single time, once it's learned how to do it once — you don't want it to have to re-figure out how to use your Gmail integration each time it runs.
That brings us to a reliability component. Businesses need what they've always needed: reliable software. There is nothing new here — every business wants reliable software. Consistent execution, measurable error rates, clear reporting. The question is how you get that reliability while retaining the flexibility to handle the unexpected.
What a Workflow Is
For the customer, a workflow is essentially a repeated action that they do on a recurring basis that they don't want to manage themselves. That's it — it's really not that difficult.
Architecturally, a workflow is just code. It is a repeated action with well-scoped inputs and outputs, executed on a schedule or fired on a trigger. Sometimes the inputs are simple — a new email hits the inbox. Sometimes they require pulling in disparate sources of information, searching the web, whatever it takes, finding that information and then putting it into practice in a single output or multiple outputs or creating some sort of artifact. The input and output can be complex, but as long as there's a scope for it, it works.
What we've built is the ability for you to describe what you need in natural language to your Righthand and say "I want a workflow for this" — and they can create it, talk you through how it should work, confirm the logic, and then manage it from there. Under the hood, it's code. To you, it's a conversation.
If you say "I want you to do this from 2pm to 5pm every single day, every minute on the minute," then it should be able to reliably do that and report back to you: "I was able to do xyz. This is how often it worked perfectly. This is the error rate." That determinism is so important for a business that is going to rely on that process in the same way that they want some element of reliability from software.
The Righthand as Hypervisor
A workflow alone doesn't solve the 2% problem — it just automates the 98% and fails on the rest. What you need is a layered system, and this is where the Righthand becomes the hypervisor over the codebase.
What a workflow presents is the reliability of software with the adjustability of an overseer. What the Righthand provides on top of the workflow is essentially an escalation mechanism, and it works like this:
- The workflow handles the deterministic 98%. It runs on schedule, executes reliably, and reports on its own performance — the same way you'd expect any reliable piece of software to behave.
- The Righthand monitors every workflow it manages. When something breaks for any reason — when it falls outside the expected path or is just too complicated for the workflow to deal with automatically — the Righthand triages it and decides what to do. It can think, investigate, pull context, even pick up the phone.
- The human only gets pulled in when it truly requires human judgment — the edge case the Righthand can't resolve on its own.
Instead of a human creating a workflow and then that human's job becoming managing the workflow, we allow the human to work with a Righthand, and that Righthand then manages the workflow underneath. You essentially take away the entire role of that individual that was otherwise working there — not by replacing them, but by freeing them to do higher-order work.
Take customer service as an example. 95% of incoming questions are covered in the docs, and a workflow handles those automatically. When something isn't in the docs, it naturally escalates to the Righthand for higher-order thinking — the Righthand can reason about it, pull context, and resolve most of what remains. The fraction that still needs a human? That's what your customer service representatives should be spending their time on — high-touch, high-judgment work. If we can automate away the other 95% and slowly chip away at that 5%, all of a sudden we've unlocked real value in the business and, frankly, real time.
Back to the freight forwarder: the 98% of loads that go smoothly are pure workflow. When a truck breaks down, the Righthand gets notified and it can pick up the phone to the driver — "Hey, what's going on? What's the deal?" The driver responds, "Hey, I'm broken down," and the Righthand reports that back to the company so a new driver can be sent on the way or the correct fees can be paid out. All of it functionally is just code.
Self-Healing Software
Here's what changes everything. The prohibitive thing for all of these companies — and the prohibitive thing in logistics, for example — is that your freight forwarder with 20 people doing a couple tens of thousands of loads a year is not at a scale where they can afford to go build their own software. All of a sudden, a Righthand can build automation software for them that is effective at doing this, and they don't need to manage their own software stack. The Righthand becomes the manager of the software stack.
When the user corrects the Righthand — "Hey, you didn't quite handle that load correctly. Because it's XYZ account, you should have done this" — that correction goes immediately into the system and the workflow updates itself. The user's job is to provide judgment, and the Righthand's job is to turn that judgment into software. You almost have self-healing software, which is functionally what the workflow becomes — the system doesn't just execute, it learns and adapts and improves based on the feedback it receives.
The role of "workflow manager" disappears entirely, because the Righthand is the workflow manager.
What This Unlocks
The beauty of this system is that you no longer have to worry about these repetitive workflows and have humans in the loop for them. The freight forwarder's 20 employees don't get replaced — they handle the genuinely novel situations, and there aren't many. The novel negotiations, the relationship-critical accounts, the situations where a human voice and human judgment actually matter.
The customer service team stops answering the same ten questions and starts solving the problems that actually build loyalty. You can imagine a world in which everyone's job becomes training a Righthand to do their job, and then they are able to go and do higher-order work that is more than one-off tasks.
The future is filled with software that learns from us as we expect other humans to learn from us — and workflows are where that starts.