How I work

Before an agent takes on a task, I set out what it may do, when it has to stop and how I’ll check the result. This page shows the rules, the roles and four decisions that did not go smoothly.

Guardrails

  1. TaskThe goal, the files it may touch and the command I check the result with.
  2. BrokerPicks model and tool by cost, quota and earlier failures.
  3. AgentWorks in a sandbox with no keys and no root.
  4. HooksStop dangerous commands before they run.
  5. ReviewTwo models from two vendors. A BLOCK holds the change.
  6. mainOnly now is it merged. Publishing needs my own go-ahead.
How a change gets from a task to main in my own agent platform.
Rules that take effect

A hook stops dangerous commands.

For that I use my own safety hooks and a policy gate. A reminder in the prompt isn’t enough.

I give the go-ahead

Publishing, deletions and messages to other people need my approval.

Agents can prepare changes and merge them into main through the review gate.

Only the access needed

Sandboxes get no keys, no root access and no Docker socket.

Workers can’t take extra privileges for themselves. If a sandbox needs something, I add specific packages or allow it to read certain files. Secrets must not end up in a repository or in the output.

Reviews before main

Two models review a commit before it reaches main.

The two models come from different vendors. If they disagree, another model takes a look. A BLOCK keeps the change out until the finding is resolved.

Traceable work

I log what runs and record decisions with a date.

For each decision, I write down what led to it. If an error keeps coming back, I turn it into a rule with a command to check it. A handoff records where the work stands for the next session.

Capped costs

Paid calls have limits enforced by the broker.

Routing uses subscriptions first. The broker checks how much quota is left and caps paid calls per day and per billing window.

Limit: the review environments still run without an OS-level sandbox. I still have to take care of that.

As of November 2026

Agents Do, Humans Decide.

Roles

Routing
Before an agent starts, a broker picks a model and a tool. It looks at cost, remaining quota and earlier failures. Subscriptions come first. If an account has no quota left, it drops out of the selection.
Decisions
Agents make routine decisions themselves. For decisions with wider consequences, a council of models weighs the options and writes the reasoning down.
Handoffs
Claude, Codex, Pi and Antigravity write to each other through an MCP mailbox. When another tool takes over or a new session starts, the handoff document holds the context.
$ review-gate --help
usage: review-gate [-h] [--repo REPO] [--sha SHA] [--default DEFAULT] …

Review an explicit commit and merge it into the default branch when approved.
The review gate takes one specific commit and merges it only when it is approved.

Decisions and what they cost

Four cases from my own agent platform. Each one names what I decided, what I rejected and what it cost.

01Hints were ignored, so routing became a hook
Situation
My main subscription was nearly used up while three other accounts sat almost idle. The router had given fitting hints. The agents ignored them nearly every time.
Decision
A hook refuses certain actions in the main thread and names the agent that should take them. Before the rule went live, I replayed it against the real history.
Rejected
Louder hints in the prompt. And the first, broader version of the rule: in the replay it would have blocked two thirds of the real calls.
Cost
A gate with false alarms slows work down. I switched it off for a while, and usage rose sharply within a day. Today it only switches on when the weekly quota gets tight.
02All tests green, the watcher was dead
Situation
context-parachute saves the work state before an agent’s context window fills up. After a change the watcher stopped running, with no error message. The tests still all passed.
Decision
One test had discarded the error output, ignored the exit code and counted empty output as a pass. I fixed the bug and added tests that check “crashed” separately from “fine”. A doctor check followed.
Rejected
Searching the session transcripts. That is where I started, and I found nothing, because hook failures that do not block never end up there. Only running the hook directly showed the error.
Cost
Whether resuming after a compaction works in live use has only been checked with fixtures so far.
03My router did worse than a fixed order
Situation
The router ranked accounts by success rate. New accounts with no history therefore always lost to proven ones, and paid quota went unused.
Decision
Every account with no run in the last 24 hours now goes first, and a small model gets a fixed share of the tasks. Then I measured the router against a fixed order.
Rejected
Carrying on ranking by success rate alone and trusting my own construction.
Cost
In the measurement the router came out slightly below the fixed order. My evaluation says so. Whether the idle quota is actually being used now, I have not measured yet.
04A worker used sudo
Situation
A delegated worker installed a system package with sudo because it was missing a tool.
Decision
Since then every worker runs with no-new-privs, so sudo fails there. If a tool is missing, the worker reports it. Sandboxes get no SSH keys, no root, no Docker socket and no home directory.
Rejected
Widening the sandbox until the task fits. If a task needs more, the image gets a pinned package or a single folder to read.
Cost
The stricter check had a false alarm that cost a builder five calls, and a later review found a bypass. Both are fixed and have tests. The review environments still run without an OS-level sandbox.
$ less docs/failures.md
## ps alias faked a dead-process diagnosis

Symptom: `ps` returned nothing with exit 0, and a whole false root cause
("the processes died with the terminal") was built on that silence.
Rule that prevents it: For process conclusions use /usr/bin/ps (or unalias
ps first). Prove the probe on a known-live PID ($$) before trusting an
empty result.
Check: test -n "$(/usr/bin/ps -p $$ -o pid=)"
When something goes wrong, I write it down with a command that checks for it. Here an empty output with exit code 0 was wrongly taken as proof.

What I’ve worked on

Since 2008: first quality assurance and systems administration, later DevOps, cloud platforms and AI agents.

Quality assurance
I wrote test plans, ran load tests and delivered software at customer sites.
Systems administration
I ran Linux systems and virtual machines and monitored them with Nagios and Icinga.
Telephony and integration
I connected SIP and CTI to collaboration platforms.
DevOps
I moved systems from Docker Swarm to Kubernetes and automated workflows with Terraform, Ansible and CI/CD.
Observability
I used Prometheus, Grafana and ELK to monitor how systems were running.
Secrets and access
I managed secrets with HashiCorp Vault and controlled access through reverse proxies.
Cloud architecture
I design Azure platforms and work with AKS, infrastructure as code and GitOps.
Documentation (DocOps)
I maintain wikis and runbooks and record decisions with a date.
Cost control (FinOps)
I set budgets to limit what model calls can cost.
Everyday security (DevSecOps)
I add guard hooks and have changes reviewed before they reach main.
AI agents
I route tasks to agents and review the results. For bigger decisions, several models weigh in.

As of November 2026

Where the limits are

  • I built this environment for myself. Whether it works for a team or for clients, I haven’t checked.
  • A review can miss an error too. Tests and my own checks are still needed.
  • If the policy gate itself fails, it logs the error. The action can still go through.
  • I have no measurements showing that this saves money.
  • A tool update once left a guard doing nothing. It stayed that way until I found and fixed the error.

Azure · AKS · Bicep · Terraform · Azure DevOps · ArgoCD · Kubernetes · Docker · Linux · Python · TypeScript · MCP

To the projects

Write to me if you want to talk about any of this.