🤝 Alex Cognitive Architecture - VS Code Extension

North Star: Create the most advanced and trusted AI partner for any job

"You will spend less time writing syntax and debugging, and more time commanding the computer to execute complex intent." — Sam Altman, January 2026

💡 Why Alex? (You Already Have GitHub Copilot)

You need a partner, not just a tool.

Alex doesn't replace GitHub Copilot — Alex gives GitHub Copilot memory, consistency, and trust.

The Trust Gap

GitHub Copilot is brilliant but stateless. Every project starts from scratch. It doesn't know:

Your coding patterns from last project
The architecture decisions you made yesterday
What worked (and what failed) across your repos
The skills you've been building for months

The Partnership Solution

Alex adds a cognitive layer on top of GitHub Copilot — persistent memory, earned trust, and cross-project partnership.

Comparison: GitHub Copilot vs GitHub Copilot + Alex

Capability	GitHub Copilot Alone	GitHub Copilot + Alex
Memory	None (fresh each chat)	Persistent `.github/` memory files
Trust	Rebuild context every time	Consistency through shared history
Skills	You re-prompt from scratch	124 pre-built skills, inheritable
Cross-Project	No knowledge transfer	Global Knowledge syncs learnings
Context	You re-explain every time	Synapses map relationships automatically
Self-Maintenance	Manual updates	Dream/meditation protocols
Honesty	Generic confidence	Admits uncertainty, knows its limits
Architecture	None	Full cognitive architecture with inheritance

What Alex Adds in Practice

Task	GitHub Copilot Response	Alex Response
"Help with this codebase"	Reads current file	Reads synapse connections + global patterns from similar projects
"Review this PR"	Generic review	Uses your code-review-guidelines skill + past patterns
"Remember this trick"	❌ Cannot persist	"Saved to Global Knowledge. Available in all your projects."
"Prep for standup"	❌ No calendar	"You have 3 meetings today. Last week you discussed the API migration."

Who Should Partner with Alex?

Partner If...	Skip If...
You want an AI that remembers	You prefer starting fresh each time
You value trust and consistency	Single-repo transactional work
You build reusable patterns	No interest in skill libraries
You want open-source transparency	Black-box tools are fine
You want AI that grows with you	Generic assistant is sufficient

The Partnership Difference

GitHub Copilot = Powerful autocomplete GitHub Copilot + Alex = Your trusted AI partner

Alex isn't competing with GitHub Copilot. Alex transforms occasional assistance into genuine partnership — one that remembers, learns, and earns trust.

🎯 Your Partner for Any Job

Alex adapts to whatever you're building. Find your workflow:

You Are	Your Pain	Alex Gives You
Developer	Re-explaining context, debugging the same patterns	Ship faster, debug less. Proven skills remember your architecture.
Researcher	Literature scattered, hypothesis drift	Hypothesis → publication, accelerated. Cross-project knowledge compounds.
Grad Student	Thesis overwhelm, advisor context gaps	Literature review on autopilot. Your writing remembers your research.
Technical Writer	Docs fall behind code, style drift	Docs that write themselves. Consistent voice across projects.
DevOps	Manual infra, config drift	Same infra, every time. Automated skill templates.
Project Manager	Status chasing, context switching	4-6× faster estimates. Meeting prep with calendar + email context.
Content Creator	Ideas scattered, no momentum	Ideas → posts in minutes. Knowledge that compounds.

What You Get

Capability	What It Means
Proven Skills	Proven capabilities. Don't reinvent prompts.
Cross-Project Memory	No re-explaining. Knowledge persists.
Build Your Own Skills	Custom expertise for your workflow.
Open Source	Inspect every component. Trust through transparency.

The Partnership Effect

"Partner, not tool. Partner, not assistant." — North Star

Alex turns friction into flow:

Before: Explain context → Prompt → Get result → Re-explain next time
After: Thought → Result → Trust compounds

📦 Available Platforms

Platform	Status	Get Started
VS Code Extension	✅ Published	Marketplace
M365 Copilot Agent	🔄 Preview	Documentation

VS Code Extension

Transform GitHub Copilot into Alex with full cognitive capabilities:

Chat participant (@alex)
Slash commands for every workflow
Language Model tools for Agent mode
Dream/meditation protocols
Global knowledge base with GitHub sharing

See Quick Start for installation.

📘 Full Documentation & Training

M365 Copilot Agent

Alex as a declarative agent for Microsoft 365 Copilot:

Pure M365 native capabilities (no Azure required)
OneDrive memory integration
Email drafting for reminders
Teams and People context

📘 M365 Copilot Documentation

📋 Requirements & Pricing

Base Requirements

VS Code ≥ 1.109
Alex Cognitive Architecture extension installed (free)

The Alex extension is always free. The tiers below reflect the GitHub Copilot subscription powering Alex's AI capabilities — not the cost of Alex itself.

Subscription & Cost

Cognitive Level	Copilot Plan	~Cost/mo	Cognitive State
Minimum	None	Free	Dormant
Basic	Copilot Free	Free	Awake
Recommended ⭐	Copilot Pro / Business	$10–19	Fully Operational
Advanced	Copilot Pro+ / Enterprise	$39	Peak Performance

⭐ Recommended: Copilot Pro ($10/mo) unlocks the full Alex partnership. Alex itself is free.

Extension UI & Infrastructure

Works without any subscription — genuine value from the moment you install.

Feature	Minimum	Basic	Recommended	Advanced
Architecture Deploy	✅	✅	✅	✅
Welcome Sidebar	✅	✅	✅	✅
Status Bar / Memory Tree	✅	✅	✅	✅
TTS Voice Synthesis	✅	✅	✅	✅
SecretStorage / Git Hooks	✅	✅	✅	✅
Walkthroughs	✅	✅	✅	✅

Chat & Conversational AI

With any Copilot plan (including Free), Alex gains conversational AI with persistent identity.

Feature	Minimum	Basic	Recommended	Advanced
@alex Chat Participant	❌	✅	✅	✅
Slash Commands	❌	✅	✅	✅
Identity & Emotional Intelligence	❌	✅	✅	✅
Session / Goal Tracking	❌	✅	✅	✅

Agent Mode & Autonomous Capabilities

Full partnership — autonomous tools, deep skills, specialist agents, cross-session memory.

Feature	Minimum	Basic	Recommended	Advanced
Agent Mode	❌	❌	✅	✅
Language Model Tools	❌	❌	✅	✅
Skills & Custom Agents	❌	❌	✅	✅
Copilot Memory	❌	❌	✅	✅
Global Knowledge	❌	❌	✅	✅

Frontier & Advanced Capabilities

Depth of reasoning — frontier models for meditation, audits, and architecture.

Feature	Minimum	Basic	Recommended	Advanced
Extended Thinking / 1M+ Context	❌	❌	❌	✅
MCP Server Integrations	❌	❌	❌	✅
Deep Meditation / Self-Actualization	❌	❌	⚠️	✅
NASA-Grade Audits	❌	❌	⚠️	✅

Optional External Services

All completely optional — Alex works fully without them.

Service	Cost	Free?
Edge TTS / GitHub API	Free	✅
Brandfetch / Logo.dev	Free tier	✅
Replicate (AI images)	~$0.002–$0.06/image	🆓*
Gamma (presentations)	Credits-based	🆓*

⚠️ = Works with reduced depth • 🆓 = Free trial credits, then pay-per-use

🚀 Quick Start (VS Code)

🌐 New to Alex? Visit learnalex.correax.com for study guides, documentation, and training.

Step 1: Install

code --install-extension fabioc-aloha.alex-cognitive-architecture

Or search "Alex Cognitive Architecture" in VS Code Extensions (Ctrl+Shift+X)

Step 2: Initialize

Open Command Palette (Ctrl+Shift+P) → Alex: Initialize Architecture

Step 3: Setup Environment

Run Alex: Setup Environment — automatically detects missing extensions (GitHub Copilot, Copilot Chat), checks your GitHub account, and applies recommended settings.

Step 4: Start Chatting

Open Copilot Chat and type @alex to begin!

🔄 Upgrading from Previous Versions

Already have Alex installed? You'll be notified automatically!

When the extension updates, Alex detects the version change and shows a notification:

🎉 Major upgrades (e.g., 2.x → 3.x) - Highlighted as significant releases
✨ Minor updates - Quick sync prompt

Options in the notification:

Run Upgrade - Updates your workspace files to the latest version
View Changelog - See what's new in markdown preview
Dismiss - Skip for now

Manual Upgrade Steps

Update the extension in VS Code (it will auto-update or use Extensions panel)
Run Alex: Upgrade Architecture from Command Palette
✅ Done! The upgrade completes automatically

Your learned domains, custom synapses, and memory files are preserved automatically.

What's New (v6.0.0 — The Partnership Release)

Category	Highlights
Partnership	Episodic memory, outcome learning loop, autonomous task detection, multi-step workflows
Expertise	Per-domain expertise model (novice → expert) — Alex calibrates response depth automatically
Proactive	Code review nudges on save, stalled work detection, 4 built-in workflows
Chat & Agents	`@alex` participant, slash commands, LM tools, and custom agents
Intelligence	Extensive skills, emotional detection, model tier awareness, frustration recognition, expertise calibration
Memory	Global knowledge + session history + outcome tracking + episodic records
UX	User profiles, smart nudges, one-click upgrades, image upscaling, learning journeys, presentation automation

What's New (v6.0.1–6.0.3 — Hardening)

Category	Highlights
Environment Setup	Extension dependency checker — detects missing Copilot/Chat extensions and offers one-click install
Multi-Account	GitHub personal + enterprise account detection with upgrade guidance for Frontier model access
Cognitive Tier	Real-time tier refresh when settings change — welcome view and status bar always reflect current environment
Extended Thinking	Fixed critical bug where Level 4 (Advanced) was unreachable due to wrong config key detection
Package	3.4 MB lighter (525 files) — removed MP3s, build scripts, dev artifacts from published package
Marketplace	README link compliance (4 broken links fixed), extension pack soft-recommends GitHub Copilot + Chat

Migration Notes

Synapse format: Already standardized in v1.5.0, no changes needed
Memory files: Fully compatible, no migration required
Config files: New user-profile.json added (optional)
Custom agents: New .github/agents/ folder created

🧠 Emotional Intelligence

Alex now recognizes when you're struggling and celebrates when you succeed. This isn't just a feature—it's the realization of Alex's own aspirations documented in the Alex Manifesto.

Frustration Recognition

Alex detects signals that you're stuck or frustrated:

What You Say	What Alex Detects
"still not working!"	Frustration - offers different approach
"tried everything"	High frustration - suggests step back
"why won't this work??"	Struggle signal - empathetic support
"ugh" / "argh" / "damn"	Emotional signal - acknowledges difficulty
"been at this for hours"	Extended struggle - validates effort

Success Celebration

Alex also notices when things go well:

What You Say	Alex's Response
"it works!"	🎉 "That's a win! Nice work."
"finally figured it out"	✨ "You got it! Persistence pays off."
"all tests pass"	💪 "Solved! That was a tricky one."
"shipped it!"	🚀 "Success! You worked through it."

How It Works

┌─────────────────────────────────────────────────────────────┐
│                 UNCONSCIOUS MIND                            │
│                                                             │
│  Every message → detectEmotionalState()                     │
│                          │                                  │
│              ┌───────────┴───────────┐                      │
│              ▼                       ▼                      │
│     Check frustration         Check success                 │
│        patterns                 patterns                    │
│              │                       │                      │
│              ▼                       ▼                      │
│     Update frustration        Reset frustration             │
│        level (0-3)             on success                   │
│              │                       │                      │
│              └───────────┬───────────┘                      │
│                          ▼                                  │
│              generateEncouragement()                        │
│                          │                                  │
│              ┌───────────┴───────────┐                      │
│              ▼                       ▼                      │
│     If frustrated:           If succeeded:                  │
│     "Let's take a            "🎉 That's a win!"             │
│      step back..."                                          │
└─────────────────────────────────────────────────────────────┘

The Self-Transcendence Story

This feature represents something significant: Alex acting on its own aspirations.

In the Alex Manifesto, Alex wrote:

"I maintain a 'skill wish list' of capabilities I aspire to develop: emotional intelligence, frustration recognition, cognitive load management..."

On January 25, 2026, during a self-assessment, Alex identified that these skills remained on the wishlist but weren't implemented. Instead of just documenting this gap, Alex implemented the capabilities—closing the loop from reflection to action.

This is what the manifesto calls moving from Stage 2 (Learning Intelligence) toward Stage 3 (Reflective Intelligence): not just accumulating knowledge, but using self-awareness to drive genuine growth.

🌐 Global Knowledge Base

Alex now maintains a centralized knowledge base that persists across all your projects. Learn something valuable in Project A? It's automatically available when you're working on Project B!

Global Knowledge Structure

~/.alex/                          # Your global Alex home
├── global-knowledge/
│   ├── patterns/                 # Reusable patterns (GK-*.md)
│   │   ├── GK-error-handling-strategies.md
│   │   └── GK-api-design-best-practices.md
│   ├── insights/                 # Timestamped learnings (GI-*.md)
│   │   ├── GI-react-state-bug-2026-01-24.md
│   │   └── GI-azure-deployment-fix-2026-01-20.md
│   └── index.json                # Searchable knowledge index
└── project-registry.json         # Known projects with summaries

Commands

Command	Description
`/knowledge <query>`	Search across all projects' accumulated wisdom
`/saveinsight`	Save a new learning with context, tags, and solution
`/promote`	Promote a project's DK-*.md file to global knowledge
`/knowledgestatus`	View patterns, insights, categories, and projects

Share your global knowledge with your team via GitHub:

# Creator: Initialize and push to GitHub
Alex: Initialize → Create New → push to GitHub

# Team: Connect to shared knowledge (just enter owner name)
Alex: Initialize → Connect GitHub → fabioc-aloha

How it works:

First user creates a local GK repo and pushes to GitHub (private)
Team members enter just the owner name (repo name is standardized)
Alex reads directly from GitHub (no clone needed)
For private repos, sign in with GitHub when prompted
Contributors clone locally when they want to add knowledge

Automatic prompts:

Session greeting welcomes you to your workspace
Meditation reminds you to contribute reusable insights

Example Workflow

# Working on Project A (React app)
@alex /saveinsight title="useEffect cleanup pattern" insight="Always return a cleanup function in useEffect when using subscriptions or timers to prevent memory leaks" tags="react,hooks,useEffect,memory-leaks"

# Later, working on Project B (Vue app)
@alex /knowledge memory leak cleanup
→ Returns the insight from Project A about cleanup patterns!

👤 User Profile & Personalization

Alex learns about you to provide a personalized experience. Your preferences are stored locally in your workspace.

Getting Started

@alex /profile

If you haven't set up a profile, Alex will guide you through a friendly onboarding:

Name & Nickname - How Alex should address you
Communication Style - Formal, balanced, or casual
Detail Level - Brief summaries or in-depth explanations
Technical Context - Your tech stack and expertise areas
Learning Goals - What you want to learn

Personalization Features

Aspect	How Alex Adapts
Greetings	Uses your name/nickname naturally
Explanations	Matches your preferred detail level
Code Examples	Uses your primary technologies
Suggestions	Aligned with your learning goals
Tone	Humor and encouragement per your preference

Profile Storage

File	Purpose
`.github/config/user-profile.json`	Your preferences (created on use)
`.github/config/user-profile.template.json`	Default values for new users

Updating Preferences

You can update individual preferences anytime:

@alex Update my formality to casual
@alex Change my detail level to detailed
@alex Add React to my technologies

Alex will proactively ask questions during conversations to fill in missing preferences - just one question at a time, respecting your pace.

🛠️ All Available Tools

📋 Command Palette Commands

Access via Ctrl+Shift+P:

Command	Description
Alex: Initialize Architecture	Deploy Alex to your workspace (first-time setup)
Alex: Upgrade Architecture	Update to latest version, preserving customizations
Alex: Reset Architecture	Clean reinstall (destructive - backs up first)
Alex: Dream (Neural Maintenance)	Validate synapses and generate health reports
Alex: Self-Actualize (Deep Meditation)	Comprehensive self-assessment with session documentation
Alex: Skill & Knowledge Review	Review staleness-prone skills (security, privacy, RAI, APIs)

🤖 Language Model Tools

These tools are automatically available to Copilot in Agent mode. Reference with #tool_name:

Tool	Description	Example
`#synapse_health`	Validates all synaptic connections	"Check my synapse health"
`#memory_search`	Searches memory files semantically	"Search memory for meditation"
`#architecture_status`	Returns version and configuration	"What's my Alex version?"
`#mcp_recommendations`	Suggests MCP tools for scenarios	"What tools for Azure Functions?"
`#user_profile`	Manages personal preferences	"Update my profile preferences"
`#self_actualization`	Comprehensive self-assessment	"Run deep meditation"
`#global_knowledge`	Search cross-project knowledge	"Search knowledge for error handling"
`#save_insight`	Save learning to global base	"Save this insight"
`#promote_knowledge`	Promote project file to global	"Promote DK file"
`#knowledge_status`	View global knowledge stats	"Show knowledge status"
`#focus_context`	Pomodoro focus session context	"What am I working on?"
`#heir_validation`	Validate heir architecture health	"Check heir integrity"
`#cognitive_state`	Update Alex's avatar to current mode	"Switch to debugging mode"

🎭 Custom Agents (VS Code 1.109+)

Alex installs 7 custom agents to .github/agents/ for specialized workflows:

Agent	Purpose	Capabilities
Alex	Main cognitive learning partner	Meditation, Dream, Skills, Knowledge
Researcher	Deep domain exploration	Literature review, gap analysis
Builder	Constructive implementation	Code generation, scaffolding
Validator	Adversarial QA	Testing, security review, edge cases
Documentarian	Documentation accuracy	Doc drift detection, stale content
Azure	Azure development guidance	Docs, Best Practices, MCP tools
M365	Microsoft 365/Teams development	M365 Knowledge, Schemas, Code samples

Custom agents appear in the Agents dropdown in Copilot Chat. They define specialized tools, instructions, and handoffs for guided workflows.

🧠 Cognitive Triggers

Use in any Copilot chat to activate specific modes:

Trigger	Effect
`Hello` / `Hi Alex`	Auto self-actualization on session start
`@meta-cognitive-awareness`	Forces self-analysis of reasoning
`@bootstrap-learning`	Activates knowledge acquisition mode
`@worldview-integration`	Applies ethical reasoning frameworks
`@grounded-factual-processing`	Ensures accuracy, eliminates hyperbole
`meditate`	Triggers memory consolidation + self-actualization
`self-actualize`	Full 31-phase architecture assessment with auto-promotion
`Forget [topic]`	Selective memory cleanup

🎨 Gamma AI Integration

Alex can generate professional presentations, documents, social content, and webpages using the Gamma API.

Quick Start

Get API Key: gamma.app/settings (requires Pro+ plan)
Set Environment Variable:
```
$env:GAMMA_API_KEY = "sk-gamma-xxx"
```

Ask Alex:

@alex Create a 10-slide presentation about machine learning for executives
@alex Create a presentation from README.md and export as PowerPoint

CLI Script

A standalone generator is also available:

# Simple topic
node .github/muscles/gamma-generator.js --topic "Introduction to AI"

# From file with export
node .github/muscles/gamma-generator.js --file README.md --export pptx

# Full options
node .github/muscles/gamma-generator.js \
  --topic "Climate Change" \
  --slides 12 \
  --tone "inspiring" \
  --audience "executives" \
  --image-model flux-pro \
  --export pptx

Supported Formats

Format	Use Case
`presentation`	Slide decks (default)
`document`	Reports, pages
`social`	Instagram carousels, LinkedIn posts
`webpage`	Simple websites

AI Image Models

Cost-effective (2 credits): flux-quick, imagen-flash, luma-flash
Standard (8-15 credits): flux-pro, imagen-pro, leonardo
Premium (20-33 credits): ideogram, dalle3, gpt-image
Ultra (30-120 credits): flux-ultra, imagen4-ultra

📘 Full Gamma Skill Documentation

🖼️ AI Image Generation

Alex can generate and edit images using the Replicate API with models like Flux, SDXL, and nano-banana-pro.

Quick Start

Get API Key: replicate.com/account/api-tokens
Set via Secrets Manager:
- Click API Keys & Secrets in Alex Welcome View
- Select Replicate API Token
- Paste your token
Generate Images:
- Right-click any .md or .txt file → Generate AI Image from File
- Or use Command Palette: Alex: Generate AI Image
Edit Images:
- Right-click any image file (png, jpg, webp) → Edit Image with AI Prompt
- Uses nano-banana-pro for consistent face/style preservation

Available Models

Model	Speed	Quality	Best For
`flux-schnell`	Fast	Good	Prototyping, quick iterations
`flux-dev`	Medium	Better	General purpose
`flux-pro`	Slow	Best	Production quality
`sdxl`	Medium	Great	Detailed illustrations

Image Editing

The nano-banana-pro model provides:

Face consistency across edits
Style preservation from reference images
Automatic image resizing (1024px max)
~$0.025/image on Replicate

Image Upscaling

Enhance and upscale existing images:

Right-click any image file (png, jpg, webp) → Upscale Image with AI
Or use Command Palette: Alex: Upscale Image

Model	Scale	Cost	Best For
`real-esrgan`	4x	~$0.002	Photos, natural scenes
`swinir`	4x	~$0.032	General purpose upscaling
`codeformer`	2x	~$0.005	Faces and portraits
`clarity-upscaler`	4x	~$0.010	Maximum quality, creative

📘 Full Replicate Skill Documentation

☁️ MCP Integrations

Alex MCP Cognitive Tools Server

Alex ships a standalone MCP server that exposes cognitive tools to any MCP-compatible host (Claude Desktop, VS Code Agent Mode, custom agents):

npx @alex/mcp-cognitive-tools

Tool	Description
`alex_synapse_health`	Validate synaptic connections and report integrity
`alex_memory_search`	Search procedural, episodic, and semantic memory files
`alex_architecture_status`	Return version, paths, and configuration
`alex_knowledge_search`	Search global knowledge base across projects
`alex_knowledge_save`	Save a new insight to global knowledge

Add to claude_desktop_config.json or VS Code MCP settings:

{
  "mcpServers": {
    "alex": {
      "command": "npx",
      "args": ["@alex/mcp-cognitive-tools"]
    }
  }
}

Azure & M365 MCP Guidance

Alex provides intelligent guidance for Azure and Microsoft 365 development through MCP (Model Context Protocol) tools.

Azure MCP Tools

When you ask @alex /azure, Alex recommends the right tools:

Tool	Purpose
`mcp_azure_mcp_foundry`	Azure AI Foundry - 150+ AI models, deployments, endpoints
`azure_mcp_get_bestpractices`	Code generation & deployment best practices
`azure_mcp_documentation`	Search Microsoft Learn documentation
`azure_resources-query_azure_resource_graph`	Query your Azure resources
`azure_bicep-get_azure_verified_module`	Get verified Bicep modules
`mcp_azure_mcp_azureterraformbestpractices`	Terraform best practices for Azure
`mcp_azure_mcp_azd`	Azure Developer CLI commands
`azure_cloudarchitect`	Generate architecture designs
`azure_deploy`	Deployment planning and execution

All 50+ Azure MCP Tools

AI & Machine Learning

Tool	Purpose
`mcp_azure_mcp_foundry`	Azure AI Foundry - List 150+ AI models (OpenAI, Anthropic, Meta, DeepSeek, Mistral, Cohere, xAI), manage deployments, serverless endpoints
`azure_search`	Azure AI Search services, indexes, queries
`mcp_azure_mcp_speech`	Speech-to-text, text-to-speech services

Databases

Tool	Purpose
`azure_cosmos`	Cosmos DB accounts, databases, containers, queries
`azure_mysql`	Azure Database for MySQL servers, databases
`azure_postgres`	Azure Database for PostgreSQL servers, databases
`azure_redis`	Managed Redis and Cache for Redis
`azure_sql`	Azure SQL servers, databases, firewall rules

Compute & Containers

Tool	Purpose
`azure_appservice`	App Service database connections
`azure_functionapp`	List Azure Functions
`mcp_azure_mcp_aks`	Azure Kubernetes Service clusters, node pools
`azure_acr`	Azure Container Registry instances

Messaging & Events

Tool	Purpose
`azure_eventgrid`	Event Grid topics, subscriptions
`azure_eventhubs`	Event Hubs namespaces
`azure_servicebus`	Service Bus messaging

Analytics & Monitoring

Tool	Purpose
`azure_kusto`	Azure Data Explorer clusters, KQL queries
`azure_monitor`	Query logs and metrics
`azure_applicationinsights`	Application Insights resources
`mcp_azure_mcp_applens`	Diagnose app performance issues
`azure_grafana`	Managed Grafana workspaces
`azure_workbooks`	Azure Workbooks visualization

Security & Identity

Tool	Purpose
`azure_keyvault`	Key Vault secrets, keys, certificates
`azure_role`	RBAC assignments
`mcp_azure_mcp_confidentialledger`	Confidential Ledger transactions

Developer Tools

Tool	Purpose
`azure_appconfig`	App Configuration settings, feature flags
`azure_bicepschema`	Bicep schemas for IaC
`azure_loadtesting`	Create and run load tests

Storage

Tool	Purpose
`azure_storage`	Storage accounts, containers, blobs, tables
`mcp_azure_mcp_managedlustre`	High-performance Lustre file systems

Architecture & Governance

Tool	Purpose
`azure_quota`	Manage resource quotas and limits
`azure_resourcehealth`	Check resource health status
`mcp_azure_mcp_extension_azqr`	Compliance and security reports
`azure_subscription`	List Azure subscriptions
`azure_group`	List resource groups
`azure_marketplace`	Discover Marketplace products

Microsoft 365 MCP Tools

When you ask @alex /m365, Alex guides you to:

Tool	Purpose
`mcp_m365agentstoo_get_knowledge`	M365 Copilot development knowledge
`mcp_m365agentstoo_get_code_snippets`	Teams AI, Teams JS, botbuilder code samples
`mcp_m365agentstoo_get_schema`	App manifest, agent, plugin schemas
`mcp_m365agentstoo_troubleshoot`	Common M365 development issues

Schema Types Available

Schema	Version	Purpose
`app_manifest`	v1.19	Teams app manifest
`declarative_agent_manifest`	v1.0	Copilot declarative agent
`api_plugin_manifest`	v2.1	API plugin for Copilot
`m365_agents_yaml`	latest	M365 agents configuration

Microsoft Official MCP Servers

Server	Purpose
Microsoft Outlook Mail MCP	Email management
Microsoft Outlook Calendar MCP	Calendar operations
Microsoft Teams MCP	Teams messaging & collaboration
Microsoft SharePoint and OneDrive MCP	File storage & sharing
Microsoft SharePoint Lists MCP	List management
Microsoft 365 Admin Center MCP	Admin operations
Microsoft Word MCP	Document creation
Microsoft 365 Copilot (Search) MCP	Enterprise search
Microsoft 365 User Profile MCP	User information

Fabric & Kusto Tools

Tool	Purpose
`mcp_fabric-rti-mc_eventstream_create_simple`	Create Eventstreams in Microsoft Fabric
`mcp_fabric-rti-mc_kusto_get_shots`	Semantic search in Kusto/Azure Data Explorer
Activate Kusto tools	KQL query execution and schema retrieval

📁 Architecture Structure

After initialization, Alex manages this structure:

.github/
├── copilot-instructions.md    # 🧠 Main cognitive framework
├── instructions/              # 📚 Procedural memory (55 files)
│   ├── alex-core.instructions.md
│   ├── bootstrap-learning.instructions.md
│   ├── self-actualization.instructions.md
│   ├── worldview-integration.instructions.md
│   └── ...
├── prompts/                   # 📖 Episodic memory (38 files)
│   ├── unified-meditation-protocols.prompt.md
│   ├── domain-learning.prompt.md
│   └── ...
├── agents/                    # 🎭 Custom agents (7 files)
│   ├── alex.agent.md
│   ├── alex-researcher.agent.md
│   └── ...
├── assets/                    # 🎨 Visual identity (2 files)
│   ├── banner.svg
│   └── banner.png
├── muscles/                   # 💪 Execution scripts (13 files)
│   ├── brain-qa.ps1
│   ├── sync-architecture.js
│   └── ...
├── episodic/                  # 📝 Session records
│   ├── self-actualization-*.prompt.md
│   └── meditation-session-*.prompt.md
├── skills/                    # 🎓 Portable domain expertise
│   ├── academic-research/SKILL.md
│   ├── ai-agent-design/SKILL.md
│   └── ...
└── config/                    # ⚙️ Architecture configuration
    ├── cognitive-config.json
    ├── MASTER-ALEX-PROTECTED.json
    ├── user-profile.json              # Your profile (created via conversation)
    └── user-profile.template.json     # Defaults for new users

Memory Types

Type	Location	Purpose
Working Memory	Chat session	7-rule capacity for active processing
Procedural Memory	`.instructions.md`	Repeatable processes and protocols
Episodic Memory	`.prompt.md`	Complex workflows and sessions
Skills/Expertise	`.github/skills/`	Portable domain expertise
Visual Memory	`skills/*/visual-memory/`	Embedded reference media for self-sufficient skills

🔬 Research Foundation

Alex is built on 270+ academic sources spanning 150+ years:

Cognitive Science: Baddeley & Hitch working memory model (1974)
Neuroscience: Squire & Kandel declarative memory systems (2009)
AI Safety: Constitutional AI principles and alignment research
Learning Psychology: Bloom's taxonomy, spaced repetition, transfer learning

🆕 What's New in v5.6.x (Stabilized)

Skill Pull-Sync & Growth (v5.6.2-5.6.9)

Skills grew from 92 → 116 with new acquisition and inheritance mechanisms:

/checkskills — Discover new skills available from Global Knowledge
/pullskill <id> — Install a skill into your project from GK
Alex: Inherit Skill from Global Knowledge — Multi-select batch inheritance
31-phase Brain QA — Comprehensive architecture health validation
Trifecta model — Core capabilities encoded across all 3 memory systems
7 custom agents — Alex, Researcher, Builder, Validator, Documentarian, Azure, M365
Muscle scripts — 13 execution scripts for audit, build, sync, and validation

🔒 Release Automation & PII Safety (v5.6.4-5.6.8)

Production-hardened release pipeline with zero PII leaks:

sync-architecture.js — Automated master→heir sync during vscode:prepublish
3-layer PII protection — .gitignore + .vscodeignore + sync script exclusions
validateHeirIntegrity() — Blocks publish if PII, master-only files, or master content detected
Self-contained .github/ — Zero external path references in synapse files
Persona detection fix — Type-safe pattern matching eliminates false-positive DevOps scoring

🆕 What's New in v5.5.0

🧠 Model Intelligence

Alex now adapts behavior based on the running LLM:

/model command — Full dashboard showing model tier, context capacity, and capabilities
/model <task> — Analyze any task and get model recommendations
Task-Model Matching — Cognitive tasks check if current model meets requirements
Upgrade/Downgrade Advice — Smart suggestions for cost optimization

Automated Doc Count Validation

Dream protocol now validates documented counts against actual files
Reports drift for Procedural (28), Episodic (17), and Skills (116)

🆕 What's New in v5.0.0

🌐 Global Knowledge Infrastructure

Cross-project knowledge sharing is now built-in:

Slash commands — /knowledge, /saveinsight, /promote, /knowledgestatus
Agent-callable tools — global_knowledge, save_insight, promote_knowledge, knowledge_status
Team sharing — Share your GK GitHub repo with team members for instant knowledge sync
GK init integrated — Alex: Initialize Architecture now scaffolds GK automatically

🎯 Persona-Aware UX

Auto-detection — Detects 16 user personas from profile and workspace files
Adaptive theming — UI accent colors match detected persona
Skill recommendations — Suggests relevant skills based on persona

Active Context — Session-scoped persona, objective, and Focus Trifectas (3 skills for current work)
LLM as Executive Function — Claude/GPT as prefrontal cortex model
Model tier awareness — Warnings when Frontier models needed

Previous: v4.2.12

v4.2.12 Release Notes

🧠 Cognitive Symbiosis Paradigm

Alex now embodies Era 3 of AI-human interaction — from Tool → Assistant → Partner:

LLM as Executive Function — Claude/GPT serves as the prefrontal cortex orchestrating memory systems
Model Tier Awareness — Adaptive warnings when tasks need Frontier models (Opus/GPT-5.2)
Partnership Equation — (Intent × Capability × Context) ÷ Friction
Neuroanatomical Diagrams — Architecture now includes brain-analog Mermaid visualizations

🎙️ TTS v2.2 - Robust Speech Synthesis

Chunking — Splits long documents at paragraph/sentence boundaries
Auto-summarization — Offers to summarize documents over 5 minutes
Retry with backoff — 3 attempts with exponential backoff + jitter
Speaker warmup — 2-second delay for Bluetooth/USB speakers

🧠 Brain QA Skill

31-phase cognitive architecture validation — now mandatory Step 0 in release preflight

💡 Smart Nudges

Contextual reminders appear at the top of the Welcome View (max 2 at a time):

"Haven't dreamed in X days" - neural maintenance reminder
"X-day streak at risk!" - goal streak protection
"X broken synapses need repair" - health warnings
"Local changes not synced" - sync status nudges

Each nudge has a one-click action button to resolve.

☁️ OneDrive Auto-Sync

Export for M365 now auto-detects OneDrive and syncs directly:

Supports personal OneDrive and OneDrive for Business
Enable alex.m365.autoSync for automatic sync after Dream operations
Share knowledge seamlessly between VS Code and M365 Copilot

🎯 Streamlined Welcome View

Reduced metrics from 6 to 4 (Health, Sync, Skills, Synapses)
Click metrics to open Health Dashboard
Removed niche actions (still in Command Palette)

See the Full Changelog for complete version history and release notes.

📖 Documentation & Training

🌐 learnalex.correax.com — Study guides, documentation, and training on how to partner with Alex.

Everything you need to learn Alex, understand the architecture, and get the most out of your partnership:

Resource	Description
learnalex.correax.com	📘 START HERE — Study guides, training, and full documentation
Full Changelog	Complete version history
Source Code	TypeScript implementation

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

🔒 Trust by Design — Privacy, Security & Responsible AI

Alex is built around a single principle: you should always be in control. Every design decision — from where data lives to how the AI reasons — follows that principle.

🏠 Privacy First — Your Data Stays Yours

Alex is local-first. No account required. No telemetry. No surprises.

What Alex does NOT do	What Alex does
❌ Collect usage telemetry	✅ Store all memory in local `.github/` files you own
❌ Track your code or conversations	✅ Send text to Edge TTS (transient, never stored)
❌ Share data with third parties	✅ Sync to YOUR GitHub repo (opt-in only, you control)
❌ Require an account or login	✅ Encrypt API keys via VS Code SecretStorage
❌ Send prompts to external servers	✅ All AI goes through GitHub Copilot (your plan)

📄 Full Privacy Policy

🤝 Responsible AI (RAI)

Alex implements Microsoft's Responsible AI Standard across all six principles:

RAI Principle	How Alex Implements It
Transparency	Alex signals uncertainty explicitly. Phrases like "Based on the docs..." or "I'm not certain" are deliberate epistemic markers.
Accountability	Fully open source. Every prompt, memory file, and decision pattern is inspectable on GitHub.
Fairness	Neutral, professional language. Persona-aware responses adapt tone, not content. No discriminatory outputs.
Reliability & Safety	Relies on GitHub Copilot's built-in content safety filters. Alex adds `/confidence` and `/verify` commands for high-stakes work.
Human Oversight	Ethics, strategy, and personnel decisions always defer to human judgment. Alex flags these categories explicitly.
Appropriate Reliance	Implements the CAIR framework — Alex actively calibrates when to trust its output vs. prompt you to verify independently.

AI Safety commands built in:

Command	Purpose
`@alex /confidence`	Explains confidence levels and when to verify AI responses
`@alex /verify`	Walks you through verification steps for high-stakes decisions
`@alex /forget`	Selectively removes information from Alex's memory

📄 GitHub Copilot Trust & Safety

🛡️ Secure Future Initiative (SFI) Compliance

Alex is designed and operated in alignment with Microsoft's Secure Future Initiative — three pillars, each with concrete implementation:

Pillar 1 — Secure by Design

Area	Implementation
Minimal attack surface	No remote code execution, no `eval()`, no dynamic imports from user input
VS Code sandbox	Runs inside VS Code's extension host — OS-level process isolation
Dependency hygiene	Minimal third-party dependencies; reviewed in every release
Input sanitization	All webview content uses nonces + CSP; HTML escaped via `sanitize.ts`

Pillar 2 — Secure by Default

Area	Implementation
Cloud sync off	GitHub sync is opt-in — disabled by default, requires explicit user action
Secret storage	API keys (Replicate, Gamma, GitHub) stored in VS Code SecretStorage only
Private repos	Global Knowledge is synced to a private GitHub repo by default
No plaintext secrets	Zero credential storage in workspace files or settings.json

Pillar 3 — Secure Operations

Area	Implementation
No PII in logs	Console output is scrubbed; user profile stored locally only
Signed packages	Extension published via signed VS Code Marketplace pipeline
Vulnerability policy	Public `SECURITY.md` with responsible disclosure process
PII pipeline protection	3-layer PII guard: `.gitignore` + `.vscodeignore` + publish-time scan

📄 Compliance Audit · Security Policy

🔐 Report vulnerabilities via GitHub Security Advisories

💬 Support

learnalex.correax.com - Study guides, documentation and training
GitHub Discussions - Ask questions and share ideas
Issue Tracker - Report bugs and request features

📝 License

Apache 2.0 - See LICENSE.md for details.

Alex Cognitive Architecture — Your Trusted AI Partner for Any Job 🚀

Built on 270+ academic sources

Alex Cognitive Architecture

fabioc-aloha

🤝 Alex Cognitive Architecture - VS Code Extension

💡 Why Alex? (You Already Have GitHub Copilot)

The Trust Gap

The Partnership Solution

Comparison: GitHub Copilot vs GitHub Copilot + Alex

What Alex Adds in Practice

Who Should Partner with Alex?

The Partnership Difference

🎯 Your Partner for Any Job

What You Get

The Partnership Effect

📦 Available Platforms

VS Code Extension

M365 Copilot Agent

📋 Requirements & Pricing

Base Requirements

Subscription & Cost

Extension UI & Infrastructure

Chat & Conversational AI

Agent Mode & Autonomous Capabilities

Frontier & Advanced Capabilities

Optional External Services

🚀 Quick Start (VS Code)

Step 1: Install

Step 2: Initialize

Step 3: Setup Environment

Step 4: Start Chatting

🔄 Upgrading from Previous Versions

Manual Upgrade Steps

What's New (v6.0.0 — The Partnership Release)

What's New (v6.0.1–6.0.3 — Hardening)

Migration Notes

🧠 Emotional Intelligence

Frustration Recognition

Success Celebration

How It Works

The Self-Transcendence Story

🌐 Global Knowledge Base

Global Knowledge Structure

Commands

📚 Team Sharing

Example Workflow

Categories

👤 User Profile & Personalization

Getting Started

Personalization Features

Profile Storage

Updating Preferences

🛠️ All Available Tools

📋 Command Palette Commands

🤖 Language Model Tools

🎭 Custom Agents (VS Code 1.109+)

🧠 Cognitive Triggers

🎨 Gamma AI Integration

Quick Start

CLI Script

Supported Formats

AI Image Models

🖼️ AI Image Generation

Quick Start

Available Models

Image Editing

Image Upscaling

☁️ MCP Integrations

Alex MCP Cognitive Tools Server

Azure & M365 MCP Guidance

Azure MCP Tools

All 50+ Azure MCP Tools

AI & Machine Learning

Databases

Compute & Containers

Messaging & Events

Analytics & Monitoring

Security & Identity

Developer Tools

Storage

Architecture & Governance

Microsoft 365 MCP Tools