a5c-ai

Resolve model profile (quality/balanced/budget) at orchestration start and map agents to specific models. Enables cost/quality tradeoffs by selecting appropriate AI models for each agent role.

Orchestrate workflows across multiple applications and APIs — inter-app coordination, data handoff, and multi-system task completion.

PM2 process management, backend/frontend cascade execution, parallel worktree builds, and cross-service integration testing.

Execute work units through the rigorous 4-phase Metaswarm cycle (Implement -> Validate -> Adversarial Review -> Commit) with independent quality gate enforcement.

Observation capture and retrieval across sessions. Stores decisions, discoveries, and bugfix patterns. Searchable via tags and relevance scoring.

Adversarial plan review by 3 independent reviewers (Feasibility, Completeness, Scope & Alignment) before presenting to user.

Transform research findings into actionable implementation plans with stakes-based rigor, test-first strategy, and granular task decomposition.

Design technical architecture, select technology stack, and define implementation strategy from specifications and constitution constraints.

Structured planning methodology with research, brainstorming, phased plan creation, risk assessment, and plan-to-build continuity.

Monitor PR lifecycle from creation through merge including CI monitoring, review comment handling, thread resolution, and merge readiness verification.

Scaffold new babysitter process definitions following SDK patterns, proper structure, and best practices. Guides the 3-phase workflow from research to implementation.

Validate implementation quality through custom checklists, scoring against constitution standards, specification coverage, and producing remediation recommendations.

Language-specific auto-lint/format/typecheck pipeline. Supports Python (ruff+pyright), TypeScript (prettier+eslint+tsc), Go (gofmt+golangci-lint). Auto-fix and convergence loops.

Hybrid search combining semantic and keyword retrieval for RAG pipelines. Implement BM25 + dense vector search with fusion strategies.

Use when receiving code review feedback, before implementing suggestions. Requires technical rigor and verification, not blind implementation.

Research-first development methodology that investigates existing solutions, brainstorms alternatives, and evaluates trade-offs before any implementation begins.

Parallel research agent orchestration dispatching 5-10 concurrent agents for comprehensive multi-source research with synthesis and validation.

For a repository in the babysitter-users catalog, locate its babysitter processes and any committed runs (.a5c/runs/<runId>/) and perform a retrospective on a chosen run -- what went well, what failed, process suggestions, quality of effect design, breakpoint patterns -- mirroring the /babysitter:re…

Roadmap parsing, analysis, and mutation operations for ROADMAP.md. Handles phase and milestone lifecycle including add, insert (decimal), remove, complete, and requirements coverage analysis.

SONA self-optimizing neural architecture with ReasoningBank trajectory learning, EWC++ anti-forgetting, and reinforcement learning feedback loops.

Manage agent sessions including initialization, handoffs, revival (seance), and persistent identity for Polecats and Crew agents.

Mandatory memory persistence system across session resets using three markdown surfaces in .claude/cc10x/. Iron law - every workflow must load at start and update at end.

Complexity-based task routing with Q-Learning optimization, Agent Booster WASM fast-path, and Mixture-of-Experts model selection.

Feature specification creation from codebase research. Produces requirements, acceptance criteria, architecture decisions, implementation plans, and risk analysis.

Specification creation and management for the Pilot Shell methodology. Covers semantic search, clarifying questions, structured spec generation, and iterative refinement.

6-phase iterative specification execution workflow covering implementation, testing, review, improvement, commit, and progress tracking with quality-gated convergence.

Write feature specifications as requirements and user stories with acceptance criteria, focusing on business value and testable conditions.

STATE.md reading, writing, and field-level updates. Provides cross-session state persistence via .planning/STATE.md with structured fields for current task, completed phases, blockers, decisions, and quick tasks.

Strict RED->GREEN->REFACTOR test-driven development with enforcement. Never write production code before a failing test. Atomic commits per TDD cycle.

Use when executing implementation plans with independent tasks in the current session. Dispatches fresh subagent per task.

Multi-agent swarm formation and coordinated execution with topology-aware agent deployment, consensus protocols, and anti-drift enforcement.

Structured debugging methodology using hypothesis-driven investigation, log analysis, and bisection to isolate and resolve defects.

Red-Green-Refactor TDD methodology with mandatory failing tests, minimal implementation, quality refactoring, and 80% coverage gating.

Template loading, variable filling, and scaffolding for all GSD artifacts. Manages 22+ templates covering every document type in the GSD system, from PROJECT.md to milestone archives.

Strict RED-GREEN-REFACTOR cycle enforcement. Tests are never skipped or deferred. Run mode only, never watch mode. Exit code evidence mandatory.

Use when starting any conversation. Establishes how to find and use skills, requiring skill invocation before any response.

HNSW vector search for pattern similarity retrieval and knowledge graph maintenance with PageRank scoring, community detection, and 3-tier memory management.

Verification-before-completion discipline ensuring all success criteria are met, tests pass, and reviews complete before declaring work done.

Evidence requirement enforcement ensuring all claims are backed by logs, test results, or exit codes. Zero = success, non-zero = failure. No guessing allowed.

Plan structure validation, phase completeness checks, reference integrity verification, and artifact existence confirmation. Provides the structured verification layer ensuring GSD artifacts are well-formed and complete.

Decompose goals into MEOWs (Molecular Expressions of Work) - trackable atomic units following Gas Town's bead-based work model.

Decompose implementation plans into discrete work units with enumerated DoD items, file scope declarations, dependency mapping, and human checkpoint flags.

Use when you have a spec or requirements for a multi-step task, before touching code. Creates bite-sized TDD implementation plans with dependency tracking.

WASM-based instant code transforms for simple tasks, achieving 352x speedup over LLM inference with zero cost.

Build dependency-aware, batched dispatch queues for parallel agent execution.

Design comprehensive system architecture with technology selection and ADRs.

Full traceability from PRD to code commit through the CCPM spec-driven pipeline.

Microsoft AutoGen multi-agent configuration for conversational AI systems

Capture raw thoughts with automatic domain classification and vault routing

Chain-of-thought and step-by-step reasoning prompts for complex problem solving

Chroma local vector database setup and operations for development and production

Verify all phases are complete with weighted quality scoring before allowing session exit.

Constitutional AI and safety guardrail prompts for aligned LLM behavior

Content moderation API integration using OpenAI Moderation, Perspective API, and others