Under the Hood

WhiteSpaceIQ/
├── backend/
│   ├── src/
│   │   ├── agents/          # Three specialized agents
│   │   │   ├── research_coordinator.py
│   │   │   ├── strategic_analyzer.py
│   │   │   └── insight_validator.py
│   │   ├── builders/        # Phase builders (1-5)
│   │   ├── services/        # Orchestration services
│   │   ├── templates/       # Jinja2 templates
│   │   └── main.py         # FastAPI application
│   └── data/
│       ├── foundations/    # Locked brand foundations
│       └── outputs/        # Generated audits
└── frontend/
    ├── components/         # React components
    ├── pages/             # Next.js pages
    └── services/          # API integration

# Foundation elements that get locked
foundation = {
    "brand_essence": {
        "mission": "User-provided mission",
        "vision": "User-provided vision",
        "values": ["integrity", "innovation", "impact"]
    },
    "voice_parameters": {
        "tone": "rebellious",  # Locked parameter
        "stance": "direct",    # Locked parameter
        "ethic": "human_first" # Locked parameter
    }
}

# Agents share context and can disagree
class AgentOrchestrator:
    async def orchestrate(self, context: SharedContext):
        research = await self.research_agent.gather(context)
        
        # Strategy agent reads research
        strategy = await self.strategy_agent.compose(
            research=research,
            foundation=context.foundation_lock
        )
        
        # Validation can reject and loop
        while not self.validator.approve(strategy):
            feedback = self.validator.get_feedback()
            strategy = await self.strategy_agent.revise(
                feedback=feedback,
                foundation=context.foundation_lock
            )
            
        return strategy

from langgraph.graph import StateGraph, END

# Define the agent graph
workflow = StateGraph(AgentState)

# Add nodes for each agent
workflow.add_node("research", research_agent)
workflow.add_node("strategy", strategy_agent)
workflow.add_node("validation", validation_agent)

# Define edges with conditional logic
workflow.add_edge("research", "strategy")
workflow.add_conditional_edges(
    "strategy",
    lambda x: "validation" if x["ready"] else "strategy"
)
workflow.add_conditional_edges(
    "validation",
    lambda x: END if x["approved"] else "strategy"
)

class FoundationLock:
    """Immutable brand voice parameters"""
    
    def __init__(self, brand_profile: BrandProfile):
        self.tone = brand_profile.tone  # e.g., "rebellious"
        self.stance = brand_profile.stance  # e.g., "direct"
        self.ethic = brand_profile.ethic  # e.g., "human_first"
        self._locked = True
        
    def validate_content(self, content: str) -> ValidationResult:
        """Check if content matches locked foundation"""
        
        tone_score = self.measure_tone_alignment(content)
        stance_score = self.measure_stance_alignment(content)
        ethic_score = self.measure_ethic_alignment(content)
        
        overall_score = (tone_score + stance_score + ethic_score) / 3
        
        return ValidationResult(
            passed=overall_score >= 0.9,  # 90% threshold
            score=overall_score,
            feedback=self.generate_feedback(content)
        )

# API Keys
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...

# Database
DATABASE_URL=postgresql://user:pass@localhost/whitespaceiq
PGVECTOR_EXTENSION=true

# Application
ENVIRONMENT=development
DEBUG=true
SECRET_KEY=your-secret-key

# Model Configuration
PRIMARY_MODEL=gpt-4-turbo-preview
VALIDATION_MODEL=claude-3-opus
EMBEDDING_MODEL=text-embedding-3-large

{
  "business_context": {
    "company_name": "Example Corp",
    "industry": "Technology",
    "target_audience": "B2B SaaS buyers"
  },
  "brand_voice": {
    "tone": "rebellious",
    "stance": "direct",
    "ethic": "human_first"
  },
  "audit_focus": [
    "competitive_analysis",
    "market_positioning",
    "growth_opportunities"
  ]
}