diff --git a/MySuperAgent_Technical_Deep_Dive.md b/MySuperAgent_Technical_Deep_Dive.md
new file mode 100644
index 00000000..c46fba48
--- /dev/null
+++ b/MySuperAgent_Technical_Deep_Dive.md
@@ -0,0 +1,1096 @@
+# Building MySuperAgent: A Deep Dive into Modern AI Orchestration
+
+**Or: How We Built an Agent Platform That Actually Works**
+
+*A technical exploration of orchestration layers, intelligent agent routing, and the architecture that makes multi-agent systems practical.*
+
+---
+
+## Introduction: The Orchestration Problem
+
+Building a single AI agent is relatively straightforward in 2025. But what happens when you need 40+ specialized agents working together? What happens when users want to connect their own tools via Model Context Protocol (MCP)? What happens when agents need to communicate with each other across networks (A2A)?
+
+You get chaos. Unless you build proper orchestration.
+
+MySuperAgent is a Next.js-based AI platform that solves this orchestration problem with an elegant, user-centric approach. At its core, it's a system that intelligently routes user requests to the right agent(s), manages external tool integrations, and provides complete transparency into what's happening under the hood.
+
+Let's dive deep into how it works.
+
+---
+
+## The Star of the Show: The Orchestration Layer
+
+### The Problem Space
+
+Imagine you have:
+- 40+ core agents (code, research, data analysis, crypto, social media, etc.)
+- User-specific MCP tools (Reddit, Brave Search, YouTube transcripts, etc.)
+- External A2A agents (connected via Agent-to-Agent protocol)
+- Users who may or may not know which agent they need
+
+How do you route requests efficiently? How do you avoid the "default agent handles everything poorly" problem?
+
+### The Solution: Intelligent Multi-Tier Orchestration
+
+MySuperAgent's orchestrator (`app/services/agents/orchestrator/index.ts`) implements a sophisticated multi-tier selection strategy:
+
+```typescript
+async runOrchestration(request: ChatRequest, walletAddress?: string): Promise<[string, AgentResponse]> {
+  // Tier 1: User-Selected Agents (if specified)
+  if (request.selectedAgents && request.selectedAgents.length > 0) {
+    // Try user's explicit choices first
+    for (const agentName of request.selectedAgents) {
+      selectedAgent = await AgentRegistry.getForRequest(agentName, this.requestId);
+      if (selectedAgent) {
+        selectionReasoning = `User-selected agent: ${agentName}`;
+        break;
+      }
+    }
+  }
+
+  // Tier 2: LLM-Based Intelligent Selection
+  if (!selectedAgent) {
+    const selectionResult = await AgentRegistry.selectBestAgentWithLLM(
+      request.prompt.content,
+      walletAddress
+    );
+    selectedAgent = selectionResult.agent;
+    selectionReasoning = selectionResult.reasoning;
+  }
+
+  // Tier 3: Default Fallback
+  if (!selectedAgent) {
+    selectedAgent = await AgentRegistry.getForRequest('default', this.requestId);
+    selectionReasoning = 'Default agent fallback';
+  }
+}
+```
+
+### What Makes This Impressive
+
+1. **LLM-Powered Agent Selection**: Instead of hardcoded routing rules, the system uses GPT-4o-mini to analyze the user's request and match it to the best agent. The prompt includes:
+   - All available agents with descriptions and capabilities
+   - User-specific MCP tools (if connected)
+   - User-specific A2A agents (if connected)
+   - Task requirements
+
+2. **User-Aware Context**: When a user has connected their own MCP servers or A2A agents, those become part of the agent pool for selection. This means your personal Reddit MCP tool can be intelligently selected for Reddit-related queries.
+
+3. **Retry with Exponential Backoff**: Network issues? The orchestrator automatically retries up to 3 times with exponential backoff (1s, 2s, 4s delays):
+
+```typescript
+async runOrchestrationWithRetry(request: ChatRequest, walletAddress?: string, maxRetries: number = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await this.executeOrchestration(request, walletAddress);
+    } catch (error) {
+      const waitTime = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+    }
+  }
+}
+```
+
+4. **Rich Metadata Generation**: Every orchestration response includes comprehensive metadata:
+   - Selected agent name and type (core/mcp/a2a)
+   - Selection reasoning ("Best match for cryptocurrency analysis tasks")
+   - Available agents list
+   - Performance metrics (tokens, timing)
+   - Whether user-specific agents were considered
+
+This metadata powers the beautiful UI visualization we'll see later.
+
+### The Non-Streaming API
+
+While many systems focus exclusively on streaming responses, MySuperAgent also provides a direct orchestration endpoint (`/api/v1/chat/orchestrate`) for more reliable, metadata-rich responses:
+
+```typescript
+// Key features:
+// - Timeout management (5 min total, 30s for selection, 4min for execution)
+// - Agent initialization with proper caching
+// - Per-request orchestrator instances (no singleton issues)
+// - Comprehensive error handling with safe error responses
+// - Automatic failure metrics tracking
+```
+
+This dual approach (streaming + non-streaming) gives the best of both worlds: real-time feedback for long tasks and reliability for critical operations.
+
+---
+
+## The Agent Architecture: Modular and Extensible
+
+### The Agent Registry: Central Nervous System
+
+The `AgentRegistry` (`app/services/agents/core/agent-registry.ts`) is a 1,138-line masterpiece that manages:
+
+1. **Lazy Loading**: Core agents (default, research) load immediately. Specialized agents load on-demand:
+
+```typescript
+this.registerLazy('crypto_data_backend', async () => {
+  const { CryptoDataAgentBackend } = await import('@/services/agents/agents/mcp-agents');
+  return new CryptoDataAgentBackend();
+}, 'Provides cryptocurrency market data, price analysis, and blockchain information');
+```
+
+2. **User-Specific Agent Pools**: Gets available agents for a specific user, including their MCP tools and A2A agents:
+
+```typescript
+async getUserAvailableAgents(walletAddress: string): Promise<Array<{
+  name: string;
+  description: string;
+  type: 'core' | 'mcp' | 'a2a';
+  capabilities?: string[];
+  status?: string;
+}>> {
+  const coreAgents = this.getAvailableAgents().map(agent => ({ ...agent, type: 'core' }));
+  const mcpTools = await this.getUserMCPTools(walletAddress);
+  const a2aAgents = await this.getUserA2AAgents(walletAddress);
+
+  return [...coreAgents, ...mcpAgents, ...a2aAgentsList];
+}
+```
+
+3. **Intelligent Caching**: User MCP tools and A2A agents are cached to avoid repeated database queries, with explicit refresh and cleanup methods.
+
+### The BaseAgent: Foundation for All Agents
+
+Every agent extends `BaseAgent` (`app/services/agents/core/base-agent.ts`), which provides:
+
+1. **Mastra Integration**: Built on top of [@mastra/core](https://github.com/mastra-ai/mastra), a powerful agent framework
+2. **Dynamic Tool Loading**: Agents can use static tools or dynamically load MCP tools
+3. **Anti-Repetition System**: Automatically detects similar previous prompts and injects instructions to avoid repetition:
+
+```typescript
+// When similar prompts are found:
+if (request.similarPrompts && request.similarPrompts.length > 0) {
+  finalContent = `🚨 CRITICAL: You MUST provide a COMPLETELY DIFFERENT response...` +
+    request.prompt.content +
+    request.similarityContext;
+}
+```
+
+4. **Structured Message Building**: Converts chat history and prompts into proper Mastra message format
+5. **Streaming Support**: Both `chat()` and `streamVNext()` methods for different use cases
+
+### The Agent Fleet: 40+ Specialized Agents
+
+The codebase includes an impressive array of specialized agents:
+
+**Core Agents** (4):
+- Default: General-purpose assistant
+- Research: Web search and information gathering
+- Code: Programming assistance and debugging
+- Data: Data analysis and visualization
+- Math: Mathematical computation
+
+**MCP Protocol Agents** (20+):
+- Crypto data analysis
+- Code analysis (Codex)
+- Social media sentiment (Elfa)
+- Rug pull detection
+- DEX screener data
+- News aggregation
+- Tweet generation
+- Image generation (Imagen)
+- RAG (Retrieval-augmented generation)
+- Reddit, Brave Search, Hacker News
+- Google Maps, Airbnb
+- YouTube transcripts
+- Puppeteer automation
+
+**Specialized Backend Agents** (15+):
+- Document analyzer
+- Web extraction
+- Instagram, TikTok, X (Twitter) analysts
+- Facebook, Reddit analysts
+- Social media intelligence
+- Business analyst
+- LinkedIn intelligence
+- Job market analyst
+- E-commerce analyst
+- Travel intelligence
+- Real estate analyst
+- YouTube analyst
+- Visual content creator
+- Content discovery
+
+Each agent is independently versioned, lazily loaded, and can be hot-swapped without affecting others.
+
+---
+
+## MCP Integration: The User's Personal Tool Belt
+
+### What is MCP?
+
+[Model Context Protocol](https://modelcontextprotocol.io/) is a standardized way to connect external tools and services to AI applications. Instead of hardcoding integrations, users can connect their own MCP servers.
+
+### How MySuperAgent Implements MCP
+
+The `UserMCPManager` (`app/services/mcp/user-mcp-manager.ts`) is a comprehensive 523-line service that handles:
+
+#### 1. Connection Management
+
+```typescript
+static async enableMCPServer(request: MCPConnectionRequest): Promise<MCPServerStatus> {
+  // 1. Validate server definition from registry
+  const serverDef = MCPServerRegistry.getServer(serverName);
+
+  // 2. Validate and encrypt user credentials
+  for (const [credName, credValue] of Object.entries(credentials)) {
+    await UserCredentialManager.storeCredential({
+      walletAddress,
+      serviceType: 'mcp_server',
+      serviceName: serverName,
+      credentialName: credName,
+      value: credValue,
+      masterKey // For encryption
+    });
+  }
+
+  // 3. Create MCP client and test connection
+  const mcpClient = await this.createMCPClient(serverDef, credentials);
+  const tools = await mcpClient.getTools();
+
+  // 4. Cache client for reuse
+  this.mcpClients.set(`${walletAddress}:${serverName}`, mcpClient);
+
+  // 5. Discover and store tools in database
+  await this.discoverAndCacheTools(walletAddress, mcpServer.id, mcpClient);
+}
+```
+
+#### 2. Health Monitoring
+
+The system continuously monitors MCP server health:
+- Periodic health checks with 5-second timeouts
+- Status tracking (healthy/error/timeout)
+- Automatic status updates in database
+- Tool availability tracking
+
+#### 3. Tool Discovery and Caching
+
+When an MCP server is connected:
+1. Tools are discovered via `mcpClient.getTools()`
+2. Tool schemas are stored in `user_available_tools` table (JSONB)
+3. Tools become available for agent selection
+4. LLM-based selection considers these tools
+
+#### 4. Secure Credential Management
+
+All credentials are:
+- Encrypted with user-specific master keys
+- Scoped to wallet addresses
+- Never exposed in plain text
+- Automatically used when executing tools
+
+#### 5. Tool Execution
+
+The `executeTool()` method handles the complexity of calling MCP tools with multiple fallback strategies:
+
+```typescript
+// Try multiple possible method names since MCP clients vary
+if (typeof client.callTool === 'function') {
+  result = await client.callTool(toolName, args);
+} else if (typeof client.executeTool === 'function') {
+  result = await client.executeTool(toolName, args);
+} else if (typeof client.runTool === 'function') {
+  result = await client.runTool(toolName, args);
+} else if (typeof client.invoke === 'function') {
+  result = await client.invoke(toolName, args);
+}
+```
+
+### Database Schema for MCP
+
+```sql
+CREATE TABLE user_available_tools (
+    id SERIAL PRIMARY KEY,
+    wallet_address VARCHAR(42) NOT NULL,
+    mcp_server_id VARCHAR(255) NOT NULL,
+    tool_name VARCHAR(255) NOT NULL,
+    tool_description TEXT,
+    tool_schema JSONB,  -- Full tool schema stored as JSON
+    is_available BOOLEAN DEFAULT true,
+    last_checked TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(wallet_address, mcp_server_id, tool_name)
+);
+```
+
+### The User Experience
+
+1. User goes to Settings → MCP Servers
+2. Selects an MCP server (e.g., "Reddit")
+3. Provides required credentials (API keys, tokens)
+4. System validates connection and discovers tools
+5. Tools automatically become available in agent selection
+6. When user asks a Reddit-related question, the orchestrator intelligently selects the Reddit MCP tool
+
+**This is powerful**: Users can extend the platform with their own tools without any code changes.
+
+---
+
+## A2A Integration: Agents Talking to Agents
+
+### What is A2A?
+
+Agent-to-Agent (A2A) communication allows MySuperAgent to connect with external agent networks. Think of it as federated agents - your local agent can delegate tasks to specialized agents running on other servers.
+
+### The A2A Manager
+
+The `UserA2AManager` (`app/services/a2a/user-a2a-manager.ts`) provides:
+
+#### 1. Agent Discovery
+
+```typescript
+static async discoverA2AAgents(serverUrl: string, walletAddress: string) {
+  const a2aClient = new A2AClient({
+    serverUrl,
+    agentId: `mysuperagent-${walletAddress}`,
+    agentName: 'MySuperAgent'
+  });
+
+  const agents = await a2aClient.discoverAgents();
+  // Returns array of A2AAgentCard with capabilities
+}
+```
+
+#### 2. Connection Management
+
+```typescript
+static async connectToA2AAgent(request: A2AConnectionRequest) {
+  // 1. Create A2A client for communication
+  const a2aClient = new A2AClient({ serverUrl, agentId, agentName });
+
+  // 2. Test connection by pinging
+  const pingResult = await a2aClient.pingAgent(agentCard.id);
+
+  // 3. Store agent info in database
+  await UserA2AAgentDB.addA2AAgent({
+    wallet_address,
+    agent_id: agentCard.id,
+    capabilities: agentCard.capabilities,
+    connection_status: pingResult ? 'connected' : 'disconnected'
+  });
+}
+```
+
+#### 3. Message & Task Exchange
+
+```typescript
+// Send a message to an external agent
+static async sendMessageToAgent(request: A2ACommunicationRequest) {
+  const a2aClient = await this.getA2AClient(walletAddress, targetAgentId);
+  const response = await a2aClient.sendMessage({ ...message, to: targetAgentId });
+  return response;
+}
+
+// Create a task for an external agent
+static async createTaskForAgent(request: A2ACommunicationRequest) {
+  const a2aClient = await this.getA2AClient(walletAddress, targetAgentId);
+  const taskResult = await a2aClient.createTask({ ...task, agentId: targetAgentId });
+  return taskResult;
+}
+```
+
+#### 4. Health Monitoring
+
+Similar to MCP, A2A agents have continuous health checks:
+- Periodic ping operations
+- Connection status tracking
+- Automatic reconnection attempts
+- Status updates in database
+
+### The A2A Database Schema
+
+```sql
+CREATE TABLE user_a2a_agents (
+    id SERIAL PRIMARY KEY,
+    wallet_address VARCHAR(42) NOT NULL,
+    agent_id VARCHAR(255) NOT NULL,
+    agent_name VARCHAR(255) NOT NULL,
+    agent_url VARCHAR(500) NOT NULL,
+    enabled BOOLEAN DEFAULT true,
+    connection_status VARCHAR(50) DEFAULT 'pending',
+    last_ping TIMESTAMP,
+    UNIQUE(wallet_address, agent_id)
+);
+```
+
+### Real-World Use Case
+
+Imagine a user asks: "Analyze market sentiment for Bitcoin across social media"
+
+1. The orchestrator sees the user has connected a "Social Media Intelligence" A2A agent
+2. LLM-based selection identifies this as the best match
+3. Task is delegated to the external agent
+4. External agent processes the request across multiple platforms
+5. Results stream back to MySuperAgent
+6. User sees comprehensive analysis without any manual routing
+
+---
+
+## The Database Architecture: Multi-Tenant by Design
+
+MySuperAgent uses PostgreSQL with a clean multi-tenant architecture. Key tables:
+
+### Jobs Table: The Core Unit of Work
+
+```sql
+CREATE TABLE jobs (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  wallet_address VARCHAR(42) NOT NULL REFERENCES users(wallet_address),
+  name VARCHAR(255) NOT NULL DEFAULT 'New Job',
+  description TEXT,
+  initial_message TEXT NOT NULL,
+  status VARCHAR(20) DEFAULT 'pending',  -- pending/running/completed/failed/cancelled
+
+  -- Scheduling support
+  is_scheduled BOOLEAN DEFAULT FALSE,
+  schedule_type VARCHAR(20),  -- once/daily/weekly/custom
+  schedule_time TIMESTAMP WITH TIME ZONE,
+  next_run_time TIMESTAMP WITH TIME ZONE,
+  interval_days INTEGER,
+  timezone VARCHAR(50) DEFAULT 'UTC'
+);
+```
+
+Each job represents an isolated conversation with its own message history, status, and optionally, a schedule.
+
+### Messages Table: Ordered Chat History
+
+```sql
+CREATE TABLE messages (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  job_id UUID NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+  role VARCHAR(10) NOT NULL,  -- user/assistant/system
+  content TEXT NOT NULL,
+  order_index INTEGER NOT NULL,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE(job_id, order_index)
+);
+```
+
+The `order_index` ensures messages stay in the correct order, even with concurrent operations.
+
+### Teams Table: Multi-Agent Workflows
+
+```sql
+CREATE TABLE teams (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  wallet_address VARCHAR(42) NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  description TEXT,
+  agent_configurations JSONB NOT NULL,  -- Array of agent configs
+  workflow_type VARCHAR(50) DEFAULT 'sequential',
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+Teams allow users to configure multiple agents to work together on complex tasks (though this feature is still being fleshed out).
+
+### User Preferences: Personalization
+
+```sql
+CREATE TABLE user_preferences (
+  wallet_address VARCHAR(42) PRIMARY KEY,
+  preferred_agents JSONB,  -- User's favorite agents
+  ui_theme VARCHAR(20) DEFAULT 'dark',
+  notification_settings JSONB,
+  similarity_threshold FLOAT DEFAULT 0.85,  -- For anti-repetition
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+### The Referrals System
+
+```sql
+CREATE TABLE referrals (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  referrer_wallet_address VARCHAR(42) NOT NULL,
+  referee_wallet_address VARCHAR(42) NOT NULL,
+  status VARCHAR(20) DEFAULT 'pending',  -- pending/completed/expired
+  reward_amount DECIMAL(18, 8),
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+Users can refer others and track rewards on-chain.
+
+### Failure Metrics: Continuous Improvement
+
+```sql
+CREATE TABLE failure_metrics (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  job_id UUID REFERENCES jobs(id),
+  wallet_address VARCHAR(42),
+  agent_name VARCHAR(255),
+  user_prompt TEXT NOT NULL,
+  assistant_response TEXT NOT NULL,
+  similarity_score FLOAT,
+  is_similar BOOLEAN DEFAULT FALSE,
+  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+The system tracks response quality and similarity to improve the anti-repetition system.
+
+### Database Query Optimization
+
+Key indexes ensure fast queries:
+
+```sql
+-- Efficient wallet-based lookups
+CREATE INDEX idx_user_available_tools_wallet ON user_available_tools(wallet_address);
+CREATE INDEX idx_user_a2a_agents_wallet ON user_a2a_agents(wallet_address);
+
+-- Status-based filtering
+CREATE INDEX idx_jobs_status ON jobs(status);
+CREATE INDEX idx_user_a2a_agents_status ON user_a2a_agents(connection_status);
+
+-- Scheduled job queries
+CREATE INDEX idx_jobs_scheduled ON jobs(is_scheduled, is_active, next_run_time)
+  WHERE is_scheduled = TRUE;
+```
+
+---
+
+## The Frontend: Transparency and Beauty
+
+### The CrewResponseMessage Component
+
+This is where orchestration metadata becomes visual art. The component (`app/components/Agents/Crew/CrewResponseMessage.tsx`) renders:
+
+#### 1. Agent Intelligence Panel
+
+Shows which agent was selected and why:
+
+```jsx
+<Box bg="gray.850" borderRadius="md" p={3}>
+  <Badge colorScheme="blue">
+    {selectedAgent.replace(/_/g, ' ')}
+  </Badge>
+
+  <Text fontSize="sm" color="gray.300" fontStyle="italic">
+    "{selectionReasoning}"
+  </Text>
+</Box>
+```
+
+Example output:
+> **Selected Agent**: crypto_data_backend
+> _"Best match for cryptocurrency market analysis tasks. This agent specializes in real-time blockchain data and DeFi analytics."_
+
+#### 2. Agent Type & Pool Information
+
+```jsx
+<Badge colorScheme={agentType === 'core' ? 'purple' : 'green'}>
+  {agentType}
+</Badge>
+
+<Badge colorScheme={userSpecificAgents ? 'green' : 'gray'}>
+  {userSpecificAgents ? 'Personal + System' : 'System Only'}
+</Badge>
+```
+
+Users can see at a glance whether their personal MCP/A2A agents were considered.
+
+#### 3. Orchestration Flow Visualization
+
+The component renders a beautiful step-by-step visualization of the orchestration process:
+
+```jsx
+{metadata.subtask_outputs.map((subtask, idx) => (
+  <Box key={idx}>
+    <Circle size="40px" bg="blue.500">
+      {idx + 1}
+    </Circle>
+
+    <Box>
+      <Text fontWeight="semibold">{subtask.subtask}</Text>
+      <CompactTaskOutput content={subtask.output} />
+
+      {/* Telemetry */}
+      <HStack>
+        <Icon as={FaClock} />
+        <Text>{subtask.telemetry.processing_time.duration}s</Text>
+
+        <Icon as={FaMemory} />
+        <Text>{subtask.telemetry.token_usage.total_tokens} tokens</Text>
+      </HStack>
+    </Box>
+  </Box>
+))}
+```
+
+Each step shows:
+- Step number
+- Task description
+- Task output (expandable)
+- Agent(s) involved
+- Processing time
+- Token usage
+
+#### 4. Typing Animation
+
+New responses use a smooth typing animation:
+
+```typescript
+// Calculate typing speed to complete in ~0.8-1.2 seconds
+const typingDuration = Math.min(1000, Math.max(800, totalLength * 3));
+const charsPerInterval = Math.max(1, Math.ceil(totalLength / (typingDuration / 16)));
+
+animationIntervalRef.current = window.setInterval(() => {
+  currentLength += charsPerInterval;
+  if (currentLength >= totalLength) {
+    setDisplayedContent(filteredContent);
+    setIsTyping(false);
+  } else {
+    setDisplayedContent(filteredContent.substring(0, currentLength));
+  }
+}, 16);
+```
+
+This creates a satisfying "agent is thinking" effect without being slow.
+
+### Context Management: The Brain
+
+The `ChatProviderDB` context (`app/contexts/chat/ChatProviderDB.tsx`) manages:
+
+1. **Isolated Conversations**: Each job has its own message history
+2. **Database Synchronization**: Messages are saved to PostgreSQL with order indices
+3. **Optimistic UI Updates**: Messages appear immediately, then persist
+4. **Job Status Management**: Tracks running/completed/failed states
+5. **Title Generation**: Automatically generates conversation titles
+
+Key pattern for preventing cross-contamination:
+
+```typescript
+// Load messages for each job independently
+for (const job of jobs) {
+  const messages = await JobsAPI.getMessages(walletAddress, job.id);
+  dispatch({
+    type: "SET_MESSAGES",
+    payload: { conversationId: job.id, messages }
+  });
+}
+```
+
+This was a critical bug fix - previously, all localStorage messages were loaded into every job!
+
+### The Settings Page: User Control
+
+Transformed from a cramped modal to a full-page tabbed interface:
+
+- **General Settings**: Theme, notifications, preferences
+- **MCP Servers**: Connect and manage external tools
+- **A2A Agents**: Discover and connect to agent networks
+- **Agent Preferences**: Choose default agents
+- **API Keys**: Manage service credentials
+
+---
+
+## The Tech Stack: Modern and Proven
+
+### Frontend
+- **Next.js 14**: React framework with API routes
+- **TypeScript**: Type safety throughout
+- **Chakra UI**: Component library for consistent design
+- **React Context**: State management (no Redux!)
+- **Privy**: Authentication with Web3 support
+
+### Backend (Next.js API Routes)
+- **Node.js**: Runtime environment
+- **PostgreSQL**: Primary database
+- **Mastra**: Agent framework (@mastra/core, @mastra/mcp)
+- **AI SDK**: Vercel's AI library for LLM integration
+- **OpenAI**: GPT-4o-mini for agent selection, various models for agents
+
+### Infrastructure
+- **Vercel**: Hosting and deployment
+- **GitHub Actions**: CI/CD (assumed)
+- **Rate Limiting**: Custom middleware for API protection
+
+### Security
+- **Encrypted Credentials**: User credentials encrypted with master keys
+- **Scoped Access**: All data scoped to wallet addresses
+- **Input Validation**: Zod schemas for API validation
+- **Rate Limiting**: Protection against abuse
+
+---
+
+## What Makes This Impressive: The Technical Highlights
+
+### 1. **True Multi-Tier Orchestration**
+
+Most "agent platforms" just route to a single agent or use hardcoded rules. MySuperAgent uses:
+- LLM-based intelligent selection
+- User-specific agent pools
+- Fallback strategies
+- Comprehensive metadata generation
+
+### 2. **User-Extensible via MCP**
+
+Users can connect their own tools without writing code. The system:
+- Discovers tools automatically
+- Stores schemas in JSONB
+- Includes tools in agent selection
+- Handles tool execution with multiple fallback strategies
+
+### 3. **A2A Federation**
+
+MySuperAgent can delegate to external agent networks. This is rare in the wild and opens up:
+- Specialized agent marketplaces
+- Multi-organization agent workflows
+- Distributed task processing
+
+### 4. **Complete Transparency**
+
+Every response includes:
+- Which agent was selected and why
+- Alternative agents that could have been used
+- Step-by-step orchestration flow
+- Performance metrics (time, tokens)
+- Whether user-specific agents were considered
+
+This transparency builds trust and helps users understand what's happening.
+
+### 5. **Anti-Repetition System**
+
+The similarity detection system:
+- Uses vector embeddings to find similar previous prompts
+- Injects strong anti-repetition instructions
+- Tracks failure metrics for continuous improvement
+- User-configurable similarity threshold
+
+### 6. **Lazy Agent Loading**
+
+With 40+ agents, startup time could be slow. Instead:
+- Core agents (default, research) load immediately
+- Specialized agents load on first use
+- Registration uses dynamic imports
+- Memory footprint stays manageable
+
+### 7. **Retry with Exponential Backoff**
+
+Network issues happen. The orchestrator:
+- Retries up to 3 times automatically
+- Uses exponential backoff (1s, 2s, 4s)
+- Logs each attempt for debugging
+- Provides detailed error context
+
+### 8. **Database-First with LocalStorage Fallback**
+
+Logged-in users get:
+- Persistent job history in PostgreSQL
+- Message ordering with indices
+- Scheduled job support
+- Cross-device synchronization
+
+Anonymous users get:
+- LocalStorage-based chat history
+- No account required
+- Seamless upgrade path when they connect wallet
+
+### 9. **Comprehensive Error Handling**
+
+Every layer has proper error handling:
+- API routes use try-catch with safe error responses
+- Orchestrator returns error responses, not exceptions
+- MCP/A2A managers handle connection failures gracefully
+- UI shows user-friendly error messages
+
+### 10. **Performance Optimizations**
+
+- Client caching for MCP/A2A connections
+- Database query indexes for fast lookups
+- Lazy component loading
+- Virtual scrolling for large message lists (assumed)
+- Request-level timeouts to prevent hangs
+
+---
+
+## The Code Quality: Attention to Detail
+
+Looking through the codebase, you notice:
+
+### 1. **Consistent Naming Conventions**
+
+After a major refactor (2025-08-18), the codebase uses:
+- `kebab-case` for service directories
+- `PascalCase` for React components
+- `camelCase` for variables and functions
+- Descriptive file names (`user-mcp-manager.ts`, not `mcpUtils.ts`)
+
+### 2. **Comprehensive Logging**
+
+Every major operation is logged:
+
+```typescript
+console.log(`[${this.name}] Starting chat with prompt:`, ...);
+console.log('[ORCHESTRATOR] Starting runOrchestration for request:', requestId);
+console.log('[UserMCPManager] Enabled MCP server', serverName);
+```
+
+These logs make debugging in production much easier.
+
+### 3. **Type Safety**
+
+Everything is typed:
+- Interfaces for all data structures
+- Zod schemas for API validation
+- Generic types for reusable functions
+- Type assertions only where necessary
+
+### 4. **Documentation**
+
+The `CLAUDE.md` file is a 1,000+ line technical manual covering:
+- Architecture overview
+- Development commands
+- Database schemas
+- Common issues and solutions
+- Migration history
+- Recent changes with explanations
+
+This is rare and valuable.
+
+### 5. **Database Migrations**
+
+17 migration files track schema evolution:
+- Each migration is numbered and dated
+- Forward-only (no rollbacks needed so far)
+- Includes indexes and triggers
+- Documented in CLAUDE.md
+
+---
+
+## Real-World Use Cases
+
+### 1. **Research Assistant**
+
+User: "Research the latest developments in quantum computing and write a summary"
+
+Flow:
+1. Orchestrator selects `research` agent via LLM
+2. Agent uses web search tools to gather information
+3. Synthesizes findings into coherent summary
+4. Returns response with sources
+5. UI shows: Research agent → Web search → Synthesis → Final answer
+
+### 2. **Crypto Analysis with Personal Tools**
+
+User (connected Reddit MCP): "What's the sentiment on Solana right now?"
+
+Flow:
+1. Orchestrator sees user has Reddit MCP tool
+2. LLM selects Reddit MCP + crypto_data_backend
+3. Reddit tool pulls recent discussions
+4. Crypto agent analyzes market data
+5. Combined analysis presented to user
+6. UI shows: Personal Reddit tool + Crypto agent → Analysis
+
+### 3. **Code Review via A2A**
+
+User (connected CodeReview A2A agent): "Review this Python function for security issues"
+
+Flow:
+1. Orchestrator identifies connected CodeReview A2A agent
+2. Task delegated to external specialized agent
+3. External agent runs security scanners
+4. Results stream back to MySuperAgent
+5. UI shows: External CodeReview agent → Security scan → Recommendations
+
+### 4. **Scheduled Market Updates**
+
+User: "Give me crypto market updates every morning at 8am"
+
+Flow:
+1. Job created with `schedule_type: 'daily'`
+2. Cron system triggers job at scheduled time
+3. Orchestrator runs with crypto_data_backend
+4. Results saved to job's message history
+5. User gets push notification (if enabled)
+
+---
+
+## Challenges and Solutions
+
+### Challenge 1: Conversation Cross-Contamination
+
+**Problem**: When creating new jobs, ALL messages from localStorage were loaded, causing messages from Job A to appear in Job B.
+
+**Solution**: Modified `loadLocalStorageData()` to only load the "default" conversation:
+
+```typescript
+// BEFORE: Loaded ALL conversations (causing cross-contamination)
+Object.entries(data.conversations).forEach(([id, conversation]) => {
+  const messages = getMessagesHistory(id);
+  dispatch({ type: "SET_MESSAGES", payload: { conversationId: id, messages } });
+});
+
+// AFTER: Only load default conversation
+const messages = getMessagesHistory("default");
+dispatch({ type: "SET_MESSAGES", payload: { conversationId: "default", messages } });
+```
+
+### Challenge 2: MCP Tool Execution Variability
+
+**Problem**: Different MCP client implementations use different method names for tool execution.
+
+**Solution**: Try multiple methods in sequence:
+
+```typescript
+if (typeof client.callTool === 'function') {
+  result = await client.callTool(toolName, args);
+} else if (typeof client.executeTool === 'function') {
+  result = await client.executeTool(toolName, args);
+} else if (typeof client.runTool === 'function') {
+  result = await client.runTool(toolName, args);
+}
+```
+
+### Challenge 3: Agent Selection Accuracy
+
+**Problem**: Hardcoded routing rules became unmaintainable with 40+ agents.
+
+**Solution**: Use LLM-based selection with structured output:
+
+```typescript
+const AgentSelectionSchema = z.object({
+  selected_agent: z.string().describe('The name of the best agent for this task'),
+  reasoning: z.string().describe('Explanation of why this agent was selected'),
+});
+
+const result = await generateObject({
+  model: openai('gpt-4o-mini'),
+  schema: AgentSelectionSchema,
+  prompt: selectionPrompt,
+});
+```
+
+### Challenge 4: Timeout Management
+
+**Problem**: Long-running agent tasks could hang indefinitely.
+
+**Solution**: Comprehensive timeout strategy:
+- 5 minutes total orchestration timeout
+- 30 seconds for agent selection
+- 4 minutes for agent execution
+- Exponential backoff on retries
+
+### Challenge 5: User Credential Security
+
+**Problem**: MCP servers require API keys and credentials.
+
+**Solution**:
+- Encrypt all credentials with user-specific master keys
+- Store encrypted values in database
+- Decrypt only when needed for tool execution
+- Automatic cleanup on user logout
+
+---
+
+## Future Directions
+
+Based on TODOs in the codebase:
+
+### 1. **Dynamic MCP/A2A Proxy Agents**
+
+Create proxy agents on-the-fly for user-specific tools:
+
+```typescript
+// Current: Tools are discovered but not executed as full agents
+// Future: Dynamic proxy agent creation
+if (selectedAgentName.startsWith('mcp_')) {
+  selectedAgent = await createMCPProxyAgent(walletAddress, toolName);
+} else if (selectedAgentName.startsWith('a2a_')) {
+  selectedAgent = await createA2AProxyAgent(walletAddress, agentId);
+}
+```
+
+### 2. **Agent Composition**
+
+Allow multiple agents to work together on complex tasks:
+
+```typescript
+// Sequential: Agent A → Agent B → Agent C
+// Parallel: Agents A, B, C work simultaneously, synthesizer combines
+// Conditional: Agent A decides which other agents to invoke
+```
+
+### 3. **Enhanced Scheduling**
+
+Current scheduling supports daily/weekly/custom. Future:
+- Conditional scheduling (run when price changes)
+- Dependencies (Job B runs after Job A completes)
+- Resource management (limit concurrent jobs)
+
+### 4. **Agent Marketplace**
+
+Allow users to:
+- Publish their own agents
+- Discover agents created by others
+- Rate and review agents
+- Monetize specialized agents
+
+### 5. **Multi-Modal Support**
+
+Extend beyond text:
+- Image analysis with vision models
+- Audio transcription and analysis
+- Video content understanding
+- Document parsing (PDF, DOCX, etc.)
+
+---
+
+## Conclusion: Why This Matters
+
+MySuperAgent represents a mature approach to multi-agent AI systems. Instead of treating agents as black boxes, it:
+
+1. **Makes orchestration transparent**: Users see which agent was selected and why
+2. **Empowers users**: MCP and A2A allow personal extensibility
+3. **Scales gracefully**: Lazy loading and caching keep performance high
+4. **Handles failure**: Retries, fallbacks, and error tracking ensure reliability
+5. **Learns continuously**: Anti-repetition and failure metrics improve over time
+
+This isn't just "ChatGPT with extra steps." It's a platform that intelligently routes requests, manages external integrations, and provides complete visibility into the AI decision-making process.
+
+The orchestration layer is the real innovation here. By using LLM-based selection with user-specific context, the system adapts to each user's unique toolset while maintaining fast, reliable performance.
+
+If you're building multi-agent systems, MySuperAgent's architecture provides a solid blueprint for:
+- Intelligent routing
+- User extensibility
+- Error resilience
+- Performance optimization
+- User transparency
+
+**The future of AI isn't a single model.** It's orchestrated systems of specialized agents, user-provided tools, and federated networks - all working together seamlessly.
+
+MySuperAgent shows us how to build that future today.
+
+---
+
+## Technical Specifications
+
+**Repository**: MySuperAgent
+**Framework**: Next.js 14 with TypeScript
+**Agent Framework**: Mastra (@mastra/core v0.12.0)
+**Database**: PostgreSQL
+**Deployment**: Vercel
+**Lines of Code**: ~15,000+ (app directory)
+**Agents**: 40+ specialized agents
+**Migrations**: 17 database schema versions
+
+**Key Files**:
+- `app/services/agents/orchestrator/index.ts` (469 lines) - Orchestration engine
+- `app/services/agents/core/agent-registry.ts` (1,138 lines) - Agent management
+- `app/services/mcp/user-mcp-manager.ts` (523 lines) - MCP integration
+- `app/services/a2a/user-a2a-manager.ts` (424 lines) - A2A integration
+- `app/components/Agents/Crew/CrewResponseMessage.tsx` (911 lines) - UI visualization
+
+**Built by**: Morpheus team
+**License**: MIT
+
+---
+
+*Last updated: December 2025*
+*Article version: 1.0*