Open source oversight, one rule per action

Human in the loop vs on the loop: open source policy decides

The open-source AI Operating System

In the loop, a person decides before the action runs. On the loop, the system acts while a person watches and can stop it. Kortix is the open-source AI Operating System, and the choice between them is a rule in a policy you write.

Try Kortix Read the docs

Actions are always_run, require_approval, block, shown as Allow, Ask, Block.

kortix.yaml

policy:  default_mode: riskpolicies:  - match: gmail.send_email    action: require_approval

Source: https://kortix.com/docs/connect/connectors

Allow, Ask, Block · a rule per action and per argument · the policy is a file in your repo

Four actions, four different answers

The same agent gets a held refund, a reviewed deploy, a screened CRM write and a report that runs on its own.

Human in the loop

What the rule hands back

A refund waits for a person

One Ask rule holds the refund call, so the agent drafts it and the turn pauses until someone decides.

Approval card

Rule: Ask on the refund call
Amount: 480.00 USD
Requested by: a session
Status: pending_approval

Nothing ran while the call was held.

Human in the loop

What the rule hands back

A production deploy waits as a change request

The deploy is prepared on the session branch, and a person reads the diff before any of it reaches main.

change-request.diff

- replicas: 2+ replicas: 4+ image: api:2026-10-24

+2 -1

The branch carries the work; the merge is the person's call.

Human on the loop

What the rule hands back

A CRM write runs for your own domain and waits for anyone else

The same action carries two rules, and the condition reads the contact's email domain, so writes to your own domain run and every other one is held.

kortix.yaml

+ policies:+   - match: crm.update_contact+     action: always_run+     conditions:+       - arg: email+         match: "*@northwind.example"+   - match: crm.update_contact+     action: require_approval

+8 -0

The second rule catches every write the first one let through.

Human over the loop

What the rule hands back

A nightly report runs and someone reads the result

Reads run under default_mode: risk, the report is written at 06:00, and the person who set the goal checks the outcome in the morning.

nightly-run

Reads: run
Writes: none in this run
Report: 06:00
Held: 0

No call was held because nothing in the run writes.

What each model decides, and what enforces it

The model columns restate each published definition; the Kortix column is what a policy file enforces on a call.

Criteria

Kortix

Human in the loop

Human on the loop

Human over the loop

Who decides

KortixYour rule, per action.

Human in the loopA person, before it runs.

Human on the loopThe system, under supervision.

Human over the loopA person, at the outcome.

When the person acts

KortixWhen a rule says Ask.

Human in the loopBefore the action runs.

Human on the loopWhile it runs, and on exceptions.

Human over the loopAt the start and at review.

What the person sees

KortixThe call, its arguments, the approval summary.

Human in the loopThe proposed output.

Human on the loopThe running behavior and flagged exceptions.

Human over the loopThe finished result against the goal.

What it costs at volume

KortixOnly the calls a rule holds.

Human in the loopA decision per action.

Human on the loopAttention on exceptions.

Human over the loopA review per cycle.

How it fails

KortixA missing rule, since the default is allow_all.

Human in the loopReviewers approve a long run without reading.

Human on the loopCoverage depends on what is watched.

Human over the loopConstraints nobody wrote down.

What enforces it

Kortixkortix.yaml rules, then the connector's.

Human in the loopA decision gate in the workflow.

Human on the loopMonitoring, alerts, an override.

Human over the loopStated goals and limits.

Model cells restate each publisher's own definition, linked in the column heading; the human-over-the-loop column is this site's synthesis, since Torch.AI defines human out of the loop and the column follows the contrast that page draws with the third model.

A held call is a rule you can read, diff and change like the rest of the project.

Approval gates you set. Off until you set them.
Session work reaches main through a change request. Merge is default-deny for agents.

1 file

the policy sits in kortix.yaml, next to the agents it governs

The oversight rules are a file in your repo

Kortix on GitHub Read the docs

Answers to the questions the pair raises

What is the difference between human in the loop and human on the loop

In the loop, a person decides before the action runs. On the loop, the system acts while a person supervises and can stop, override or change its policy. The difference is who holds the decision at the moment of action.

Is human in the loop better than human on the loop

Neither is better on its own. In-the-loop suits actions that are hard to undo. On-the-loop suits high volume where someone can watch and step in. The choice belongs to each action, not to the agent.

What is human over the loop

A person sets the goal and the limits, then reviews the outcome rather than the steps. The system runs inside them. It sits further out than on-the-loop oversight, where someone still watches the running work.

What is human out of the loop

No person reviews or supervises the work, and the system's output stands. Torch.AI names it alongside the other two, as the case with no one watching. It fits actions you would let run unattended.

When should an AI agent ask for approval before it acts

When the action is hard to undo, reaches outside your organization, or spends above a threshold you set. Write the rule for that call, and let the rest of the agent keep running.

Decide it per action, in a file you own.

Start with the one action that should wait; leave the rest running.

Try Kortix How to choose