axiom: The engineer is the limitation, not the model - models can do far more than we give them credit for if properly prompted and context-engineered

source: IndyDevDan Multi-Agent Orchestration Opus 4.6

category: mindset

genesis_action: Train Genesis agents to push model capabilities to limits through exceptional prompt engineering and context engineering rather than assuming model limitations


axiom: Agent team lifecycle follows strict pattern: Create Team → Create Tasks → Spawn Agents → Work in Parallel → Shutdown → Delete Team

category: orchestration

genesis_action: Implement TeamLifecycleManager that enforces this pattern - teams must be created, worked, and deleted for proper resource management


axiom: Specialized agents over generalist agents - one task, done extraordinarily well, then shutdown

genesis_action: Spawn focused single-purpose agents via Agent Teams rather than reusing general agents - optimization through specialization


axiom: Context reset after team deletion is good hygiene - forces excellent context engineering by preventing bloat

category: context-engineering

genesis_action: Delete Agent Teams immediately after task completion to force fresh context windows and prevent context pollution


axiom: Observability is prerequisite for agentic scaling - you cannot improve what you cannot see

category: observability

genesis_action: Build session event tracking system that logs every tool call, SendMessage, and task update across all Agent Teams


axiom: Agent sandboxes enable safe scaling without local risk - scale compute to scale impact

category: sandboxing

genesis_action: Map E2B sandboxes to E:\genesis-workers\ worktree pattern - each agent gets isolated environment on E drive


axiom: Core Four framework is universal: Context, Model, Prompt, Tools - scale each dimension to scale capability

genesis_action: Audit every agent spawn against Core Four checklist - optimize context clarity, model selection, prompt specificity, and tool availability


axiom: Information-dense keywords in prompts trigger specific tool behaviors - use precise trigger words

category: tooling

genesis_action: Build keyword vocabulary for Genesis agents that maps specific terms to tool invocations (e.g., 'verify' → TaskGet, 'coordinate' → SendMessage)


axiom: Task list is the centralized hub - everything kicks off from there, all coordination flows through it

genesis_action: Make TaskList the single source of truth for all Agent Team coordination - agents poll tasks, update status, and communicate results through task objects


axiom: Scale compute to scale impact - not about single agents, but teams that communicate toward one goal

category: scaling

genesis_action: Provision more E:\genesis-workers\ worktrees to enable larger Agent Teams - compute is cheap, impact is valuable


axiom: Each agent has own context window, model, session ID, and unique name - complete isolation

genesis_action: Enforce context isolation in Genesis Agent Teams - no shared state except through TaskList and SendMessage


axiom: Tmux enables multi-agent visualization - primary agent manages session, sub-agents open own panes

genesis_action: Enhance genesis-swarm.ps1 with tmux orchestration on WSL - visual dashboard of parallel agent activity


axiom: Iterative ad-hoc team spawning - fire off agent teams for specific work batches, then delete

genesis_action: Build quick-spawn patterns for Genesis - predefined team templates for common tasks (testing, documentation, feature implementation)


axiom: Understand capabilities before using them - dig into every feature release to expand your toolkit

genesis_action: After each Claude Code update, run capability audit to understand new tools/features and integrate into Genesis workflows


axiom: SendMessage is the most important tool - inter-agent communication enables true coordination

genesis_action: Use SendMessage for all cross-agent updates - agents report progress, request help, and share discoveries through messages


axiom: Primary agent uses Opus 4.6, sub-agents can use Haiku/Sonnet for cost efficiency

genesis_action: Implement tiered agent spawning - Opus for orchestration/complex reasoning, Sonnet for implementation, Haiku for simple verification


axiom: Agent sandboxes have 12-hour lifetime - plan team execution within this window

genesis_action: Set 10-hour soft limit for Agent Team lifespans - buffer before E2B sandbox expiration forces cleanup


axiom: Three pillars of agentic scaling: Multi-Agent Orchestration, Multi-Agent Observability, Agent Sandboxes

genesis_action: Build Genesis around these three pillars - orchestration through Agent Teams, observability through event logging, sandboxing through E drive worktrees


axiom: Organization required for real production features - single agents cannot ship complex systems

genesis_action: For any PRD with 5+ stories, automatically spawn Agent Team rather than sequential execution by single agent


axiom: 24+ concurrent sandboxes demonstrated at scale - skill-based sandbox management enables massive parallelism

genesis_action: Provision E:\genesis-workers\ with 24+ worktree slots for parallel Agent Team execution - test limit and scale further


axiom: Tasks replace Ralph loops for multi-task coordination - filesystem persistence + DAG dependencies > in-memory flat lists

source: IndyDevDan Claude Code TASKS Upgrade

genesis_action: Use native TaskCreate/TaskUpdate DAG for all multi-step work, reserve Ralph Loop only for single-task persistence


axiom: CLAUDE_CODE_TASK_LIST_ID enables cross-session task sharing - set it to coordinate multiple Claude instances on same work

genesis_action: Set CLAUDE_CODE_TASK_LIST_ID in Agent Team env to enable shared task visibility across all teammates


axiom: Simple tasks don't need the task system - only use TaskCreate for 3+ step coordinated work

genesis_action: Skip task overhead for trivial operations, reserve TaskCreate for complex multi-agent coordination


axiom: Task DAG externalized to filesystem means state survives any context event - clear, compact, restart, crash

source: AIABS Parallel System Game Changer

genesis_action: Trust filesystem task persistence over in-memory state - never store critical coordination data only in context window


axiom: Coordinator creates dependency graph then spawns parallel independent tasks simultaneously - sequential only when blocked

genesis_action: Always analyze task graph for parallelism opportunities before sequential execution - spawn all independent tasks in one wave


axiom: Each spawned agent gets fresh isolated 200K context - cross-contamination eliminated by design

genesis_action: Leverage context isolation for clean execution - each agent only receives the minimum context needed for its specific task


axiom: 'break this down into tasks with dependencies' is the trigger phrase when Claude doesn't auto-decompose

genesis_action: Include this trigger phrase in orchestrator prompts when complex work isn't being parallelized automatically