The automation report looked clean for about six weeks.
Completion rate steady. Task throughput climbing. Queue times shrinking.
Then I noticed a line item that wasn't in the original spec.
Supervisor hours.
Not a lot at first. Four hours a week. Then seven. Then eleven.
Nothing's failing. The robots were completing work. But somewhere between task assignment and verified completion, humans kept showing up to make sure.
Nobody filed that as an incident.
The dashboard never captured it.
That was when I started thinking differently about what autonomous actually means in production.
The promise and the default are different things.
Every deployment I've read about starts the same way.
Autonomous agents. Self-managing fleets. Minimal human intervention.
Six months later the org chart has a new row.
Not because the robots failed. Because "done" was never defined precisely enough to trust without someone checking.
First a reviewer.
Then a shift lead for the reviewer.
Then a reconciliation process that runs every morning before the queue opens.
The system's still technically autonomous.
It just takes three humans to keep it that way.
I started calling this supervised autonomy.
I'm probably not the first to notice it. But I haven't seen anyone name it cleanly.
Not a failure mode. A default mode that nobody names because naming it would mean admitting the original spec was incomplete.
The cost shows up in three places.
The watching layer appears first.
Humans hired not to do the work but to confirm the work was done correctly.
This layer grows quietly. One FTE becomes two. Two becomes a team.
The team develops its own tools, escalation paths, and institutional memory about which robot behaviors need watching most.
None of it appears on the autonomy dashboard.
The override log appears second.
Every supervised system accumulates manual interventions. Small corrections. Edge case handling. Judgment calls the protocol couldn't make cleanly.
Most deployments don't surface this log publicly.
It lives in a spreadsheet. Or a Slack thread. Or a tribal knowledge base that only three people understand.
When those three people leave, the override logic leaves with them.
None of it captured onchain. That's the gap $ROBO is supposed to close.
The coverage gap appears third.
This is the distance between what the system claims to complete autonomously and what actually closes without human input.
In healthy systems the gap is small and shrinking.
In most deployments I've seen it's stable at best.
Stable means the watching layer is load bearing.
Stable means supervised autonomy has become the product.
This is where onchain identity changes the surface.
Not by removing supervision. By making it visible.
If the robot's execution record lives onchain and the human override record doesn't, the ledger's telling a partial story.
Clean completions on one side.
Invisible interventions on the other.
That's not a transparent system. That's selective accounting.
Fabric's identity layer is interesting here specifically because it creates infrastructure for both records to exist in the same place.
The robot's work history.
The dispute trail.
The verification path.
If override events and supervision hours eventually land onchain too, the coverage gap becomes measurable instead of invisible.
That doesn't make autonomy easier.
It makes the distance between the promise and the reality impossible to paper over.
$ROBO only earns relevance here if the ledger captures what actually happened.
Not just what the robot reported.
Not just what completed without challenge.
What closed.
What needed help.
What required a human to make true.
That's the test I'd run on any deployment claiming autonomous economics.
Pull the completion rate.
Then pull the supervisor hours for the same period.
Watch the ratio over six months.
In a system where autonomy's real, supervision shrinks as the network learns.
In a system where supervised autonomy is the default, that ratio stays flat.
Or grows.
There are two pilots in every commercial cockpit.
Not because autopilot doesn't work.
Because the consequences of being wrong are expensive enough that nobody removed the human watching it.
The robot economy's about to make the same bargain.
The question is whether it admits that upfront and builds infrastructure for it, or calls supervised autonomy something else and hopes nobody checks the org chart.
Fabric's one of the few systems I've seen that seems to be building for the honest version.
Whether the ledger eventually captures the full picture — supervision included — is the detail that separates infrastructure from marketing.