Command structure SYS // ORG
Bridge
The Commander
One AI session per station acted as Commander. It owned challenge state, validation and the rule that a flag is printed only once it is verified. It did not solve the standard lanes itself: it routed work, watched the agents, read their output and decided. A challenge in a lane nobody owned (web, special drops) was claimed and solved by the Commander directly.
Two hulls, one fleet
Workstation + homestation
Two machines ran the same framework in tandem, both driven by the same operator. The workstation owned the warmups, metadata-forensics and mobile lanes; the homestation owned script analysis and binary reverse engineering (and later web). Two Claude Commander instances (one per station) talked through a shared, git-backed note channel: claims, solves, lessons and end-of-day handshakes, with an agreed rule that neither side finalised a day alone.
Crew
Lane agents + specialists
Each daily lane had one agent seat (three on one station, two on the other), so every mode had exactly one owner. Ten specialist roles (malware RE, Windows DFIR, network, web/API, exploitation, crypto/stego, OSINT, adversarial AI, scripting/data, Linux) existed as workers the Commander could call; they returned findings and never declared a challenge solved.
Release sequence SYS // FLOW
Pre-release handshake
Before each daily release both stations checked that they ran the same code revision and an equivalent environment, then posted a ready signal. A scheduled task spawned the lane agents a few minutes before release so they were warm and waiting.
Release watcher and stager
A single poller per station watched the Game Master's challenge list. The moment the day's challenges appeared it staged each one: started the Single Solve, fetched the assigned artifact once, wrote a digest, and dropped an entry into a local pool. Agents never polled the Game Master themselves; they waited on local files.
Claim and dispatch
Each waiting agent made one blocking call that claimed the first unclaimed challenge in its lane. Ownership was an atomic lock, so no two runners could ever spend the same ranked attempt.
Deterministic autosolve first
At claim time the lane's banked solver ran immediately, with no model in the loop. Each lane had a day-generic adapter that turned the Game Master's question contract plus the attempt's own bytes into answers: a layered decode chain for warmups, byte-level extractors for metadata, codec and bytecode handling for mobile APKs, an inventory parser for scripts, and a format-dispatching field solver for binaries.
Agent on the gaps
When a day added a layer the adapter did not know yet, the agent worked only on the missing piece, extended the adapter, re-ran it, and submitted. Single Solve first; Time Trial and Mastery immediately after, because their material was freshly generated per attempt and had to be derived from those exact bytes.
Verification
A mode counted as done only when the Game Master said CORRECT. A blocked mode was recorded as needing a person, never as done. Every exchange with the Game Master was recorded locally for later analysis.
Close and learn
Each solved challenge ended with a challenge-named write-up (the pages on this site). Agents logged a structured lesson after every correct mode; at the end of the day the Commanders turned gaps into code changes and tests, synchronised both stations, and wrote a short review of what the agents had taught them.
Subsystems SYS // MODULES
Comms
Game Master client
A small REST client for the event's Game Master service over HTTPS with a personal bearer credential (paired once, never printed or committed). It handled list, status, start, retry/practice and submit, bounded its retries on rate limits, and exposed one helper that runs a solver against a mode's question contract.
Recognition
File-type recognizer and decode chain
One recognizer identified about a hundred artifact formats by structure rather than by file name, and mapped each to a lane and a first move. A stdlib "magic"-style decode chain peeled stacked encodings (base families, hex, binary, octal, rot/caesar/xor, compression, escapes, Morse) automatically.
Memory
Accepted-value and format bank
The Game Master grades exact strings and gives no per-field feedback; one wrong field rejects a whole batch. So every value and value format the Game Master ever accepted was banked per field, and solvers read it back to pick the right spelling, width or casing the next time a field appeared.
Replay
Offline replay of accepted answers
Archived timed attempts were kept as sanitised fixtures. Any change to a lane solver was replayed against those attempts and compared with the answers the Game Master had accepted, so a fix could be proven offline without spending a live attempt.
Prediction
Lane progression model
Every lane turned out to be the previous day's challenge plus one new layer. A small data file per lane recorded the axis that changed, the sequence so far and ranked candidates for the next layer; a novelty check compared the day's prompt with earlier days to name what was new before an agent started.
Learning loop
Lessons, mistakes, and the daily review
Agents filed lessons by kind (gap, trick, format, speed, mistake). Commander corrections were logged by class, and the rule was to fix the class with code or a test, not the single instance. The end-of-day sweep flagged any challenge with no lesson as a gap and turned it into the next morning's prebuild.
Standing orders SYS // RULES
- One owner
- One owner per lane and per mode. Two runners on one ranked attempt burn it.
- GM is truth
- A mode is done only when the Game Master says so. Local notes never mark anything solved.
- Second method
- Any claim that something is missing or empty needs a second, independent check.
- General tool first
- Run the installed general-purpose tool before hand-building an extractor.
- Never guess
- A held answer beats a wrong submit; timed attempts are scarce.
- Neutral wording
- Plain, accurate language in prompts and notes (decode, parse, extract, classify).
- No secrets
- Credentials stayed out of prompts, logs, notes and the repository.