> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

Master Console: The Theatrical Multi-Agent Framework That's Really Just Structured Prompting

[ View on GitHub ]

Master Console: The Theatrical Multi-Agent Framework That's Really Just Structured Prompting

Hook

What if your 'autonomous AI company' is just one LLM pretending to be five people through sequential markdown prompts? Master Console sells multi-agent orchestration but delivers something far more mundane—and occasionally useful.

Context

LLM coding assistants have a chaos problem. You ask Claude to refactor your API, and three sessions later you've lost track of what changed, why, and whether it introduced security issues. There's no audit trail, no validation gates, no separation between 'write the feature' and 'review the feature.' You're flying without instruments.

Master Console attempts to solve this by imposing workflow rigor on Claude Code sessions. It installs 235 markdown-based slash commands, 78 Node.js event hooks, and a role-based agent system into your project's .claude/ directory. The pitch: transform a single LLM session into a simulated software company where different 'personas' (Alpha the architect, Beta the builder, Gamma the security reviewer) collaborate through a six-phase sprint workflow. It's theatrical, ambitious, and fundamentally a filesystem-based state machine that uses git worktrees for isolation and CLI dispatch to avoid touching API keys directly.

Technical Insight

Isolation Layer

State Persistence

Event: prompt/edit/command

Validates format & policy

Enforces review markers

Invokes agent persona

Maps to provider CLI

Shells out

Generated code

Chains agent invocations

Orchestrates workflow

Creates branch

Parallel builds

Context injection

Persona specs

Claude Code Session

Hook System

Events Log

Slash Commands

235 .md files

Role Registry

Provider Dispatch

OpenAI/Gemini/Codex

Skills Engine

Sprint Lifecycle

Scored Learnings

.claude/project/

Git Worktrees

System architecture — auto-generated

The architecture is clever in specific places and overcomplicated everywhere else. At its core, Master Console intercepts Claude Code events through Node.js hooks that fire on prompts, edits, and command execution. These hooks validate outputs against policies before they land in your codebase—think pre-commit hooks but running synchronously during LLM generation.

Here's what a typical hook looks like in .claude/hooks/validate-tracker.js:

module.exports = async (context) => {
  const { editedFiles, agentRole } = context;
  
  for (const file of editedFiles) {
    if (file.path.includes('TRACKER')) {
      const content = await fs.readFile(file.path, 'utf8');
      if (!content.match(/^## \[\d{4}-\d{2}-\d{2}\]/m)) {
        throw new Error('Tracker format violation: missing date header');
      }
      if (agentRole === 'security' && !content.includes('<!-- REVIEWED -->')) {
        throw new Error('Security review incomplete');
      }
    }
  }
};

This is genuinely useful infrastructure—it prevents malformed tracker files and enforces review markers before code proceeds. The hook system is the most defensible part of the framework.

The git worktree isolation is pragmatic engineering masquerading as multi-agent orchestration. When you invoke the 'builder' persona through a slash command like /skill:beta:feature, the framework creates a separate git worktree:

git worktree add ../builds/feature-xyz -b agent/beta/feature-xyz
cd ../builds/feature-xyz
# Builder agent works here in isolation

This prevents concurrent edits from colliding if you're switching between agent personas rapidly. It's filesystem-level mutex locking, not because multiple agents run simultaneously (they don't), but because you're context-switching between different markdown prompt templates that inject role-play instructions. The 'Alpha' persona gets .claude/personas/alpha.md injected into the Claude Code session, which contains instructions like 'You are the system architect. Focus on design decisions and tradeoffs.' Switch to Beta, and you get different markdown with 'You are the builder. Focus on implementation and code quality.'

The cross-provider dispatch is where things get brittle. Master Console shells out to three different CLI tools instead of calling APIs directly:

const providers = {
  claude: 'claude-code',
  openai: 'openai-codex',
  gemini: 'antigravity'  // Custom wrapper CLI
};

async function dispatch(prompt, provider = 'claude') {
  const cli = providers[provider];
  const result = await exec(`${cli} prompt "${prompt}"`);
  return result.stdout;
}

This means API keys never touch the framework code—they're managed by each provider's CLI. It's a security choice, but creates hard dependencies on proprietary tooling. The 'antigravity' CLI for Gemini appears to be custom infrastructure with no public documentation. If you can't install it, the multi-provider fallback silently degrades to Claude-only.

The security review requirement is the most interesting policy enforcement. The framework refuses to mark security reviews complete unless multiple provider CLIs are configured:

if (reviewType === 'security') {
  const availableProviders = await checkInstalledCLIs();
  if (availableProviders.length < 2) {
    throw new Error('Security reviews require multi-lab consensus');
  }
  // Run review with both Claude and OpenAI, compare outputs
}

This is rare: automated bias mitigation that requires multiple AI labs to weigh in. The implementation is shallow (it just checks if CLIs exist, not whether answers differ meaningfully), but the intent is laudable. It acknowledges that single-model security reviews have blind spots.

The append-only events log creates session persistence. Every agent action appends to .claude/project/events.jsonl, and a nightly 'dream consolidation' process scores learnings for promotion to long-term memory. This is prompt engineering vocabulary for pruning and deduplication—there's no semantic compression or RAG-style retrieval, just heuristics about which log entries to keep.

Gotcha

The Windows-first design is disqualifying for many teams. The installer is PowerShell with an 'untested' Node.js fallback for Linux/macOS. For a developer tool in 2024, treating Unix systems as second-class citizens is backward—most production infrastructure runs on Linux, and most developers use macOS or WSL. You'll spend your first hour debugging installer scripts that assume Windows registry paths.

The 'multi-agent' framing is overselling sequential role-play. There's no parallelism, no independent agents running concurrently, no actual distribution of work. The sprint workflow that promises Alpha designs while Beta builds is strictly sequential context-switching. You wait for one markdown persona to finish before the next begins. This is slower than doing the work yourself with discipline, not faster. The 'autonomous AI company' metaphor collapses under scrutiny—you're the CEO, project manager, and all five employees, manually invoking slash commands to switch hats. Hard dependency on Claude Code specifically (not the Claude API, not generic LLM tooling) means you're locked into Anthropic's CLI product roadmap. If they change pricing, deprecate features, or pivot to a different developer experience, your workflow breaks. There's no escape hatch to generic LLM providers or local models.

Verdict

Use if: you're a solo founder or tiny team drowning in LLM session chaos, you already use Claude Code exclusively and want to impose workflow discipline without learning CI/CD properly, you run Windows and have high tolerance for installing three proprietary CLIs, or you value the hook-based validation system enough to accept vendor lock-in. The git worktree isolation and pre-commit-style policy enforcement are legitimately useful for preventing malformed LLM outputs from landing in your codebase. Skip if: you work on a team with actual humans doing code review (the framework is a substitute for engineering process, not an enhancement), you run Linux or macOS as your primary development environment (the Windows-first installer will frustrate you), you care about vendor lock-in or need to support multiple LLM backends without CLI dependencies, or you want actual multi-agent parallelism instead of sequential role-play theater. The 2-star GitHub count and single-maintainer status suggest this hasn't found product-market fit beyond solving its creator's specific workflow problems. Plain Claude Code with good prompts and shell scripts replicates 80% of the value without 235 markdown files.