The Supervisor · the drift-control layer
Managed AI agents that don't get stuck
The dirty secret of autonomous agents is that they fail quietly — they loop, they stall on a hung tool call, or they declare victory without finishing. PAI's Supervisor watches every run from the outside: a definition of done, honest heartbeats, and an intervention ladder from a gentle nudge to a hard cancel — with a Monitor and kill switch in your pocket.
The real failure mode: agents that get stuck
Search “AI agents get stuck” and you'll find the same story everywhere: an agent that was supposed to do one job is now twenty minutes into a loop, or sitting idle on a tool call that never returned, or has reported “done” without actually finishing. The problem isn't the model — it's that most agent stacks don't watch the run itself. They trust the agent to report on its own progress, which is exactly the thing a stuck agent can't do. Reliable AI agents need a supervisor that is independent of the agent.
The Supervisor: independent oversight of every run
That's what the Supervisor is — the drift-control layer that sits outside the agent and watches each run end to end. It doesn't ask the agent how it's doing. It derives its own expectations up front, observes honest signals during the run, and checks the result against what was promised. This is the part of PAI that maps most directly to shipped, tested code, so it can speak plainly about what it does.
Run contracts: a definition of done, before the run starts
Before a Pie's run begins, the Supervisor derives a run contract: a short, checkable definition of done (drawn from the task's acceptance criteria when they exist), a timebox, and a heartbeat cadence. A run with no definition of done is a run that can't be judged finished — so every run gets one. The contract is the yardstick everything else measures against.
Honest heartbeats: no fake progress bars
During the run, the agent emits beacons on a wall clock: started, periodic waiting, then finished. Deliberately, these are not a fabricated progress percentage — a number that climbs to 90% and sticks is worse than nothing. An honest “still waiting, 4 minutes in” is what actually tells you a run has stalled. Beacon delivery is best-effort by design: a dropped beacon never fails the run, but a silence where a heartbeat should be is the signal the Supervisor watches for.
Stall and drift detection
From those signals the Supervisor maintains a live snapshot of every run and classifies it: running, stalled (the heartbeats stopped), diverged (it's wandering off the contract), finished, failed, or cancelled. After the run it computes an adherence report — which parts of the definition of done were actually met — and it can never silently drop an item: every part of the contract is accounted for as met or unmet. That's how you get an agent that can't quietly declare a half-done job complete.
The intervention ladder: nudge, then cancel
Detection without action is just a nicer dashboard. When a run stalls or drifts, the Supervisor escalates through an ordered ladder, harmless to destructive: a nudge (a resume prompt) → cancel the run → release the issue back to the queue → pause the agent. Crucially, the safety net is itself on a leash: an intervention you trigger from your phone runs immediately, but a destructive intervention the Supervisor wants to take automatically parks behind a default-deny approval first. The thing that cancels your agents can't overreach without your yes.
A Monitor and a kill switch in your pocket
All of this surfaces where you live: the Pocket Companion. You get a live Monitor of what's running and, when something feels off at 11pm, a one-tap kill switch that pauses every Pie on the instance instantly — with the stop recorded in the audit chain like everything else. Pair this with hard-stop budgets and the loops that cause runaway spend get caught two ways: the budget wall and the stall detector. The result is the thing raw agent runtimes can't give you on their own — not just agents that act, but managed AI agents you can trust to keep moving, and to stop when they shouldn't.
Keep reading
Supervision is the safety net. These are the rest of the controls.
AI CEO Autopilot
The delegation loop the Supervisor watches over — goal in, staffed workforce out, every step gated.
Hard-stop AI agent budgets
Stall detection plus a budget wall — runaway loops caught two ways before they cost you.
Run multiple businesses with one AI workforce
Supervised, isolated workforces across every company you run — one phone, one Monitor.
Managed AI agents — FAQ
Autonomous agents fail quietly. A task has no clear definition of done, so the agent loops; a tool call hangs, so the run waits forever; or the agent declares success without finishing. Raw agent frameworks rarely watch the run itself — so a stuck agent just sits there burning time and tokens until you happen to check. The fix is supervision: something independent that knows what 'done' looks like and steps in when a run drifts.
The Supervisor is the layer that watches every run from the outside. Before a run starts it derives a run contract — a short definition of done plus a timebox and a heartbeat cadence. During the run it tracks honest wall-clock beacons (started / waiting / finished, never a fake progress bar). After the run it scores adherence: did the work actually meet the definition of done? It classifies each run as running, stalled, diverged, finished, failed, or cancelled.
It intervenes, from gentlest to firmest: a nudge (a resume prompt), then cancel the run, then release the issue back to the queue, then pause the agent. An owner-initiated intervention from your phone executes immediately. An automatic destructive intervention the Supervisor wants to take parks behind a default-deny approval first — so the safety net itself can't overreach without your say-so.
Raw agent runtimes give you reach — channels, tools, browsers — but they trust the run to report on itself. PAI adds the run contract, the honest beacons, the adherence check, and the intervention ladder on top, all signed into a tamper-evident chain. You don't just run agents; you run agents you can watch, correct, and prove. That supervision layer is the strongest differentiator over a bare agent stack.
Yes. The Pocket Companion gives you a live Monitor of what's running and a one-tap kill switch that pauses every Pie on the instance instantly, with the stop recorded in the audit chain. The off switch is always closer than the incident — and it's in your pocket.
Run agents you can actually trust
See the Supervisor alongside every other capability — and the honest status of each — then choose your plan.