← All writing
20 Nov 2026AI Engineering8 min read中文

I Work in Aviation. So I Built My AI Agents a Control Tower.

Why one governance repo now steers every project my agents touch

By day I work in aviation. By night, it turns out, I build control towers. Not for aircraft: for the AI agents I use to write code in my side projects. The day job only gave me the name, but the name fits better than I expected.

This is the first post in a series about that setup. The posts draw on the repos themselves (decision records, pull requests, the moments I had to correct the AI), on my own recollection where the repos are silent, and on linked sources. Some of what I built turned out to be an established pattern I had never read about. I’ll say which parts.

Starting With One Project

The first project in this setup was a career toolkit: a factual resume and the workflows to tailor and check it. A colleague who has given me a lot of good advice on AI suggested opencode as the agent harness, and it was a sensible place to start. In my setup it couldn’t use my Claude Pro subscription, so in practice it only ran Codex.

That taught me something that wasn’t about code: the harness has to fit the subscriptions you actually have. I pay for both Claude and ChatGPT with Codex, and I wanted one layer of rules that would apply to whichever model did the work.

Where This Was Heading

The next project was an AI fitness coach. Before I wrote a line of it, I could see where this was going. Each repo would carry its own copy of everything:

  • Rules: how the agent plans, when it asks me, what it may merge. Copied per repo, they drift.
  • Models: which agent runs where, on which subscription, with which settings.
  • Cost: subscriptions, a domain, cloud hosting and, later, API calls. I wanted fixed costs and future usage tracked in one place, not per project.
  • Autonomy: how much I trust an agent in a repo that holds health data versus a blog.

One project is fine. With more, I’d be the one keeping all of it in sync. I’ve seen that silo problem many times in data teams.

Why a Separate Governance Repo

So I designed a control tower before the fitness coach had any product code. Version one came out of a chat with Claude at the gym, between sets. Version two became the first commit.

A control tower doesn’t fly aircraft. It issues clearances, keeps aircraft apart, and watches the traffic on and around the airfield. That was the job.

Airfield My setup
Control tower control-tower, one governance repo
Aircraft Each project repo and the agent session working in it
Flight plan A card (GitHub issue) with acceptance criteria
Clearance My approval of the plan; merge rights by risk tier
Air traffic rules AGENTS.md and GUARDRAILS.md: rules every agent loads
Records of why each rule exists Architecture Decision Records (ADRs)

An Architecture Decision Record (ADR) is a short, dated file that records one decision: the context, the options and why one won. The tower keeps one for every real decision, so the setup remembers why it is the way it is, not any agent’s memory. How that history is kept gets its own post later in the series.

The first ADR records a second reason for keeping the tower separate: “If the workflow lives inside one project, it dies with that project.” Silos were the problem I could see coming. This one is about survival: the fitness coach might not last, but the way I work with agents should.

I also ruled out a monorepo. A product may be sold or opened up one day, health and finance data need their own boundary, and GitHub lets me restrict fine-grained access by repository.

When the AI Pushed Back

The AI pushed back, more than once. I was pouring a lot of energy, and a lot of tokens, into the tower, and it kept pointing out that I had no product code, only a framework, and that this looked like a way to put off the real work. Its point was fair. I built it anyway.

Looking back, it was half right. Building the tower first was the right call. Sinking into it was not. A tower designed before there is any traffic is full of assumptions, and every assumption turns into management overhead that someone, or some agent, has to carry. Running the fitness coach through the tower showed which parts were real, and the decision records show what I cut:

  • A plan built around the tower: weeks of tower work (a server, a full cost controller, a planner bot) before the first line of the product, with no API spend to control and no autonomous agent to govern yet. ADR 0014: “Product first; control plane on demand”.
  • An architecture for a system that didn’t exist: a planner bot, a reviewer, a cost pipeline, nine database tables and a dashboard. Every session read it, and every decision had to reconcile with it. ADR 0026 cut the document down to what exists.
  • Ceremony: separate sessions per role and minutes for every decision, which nobody read back. ADR 0009 dropped them.
  • Rules and reviews: every incident added a rule, until a fitness coach session loaded about 8,000 words of rules before any work, and 68% of the tower’s own PRs waited for my review. Those two get their own posts.

So the tower stays, but it only grows when a project needs it. Several lessons from the projects have since come back as shared rules, checks or reference notes, and every other repo picks them up.

How Rules Reach Every Repo

The first design failed almost at once. It shared rules by copying a template into each project, and a rule had already changed: the fitness coach’s copy still told the agent that I merge every PR and that it should update a DEVLOG. Both were out of date. Every rule change would have needed a sync PR in every repo.

ADR 0012 sorted shared things into three kinds and gave each one a delivery mechanism:

Kind Example How it reaches a project When the tower changes
Policy AGENTS.md, GUARDRAILS.md Imported at user level, never copied The next local session, once I pull the tower
Automation The risk-tier check A reusable GitHub workflow, called by reference The next workflow run, no sync PR
Scaffolding README, roadmap, ADR template Copied once, then owned by the project No sync

The policy part is a one-line import. Claude Code loads ~/.claude/CLAUDE.md in every local session, whichever repo I open. That file points at the tower, the tower’s file pulls in the shared rules, and each project’s own CLAUDE.md adds its project-specific rules on top:

Terminal: the import chain from ~/.claude/CLAUDE.md to control-tower’s AGENTS.md and GUARDRAILS.md, then a project’s own AGENTS.md

Codex has no import mechanism, so its global AGENTS.md holds a single pointer telling it to read the same files. It follows that by instruction, which is weaker. More on that in the next post.

The automation part is a short caller in each project. This is the job in this blog’s repo:

jobs:
risk-tier:
uses: ciaeric/control-tower/.github/workflows/risk-tier.yml@main
with:
extra_critical: "public/CNAME astro.config.mjs scripts/legacy-urls.txt scripts/check-urls.mjs package.json package-lock.json AGENTS.md"

It classifies every PR by the files it touches and labels it. The label tells the agent whether it may merge after my plan approval, or must wait for me:

Terminal: gh pr checks shows the shared risk-tier check passing, and the PR carries the risk:high label it set

Onboarding a New Repo

The tower paid off when the next repos came in. Four are onboarded today: the career toolkit, the fitness coach, my homelab NAS, and this blog. Four more ideas sit in the registry without a repo yet. A new repo gets an entry in projects.yaml with an autonomy cap, a short project AGENTS.md, and the workflow caller above. The shared rules and checks come with it on day one.

Terminal: gh repo list shows control-tower next to the four project repos it governs

The small proof I like best is language. I work with my agents in Chinese, and everything written to a repo is English. That rule lives in one file that every local session loads. When agents still slipped into English, I added one user-level hook that reminds the agent every time I submit a prompt. One fix, every repo.

A rule in text wasn’t enough on its own. That’s the next post.

Did I Invent This?

No. I designed this on my own, but when I searched afterwards I found the core idea is well established:

What I’d still call mine:

  • Solo scale: a governance setup with no admin console, built from a user-level import and a reusable workflow.
  • Four jobs in one place: shared rules, autonomy caps per project, cost tracking and reusable automation, for one person’s projects.
  • Distribution by kind: copy scaffolding, reference policy, call automation.

If You’re Starting Your Second Project

You don’t need a tower for one project. At two, you start to feel it. Here’s the minimum I’d build:

  1. One repo for shared rules, loaded by reference, never copied.
  2. One registry of your projects and how far you trust the agent in each.
  3. One check outside the model that every repo calls, to flag what must not merge without you. If it has to be a hard stop, back it with a platform rule.
  4. Decision records from day one, so you can see which half of your first plan was wrong.

Then go and build the product. The tower is there to give clearances.

Thanks

Eric Dong