Multi-Agent Orchestration

# In your main agent session, spawn a research sub-agent:
sessions_spawn(
  task: "Research the top 5 AI agent frameworks. 
         Compare features, pricing, community size. 
         Save findings to knowledge/research/frameworks.md",
  model: "sonnet",
  mode: "run"  # one-shot: runs task and returns result
)

# Spawn a content sub-agent:
sessions_spawn(
  task: "Read knowledge/research/frameworks.md. 
         Draft a Twitter thread comparing them. 
         Save to content/drafts/frameworks-thread.md",
  model: "sonnet",
  mode: "run"
)

# Main agent reviews both outputs and publishes

# Create separate Claude Projects for each "agent":

Project: "Research Agent"
  - Instructions: "You are a research analyst. 
    Your job is to find data and write briefs."
  - Upload: industry reports, competitor lists

Project: "Content Agent"  
  - Instructions: "You are a content writer. 
    You write in [my voice]. Never be corporate."
  - Upload: tacit.md, brand guidelines, past posts

# Workflow:
# 1. Ask Research Agent to investigate topic
# 2. Copy findings into Content Agent conversation
# 3. Content Agent drafts posts
# 4. You review and post

# With Claude Code CLI (true multi-agent):
# Run separate Claude Code instances in different 
# terminal tabs, each with different system prompts

# Create Custom GPTs:

GPT: "Market Researcher"
  Instructions: "You research markets. You use 
  browsing to find real data. Output structured 
  markdown reports."

GPT: "Content Writer"
  Instructions: "You write social media content. 
  You match [voice examples]. You output 
  platform-ready drafts."

GPT: "Code Reviewer"
  Instructions: "You review code for bugs, 
  security issues, and best practices. 
  You are brutally honest."

# API orchestration (Python):
import openai

# Step 1: Research
research = openai.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": researcher_prompt},
        {"role": "user", "content": "Research AI agents market"}
    ]
)

# Step 2: Content (uses research output)
content = openai.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": writer_prompt},
        {"role": "user", "content": f"Write a thread based on: {research}"}
    ]
)

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Market Research Analyst",
    goal="Find validated business opportunities",
    backstory="You're a veteran analyst who reads Reddit, "
              "Twitter, and HN to find pain points.",
    tools=[SearchTool(), WebScrapeTool()],
    llm="claude-sonnet-4-20250514"
)

writer = Agent(
    role="Content Strategist",
    goal="Turn research into engaging content",
    backstory="You write punchy, no-BS content that "
              "sounds human, not corporate.",
    llm="gpt-4o"
)

# Define tasks
research_task = Task(
    description="Find 5 pain points in the AI agent space",
    agent=researcher,
    expected_output="Markdown report with quotes and sources"
)

content_task = Task(
    description="Write a Twitter thread from the research",
    agent=writer,
    expected_output="Thread draft, 5-7 tweets",
    context=[research_task]  # Depends on research output
)

# Run the crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, content_task],
    verbose=True
)

result = crew.kickoff()

from langchain.agents import initialize_agent, Tool
from langchain.chat_models import ChatOpenAI

# Create specialized chains
research_llm = ChatOpenAI(model="gpt-4o", temperature=0)
content_llm = ChatOpenAI(model="gpt-4o", temperature=0.7)

# Define tools for research agent
tools = [
    Tool(name="Search", func=search_tool, 
         description="Search the web for information"),
    Tool(name="ReadReddit", func=reddit_tool,
         description="Read Reddit posts and comments"),
]

# Research agent
researcher = initialize_agent(
    tools, research_llm, 
    agent="zero-shot-react-description",
    verbose=True
)

# Pipeline: research → content
research_output = researcher.run(
    "Find pain points about AI agents on Reddit"
)
content_output = content_llm.predict(
    f"Write a thread based on: {research_output}"
)

# n8n Workflow: Research → Draft → Approve → Post

Node 1: Schedule Trigger (7 AM daily)
  ↓
Node 2: HTTP Request → Search Twitter API
  ↓
Node 3: AI Agent (OpenAI) → "Analyze these tweets. 
         Find 3 trending topics in [niche]."
  ↓
Node 4: AI Agent (Claude) → "Write 3 tweet drafts 
         about the top topic. Voice: [examples]."
  ↓
Node 5: Slack Message → Send drafts to #content-review
  ↓
Node 6: Wait for Approval (Slack reaction ✅)
  ↓
Node 7: HTTP Request → Post to Twitter API

# Make.com: Same flow, drag-and-drop modules
# Zapier: Same concept, but use "Paths" for branching

# Project Memory Architecture

## Knowledge Base (always available)
- /docs/architecture.md — system design decisions
- /docs/api-spec.md — API contracts
- /docs/patterns.md — preferred code patterns

## Decision Protocols
- New component? → Use shadcn/ui + Tailwind
- State management? → Zustand for client, React Query for server
- Database? → Convex (dev) / Postgres (production)
- Testing? → Vitest + Playwright

## Tacit Knowledge (my preferences)
- I prefer composition over inheritance
- Use named exports, not default exports
- Error messages should be user-friendly
- Comments explain WHY, not WHAT
- Keep functions under 50 lines

## Multi-Agent Setup
- Tab 1: "Architect" — designs components, writes interfaces
- Tab 2: "Builder" — implements from architect's design
- Tab 3: "Reviewer" — reviews builder's code, catches bugs