A supervisor agent, operated under human control.

The agent is an orchestrator that coordinates the work of measuring share of voice, analyzing why competitors are cited, drafting recommendations and preparing assets. It moves at machine speed through everything up to the point of publication, which is where it hands control to a person. Nothing it proposes reaches your audience without an explicit approval, and nothing it does is invisible: every action is logged with its cost and its provenance.

This is a deliberate design choice rather than a limitation we are apologizing for. An agent that could publish on its own would be faster in the narrow sense and far riskier in the way that matters, because the one irreversible action — putting something on the public web in your name — is exactly the action that should never happen without human judgement. SkuLift makes the safe path the default path, so speed and accountability stop being a trade-off.

It helps to be precise about what "supervised" buys you. The supervision is not a person watching a screen and hoping to catch a mistake in time; it is a gate built into the agent's own workflow, so the agent literally cannot complete a publication transition without an approval.

The difference is the difference between a smoke alarm and a fuse: one warns you after something has gone wrong, the other makes the wrong thing impossible. SkuLift's human gate is the fuse.

An agent that wanders is an agent you cannot trust. SkuLift's supervisor follows an explicit state machine, moving through planning, measuring, analyzing, recommending, a human gate, executing and re-measuring before returning to idle. Because the states and the transitions between them are defined, the agent's behaviour is predictable and auditable: at any moment you can see which state it is in, why it entered it, and what it is allowed to do there.

The supervisor coordinates specialised sub-agents but never lets them chain unsupervised, and it never spawns another orchestrator. Those constraints are structural guardrails, not guidelines: they bound the blast radius of any single decision and keep the system legible. A supervised agent that runs a finite, inspectable state machine is the opposite of an open-ended autonomous system that does whatever its prompt suggests — and for a brand-critical channel, that difference is the whole point.

The state machine also makes the agent's autonomy bounded in a way that is easy to reason about. In any given state, the set of actions the agent may take is fixed and small, and the transitions out of a state are defined rather than open-ended.

This means a technical or legal team auditing the system does not have to reason about an arbitrarily large action space; they can read the state diagram, understand every transition, and verify that no combination of states and inputs leads to an unintended outcome. Predictable state transitions are what make a complex system auditable.

Equally important is what the supervisor is forbidden from doing. It does not spawn another orchestrator, so the system can never recursively expand into an unbounded tree of agents acting on your brand without your knowledge.

It does not chain sub-agents without explicit orchestration, so the dependency graph stays simple and auditable. And it does not execute irreversible actions without a gate. The prohibitions are as constitutive of the architecture as the permissions.

The agent measures across engines, analyzes the cited sources, plans a ranked backlog, drafts answer-first recommendations, stops at the human gate, executes only what was approved, publishes through governed integrations, and re-measures to prove the lift. Mapping the loop to discrete actions is what makes the agent observable rather than a black box: each action is a logged event with an input, an output and a cost, and the human gate sits exactly between the reversible drafting work and the irreversible act of publishing.

Observability is what turns this mapping from a diagram into a control surface. Because each of the eight actions emits a logged event — with its inputs, its outputs, its cost and its timestamp — a supervisor can see exactly where a cycle stalled, why a recommendation was rejected, or what changed between two measurement runs.

Without that log, the loop is a black box: you see inputs and outputs but not the decisions in between. With it, the loop is a transparent system where every step is interrogable, and interrogability is what lets the platform improve over time rather than repeating the same cycle on autopilot.

The eight-step view is also how a non-technical stakeholder builds an accurate mental model of what the agent does. Rather than a vague claim that AI handles your visibility, they see a concrete pipeline: measure, analyze, plan, recommend, gate, execute, publish, re-measure. That clarity matters at the executive level, because the people accountable for a brand are rightly wary of automation they cannot picture, and a legible loop is far easier to sponsor than a black box.

Because the mapping is explicit, a reviewer never has to guess what the agent did or intends to do. The run reads as a timeline of named actions, each attributable and each bounded, which is what lets a person supervise an automated system effectively rather than simply hoping it behaved.

When the agent reaches the gate, it presents exactly what would be published, why it was recommended, and what metric it is expected to move. A reviewer can approve, reject or amend, and the agent acts only on the decision. There is no path around the gate: it is built into the state machine as a transition the agent cannot complete on its own, so even under deadline pressure the safe behaviour is the only available behaviour.

This matters most for the one action that cannot be undone cleanly. Measurement, analysis and drafting are all reversible — a bad draft is discarded at no cost — but a published change is live, in your name, and visible to engines immediately.

Making the gate structural rather than advisory means publication cannot happen by accident, by impatience, or because no one got around to setting up a review workflow. It happens when a named person says yes, and that named person's decision is logged.

A common worry is that a human gate slows everything down, and the design specifically answers it. Because the agent does all of the reversible work — measuring, analysing, planning, drafting — at machine speed, the human sees a complete, pre-evaluated recommendation package rather than a raw signal.

The time a reviewer spends is the time to read a well-formed proposal and approve or reject it. In practice this is measured in minutes rather than days, because the agent has already done the work of turning a gap into a concrete recommendation. The gate is not a bottleneck; it is the moment the human adds judgment rather than effort.

The gate is also where accountability lives. When a person approves a change, there is a named decision attached to every published asset, recorded in the audit trail alongside the recommendation that motivated it.

That accountability is what makes the platform safe to hand to a team rather than keeping it confined to a specialist. Anyone can approve a gate knowing that their decision is attributed, that it was pre-screened by an evaluator, and that the undo path is documented. The gate does not slow teams down; it gives them the confidence to move.

A recommendation only creates value once it is executed, so SkuLift turns each approved recommendation into a Lift: a discrete piece of work with a clear definition of done, produced in Studio and pushed live through the same governed pipeline the rest of the platform uses. Because each Lift carries its provenance — which recommendation, which approval, which cycle — a later re-measurement can attribute a change in share of voice back to the specific Lift that caused it.

That traceability closes the loop between doing the work and proving it worked. Rather than a pile of content of uncertain effect, you get a record of cause and effect: this Lift shipped, that metric moved.

The connection is not always tight — attribution in AI search is probabilistic rather than deterministic — but the regular re-measurement cadence makes it as tight as the signal permits. Over a long enough run, the evidence base becomes convincing even when individual Lifts are ambiguous.

Lifts are also how the agent learns responsibly. Because each Lift is tied to an approval and a measured outcome, the system accumulates a per-brand record of which kinds of work earned citations and which did not, and can use that record to rank future recommendations.

This is the memory component of the loop: the agent is not re-discovering what works from scratch each cycle; it is building on what has been tried and verified. The result is a programme that gets smarter about your specific brand and category over time, rather than applying generic best practice indefinitely.

Studio and Lifts together also keep the human firmly in the creative loop, not just the approval loop. A reviewer does not merely accept or reject a finished Lift; they can shape it, because the agent produces editable, brand-controlled drafts rather than opaque finished artefacts. That keeps the brand voice in human hands while the agent absorbs the mechanical effort, which is the right division of labour for work that carries a brand’s name.

Budget guardrails cap what any run can spend, in turns, in time and in euros, with a workspace-level daily ceiling so an unexpected loop can never surprise a budget.

The evaluator is an automated quality check — an LLM-as-judge paired with schema validation — that screens recommendations and outputs before a human ever sees them, so the human gate receives pre-filtered, on-spec work rather than raw drafts. Observability means every action the agent takes is a logged event with its input, output, cost and provenance.

Together these guardrails are what make supervised autonomy responsible rather than merely fast. The budget bounds the cost, the evaluator bounds the quality, the audit trail bounds the uncertainty, and the human gate bounds the risk of anything reaching the public web unreviewed. None of them is a bolt-on: each is part of the agent's architecture, which is why the system can be trusted to run continuously on a brand-critical channel instead of being supervised by hand at every step.

It is worth noting that none of these guardrails depends on the agent choosing to respect them. The budget ceiling is enforced by the platform, not requested of the agent. The human gate is a transition the agent cannot skip.

The evaluator runs before the human sees anything, not after. These are structural constraints rather than behavioural guidelines, and the distinction matters: a system that relies on an AI choosing to follow rules is not a governed system. A system that makes the rules unbypassable is.

Finally, the guardrails are what make the agent safe to scale across markets and workspaces. A single supervised run is easy to watch; dozens running in parallel are not, unless the safety is structural.

When every run is capped, every output is pre-screened and every publication requires a gate, the parallel runs do not multiply the risk — each is as safe as a single run because the guardrails are applied independently at the run level rather than requiring a human to watch all of them simultaneously.

In short, the guardrails are the reason the word supervised in supervised agent is load-bearing rather than decorative. They convert a capable but unaccountable automaton into a system a serious organisation can hand to a team.

Without them, supervised would mean watched sometimes. With them, it means governed always. The difference is not a feature; it is the architecture.

These guardrails do not throttle the agent, they are what make it usable around the clock. Because every limit is explicit, the agent can run day and night without constant babysitting: it stops itself when a budget is reached, queues anything that needs human judgement, and resumes the moment approval is given. Supervision is therefore not an occasional brake but the mechanism that licenses everyday autonomy, keeping an accountable person in the loop at exactly the points where a decision commits the brand.