Day 28: Human-in-the-Loop Architecture — Machine Second, Human First in Practice

Efficiency is the goal of automation, but in high-consequence settings, full autonomy is the wrong target. Actions that change production data, move money, reconfigure network hardware or contact customers should combine the machine's speed with verified human judgment. The principle is Human First, Machine Second.

In plain terms: A junior colleague can read, research and draft all day without asking. But before they wire money or delete a database, they get a sign-off from someone senior.

1. Define the decision boundary

Divide actions into two classes with automatic gates.

• Reversible, low-impact (fully autonomous): reading documentation, summarising logs, querying read-only metrics, drafting a remediation plan.
• Irreversible or high-impact (gated): dropping a table, changing a switch VLAN, deploying to production, approving spending.

Decide the class in code and policy, using an allow-list of action types. Do not ask the model whether its own action is risky, because a confused or manipulated model will answer wrongly.

2. Engineer the approval gate

A human-in-the-loop workflow needs an asynchronous pause and resume inside your orchestration.

1. Interrupt. When an action is high-impact, the agent stops, saves its state to durable storage and enters a WAITING_FOR_APPROVAL state.
2. Notify with context. An alert goes to Slack, Teams or a portal with the proposed command, the agent's reasoning and the expected outcome.
3. Authorise. The human approves or rejects, and the decision is authenticated and signed so it cannot be forged.
4. Resume or revise. On a verified approval the saved state is restored and the action runs. On a rejection the human's note is added to the agent's context so it drafts a safer alternative.

Here is the core logic in Python. It assumes a database helper db for saving state and a shared secret for signing approvals. In production you would use your identity provider and a proper signing scheme, and a framework such as LangGraph offers built-in interrupt and resume.

import hmac, hashlib, json

HIGH_IMPACT = {"drop_table", "change_vlan", "deploy_prod", "approve_spend"}   # policy, not model opinion
SECRET = b"load-from-a-secrets-manager"

def execute_or_pause(run_id: str, action: dict, state: dict):
    if action["type"] not in HIGH_IMPACT:
        return perform(action)                                   # reversible: just do it

    db.save(run_id, {"status": "WAITING_FOR_APPROVAL", "action": action, "state": state})
    notify_approvers(run_id, action, reasoning=state["reasoning"])   # command + why + expected outcome
    return "paused"

def sign(run_id: str, decision: str, approver: str) -> str:
    msg = f"{run_id}:{decision}:{approver}".encode()
    return hmac.new(SECRET, msg, hashlib.sha256).hexdigest()

def resume(run_id: str, decision: str, approver: str, signature: str, note: str = ""):
    if not hmac.compare_digest(signature, sign(run_id, decision, approver)):
        raise PermissionError("Invalid approval signature")      # never trust an unsigned decision
    saved = db.load(run_id)
    if decision == "approve":
        return perform(saved["action"])
    saved["state"]["human_feedback"] = note                      # rejection: teach the next attempt
    return replan(saved["state"])

Balancing autonomous reasoning with human oversight keeps the organisation safe while still capturing most of the productivity gain, because people only review the small share of actions that carry real risk.

Coming Up Next

Day 29: Managing technical debt, drift and model governance in enterprise IT.

#HumanInTheLoop #HITL #EnterpriseGovernance #TechLeadership #ProcessAutomation