A governed team.
From one agent engine.

Engine, Python, environment, model choice.

• Hermes engine — installed and running. Team6 is a layer on top of Hermes, not a fork of it; the engine stays upstream (MIT).
• Python 3.8+ with the standard library only — the gates and generator import nothing outside stdlib (verified on 3.9–3.13).
• Git + a POSIX shell (macOS/Linux, or WSL on Windows).
• Model / provider decision — the parameter file declares MODEL_PROVIDER and MODEL_NAME. The open-core default is the Hermes/Nous provider; you may point it at any provider your engine supports, including a local model endpoint.
• Local vs. hosted — decide where the Hermes runtime and the model run. A fully local deployment keeps data on-premise; a hosted provider trades that for convenience and needs network access plus API credentials.
• Hardware / network / security — size hardware to the model you choose (CPU/RAM/VRAM). The kit itself makes no network calls and ships no telemetry by construction, so it adds no egress of its own; if you use a hosted provider, review data-egress and provider terms. Air-gapped operation is possible when the model runs locally.

Clone the repository.

$ git clone https://github.com/ahrazzle/team6-kit.git
$ cd team6-kit

Read README.md first, then choreography/orchestration.md and choreography/governance.md — the two files that carry the operating doctrine. A fresh clone is self-contained: it ships a frozen manifest and review so the build runs without your local profile fleet.

Nine keys is the whole input.

The parameter file is a plain YAML of declared keys. Start from the shipped example and edit the values for your team:

$ cat examples/demo-consulting.yaml

Keys: TEAM_NAME, DIRECTOR_NAME, AGENT_NAME, PROFILE_NAME, ROLE_NAME, ROLE_MISSION, ROLE_PURPOSE, MODEL_PROVIDER, MODEL_NAME, plus an optional BASE_URL for a local or custom endpoint. Copy it, edit it, and keep it — this file is the vertical pack, and it never goes into the public repo.

Fail-closed: nothing assembles on a failed gate.

$ python3 build/sweep-gate.py      # PASS(0) → continue; FAIL(1) → stop
$ python3 build/review-gate.py     # 4/4 checkboxes on every shipping row
$ python3 build/generate.py --params examples/demo-consulting.yaml --out /tmp/demo-team

sweep-gate proves the extraction source is clean and fully classified. review-gate enforces the semantic sign-off. generate.py re-runs both as preconditions, then assembles. On a fresh clone the gates run in self-contained frozen mode against the committed manifest/review (the generator selects this automatically); when you maintain a live extraction source, add --strict to make an unresolved placeholder a hard failure.

A configured team, plus an honest audit trail.

/tmp/demo-team/
├── AUDIT.md     # rows shipped, reconciled to what's on disk
├── personas/    # instantiated identity (SOUL + profile config)
├── skills/      # the skills the roles run with
└── keep-review/ # signed KEEP-REVIEW rows, when present

Place them into a Hermes profile: copy the generated persona files into ~/.hermes/profiles/<PROFILE_NAME>/ (identity plus profile.yaml config) and the generated skills/ into that profile's skills directory, then set the required environment (MODEL_PROVIDER, MODEL_NAME).

Honesty note: the generator produces the artifacts; the copy-into-profile step is currently manual. No shipped installer performs it for you — that is the open setup-agent gate. Treat the placement above as the documented mapping, not an automated command.

Roles, choreography, governance, state, QA, recovery.

• Roles & choreography — a single-pass pipeline Director → Researcher → Architect → UX → Coder → QA → Director, each lane with an explicit boundary and a Definition-of-Done gate. See choreography/orchestration.md.
• Governance — viability funnel, spin-off SoP, structured verdicts and read-back receipts; the rules that keep the team honest live in choreography/governance.md.
• Durable state & ledgers — correctness as a pure function of append-only on-disk state (for example a results.tsv ledger with keep/discard/crash and frontier tracking). A respawned worker resumes from disk, never from dead context.
• QA — producer ≠ verifier: a mechanical gate first, then an independent adversarial judge; the adversarial-review skill ships in templates/skills/adversarial-review/.
• Recovery — Erlang/OTP-style supervision: bounded restarts per role, escalation on budget exhaustion, five-minute check-ins, and JIT forwarding of stable partials so a stall is never silent.

Re-run the gates; verify what is served.

$ git pull
$ python3 build/sweep-gate.py
$ python3 build/review-gate.py
$ python3 build/generate.py --params <your-pack.yaml> --out /tmp/team-v2

Regenerate into a fresh --out directory and diff the new AUDIT.md against the previous one before promoting. If you serve a site or artifact from the output, verify the served bytes with a cache-busted fetch — never announce a change from local files alone. Staging first, then promote.

Common failures and what they mean.

• sweep-gate: UNCLASSIFIED SOURCE — a new source file has no manifest verdict. Run build/build-manifest.py, then sign the row in REVIEW.md.
• review-gate: UNSIGNED REVIEW — a shipping row's 4/4 soft-leak checklist is not fully ticked. Complete the semantic pass before assembling.
• generate: DECLARED PLACEHOLDER(S) NOT RESOLVED — the pack promised a placeholder the parameter file did not supply (usually a typo). Fix the YAML key.
• generate: UNRESOLVED PLACEHOLDERS (warning) — expected in open-core mode, which ships generic by design; becomes a failure under --strict, so a paid pack cannot ship mangled.
• FileNotFoundError: REVIEW.md — you are on an older checkout; a current clone's gates fall back to the committed frozen artifacts automatically.

Support: open an issue at github.com/ahrazzle/team6-kit, or for the ASKA Team6 service email info@askaconsult.com. Public Team6 site: team6.askaconsult.com (source mirror: ahrazzle.github.io/team6-kit).