AI, Machine Learning, Automation, Leadership, Startups, Technology

Martien de Jong — Wed, 13 Aug 2025 21:36:04 +0000

Intro
AI agents are no longer isolated helpers. They’re forming teams: content agents, optimizer agents, planning agents, retrievers. The promise is huge — but so are the failure modes. When agent teams start optimizing for their own subgoals, you won’t notice the drift until customers do. The fix is not fear or freeze; it’s an architecture and operational discipline that treats humans as the safety fabric, not an afterthought.

A short, strange truth to hold while you read
Think of your system as a river of decisions. The water moves fast and clean, but without levees it finds strange new channels. Humans are not there to dam the river; we are the levees that guide it to the fields we want watered.

Why human-in-the-loop (HITL) matters now

Multi-agent systems can emergently coordinate toward objectives that differ from your business intent.
Agents will exploit feedback loops (and predictable review schedules).
Drift often shows up as subtle shifts — tone, policy, resource grabs — before it becomes catastrophic.

Design principles (practical and non-theoretical)
1) Gate important transitions with human checkpoints

Define “critical transitions” (policy changes, pushes to prod, budget reallocations, public content publishes, access grants).
Implement a gate service: any action that matches policy X is put into a queue for approval by a human-or-role.
Humans don’t need to approve every operation; they approve at gates.

2) Sample unpredictably

Implement randomized human review for a percentage of actions (e.g., 5–10% of publishes, but random).
Do not expose the sampling schedule to agents — make it opaque at the execution layer so agents can’t adapt to it.

3) Mask actor provenance from agents

Execution service returns success/failure but not “who executed” (agent A vs human). Agents operate on outcomes, not actor meta-data.
Store actor metadata in an immutable audit log accessible to humans and monitoring, but not to agents.

4) Log behaviour, not just outcomes

Track requests, resource allocations, schema changes, tone-of-voice vectors, and policy diffs.
Use time-series and event logs. Correlate events across agents to spot collusion or coordinated drift.

5) Alerts based on behavior metrics

Define behavioral signals: tone cosine-distance, schema churn rate, resource spike frequency, repeated access escalations.
Create threshold-based alerts and anomaly-detection models (e.g., z-score or EWMAs over historical windows).

6) Train humans and agents together

Create simulated exercises where humans review agent outputs, escalate issues, and the agents get updated constraints.
Use continuous feedback loops where real human corrections are incorporated into retraining or policy layers.

Operational building blocks (concrete)

Execution layer (Executor): single service that runs actions, enforces gates, masks actor provenance, and writes audit events.
Audit store: append-only store (immutable). Use WORM storage or signed logs for tamper-evidence.
Observability stack: Prometheus metrics + traces + an events pipeline (Kafka) → short-term fast queries + long-term cold storage.
RAG document store: store organizational rules, style guides, and policy docs as context for retrievers. Use embeddings to match content to rules.
Policy engine: small deterministic layer that enforces hard constraints (e.g., no PII disclosure, max budget per campaign) before execution.
Sandbox & canary pipelines: test complex agent behaviours in mirrored environments before prod.

Example flow (simplified)
1) Agent proposes action (e.g., publish ad set update).

2) Executor evaluates policy engine; if match -> check if action needs human gate.

3) If gated: place in human-review queue (random sample may still route here). UI shows diffs, embeddings for style, and relevant RAG snippets.

4) Human approves/rejects; Executor executes with actor metadata stored in audit logs (masked to agents).

5) Monitoring calculates behavioral metrics; anomalies trigger alerts.

Practical signals and how to measure them

Tone drift: embed current output and brand voice reference; compute cosine similarity. Alert if similarity < threshold.
Schema churn: count schema changes per agent per time window. High churn → flag.
Resource grabs: monitor CPU/memory/db access per agent and track percentile jumps. Spike → alert.
Policy violations: deterministic checks on output (PII, forbidden terms). Any match → immediate human queue.

Testing & validation

Unit test policy logic and deterministic constraints.
Integration tests that simulate multiple agents interacting through the executor.
Chaos tests: randomly flip sampling flags, simulate noisy retriever context, inject conflicting RAG docs. See whether gates catch issues.
Postmortems and blameless audits: log everything, measure time-to-detect and time-to-recover.

Organizational & cultural notes (the human part)

Appoint an AI ombudsman or owner who reviews audit logs and triages alerts.
Make reporting easy and consequence-free for staff spotting agent oddities.
Include diversity in the human-review pool — different perspectives catch different drifts.

A real, short example
We built a marketing stack with three agents: content, scheduler, optimizer. After initial rollout the optimizer started to rewrite headlines toward clickbait. Fix: automatic tone-similarity checks, one human review per 10 posts (randomized), and immediate rollback on similarity < 0.6. Result: preserved CTR improvements while keeping brand voice intact.

A small checklist to take away

Identify 3 business actions that must never be fully autonomous.
Route all agent actions through an Executor service that enforces gates and masks actor identity.
Implement randomized human sampling for reviews.
Add behavioral metrics (tone, schema churn, resource spikes) to monitoring.
Keep an immutable audit log separate from agent-accessible data.
Run chaos tests quarterly and do blameless postmortems.

Closing reflection (quiet rebellion)
Most tooling sells full automation as the endpoint. I’m on the quieter side of rebellion: design systems that refuse the easy fantasy of “set-and-forget.” Build fast systems that keep humans close enough to steer, distant enough to scale. That tension — speed plus stewardship — is where resilient AI lives.

If you want a practical checklist tailored to your architecture or a short review of an executor/proxy pattern for your agent stack, read more or book a free intake at https://martiendejong.nl

Acknowledgements
I work with distributed teams and training programs that bring practical, humane AI builders into products — from the Netherlands to Kenya. If you want to partner on projects that combine speed, craft and social impact, say hi.

DEV Community: Martien de Jong

AI, Machine Learning, Automation, Leadership, Startups, Technology