Deep Research System Design - Claude-Flow + AgentDB Architecture

DEEP_RESEARCH_SYSTEM.md

Deep Research System Design

Goal: Build a research system that goes deeper than Perplexity using Claude

---

Problem Statement

Perplexity Deep Research excels at:

• Discovery & real-time web search
• • Cited, synthesized answers from the web
• • 3-5 iterative search passes
• • Exportable reports (PDF, Markdown)

Where we want to go deeper:

• Multi-stage reasoning with extended thinking
• • Cross-source validation and contradiction detection
• • Integration with internal knowledge (Google Workspace, docs)
• • Memory persistence across research sessions
• • Deeper source analysis (follow citation trails)
• • Higher quality synthesis and long-form output

---

Architecture Overview

Framework Stack

┌─────────────────────────────────────────────────────
                    USER INTERFACE                        
                                  (Claude Chat / API / Custom UI)             
                                  └────────────────────────────────────────────────
                                                              
                                                                                          
                                                                                          ┌──────────────────────────────────────────────────────
                                                                                                              CLAUDE-FLOW v2.7                      
                                                                                                                         Agent Orchestration Platform                   
                                                                                                                           ┌─  ┌─────  
                                                                                                                              Swarm Mgmt    Hive-Mind      25 Claude Skills  
                                                                                                                                 64 Agents     Coordination   Natural Lang      
                                                                                                                                   └────  └──  
                                                                                                                                   └─────────────────────────────────────────
                                                                                                                                                               
                                                                                                                                                                                           
                                                                                                                                                                                           ┌────────────────────────────────────
                                                                                                                                                                                                                 AGENTDB v1.3.9                      
                                                                                                                                                                                                                            High-Performance Memory & Vector DB            
                                                                                                                                                                                                                              ┌───────  ┌─────────────────  
                                                                                                                                                                                                                                 Vector        Semantic       RAG Engine        
                                                                                                                                                                                                                                    Search 96x    Memory         Document Index    
                                                                                                                                                                                                                                      └──  └──────────  
                                                                                                                                                                                                                                      └───────────────────────
                                                                                                                                                                                                                                                                  │
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              ┌───────────────────────────────
                                                                                                                                                                                                                                                                                                                  MCP CONNECTORS                        
                                                                                                                                                                                                                                                                                                                    ┌──────  ┌─────────┐    
                                                                                                                                                                                                                                                                                                                      Web Search Academic  Google    Custom APIs     
                                                                                                                                                                                                                                                                                                                        Brave/etc Semantic  Workspace Domain-spec     
                                                                                                                                                                                                                                                                                                                          └───────   └──   
                                                                                                                                                                                                                                                                                                                          └──────────────────────────────────────────────────
                                                                                                                                                                                                                                                                                                                          ```
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ---
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ##  Key Components
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ### 1. Claude-Flow (ruvnet/claude-flow)
                                                                                                                                                                                                                                                                                                                          **Role:** Agent orchestration and coordination
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          **Key Features for Deep Research:**
                                                                                                                                                                                                                                                                                                                          - **Hive-Mind Intelligence**: Queen-led coordination for complex multi-step research
                                                                                                                                                                                                                                                                                                                          - **25 Claude Skills**: Natural language activation for research tasks
                                                                                                                                                                                                                                                                                                                          - **100 MCP Tools**: Comprehensive toolkit for automation
                                                                                                                                                                                                                                                                                                                          - **Swarm Orchestration**: Parallel research agents (researcher, analyst, synthesizer)
                                                                                                                                                                                                                                                                                                                          - **Session Persistence**: Resume research across sessions
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          **Research-Relevant Skills:**
                                                                                                                                                                                                                                                                                                                          - `pair-programming`  adapt for pair-research
                                                                                                                                                                                                                                                                                                                          - `github-code-review`  adapt for source review
                                                                                                                                                                                                                                                                                                                          - `agentdb-vector-search`  semantic memory search
                                                                                                                                                                                                                                                                                                                          - `swarm-orchestration`  multi-agent research coordination
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ### 2. AgentDB (louloulin/AgentDB)  
                                                                                                                                                                                                                                                                                                                          **Role:** Memory, vector search, and RAG
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          **Performance Stats:**
                                                                                                                                                                                                                                                                                                                          - Vector Search: 22ms (5x faster than target)
                                                                                                                                                                                                                                                                                                                          - Semantic Search: 17ms (3x faster than target)
                                                                                                                                                                                                                                                                                                                          - 96x-164x faster than alternatives
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          **Key Features:**
                                                                                                                                                                                                                                                                                                                          - **HNSW Indexing**: O(log n) vector search
                                                                                                                                                                                                                                                                                                                          - **9 RL Algorithms**: Q-Learning, PPO, MCTS, Decision Transformer
                                                                                                                                                                                                                                                                                                                          - **Reflexion Memory**: Learn from past research patterns
                                                                                                                                                                                                                                                                                                                          - **Skill Library**: Auto-consolidate successful research strategies
                                                                                                                                                                                                                                                                                                                          - **Quantization**: 4-32x memory reduction
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ### 3. MCP Connectors (To Build/Integrate)
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          **Required Connectors:**
                                                                                                                                                                                                                                                                                                                          ```
                                                                                                                                                                                                                                                                                                                          [ ] Web Search API (Brave, Tavily, Serper)
                                                                                                                                                                                                                                                                                                                          [ ] Academic Search (Semantic Scholar, arXiv, PubMed)
                                                                                                                                                                                                                                                                                                                          [ ] Google Workspace (Gmail, Docs, Calendar)
                                                                                                                                                                                                                                                                                                                          [ ] Document Processing (PDF, DOCX extraction)
                                                                                                                                                                                                                                                                                                                          [ ] Citation Graph API (follow reference trails)
                                                                                                                                                                                                                                                                                                                          ```
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ---
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ##  Research Pipeline Design
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          ### Phase 1: Query Decomposition
                                                                                                                                                                                                                                                                                                                          ```
                                                                                                                                                                                                                                                                                                                          User Query  Claude Extended Thinking  Sub-questions
                                                                                                                                                                                                                                                                                                                                                                 Research angles
                                                                                                                                                                                                                                                                                                                                                                                                        Source types needed
                                                                                                                                                                                                                                                                                                                                                                                                                                               Depth parameters
                                                                                                                                                                                                                                                                                                                                                                                                                                               ```
                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Phase 2: Parallel Discovery (Swarm)
                                                                                                                                                                                                                                                                                                                                                                                                                                               ```
                                                                                                                                                                                                                                                                                                                                                                                                                                               ┌─
                                                                                                                                                                                                                                                                                                                                                                                                                                                 QUEEN AGENT      Coordinates research strategy
                                                                                                                                                                                                                                                                                                                                                                                                                                                 └─
                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ┌
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ┌──  ┌──────── 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             Web      Academic Internal │Expert  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             Searcher Searcher Doc      Source  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Searcher Finder  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               └────────   └──────
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Phase 3: Cross-Validation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Sources  Claim Extraction  Cross-Reference Matrix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Contradiction Detection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Confidence Scoring
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Source Quality Weighting
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ### Phase 4: Deep Analysis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Validated Claims  Extended Thinking Analysis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Follow citation trails (depth 2-3)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       Identify gaps in knowledge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         Generate follow-up searches
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ### Phase 5: Synthesis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         Analyzed Content  Structured Report Generation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           Inline Citations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             Confidence Annotations
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Export (Markdown, PDF, Notion)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ---
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ##  Differentiators vs Perplexity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Feature | Perplexity | Our System |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |---------|------------|------------|
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Search Passes | 3-5 | Unlimited (depth parameter) |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Source Types | Web | Web + Academic + Internal + Custom |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Memory | Session only | Persistent (AgentDB) |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Reasoning | Hidden | Extended thinking visible |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Contradictions | Not surfaced | Explicit detection |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Citation Depth | 1 level | Follow trails 2-3 deep |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Learning | None | Reflexion memory, skill consolidation |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Customization | Fixed | MCP connectors, custom agents |
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ---
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ##  Implementation Roadmap
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Phase 1: Foundation (Week 1-2)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Install claude-flow v2.7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Configure AgentDB integration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Set up basic MCP connectors (web search)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Test swarm orchestration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Phase 2: Research Agents (Week 3-4)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Create specialized research agents
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Implement query decomposition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Build cross-validation logic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Add citation trail following
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Phase 3: Memory & Learning (Week 5-6)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Configure reflexion memory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Implement skill consolidation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Add research pattern learning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Session persistence
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Phase 4: Quality & Output (Week 7-8)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Source quality scoring
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Contradiction detection UI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Report generation templates
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Export formats
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ---
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ##  Quick Start Commands
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ```bash
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # Install claude-flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha init --force
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # Set up AgentDB
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npm install [email protected]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # Initialize research swarm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha swarm init --topology mesh --max-agents 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # Spawn research agents
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha swarm spawn researcher "deep research on [topic]"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha swarm spawn analyst "cross-validate findings"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha swarm spawn synthesizer "compile final report"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # Use hive-mind for complex research
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha hive-mind spawn "comprehensive research on [topic]" --claude
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # Query memory
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha memory vector-search "previous research on [topic]" --k 10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               # Store research findings
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               npx claude-flow@alpha memory store-vector research_findings "key insights" --namespace research
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ```
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ---
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ##  Notes & Ideas
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Open Questions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Best web search API for research quality?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] How to handle rate limits across multiple sources?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] Optimal swarm topology for research tasks?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - [ ] How to measure research quality/depth?
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ### Future Enhancements
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - Real-time collaboration mode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - Research template library
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - Domain-specific knowledge bases
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - Quality benchmarking system
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ---
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ##  Resources
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - **claude-flow**: https://github.com/ruvnet/claude-flow
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - **AgentDB**: https://github.com/louloulin/AgentDB
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - **Claude Research (official)**: https://claude.com/blog/research
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               - **MCP Protocol**: https://modelcontextprotocol.io
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ---
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               *Last Updated: December 2024*
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               *Status: Design Phase*