KEVIN THEOBALD

Field report — July 2026

I Can't Code. My Company Runs on AI Agents Anyway.

How one non-coder designs, governs and runs 11 subagents and 75 skills across 100+ scheduled automations — including the failures.

system nominal · 6 fixes shipped, 0 rollbacks

Section 01 — One person, one real company

I'm Kevin Theobald. I run a small e-commerce company in Basel, Switzerland. My main brand sells kitchen accessories I invented and patented myself, sold on Amazon in 8 EU marketplaces. No IT department, no developer, no technical co-founder. I can't read code.

The company still runs on software — built by AI agents, mostly Claude Code, with a second model from a competing vendor as reviewer. At one snapshot this week, 7 Claude sessions were working in parallel; later the same night, 15.

What a bad night looks like now

Past midnight, a background job hangs. A watchdog notices within the hour. A repair loop checks that a restart is provably safe, restarts the job, verifies it came back healthy, and writes one line into the morning digest.

My phone stays dark. I read about it over coffee. I've never seen the code that did this — I couldn't read it anyway.

What the agents handle

Email:
every inbound mail across 3 mailboxes gets classified; about 70% is noise and gets filed silently. What matters lands on my phone as a card with buttons — one tap drafts a reply, 4 independent quality gates check it, one more tap sends it. Agents never send email on their own. No exceptions.
Advertising:
Amazon PPC runs in-house. Agents collect the data, flag anomalies, write the weekly report and prepare campaign changes. Anything that moves money needs my approval plus an adversarial second review. Go-lives are verified programmatically on all 4 levels of Amazon's campaign hierarchy.
IP enforcement:
every night, monitors comb 8 marketplaces for products infringing my patents and registered designs — image hashing, embeddings, a vision model. Evidence is archived automatically; infringement reports come out as court-ready PDFs, and filing always needs my explicit go. Well over 100 infringing listings are down already — roughly 2 in 3 of everything I file, with more every week. The manual version of this is a person watching those marketplaces by hand: hours and real money, and they'd still miss the copies the nightly sweep catches.
Guest hosting:
alongside the products, I let out a holiday apartment in the Swiss Alps. For every booking, agents draft the guest messages and set the smart-lock entry code automatically — check-in and check-out run without me, and I only step in when a guest needs something out of the ordinary.
Everything else:
invoice filing, FBA inbound shipments end-to-end, listing audits, automated review requests — plus 2 knowledge bases the system re-crawls monthly, so agents answer from current documentation instead of model memory.

The real question isn't what it does — it's why it hasn't blown up yet.

The machine, by the numbers

Scheduled_jobs

0

across 8 EU marketplaces

Agent_skills

0

custom Claude Code skills

Helper_scripts

0

shell/Python automation

Automated_tests

0

green before every deploy

"This isn't a demo. It's the machine my company actually runs on."

Section 02 — The operations layer

  1. Autonomy is earned, not granted.

    Every subsystem climbs the same ladder: shadow mode (it proposes, executes nothing) → pilot on real data → gated mode (every action needs my tap) → auto mode, for a narrow, defined class of actions. The newest subsystem — an investigator that root-causes alarms — ran a supervised shadow week before it earned auto mode.

    36 cases · 17 false alarms dismissed · 6 real fixes shipped · 0 rollbacks

  2. The maker is never the checker.

    Nothing important is verified by the model that produced it — where it counts, not even by the same vendor. Claude's fixes are reviewed by OpenAI's Codex; Codex's code is verified by Claude. Mixing vendors is the cheapest insurance I've found.

  3. Fix quietly. Escalate loudly.

    Background failures don't interrupt me. The system fixes what's provably safe, files the rest to a dashboard, and sends one digest a day. Only a short list of true emergencies may ping my phone. House rule: an automation that pages me more than it saves me gets reworked.

  4. Everything has an off switch.

    Every autonomous loop has a one-line kill switch, snapshots before changes, automatic rollback if the audit fails, and a hard cap of 2 fix attempts before it escalates to me. The agents' own guardrails and configs sit in a protected zone no agent may touch — no agent can edit the rules it's judged by.

  5. Every incident becomes a rule.

    Every real failure ends as a written rule, loaded into every future session. A model once wrote "Friday" next to a date that was a Saturday — since then, every weekday next to a date is verified programmatically. Every number in outbound text must trace to a source file.

  6. A canary for context rot.

    Long AI sessions degrade quietly. My canary is simple: the assistant has to address me by name in every reply. The day the name disappears, the context is rotting — time for a fresh session.

  7. Measure, don't guess.

    A 7-day token audit found one repair loop running ~95% no-op — about $231 a week of API-equivalent spend for zero changes. I built an LLM-free pre-check gate the same day. A separate benchmark moved email drafting to a mid-tier model at equal quality and ~1.8x lower cost.

Section 03 — What went wrong

You don't get to claim "safe" without showing the crashes. 4 of mine:

INCIDENT_01

The campaigns that said "live"

3 ad campaigns reported "live" — underneath, every ad group, keyword, and product ad was still paused, serving nothing. I caught it myself, with domain knowledge — not tooling.

→ A 4-level programmatic go-live check is now mandatory.

INCIDENT_02

The backup that quietly rotted

A shell-script flaw mis-rotated backups for 4 weeks before anyone noticed.

→ Every file-touching helper script now needs a fixture-based smoke test before it may run on schedule.

INCIDENT_03

The tests that paged for nothing

A migration test hit the real alert channel — 6 fake emergencies pinged my phone.

→ Tests are now hermetically sealed from production alerting.

INCIDENT_04

The drafts that vanished

Reply drafts were silently discarded by an over-strict verifier.

→ Fixed with regression tests. "The pipeline says OK" is never the final word.

None of this is an argument against the system. It is the system: failures get caught, contained, reversed — and turned into rules.

Conducting agents is a real job now

I still can't write a for-loop. But running this machine turned into a real role — and it's more like conducting an orchestra than operating a tool. I specify outcomes precisely, decide what may run autonomously and what never will, design verification that doesn't rest on trusting any single model, budget attention and tokens, and harden the system incident by incident. Dozens of agents play; my job is to keep them in time and catch the wrong notes before they reach a human.

That's not a coding skill. It's a different kind of expertise entirely.

Not a developer's skill set. It's how a conductor holds an orchestra together — and how a CFO thinks about controls.

github.com/kevintheo-ai/agent-ops-kit

The watchdog pattern, the LLM-free pre-check gate, a heal-loop template with kill switch, shadow mode, protected zones and rollback — plus the staged-autonomy ladder as a checklist. MIT license. It's the scaffold I wish I'd had on day one.

git clone github.com/kevintheo-ai/agent-ops-kit

View on GitHub →