2 posts tagged with "ai-agents"

  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).

  Slack msg / CLI / auto-trigger
          |
          v
  ┌─────────────────┐
  │  Warm Devbox     │  <-- EC2, pre-cloned repo, ~10s ready
  │  (isolated)      │      no internet, no prod access
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │  Blueprint       │  <-- state machine: deterministic + agentic nodes
  │  Orchestration   │
  └────────┬────────┘
           |
     ┌─────┴──────┐
     |             |
     v             v
  [Agentic]    [Deterministic]
  "Implement"  "Run linters"
  "Fix CI"     "Push changes"
     |             |
     └─────┬───────┘
           |
           v
  ┌─────────────────┐
  │  Local Lint      │  <-- heuristic, <5s
  │  (shift left)    │
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │  CI: selective   │  <-- from 3M+ tests, only relevant
  │  test run        │
  └────────┬────────┘
           |
      pass? ──no──> autofix? ──yes──> apply, retry once
           |                    no──> hand to human
          yes
           |
           v
  ┌─────────────────┐
  │  PR created      │  <-- follows Stripe PR template
  │  (human review)  │
  └─────────────────┘

  Engineer writes prompt
          |
          v
  ┌─────────────────┐
  │  Codex agent     │  <-- reads AGENTS.md (table of contents, ~100 lines)
  │  (isolated       │      walks dir tree root -> CWD
  │   worktree)      │      loads docs/ as needed (progressive disclosure)
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │  Work depth-     │  <-- break goal into building blocks
  │  first           │      design -> code -> test -> review
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │  Custom linters  │  <-- Codex-written, error msgs include remediation
  │  (architectural  │      enforce layer deps, naming, file size
  │   constraints)   │
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │  Agent self-     │  <-- review own changes
  │  review          │      request additional agent reviews
  │                  │      respond to feedback, iterate
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │  Agent-to-agent  │  <-- humans optional in review
  │  review loop     │      squash & merge when satisfied
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │  PR merged       │
  └─────────────────┘

  ── background ──────────────────────
  "Garbage collection" agents run periodically:
    - scan for stale docs
    - detect architectural violations
    - open fix-up PRs
  "Doc-gardening" agent:
    - cross-link and validate knowledge base

  prd.json (task inventory)
  prompt.md (instructions)
  AGENTS.md (conventions)
          |
          v
  while stories remain:
          |
          v
    ┌───────────────┐
    │ Agent picks    │  <-- reads prd.json, selects next by priority
    │ next story     │
    └───────┬───────┘
            |
            v
    ┌───────────────┐
    │ Implement      │  <-- single context window per story
    └───────┬───────┘
            |
            v
    ┌───────────────┐
    │ Typecheck +    │  <-- must be fast, "broken code compounds"
    │ Tests          │
    └───────┬───────┘
            |
       pass? ──no──> skip, log failure
            |
           yes
            |
            v
    ┌───────────────┐
    │ Auto-commit    │
    │ Mark story     │
    │ done           │
    └───────┬───────┘
            |
            v
    ┌───────────────┐
    │ Append to      │  <-- pattern accumulation
    │ progress.txt   │      by iteration 10, agent understands patterns
    └───────┬───────┘
            |
            └──> next iteration

  ── code review layer (Code Factory) ──
  Risk tiers:
    Low    -> fully automated merge
    Medium -> automated with CI gates
    High   -> require human confirmation

  Review agent validates PR:
    - review state must match current HEAD SHA
    - evidence: tests + browser recording + review
    - auto-resolve only bot-only stale threads

  dmux TUI
    |
    |──> press 'n'
    |
    v
  ┌─────────────────┐
  │ Generate slug    │  <-- AI-generated branch name via OpenRouter
  └────────┬────────┘
           |
           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 detected via LLM analysis of terminal
  │ autonomously     │      polls every 1s
  └────────┬────────┘
           |
           v
  press 'm' to merge
           |
           v
  ┌─────────────────┐
  │ AI commit msg    │  <-- conventional commits via OpenRouter
  │ Merge to main    │
  │ Remove worktree  │
  └─────────────────┘

  Hooks fire at each stage:
    worktree_created -> e.g. pnpm install
    pre_merge        -> e.g. run tests
    post_merge       -> e.g. git push, close issue

  Create ticket (informal description)
          |
          v
  ┌─────────────────┐
  │ Launch N agents  │  <-- each gets isolated container
  │ on same ticket   │      full repo, dev tools, test runners
  └────────┬────────┘
           |
     ┌─────┼─────┐
     v     v     v
  [Agent1][Agent2][Agent3]   <-- Claude/Codex/Amp/Gemini
     |     |     |
     v     v     v
  [Live] [Live] [Live]      <-- browser previews appear ~30s
  [prev] [prev] [prev]
     |     |     |
     └─────┼─────┘
           |
           v
  ┌─────────────────┐
  │ Compare previews │  <-- interact with each, test functionality
  │ Diff viewer      │      audit code changes across agents
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Select best      │
  │ One-click PR     │
  └─────────────────┘

  Create task (any interface)
          |
          v
  ┌─────────────────┐
  │ Spawn cloud      │  <-- fresh isolated container
  │ sandbox          │      clone repo, create branch
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Agent executes   │  <-- writes code, runs tests, iterates
  │ autonomously     │      checkpoints pushed to GitHub
  │ (background)     │      AI-generated commits
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ PR created       │  <-- automatic when agent finishes
  │ automatically    │
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Human reviews    │  <-- dashboard, CLI, or GitHub
  │ and merges       │
  └─────────────────┘

  If agent struggles:
    "Abandon and retry with different instructions"
    (more effective than course-correcting)

  Task queue
      |
      v
  ┌─────────────────┐
  │ Orchestrator     │  <-- "K8s for agents"
  │ (Gas Town)       │
  └────────┬────────┘
           |
     ┌─────┼─────┼─────┐
     v     v     v     v
  [Agent][Agent][Agent][Agent] ... x20-30
     |     |     |     |
     v     v     v     v
  [Git-backed persistent state]
           |
           v
  ┌─────────────────┐
  │ Merge queue      │  <-- conflict resolution between agents
  └────────┬────────┘
           |
           v
  ┌─────────────────┐
  │ Patrol agents    │  <-- quality control watchdogs
  └────────┬────────┘
           |
           v
  merged to main

All systems follow roughly the same skeleton:

  trigger (human or automated)
      |
      v
  isolate (worktree / container / devbox)
      |
      v
  agent works (agentic + deterministic nodes)
      |
      v
  fast feedback (lint / typecheck / tests -- shift left)
      |
      v
  quality gate (CI / agent review / live preview / patrol)
      |
      v
  output (PR / branch / merged code)
      |
      v
  human decision point (review / select / merge / abandon)