One post tagged with "agent-teams"

  Boris (human)
      |
      |──> 5 terminal tabs (iTerm, OS notifications)
      |──> 5-10 browser sessions (claude.ai/code)
      |──> mobile sessions (fire-and-forget)
      |
      v
  Each session = independent Claude Code instance
      |
      |── Model: Opus 4.5 + extended thinking (always)
      |── CLAUDE.md: shared knowledge base (updated weekly)
      |── Plan Mode first, then auto-accept
      |
      v
  ┌───────────────┐
  │ PostToolUse    │  <-- formatting hooks fix style drift
  │ hooks          │
  └───────┬───────┘
          |
          v
  ┌───────────────┐
  │ Verification   │  <-- Chrome extension, agent self-tests
  │ loops          │
  └───────┬───────┘
          |
          v
  ┌───────────────┐
  │ PR             │  <-- /commit-push-pr slash command
  └───────────────┘

  "Teleport" hands sessions between terminal ↔ browser ↔ mobile

  Layer 1: SUBAGENTS (in-session)
  ────────────────────────────────
  Parent agent
      |
      |── Task("Explore", "find all API routes")  <-- Haiku, read-only
      |── Task("code-reviewer", "review changes")  <-- custom .claude/agents/*.md
      |── Task("general", "refactor auth")         <-- background, full tools
      |
      v
  Results summarized back to parent
  Subagents CANNOT talk to each other


  Layer 2: AGENT TEAMS (cross-session, experimental)
  ───────────────────────────────────────────────────
  CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
  tmux -CC
      |
      v
  ┌──────────────┐
  │  Team Lead    │  <-- Opus, plans work, assigns tasks
  └──────┬───────┘
         |
    ┌────┼────┐
    v    v    v
  [T1] [T2] [T3]   <-- Teammates (Sonnet/Haiku), each in tmux pane
    |    |    |
    v    v    v
  Shared task list + mailbox system
  Direct inter-agent messaging
  Dependencies: task A blocks task B

  Display: in-process OR tmux split panes
  Quality gates: TeammateIdle, TaskCompleted hooks


  Layer 3: AGENT SDK (programmatic)
  ─────────────────────────────────
  from claude_code import Agent, AgentDefinition

  agents = [
      Agent("planner", model="opus", tools=[...]),
      Agent("coder",   model="sonnet", tools=[...]),
      Agent("tester",  model="haiku",  tools=[...]),
  ]
  results = await asyncio.gather(*[a.run(task) for a in agents])

  Full control: hooks as callbacks, MCP, permissions, session resume


  Layer 4: GIT WORKTREES (manual)
  ───────────────────────────────
  claude -w feature-1  &  claude -w feature-2  &  claude -w feature-3
      |                       |                       |
      v                       v                       v
  .worktrees/feature-1   .worktrees/feature-2   .worktrees/feature-3
  (independent branch)   (independent branch)   (independent branch)

  Human merges when done. No coordination.

  Simon (human)
      |
      ├──> Claude Code (Sonnet 4.5)    <-- primary terminal agent
      ├──> Codex CLI (GPT-5-Codex)     <-- second terminal agent
      ├──> Claude Code for Web          <-- async, fire-and-forget
      ├──> Codex Cloud                  <-- async
      └──> Jules                        <-- async
           |
           v
      Each in separate terminal / browser tab
      Isolation: fresh /tmp checkouts per task
      No coordination framework -- human is the router

  ── tools ──────────────────────────
  llm CLI           <-- logs everything to SQLite, analyzed via Datasette
  files-to-prompt   <-- convert repo files to LLM context
  shot-scraper      <-- automated screenshots for visual testing

  dmux TUI
    |
    |──> press 'n'
    |
    v
  ┌─────────────────┐
  │ AI-generate slug │  <-- OpenRouter (gpt-4o-mini)
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Create git       │  <-- .dmux/worktrees/<slug>/
  │ worktree         │      full independent working copy
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Split tmux pane  │
  │ Launch agent     │  <-- claude/codex/opencode (--acceptEdits)
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Agent works      │  <-- status via LLM analysis of terminal (1s poll)
  │ autonomously     │
  └────────┬────────┘
           |
           v
  press 'm' to merge
           |
           v
  ┌─────────────────┐
  │ AI commit msg    │  <-- conventional commits via OpenRouter
  │ Merge to main    │
  │ Remove worktree  │
  └─────────────────┘

  Hooks: worktree_created, pre_merge, post_merge
  A/B mode: two agents, same prompt, side-by-side
  Web dashboard + REST API for programmatic control

  User prompt
      |
      v
  ┌─────────────────┐
  │ OpenClaw gateway │  <-- local-first, 50+ integrations
  │ (agent router)   │      messaging, coding, browser, etc.
  └────────┬────────┘
           |
     ┌─────┼─────┐
     v     v     v
  [Sub-1][Sub-2][Sub-3]  <-- sub-agent collaboration
     |     |     |         40% accuracy boost vs monolithic prompting
     └─────┼─────┘
           |
           v
  ┌─────────────────┐
  │ Output           │  <-- declarative agent config in YAML
  └─────────────────┘

  Not primarily a coding tool -- general-purpose AI assistant
  Can run with local models (Ollama + Llama 3.3) for $0/mo
  Will remain open source under OpenAI stewardship

  Create ticket (informal)
      |
      v
  ┌─────────────────┐
  │ Launch N agents  │  <-- each in isolated cloud container
  │ on same ticket   │      (Modal / Morph Cloud)
  └────────┬────────┘
           |
     ┌─────┼─────┐
     v     v     v
  [Agent1][Agent2][Agent3]   <-- Claude/Codex/Amp/Gemini
     |     |     |
     v     v     v
  [Live] [Live] [Live]      <-- browser previews ~30s
  [prev] [prev] [prev]
     |     |     |
     └─────┼─────┘
           |
           v
  ┌─────────────────┐
  │ Compare previews │  <-- visual diff, interact with each
  │ Select best      │
  │ One-click PR     │
  └─────────────────┘

  ┌─────────────────┐
  │ Refinery         │  <-- reverse-engineer codebase into knowledge graph
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Planner          │  <-- AI generates migration/transformation plans
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Foundry          │  <-- specialized agents execute plan
  │ (agent workers)  │      across multiple repos
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Validator        │  <-- quality gate, CI, tests
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Factory Line     │  <-- full pipeline for enterprise
  │ output: PRs      │      code modernization at scale
  └─────────────────┘

  Create task (web / CLI / GitHub / Slack / mobile)
      |
      v
  ┌─────────────────┐
  │ Cloud sandbox    │  <-- isolated container, clone repo, create branch
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Agent works      │  <-- background, checkpoints pushed to GitHub
  │ autonomously     │      AI-generated commits
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ PR created       │  <-- automatic when done
  └────────┬────────┘
           |
           v
  Human reviews and merges

  DEAD: Codex reached 28% agent usage on Terragon within 1 month
        Native background agents made the wrapper unnecessary

  Long-form video input
      |
      v
  ┌─────────────────┐
  │ AI Moment        │  <-- "AI employee" 1: detect viral-worthy segments
  │ Detection        │
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Auto-Clipping    │  <-- "AI employee" 2-N: extract, reframe, caption
  │ + Captioning     │
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Branding +       │  <-- template application
  │ Formatting       │
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Multi-Platform   │  <-- TikTok, YouTube, Instagram, X, LinkedIn
  │ Scheduling       │
  └─────────────────┘

  Note: Specific agent breakdown from video tweet, not independently verified.
  The product itself IS the AI automation -- "employees" = AI pipeline stages.

What works across all setups:

1. ISOLATION     -- worktrees, containers, or separate sessions
                    agents must not conflict with each other

2. PLAN FIRST    -- Opus/expensive model plans, cheaper model executes
                    Boris: Plan Mode → auto-accept
                    Agent Teams: team lead plans, teammates execute

3. MEMORY        -- CLAUDE.md / AGENTS.md / progress.txt
                    errors documented so they never repeat
                    updated by the agent, not the human

4. VERIFICATION  -- automated tests, browser screenshots, self-review
                    humans review throughput, not individual lines

5. MODEL TIERING -- Opus for planning ($$$), Sonnet for coding ($$), Haiku for tests ($)
                    "correct answer costs less total iteration time than fast wrong ones"

What doesn't work:

1. NO TESTS      -- agents spiral without verification signals
2. NO MEMORY     -- same mistakes repeat across sessions
3. SHARED STATE  -- agents editing same files = merge hell
4. NO REVIEW     -- "vibe coding" produces unmaintainable code (Chollet, Karpathy)

  FREE / OSS:
    dmux (MIT)         -- monetizes separately via FormKit Pro
    OpenClaw (MIT)     -- Cloud tier planned $39/mo, creator joined OpenAI
    claude-flow (MIT)  -- reputation/consulting play
    Ralph/Compound (MIT) -- promotes Amp (Sourcegraph)
    Terragon (Apache-2.0) -- released on shutdown

  SAAS / COMMERCIAL:
    Superconductor     -- BYOK, undisclosed platform fee, early access
    8090               -- $200/seat/mo, $1M/yr managed delivery
    VugolaAI           -- free tier + crypto token (VGLA)

  PLATFORM:
    Claude Code        -- $200/mo Max plan or API usage (~$1B ARR)
    OpenAI Codex       -- subscription + API
    GitHub Agent HQ    -- Copilot subscription (multi-vendor agents)

  The trend: orchestration tools struggle to monetize when platforms
  add native multi-agent features (see: Terragon shutdown).
  Survivors either go enterprise (8090) or stay free and build community (dmux, OpenClaw).