From Unzip to Verified PASS in Three Minutes: Assembling an AI Agent Team That Checks Its Own Work

Most agent frameworks ask you to do one thing: trust the README. Copy some prompts, paste a config, and hope the whole thing holds together. When it doesn't, you're on your own - nothing tells you whether you assembled it wrong or the instructions were wrong to begin with.

When I packaged my 16-role AI agent "company" as an open-source kit, I wanted the opposite experience. The question I cared about: can a stranger reproduce my setup, and can a machine prove they did? Here's the answer I shipped, and the thinking behind it.

The three-minute path

The whole assembly is four steps:

• Unpack. One archive, 38 files, no build step. Windows gets a zip, Unix/macOS a tar.gz (older unzip builds mangle non-ASCII filenames, so tar.gz there).
• Copy two things to two places. The 22 charters and 5 templates go to docs/empire/ in your project. Two knowledge-graph seed files go to docs/knowledge-graph/. That split is deliberate - the org chart and the memory system are different subsystems.
• Create an empty battle log. One markdown file, docs/PROJECT_MEMORY.md. This is the shared memory every role reads and writes.
• Run the check. node scripts/verify-empire.mjs <project-root> If it prints PASS, the team is assembled. If it doesn't, it tells you exactly which file is missing or inconsistent.

What "PASS" actually means

The verify script isn't a formality. It checks that the 22 charters are all present, that cross-references between them resolve, that the role roster matches the charters, and that the hard-boundary clauses exist where the rules say they must. Assembled-wrong fails loudly, with the specific gap named.

There's a second script for the knowledge-graph side (verify-graph.mjs) and a third one (pack-lint.mjs) that scans the pack itself for author-internal terms before shipping - more on that below.

The recorded run: proof, not promises

Inside the pack there's a file called 成功验证.md - "verified run." It is not a testimonial. It's a log of an actual assembly performed in a clean directory, from unpack to summon, with the commands and outputs written down. Every step in the manual maps to a step in the record.

The rule this enforces on me as the author: if a step in the docs can't be reproduced, the record catches it. This isn't theoretical - during development, an earlier version of the docs skipped the knowledge-graph seed step, and the verification record is what exposed it (the graph check failed on a fresh assembly even though it passed in my own workspace, where the old files masked the gap). The fix went into both the docs and the script.

The lesson generalizes: a self-check that runs in the author's environment proves nothing. Run the check where nothing pre-exists.

The pack scans its own wording

One more script ships in the pack: a lint that scans every markdown file for terms that shouldn't be in a public distribution - the author's internal project names, platform identifiers, automation IDs, that layer of private context. The wordlist itself is encoded into the script, so the check can run without the forbidden terms ever appearing in the repo.

This one earned its keep the embarrassing way. After I added a new section mentioning my internal tooling directory, the lint flagged the path on the next run - I'd have shipped it otherwise. The check doesn't get tired and doesn't assume good intentions, which is exactly what you want from a checker.

What this has to do with agent teams

The assembly story is the small version of a bigger claim: agent teams need machine-checkable state, not narrative state. "It's set up" and "it works" are claims, and claims need a command that can fail. The same discipline that verifies the assembly (a script with a PASS) verifies the team's daily output (evidence grades on every "done") and verifies its boundary conditions (a reviewer role whose objections are checkable, not vibes).

Everything I described - the 16 role charters, the ten rules of engagement, the battle log format, the verify scripts - ships in one free pack:

• Repo: https://github.com/yyyz1yyyz2/empire-iron-corps
• Downloads + install guide: https://empire-iron-corps.vercel.app
• License: docs CC BY 4.0, code MIT

Honest notes, as always: the charters are written in Chinese (an English edition of the pack itself is on the roadmap - this post is the English tour). All 16 member names are explicitly fictional AI personas. No income claims anywhere; it's an organizational pattern, not a product pitch. Disclosure: my own open-source project; nothing here is paid promotion. If you assemble it and something doesn't reproduce, that's the most useful issue report I could ask for.