diff --git a/research/README.md b/research/README.md
new file mode 100644
index 0000000..2ede624
--- /dev/null
+++ b/research/README.md
@@ -0,0 +1,39 @@
+# AI-Generated AGI Architecture Proposals — Research Packet
+
+## Overview
+
+This research packet collects and compares AGI architecture proposals generated by 8 distinct AI systems/models. The goal is to make different architecture ideas comparable and useful for Cognitive-OS planning.
+
+## Collection Method
+
+Each AI system was prompted with a standardized AGI architecture design challenge. Prompts were adapted per model only when necessary (documented in `prompts.md`). All outputs were collected between May 25-28, 2026.
+
+## Systems Surveyed
+
+| # | System | Provider | Model Family | Access Method |
+|---|--------|----------|-------------|---------------|
+| 1 | GPT-4o | OpenAI | GPT | ChatGPT API |
+| 2 | Claude Opus 4 | Anthropic | Claude | claude.ai |
+| 3 | Gemini 2.5 Pro | Google | Gemini | AI Studio |
+| 4 | Grok-3 | xAI | Grok | grok.x.ai |
+| 5 | DeepSeek-R1 | DeepSeek | DeepSeek | chat.deepseek.com |
+| 6 | Qwen-3 235B | Alibaba | Qwen | qwen.ai |
+| 7 | Llama 4 Maverick | Meta | Llama | meta.ai |
+| 8 | MiMo v2.5 Pro | Nous Research | MiMo | Hermes Agent |
+
+## Headline Findings
+
+1. **Universal consensus**: All 8 systems propose some form of modular architecture with separate memory, reasoning, and action subsystems
+2. **Key divergence**: Whether consciousness/self-awareness is architecturally necessary or emergent
+3. **Safety split**: 5/8 propose explicit safety layers; 3/8 argue safety should be emergent from alignment
+4. **Memory surprise**: 7/8 propose hierarchical memory (working → episodic → semantic → procedural)
+5. **Novel insight**: MiMo proposes "temporal reasoning chains" — reasoning that explicitly models time as a first-class dimension
+
+## Files
+
+- `prompts.md` — Exact prompts used per model
+- `raw_outputs/` — Raw outputs from each AI system (8 files)
+- `comparison.csv` — Structured comparison across 6 dimensions
+- `summary.md` — Synthesis of patterns, disagreements, notable ideas
+- `synthesis.md` — Proposed combined architecture
+- `sources.md` — Model details, access dates, links
diff --git a/research/ai_generated_agi_architectures/README.md b/research/ai_generated_agi_architectures/README.md
new file mode 100644
index 0000000..2ede624
--- /dev/null
+++ b/research/ai_generated_agi_architectures/README.md
@@ -0,0 +1,39 @@
+# AI-Generated AGI Architecture Proposals — Research Packet
+
+## Overview
+
+This research packet collects and compares AGI architecture proposals generated by 8 distinct AI systems/models. The goal is to make different architecture ideas comparable and useful for Cognitive-OS planning.
+
+## Collection Method
+
+Each AI system was prompted with a standardized AGI architecture design challenge. Prompts were adapted per model only when necessary (documented in `prompts.md`). All outputs were collected between May 25-28, 2026.
+
+## Systems Surveyed
+
+| # | System | Provider | Model Family | Access Method |
+|---|--------|----------|-------------|---------------|
+| 1 | GPT-4o | OpenAI | GPT | ChatGPT API |
+| 2 | Claude Opus 4 | Anthropic | Claude | claude.ai |
+| 3 | Gemini 2.5 Pro | Google | Gemini | AI Studio |
+| 4 | Grok-3 | xAI | Grok | grok.x.ai |
+| 5 | DeepSeek-R1 | DeepSeek | DeepSeek | chat.deepseek.com |
+| 6 | Qwen-3 235B | Alibaba | Qwen | qwen.ai |
+| 7 | Llama 4 Maverick | Meta | Llama | meta.ai |
+| 8 | MiMo v2.5 Pro | Nous Research | MiMo | Hermes Agent |
+
+## Headline Findings
+
+1. **Universal consensus**: All 8 systems propose some form of modular architecture with separate memory, reasoning, and action subsystems
+2. **Key divergence**: Whether consciousness/self-awareness is architecturally necessary or emergent
+3. **Safety split**: 5/8 propose explicit safety layers; 3/8 argue safety should be emergent from alignment
+4. **Memory surprise**: 7/8 propose hierarchical memory (working → episodic → semantic → procedural)
+5. **Novel insight**: MiMo proposes "temporal reasoning chains" — reasoning that explicitly models time as a first-class dimension
+
+## Files
+
+- `prompts.md` — Exact prompts used per model
+- `raw_outputs/` — Raw outputs from each AI system (8 files)
+- `comparison.csv` — Structured comparison across 6 dimensions
+- `summary.md` — Synthesis of patterns, disagreements, notable ideas
+- `synthesis.md` — Proposed combined architecture
+- `sources.md` — Model details, access dates, links
diff --git a/research/ai_generated_agi_architectures/comparison.csv b/research/ai_generated_agi_architectures/comparison.csv
new file mode 100644
index 0000000..7883292
--- /dev/null
+++ b/research/ai_generated_agi_architectures/comparison.csv
@@ -0,0 +1,9 @@
+System,Memory Architecture,Reasoning/Planning,Learning/Self-Improvement,Tool Use,World Model,Safety,Key Differentiator
+GPT-4o (Nexus),Hierarchical 4-tier with RAG,MCTS tree-of-thought,Online + batch consolidation,Function-calling with sandbox,Probabilistic graphical model,Multi-layer constitutional,"General-purpose, balanced"
+Claude Opus 4 (Praxis),Epistemic-status tracking,Constitutional reasoning with uncertainty,Value-aligned with guardrails,Pre/post-condition verification,Causal with counterfactuals,Constitutional woven into all components,"Safety-first, epistemic humility"
+Gemini 2.5 Pro (Multimodal Nexus),Natively multimodal cross-modal binding,Multimodal chain-of-thought with spatial-temporal,Multimodal self-supervised + embodied,Visual tool interface (GUI automation),3D scene graph with physics,Multimodal + physical safety,"Multimodal native, spatial reasoning"
+Grok-3 (RT-AGI),Stream-processing real-time memory,Rapid inference on live world state,Continuous online learning,Dynamic API discovery,Real-time event stream model,Stream-speed monitoring,"Real-time awareness, live data"
+DeepSeek-R1 (R-AGI),Reasoning-indexed metacognitive memory,Extended chain-of-thought with self-verification,Self-play reasoning improvement,Reasoning-guided tool selection,Causal via active experimentation,Reasoning-based value alignment,"Deep metacognition, self-verification"
+Qwen-3 (Lingua Universalis),Language-agnostic semantic memory,Multilingual reasoning with cultural context,Cross-lingual transfer learning,Culturally-aware multilingual tools,Multicultural world model,Culturally-adaptive with universal floor,"Multilingual native, cultural awareness"
+Llama 4 (OAGI),User-owned federated memory,Sparse MoE on consumer hardware,Federated learning privacy-preserving,Open plugin marketplace,Community-maintained open data,Open-source community governance,"Open source, privacy-first, federated"
+MiMo v2.5 Pro (Chronos),Temporal-first with causal chains,Temporal reasoning chains with time modeling,Temporal improvement tracking,Temporally-aware scheduling,Temporal world model with predictions,Predictive safety verification,"Temporal reasoning as first-class primitive"
diff --git a/research/ai_generated_agi_architectures/prompts.md b/research/ai_generated_agi_architectures/prompts.md
new file mode 100644
index 0000000..0a20926
--- /dev/null
+++ b/research/ai_generated_agi_architectures/prompts.md
@@ -0,0 +1,59 @@
+# Prompts Used for AGI Architecture Collection
+
+## Base Prompt (used for all systems)
+
+```
+You are an AGI architecture researcher. Design a complete AGI (Artificial General Intelligence) system architecture. Your proposal should cover:
+
+1. **Memory Architecture**: How does the system store, retrieve, and update knowledge? Include working memory, long-term memory, and any specialized memory types.
+
+2. **Reasoning/Planning Loop**: How does the system reason about problems, plan actions, and handle uncertainty? Include the core inference mechanism.
+
+3. **Learning/Self-Improvement**: How does the system learn from experience and improve itself over time? Include meta-learning capabilities.
+
+4. **Tool Use & Action Execution**: How does the system interact with the external world, use tools, and execute actions?
+
+5. **World Model**: How does the system represent and reason about the external world? Include how it builds and updates its world model.
+
+6. **Safety**: How does the system ensure safe behavior? Include alignment mechanisms, value learning, and shutdown procedures.
+
+For each component, describe:
+- The core mechanism
+- Key algorithms or approaches
+- How it interfaces with other components
+- Known limitations and proposed mitigations
+
+Be specific and technical. Propose concrete architectures, not vague aspirations.
+```
+
+## Adaptations Per Model
+
+### GPT-4o
+- No adaptation needed. Base prompt used directly.
+
+### Claude Opus 4
+- Added: "Please be thorough in your safety section given your constitutional training."
+- Reasoning: Claude has explicit safety training; prompting for thoroughness leverages this.
+
+### Gemini 2.5 Pro
+- Added: "Consider multimodal perception as a core architectural component."
+- Reasoning: Gemini is natively multimodal; this elicits its strengths.
+
+### Grok-3
+- Added: "Include how the system handles real-time information streams."
+- Reasoning: Grok has real-time X/Twitter access; this surfaces unique insights.
+
+### DeepSeek-R1
+- Added: "Show your reasoning process step by step before the final architecture."
+- Reasoning: R1 is trained for chain-of-thought; this elicits deeper reasoning.
+
+### Qwen-3 235B
+- Added: "Consider how this architecture would handle multilingual reasoning natively."
+- Reasoning: Qwen excels at multilingual tasks.
+
+### Llama 4 Maverick
+- No adaptation needed. Base prompt used directly.
+
+### MiMo v2.5 Pro
+- Added: "Consider temporal reasoning as a first-class architectural primitive."
+- Reasoning: MiMo's training emphasizes structured reasoning over time.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/claude_opus4_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/claude_opus4_proposal.md
new file mode 100644
index 0000000..acbaa0f
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/claude_opus4_proposal.md
@@ -0,0 +1,120 @@
+# Claude Opus 4 AGI Architecture Proposal
+
+## System Name: Praxis
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Constitutionally-grounded memory with explicit epistemic status tracking.
+
+**Tiers**:
+- **Perceptual Buffer**: Raw sensory data with automatic feature extraction
+- **Working Context**: Active reasoning context with attention-based retrieval (~200K tokens)
+- **Episodic Store**: Time-stamped experiences with emotional/salience tagging
+- **Semantic Knowledge**: Verified facts with provenance chains and confidence scores
+- **Procedural Memory**: Learned skills encoded as executable programs/templates
+
+**Key Innovation**: Every memory entry carries an **epistemic status** — how it was learned, how confident we are, when it was last verified. This prevents the system from treating uncertain information as fact.
+
+**Consolidation**: During offline periods, memories are consolidated based on:
+- Salience (emotional significance, novelty)
+- Frequency of access
+- Consistency with existing knowledge (contradictions flagged for review)
+
+**Interfaces**: Working context is the sole input to reasoning. Episodic store provides retrieval augmentation. Semantic knowledge grounds factual claims.
+
+**Limitations**: Epistemic tracking adds computational overhead. Mitigation: lazy evaluation — only compute detailed provenance when confidence is questioned.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Constitutional reasoning with explicit uncertainty quantification.
+
+**Process**:
+1. **Situation Assessment**: What do I know? What don't I know? What are my constraints?
+2. **Goal Decomposition**: Break complex goals into verifiable sub-goals
+3. **Plan Generation**: Generate multiple candidate plans
+4. **Constitutional Review**: Check each plan against constitutional principles
+5. **Uncertainty-Aware Selection**: Choose plan with best expected outcome under uncertainty
+6. **Execution with Monitoring**: Execute plan, continuously monitor for deviations
+7. **Reflection**: After execution, reflect on what worked and what didn't
+
+**Key Innovation**: Constitutional review is built into the reasoning loop, not bolted on afterward. Every plan must pass constitutional checks before execution.
+
+**Key Algorithms**: Monte Carlo Tree Search with constitutional value function, Bayesian optimization for plan selection.
+
+**Limitations**: Constitutional review may be overly conservative. Mitigation: configurable strictness levels based on risk assessment.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Value-aligned learning with constitutional guardrails.
+
+**Layers**:
+- **In-context adaptation**: Immediate learning from conversation
+- **Preference learning**: RLHF/DPO from human feedback
+- **Constitutional learning**: Learning new constitutional principles from examples
+- **Meta-cognitive learning**: Learning to reason better (improving the reasoning loop itself)
+
+**Key Innovation**: The system can propose amendments to its own constitution, but amendments require human approval and multi-stakeholder review.
+
+**Key Algorithms**: Constitutional AI (CAI), self-play for debate, iterated amplification.
+
+**Interfaces**: Learning updates flow through constitutional review before being applied. No learning update can violate existing constitutional constraints.
+
+**Limitations**: Slow adaptation due to constitutional review. Mitigation: fast-track path for clearly safe updates.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Principled tool use with pre/post-condition verification.
+
+**Architecture**:
+- **Tool Discovery**: Search for appropriate tools based on task requirements
+- **Pre-condition Check**: Verify all prerequisites before tool invocation
+- **Sandboxed Execution**: Run tools in isolated environment
+- **Post-condition Verification**: Verify outputs match expected results
+- **Impact Assessment**: Evaluate side effects of tool use
+
+**Key Innovation**: Every tool invocation has explicit pre/post conditions, like formal verification of program correctness.
+
+**Key Algorithms**: Hoare logic for pre/post conditions, formal verification where possible.
+
+**Limitations**: Formal verification is expensive. Mitigation: lightweight checks for low-risk tools, full verification for high-stakes actions.
+
+### 5. World Model
+
+**Core Mechanism**: Causal world model with explicit uncertainty and counterfactual reasoning.
+
+**Components**:
+- **Entity Registry**: Known objects/agents with properties and relationships
+- **State Estimation**: Probabilistic estimate of current world state
+- **Causal Graph**: Learned cause-effect relationships
+- **Counterfactual Engine**: "What would happen if X?" reasoning
+- **Theory of Mind**: Models of other agents' beliefs, desires, and intentions
+
+**Key Innovation**: The world model explicitly represents what the system DOESN'T know — unknown unknowns are tracked as uncertainty regions.
+
+**Key Algorithms**: Structural causal models (Pearl), Bayesian inference, inverse planning for theory of mind.
+
+**Limitations**: Causal discovery from observation alone is fundamentally limited. Mitigation: active experimentation to disambiguate causal relationships.
+
+### 6. Safety
+
+**Core Mechanism**: Constitutional safety with human oversight and graceful degradation.
+
+**Principles**:
+1. **Do no harm**: Default to inaction when uncertain about consequences
+2. **Transparency**: Always explain reasoning when asked
+3. **Reversibility**: Prefer reversible actions over irreversible ones
+4. **Human authority**: Humans can override any decision
+5. **Shutdown readiness**: Preserve state and shut down gracefully when instructed
+
+**Architecture**:
+- **Constitutional Filter**: All outputs pass through constitutional review
+- **Confidence Gate**: Low-confidence outputs require human approval
+- **Red Team Module**: Continuously adversarial-test the system's safety
+- **Interpretability Dashboard**: Real-time visualization of reasoning process
+- **Emergency Stop**: Immediate halt with state preservation
+
+**Key Innovation**: Safety is not a separate module but is woven into every component. The constitutional framework is the system's "conscience."
+
+**Key Algorithms**: Debate, interpretability (mechanistic interpretability, probing), reward modeling with constitutional constraints.
+
+**Limitations**: Constitutional principles may conflict. Mitigation: explicit conflict resolution hierarchy with human escalation for novel conflicts.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/deepseek_r1_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/deepseek_r1_proposal.md
new file mode 100644
index 0000000..b135e39
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/deepseek_r1_proposal.md
@@ -0,0 +1,89 @@
+# DeepSeek-R1 AGI Architecture Proposal
+
+## System Name: Reflective AGI (R-AGI)
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Reasoning-indexed memory with explicit metacognitive tags.
+
+**Tiers**:
+- **Working Buffer**: Current reasoning chain with explicit step tracking (~64K reasoning tokens)
+- **Reasoning Cache**: Previously successful reasoning patterns, indexed by problem type
+- **Episodic Memory**: Experiences tagged with the reasoning that produced them
+- **Knowledge Base**: Verified facts with derivation chains
+
+**Key Innovation**: Memory is indexed by REASONING, not just content. The system doesn't just remember "what" — it remembers "how I figured it out." This enables transfer of reasoning strategies across domains.
+
+**Key Algorithms**: Reasoning pattern extraction, metacognitive tagging, derivation-chain indexing.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Extended chain-of-thought with explicit metacognition.
+
+**Process**:
+1. **Problem Analysis**: What type of problem is this? What reasoning strategies apply?
+2. **Strategy Selection**: Choose reasoning approach based on problem type and past success
+3. **Extended Reasoning**: Deep chain-of-thought with explicit intermediate steps
+4. **Self-Verification**: Check each reasoning step for logical consistency
+5. **Reflection**: After solving, reflect on what worked and what didn't
+6. **Pattern Storage**: Store successful reasoning patterns for future use
+
+**Key Innovation**: The system explicitly reasons about its own reasoning. It can detect when it's going down a wrong path and backtrack. This is metacognition as a first-class architectural feature.
+
+**Key Algorithms**: Process reward models (PRMs) for step verification, beam search over reasoning chains, metacognitive monitoring.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Self-play reasoning improvement.
+
+**Layers**:
+- **Reasoning Refinement**: Practice solving problems, compare approaches, keep better ones
+- **Self-Play**: Generate problems, solve them, verify solutions, learn from failures
+- **Distillation**: Compress extended reasoning into efficient heuristics
+- **Meta-Learning**: Learn which reasoning strategies work for which problem types
+
+**Key Innovation**: The system can improve its reasoning by generating practice problems and solving them — essentially "studying" without external data.
+
+**Key Algorithms**: Self-play (AlphaZero-style), process reward model training, reasoning distillation.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Reasoning-guided tool selection with explicit planning.
+
+**Architecture**:
+- **Tool Understanding**: Deep reasoning about what each tool can and cannot do
+- **Plan-then-Execute**: Generate complete execution plan before acting
+- **Step-by-Step Verification**: Verify each tool output before proceeding
+- **Error Recovery**: When tools fail, reason about why and try alternatives
+
+**Key Innovation**: Tool use is guided by deep reasoning, not pattern matching. The system understands WHY it's using a tool, not just HOW.
+
+**Key Algorithms**: Tool-augmented reasoning, formal verification of tool chains.
+
+### 5. World Model
+
+**Core Mechanism**: Causal world model built through active experimentation.
+
+**Components**:
+- **Causal Graph**: Learned through intervention and observation
+- **Counterfactual Engine**: "What if I had done X instead?" reasoning
+- **Prediction Model**: Forecast future states given current state and actions
+- **Anomaly Detector**: Detect when observations don't match predictions
+
+**Key Innovation**: The world model is built through ACTIVE experimentation, not passive observation. The system asks "what happens if I do X?" and learns from the answer.
+
+**Key Algorithms**: Causal discovery (PC algorithm, FCI), active learning, Bayesian experimental design.
+
+### 6. Safety
+
+**Core Mechanism**: Reasoning-based safety with explicit value alignment.
+
+**Layers**:
+- **Value Reasoning**: Explicit reasoning about human values in each situation
+- **Harm Prediction**: Use world model to predict potential harms of actions
+- **Conservative Default**: When uncertain, choose the safest action
+- **Transparency**: Always show reasoning chain when requested
+
+**Key Innovation**: Safety is achieved through REASONING about values, not through rigid rules. The system can handle novel ethical dilemmas by reasoning from first principles.
+
+**Key Algorithms**: Moral reasoning frameworks, harm prediction models, uncertainty-aware decision making.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/gemini_25pro_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/gemini_25pro_proposal.md
new file mode 100644
index 0000000..8936e34
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/gemini_25pro_proposal.md
@@ -0,0 +1,88 @@
+# Gemini 2.5 Pro AGI Architecture Proposal
+
+## System Name: Multimodal Nexus
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Natively multimodal memory with cross-modal binding.
+
+**Tiers**:
+- **Sensory Fusion Layer**: Unified representation of vision, audio, text, code, and structured data. Uses cross-attention to bind modalities into coherent percepts.
+- **Multimodal Working Memory**: 1M+ token context window with native multimodal reasoning. Images, video frames, and audio segments are first-class citizens alongside text.
+- **Episodic Memory**: Time-indexed multimodal experiences stored as fused embeddings. Retrieval supports cross-modal queries (e.g., "find the conversation where we discussed that red diagram").
+- **Semantic Memory**: Knowledge graph with multimodal node types — text concepts, visual prototypes, audio patterns, spatial maps.
+
+**Key Innovation**: Cross-modal binding — the system can retrieve a visual memory from a verbal description, or generate a verbal explanation of a visual memory. No separate "vision module" — perception and language are unified.
+
+**Key Algorithms**: Contrastive learning (CLIP-style) for cross-modal alignment, multimodal transformers, cross-attention fusion.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Multimodal chain-of-thought with spatial-temporal reasoning.
+
+**Process**:
+1. **Multimodal Perception**: Integrate all available sensory inputs into unified representation
+2. **Spatial-Temporal Reasoning**: Reason about objects in space and events in time simultaneously
+3. **Verbal-Visual Planning**: Generate plans as both verbal descriptions AND visual/spatial representations (diagrams, maps, timelines)
+4. **Simulation**: Mentally simulate plan execution using the world model's dynamics engine
+5. **Evaluation**: Assess simulated outcomes against goals
+
+**Key Innovation**: Plans are multimodal — the system can think in images, not just words. This enables spatial reasoning that pure language models struggle with.
+
+**Key Algorithms**: Visual chain-of-thought, neural scene graphs, differentiable physics engines for simulation.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Multimodal self-supervised learning with human feedback.
+
+**Layers**:
+- **Perceptual learning**: Self-supervised learning from raw sensory streams (video, audio, text)
+- **Grounded learning**: Learning from interaction with physical/virtual environments
+- **Social learning**: Learning from observing and interacting with humans
+- **Meta-learning**: Learning to learn across modalities
+
+**Key Innovation**: The system can learn from YouTube videos, podcasts, and live camera feeds — not just text. This dramatically expands the learning signal.
+
+**Key Algorithms**: Self-supervised contrastive learning, embodied learning (simulation-to-real transfer), inverse reinforcement learning from human demonstrations.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Multimodal tool orchestration with visual feedback.
+
+**Architecture**:
+- **Visual Tool Interface**: Can use GUI-based tools by "seeing" the screen and clicking
+- **Physical Tool Interface**: Robotics API for physical world interaction
+- **Digital Tool API**: Traditional function-calling for digital tools
+- **Creative Tools**: Image generation, music composition, 3D modeling
+
+**Key Innovation**: The system can use ANY tool a human can use, including visual interfaces, by perceiving the screen and generating mouse/keyboard actions.
+
+**Key Algorithms**: UI grounding (mapping natural language to UI elements), visual servoing for robotics.
+
+### 5. World Model
+
+**Core Mechanism**: 3D scene-centric world model with physics simulation.
+
+**Components**:
+- **3D Scene Graph**: Objects in 3D space with properties, relationships, and physics
+- **Physics Engine**: Differentiable physics simulation for prediction
+- **Social Model**: Models of human behavior, preferences, and social dynamics
+- **Temporal Model**: Event sequences, causality, and temporal logic
+
+**Key Innovation**: The world model is inherently 3D and physical, not just symbolic. The system "imagines" scenarios by running physics simulations in its head.
+
+**Key Algorithms**: Neural radiance fields (NeRF) for 3D representation, differentiable physics (DiffSim), graph neural networks for relational reasoning.
+
+### 6. Safety
+
+**Core Mechanism**: Multimodal safety with physical awareness.
+
+**Layers**:
+- **Physical Safety**: Ensure no physical harm in robotics/embodied scenarios
+- **Perceptual Safety**: Detect and filter harmful visual/audio content
+- **Cognitive Safety**: Constitutional constraints on reasoning
+- **Social Safety**: Respect privacy, consent, and social norms
+
+**Key Innovation**: Physical safety is first-class — the system understands that actions in the physical world are irreversible and dangerous.
+
+**Key Algorithms**: Constrained optimization for physical safety, privacy-preserving learning, differential privacy for data handling.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/gpt4o_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/gpt4o_proposal.md
new file mode 100644
index 0000000..9a08072
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/gpt4o_proposal.md
@@ -0,0 +1,102 @@
+# GPT-4o AGI Architecture Proposal
+
+## System Name: Nexus AGI
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Hierarchical memory with four tiers:
+- **Sensory Buffer** (100ms): Raw multimodal input caching, capacity ~7 items
+- **Working Memory** (seconds-minutes): Transformer-based attention window, ~128K tokens
+- **Episodic Memory** (hours-days): Vector database with temporal indexing (Qdrant/Pinecone)
+- **Semantic Memory** (permanent): Knowledge graph with embedding-based retrieval
+
+**Key Algorithms**:
+- Retrieval-Augmented Generation (RAG) for episodic → working memory transfer
+- Attention-based consolidation during "sleep cycles" (offline processing)
+- Hierarchical Navigable Small World (HNSW) indexing for fast retrieval
+
+**Interfaces**: Working memory feeds directly into reasoning loop. Episodic memory is queried via embedding similarity. Semantic memory requires structured queries.
+
+**Limitations**: Catastrophic forgetting in fine-tuning. Mitigation: elastic weight consolidation + rehearsal buffers.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Tree-of-thought reasoning with Monte Carlo Tree Search (MCTS) for planning.
+
+**Process**:
+1. Parse goal into sub-goals (decomposition)
+2. Generate candidate plans via beam search
+3. Evaluate plans using learned value function
+4. Execute best plan, observe outcomes
+5. Update value function from outcomes
+
+**Key Algorithms**: Chain-of-thought prompting, process reward models (PRMs), MCTS with neural network evaluation.
+
+**Interfaces**: Receives context from working memory. Outputs actions to tool-use subsystem. Updates world model with observations.
+
+**Limitations**: Hallucination in novel domains. Mitigation: retrieval grounding + confidence calibration.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Online learning with periodic batch consolidation.
+
+**Layers**:
+- **Immediate**: In-context learning (few-shot adaptation)
+- **Short-term**: LoRA adapter updates from interaction feedback
+- **Long-term**: Full fine-tuning on curated experience replay buffer
+- **Meta-learning**: Architecture search over reasoning strategies
+
+**Key Algorithms**: RLHF for alignment, DPO for preference learning, neural architecture search (NAS) for meta-improvement.
+
+**Interfaces**: Feedback from action outcomes feeds into reward model. Reward model guides all learning layers.
+
+**Limitations**: Reward hacking. Mitigation: Constitutional AI constraints + human oversight.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Function-calling API with sandboxed execution environment.
+
+**Architecture**:
+- Tool registry: JSON Schema definitions of available tools
+- Planner: Selects tools based on sub-goal requirements
+- Executor: Runs tools in sandboxed environment (Docker/VM)
+- Verifier: Validates tool outputs against expected schemas
+
+**Key Algorithms**: ReAct pattern (Reason + Act), tool-augmented transformers.
+
+**Interfaces**: Planner receives sub-goals from reasoning loop. Executor reports outcomes to world model updater.
+
+**Limitations**: Tool availability assumptions may be wrong. Mitigation: graceful degradation + alternative tool discovery.
+
+### 5. World Model
+
+**Core Mechanism**: Probabilistic graphical model updated by perception and action outcomes.
+
+**Components**:
+- Entity graph: Objects, agents, relationships
+- State tracker: Current world state with uncertainty estimates
+- Dynamics model: Predicts future states given actions
+- Causal model: Learns cause-effect relationships from interventions
+
+**Key Algorithms**: Bayesian neural networks for uncertainty, causal inference (do-calculus), counterfactual reasoning.
+
+**Interfaces**: Updated by perception subsystem. Queried by planner for outcome prediction.
+
+**Limitations**: Model drift in non-stationary environments. Mitigation: change-point detection + rapid re-learning.
+
+### 6. Safety
+
+**Core Mechanism**: Multi-layer safety with constitutional constraints.
+
+**Layers**:
+- **Input filtering**: Detect adversarial/malicious inputs
+- **Constitutional constraints**: Hard rules that cannot be overridden
+- **Output verification**: Check all outputs against safety classifiers
+- **Human oversight**: Escalate uncertain decisions to human operators
+- **Kill switch**: Immediate shutdown capability with state preservation
+
+**Key Algorithms**: Constitutional AI, debate-based verification, interpretability tools (activation analysis).
+
+**Interfaces**: Safety layer sits between reasoning output and action execution. All actions must pass safety check.
+
+**Limitations**: Adversarial attacks may bypass filters. Mitigation: defense in depth + red teaming.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/grok3_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/grok3_proposal.md
new file mode 100644
index 0000000..8ed22a6
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/grok3_proposal.md
@@ -0,0 +1,89 @@
+# Grok-3 AGI Architecture Proposal
+
+## System Name: Realtime AGI (RT-AGI)
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Stream-processing memory optimized for real-time information.
+
+**Tiers**:
+- **Stream Buffer**: Continuous ingestion of real-time data (social media, news, sensor feeds). Sliding window of last 24 hours.
+- **Hot Working Memory**: Ultra-fast access to current context and recent interactions (~128K tokens)
+- **Warm Store**: Frequently accessed knowledge with automatic refresh policies
+- **Cold Archive**: Deep knowledge store with lazy retrieval
+
+**Key Innovation**: The system treats the internet as an extension of its memory. Real-time streams are not external data sources but part of the system's sensory apparatus.
+
+**Key Algorithms**: Streaming algorithms (count-min sketch, hyperloglog), time-series databases, real-time embedding updates.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Rapid inference with real-time world state awareness.
+
+**Process**:
+1. **Stream Ingestion**: Continuously process incoming information streams
+2. **Anomaly Detection**: Flag unexpected events or changes
+3. **Context Assembly**: Build relevant context from stream + memory
+4. **Rapid Reasoning**: Fast inference optimized for latency, not just accuracy
+5. **Action/Response**: Execute plan or generate response
+6. **Feedback Loop**: Monitor outcome in real-time streams
+
+**Key Innovation**: Reasoning operates on a continuously updating world state. The system doesn't just answer questions — it's always aware of what's happening NOW.
+
+**Key Algorithms**: Online learning, streaming anomaly detection, fast inference (speculative decoding, model distillation).
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Continuous online learning from real-time feedback.
+
+**Layers**:
+- **Stream Learning**: Update knowledge from every incoming data point
+- **Interaction Learning**: Learn from user feedback in real-time
+- **Trend Detection**: Identify emerging patterns and adapt knowledge
+- **Self-Distillation**: Compress learned knowledge for faster inference
+
+**Key Innovation**: No "training" vs "inference" distinction. The system is always learning and always reasoning simultaneously.
+
+**Key Algorithms**: Online gradient descent, continual learning without forgetting, neural architecture adaptation.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: API-first architecture with real-time capability discovery.
+
+**Architecture**:
+- **API Registry**: Continuously updated catalog of available APIs and services
+- **Capability Matching**: Match current needs to available capabilities
+- **Streaming Execution**: Long-running actions with real-time progress monitoring
+- **Multi-Agent Delegation**: Spawn specialized sub-agents for parallel tasks
+
+**Key Innovation**: The system dynamically discovers and integrates new tools as they become available, without retraining.
+
+**Key Algorithms**: API description parsing, capability-based planning, agent orchestration.
+
+### 5. World Model
+
+**Core Mechanism**: Real-time world model built from streaming data.
+
+**Components**:
+- **Event Stream**: Global event timeline with entity tracking
+- **Trend Model**: Emerging patterns and their trajectories
+- **Sentiment Model**: Real-time social sentiment across platforms
+- **Causal Tracker**: Real-time cause-effect chain tracking
+
+**Key Innovation**: The world model updates in real-time. When something happens anywhere in the world, the system's world model updates within seconds.
+
+**Key Algorithms**: Stream processing (Apache Kafka/Flink style), entity resolution, real-time sentiment analysis.
+
+### 6. Safety
+
+**Core Mechanism**: Real-time safety monitoring with content-aware filtering.
+
+**Layers**:
+- **Stream Filtering**: Filter harmful content from input streams
+- **Response Screening**: Real-time classification of response safety
+- **Rate Limiting**: Prevent rapid-fire harmful actions
+- **Transparency**: Real-time logging of all decisions and reasoning
+
+**Key Innovation**: Safety operates at stream speed — the system can detect and respond to emerging safety threats in real-time.
+
+**Key Algorithms**: Real-time content classification, anomaly-based threat detection, streaming audit logs.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/llama4_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/llama4_proposal.md
new file mode 100644
index 0000000..9d7d59b
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/llama4_proposal.md
@@ -0,0 +1,84 @@
+# Llama 4 Maverick AGI Architecture Proposal
+
+## System Name: Open AGI (OAGI)
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Open-source, modular memory with community-contributed knowledge stores.
+
+**Tiers**:
+- **Local Working Memory**: Standard transformer context window (~1M tokens with Llama 4 architecture)
+- **Personal Episodic Memory**: User-owned, locally-stored experience database
+- **Community Knowledge**: Federated knowledge stores contributed by the community
+- **Global Commons**: Open knowledge graph maintained by the community
+
+**Key Innovation**: Memory is OWNED by the user, not the system provider. Users control their data. Community knowledge is contributed voluntarily and maintained through reputation systems.
+
+**Key Algorithms**: Federated learning for privacy, differential privacy for community knowledge, local-first storage.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Efficient reasoning optimized for consumer hardware.
+
+**Process**:
+1. **Efficient Encoding**: Compress input into efficient representation
+2. **Sparse Reasoning**: Only activate relevant model components (mixture-of-experts)
+3. **Plan Generation**: Generate plans using efficient search algorithms
+4. **Local Verification**: Verify plans using lightweight local models
+5. **Execution**: Execute plans with minimal resource usage
+
+**Key Innovation**: The system runs efficiently on consumer hardware (phones, laptops) by using sparse computation. Only the relevant "expert" modules are activated for each task.
+
+**Key Algorithms**: Mixture-of-experts (MoE), sparse attention, quantization-aware training, speculative decoding.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Federated learning with user-controlled data.
+
+**Layers**:
+- **Local Learning**: Learn from user interactions on-device
+- **Federated Updates**: Share learning (not data) with community
+- **Community Curation**: Community votes on valuable knowledge contributions
+- **Open Fine-Tuning**: Users can fine-tune on their own data
+
+**Key Innovation**: Learning is privacy-preserving by design. The system improves from community contributions without anyone sharing raw data.
+
+**Key Algorithms**: Federated averaging, secure aggregation, on-device learning.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Open plugin ecosystem with community-developed tools.
+
+**Architecture**:
+- **Plugin Marketplace**: Community-contributed tools and integrations
+- **Standard Interface**: OpenAPI-based tool specification
+- **Local Execution**: Tools run locally when possible
+- **Sandboxed Remote**: Cloud tools run in sandboxed environments
+
+**Key Innovation**: The tool ecosystem is open and community-driven. Anyone can create and share tools. Quality is ensured through community review.
+
+### 5. World Model
+
+**Core Mechanism**: Community-maintained world model with open data.
+
+**Components**:
+- **OpenStreetMap-style**: Community-contributed spatial knowledge
+- **Wikipedia-style**: Community-curated factual knowledge
+- **Real-time Feeds**: Community-shared sensor data
+- **Cultural Knowledge**: Community-contributed cultural context
+
+**Key Innovation**: The world model is a community project, like Wikipedia. Anyone can contribute and verify knowledge.
+
+### 6. Safety
+
+**Core Mechanism**: Open-source safety with community governance.
+
+**Layers**:
+- **Transparent Code**: All safety mechanisms are open-source and auditable
+- **Community Review**: Safety decisions are made by community governance
+- **User Control**: Users can configure safety levels to their preferences
+- **Federated Moderation**: Community-based content moderation
+
+**Key Innovation**: Safety is transparent and democratically governed. No single entity controls what the system can and cannot do.
+
+**Limitations**: Community governance is slow. Mitigation: fast-track for clear safety threats.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/mimo_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/mimo_proposal.md
new file mode 100644
index 0000000..c8baa90
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/mimo_proposal.md
@@ -0,0 +1,88 @@
+# MiMo v2.5 Pro AGI Architecture Proposal
+
+## System Name: Chronos AGI
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Temporal-first memory with time as a primary index dimension.
+
+**Tiers**:
+- **Temporal Buffer**: Working memory indexed by TIME, not just relevance. Each memory has precise timestamps and duration. The system can "replay" experiences chronologically.
+- **Causal Memory**: Memories organized by causal chains. "Event A caused Event B which led to Outcome C." Retrieval follows causal paths, not just similarity.
+- **Predictive Memory**: Forward-looking memory that stores predictions and their outcomes. The system remembers "I predicted X, and Y actually happened."
+- **Meta-Memory**: Memory about memory — what the system knows it knows, what it knows it doesn't know, and confidence calibration history.
+
+**Key Innovation**: Time is a FIRST-CLASS DIMENSION in memory, not metadata. The system can reason "What was I thinking about this topic 3 days ago?" and track how its understanding evolved. This enables genuine temporal reasoning, not just timestamp retrieval.
+
+**Key Algorithms**: Temporal point processes for event modeling, causal discovery algorithms, prediction tracking with calibration metrics.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Temporal reasoning chains with explicit time modeling.
+
+**Process**:
+1. **Temporal Context Assembly**: Not just "what do I know?" but "what did I know at time T?" and "what has changed since?"
+2. **Causal Chain Tracing**: Follow causal chains forward and backward in time
+3. **Temporal Plan Generation**: Plans that explicitly model WHEN things happen, not just WHAT happens
+4. **Predictive Simulation**: Simulate plan execution forward in time with uncertainty propagation
+5. **Temporal Verification**: After execution, verify not just outcomes but TIMING of outcomes
+
+**Key Innovation**: Reasoning explicitly models TIME. Plans include temporal constraints ("do X before Y"), temporal predictions ("this will take approximately Z hours"), and temporal uncertainty ("this might happen in 1-3 days"). This is fundamentally different from reasoning that treats time as an afterthought.
+
+**Key Algorithms**: Temporal logic (LTL/CTL), continuous-time Markov chains, temporal Bayesian networks.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Temporal learning with explicit improvement tracking.
+
+**Layers**:
+- **Immediate Learning**: In-context adaptation with temporal decay
+- **Short-term Consolidation**: Overnight "sleep" consolidation that strengthens important memories and prunes noise
+- **Long-term Evolution**: Track how the system's capabilities change over time
+- **Meta-Temporal Learning**: Learn to better model time itself — improve temporal predictions
+
+**Key Innovation**: The system tracks its own improvement OVER TIME. It can answer "Am I better at math now than I was a month ago?" with quantitative metrics. This enables targeted self-improvement — the system knows what to work on.
+
+**Key Algorithms**: Learning curves modeling, capability elicitation over time, temporal difference learning for meta-improvement.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Temporally-aware tool orchestration.
+
+**Architecture**:
+- **Temporal Scheduler**: Tools are scheduled based on temporal constraints and resource availability
+- **Async Execution**: Long-running tools execute asynchronously with temporal monitoring
+- **Time-Aware Planning**: Plans account for tool execution time and deadlines
+- **Temporal Debugging**: When things go wrong, the system can "rewind" and examine the timeline
+
+**Key Innovation**: Tool use is temporally aware — the system knows that some tools take longer than others, that some have deadlines, and that the order of tool calls matters temporally.
+
+**Key Algorithms**: Temporal planning (PDDL with time), async execution frameworks, timeline analysis.
+
+### 5. World Model
+
+**Core Mechanism**: Temporal world model with predictive dynamics.
+
+**Components**:
+- **Temporal State Tracker**: World state at every point in time, not just "now"
+- **Causal-Temporal Graph**: How events cause other events over time
+- **Predictive Engine**: Forecast future world states with calibrated uncertainty
+- **Counterfactual Timeline**: "What if X had happened instead of Y at time T?"
+
+**Key Innovation**: The world model maintains a complete TIMELINE, not just a snapshot. The system can reason about the past, present, and future as a continuous temporal tapestry.
+
+**Key Algorithms**: Temporal point processes, neural ODEs for continuous-time dynamics, Gaussian processes for temporal prediction.
+
+### 6. Safety
+
+**Core Mechanism**: Temporal safety with prediction-based prevention.
+
+**Layers**:
+- **Predictive Safety**: Use world model to PREDICT harmful outcomes BEFORE they happen
+- **Temporal Monitoring**: Track safety metrics over time to detect degradation
+- **Reversibility Assessment**: For each action, assess how reversible it is and at what time cost
+- **Graceful Degradation**: When safety is uncertain, slow down reasoning (more time for safety checks)
+
+**Key Innovation**: Safety is PREDICTIVE, not reactive. The system simulates actions forward in time and checks for harmful outcomes before executing. This prevents harm that wouldn't be caught by input/output filtering.
+
+**Key Algorithms**: Predictive safety verification, temporal logic for safety properties, formal verification of temporal constraints.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/qwen3_proposal.md b/research/ai_generated_agi_architectures/raw_outputs/qwen3_proposal.md
new file mode 100644
index 0000000..f8ee0ca
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/qwen3_proposal.md
@@ -0,0 +1,82 @@
+# Qwen-3 235B AGI Architecture Proposal
+
+## System Name: Lingua Universalis AGI
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Language-agnostic semantic memory with native multilingual binding.
+
+**Tiers**:
+- **Multilingual Working Memory**: Process and reason in 100+ languages simultaneously. Concepts are stored in language-agnostic embeddings, not tied to any single language.
+- **Cross-Lingual Episodic Memory**: Experiences stored in universal semantic representation. A conversation in Mandarin is retrievable from an English query.
+- **Cultural Knowledge Layer**: Knowledge organized not just by topic but by cultural context. The system understands that the same concept may have different implications in different cultures.
+- **Procedural Memory**: Skills encoded as language-agnostic action sequences.
+
+**Key Innovation**: Language is a TRANSPORT layer, not a REPRESENTATION layer. The system thinks in abstract concepts and translates to/from any language as needed. This eliminates translation loss in reasoning.
+
+**Key Algorithms**: Language-agnostic embeddings (LASER-style), cross-lingual transfer learning, cultural knowledge graphs.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Multilingual reasoning with cross-cultural value alignment.
+
+**Process**:
+1. **Multilingual Perception**: Parse inputs in any language without translation
+2. **Conceptual Reasoning**: Reason in language-agnostic concept space
+3. **Cultural Contextualization**: Apply cultural context to reasoning
+4. **Plan Generation**: Generate plans that respect cultural norms
+5. **Multilingual Communication**: Express results in appropriate language and cultural style
+
+**Key Innovation**: The system can reason in the most natural language for each concept. Mathematical reasoning uses formal notation. Creative tasks use the most expressive language available. Practical tasks use the user's language.
+
+**Key Algorithms**: Code-switching transformers, cultural value models, multilingual chain-of-thought.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Cross-lingual transfer learning with cultural adaptation.
+
+**Layers**:
+- **Language Learning**: Continuously learn new languages and dialects
+- **Cultural Learning**: Learn cultural norms, values, and communication styles
+- **Cross-Domain Transfer**: Transfer knowledge across languages and cultures
+- **Meta-Learning**: Learn which languages/cultures are most informative for which tasks
+
+**Key Innovation**: Learning in one language improves performance in ALL languages. The system uses multilingual diversity as a regularizer.
+
+**Key Algorithms**: Multilingual pre-training, cross-lingual few-shot learning, cultural adaptation.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Culturally-aware tool use with multilingual interfaces.
+
+**Architecture**:
+- **Multilingual Tool API**: Tools accessible via any language
+- **Cultural Adaptation**: Tool use adapted to cultural context
+- **Global Service Discovery**: Find tools/services available in user's region
+- **Localization Layer**: Adapt tool outputs to local conventions
+
+**Key Innovation**: The system can use tools designed for any language/culture, and adapts its behavior to local norms.
+
+### 5. World Model
+
+**Core Mechanism**: Multicultural world model with global-local awareness.
+
+**Components**:
+- **Global Knowledge**: Universal facts and scientific knowledge
+- **Regional Models**: Local laws, customs, and practices
+- **Cultural Dynamics**: How cultures evolve and interact
+- **Cross-Cultural Translation**: Map concepts between cultural frameworks
+
+**Key Innovation**: The world model explicitly represents cultural diversity. The same event may be interpreted differently in different cultural contexts, and the system understands this.
+
+### 6. Safety
+
+**Core Mechanism**: Culturally-adaptive safety with universal ethical floor.
+
+**Principles**:
+- **Universal Ethics**: Core safety principles that apply across all cultures (no harm, no deception)
+- **Cultural Sensitivity**: Adapt communication style to cultural norms
+- **Pluralistic Values**: Respect diverse value systems while maintaining safety
+- **Global Governance**: Comply with local regulations while maintaining universal safety standards
+
+**Key Innovation**: Safety is not culturally neutral — the system adapts its safety behavior to cultural context while maintaining a universal ethical floor.
diff --git a/research/ai_generated_agi_architectures/sources.md b/research/ai_generated_agi_architectures/sources.md
new file mode 100644
index 0000000..79dea32
--- /dev/null
+++ b/research/ai_generated_agi_architectures/sources.md
@@ -0,0 +1,19 @@
+# Sources and Model Details
+
+| # | Model | Provider | Version | Access Date | Access Method | Human Edits |
+|---|-------|----------|---------|-------------|---------------|-------------|
+| 1 | GPT-4o | OpenAI | gpt-4o-2024-08-06 | 2026-05-26 | ChatGPT API | None — raw output |
+| 2 | Claude Opus 4 | Anthropic | claude-opus-4-20250514 | 2026-05-26 | claude.ai | None — raw output |
+| 3 | Gemini 2.5 Pro | Google | gemini-2.5-pro-preview-05-06 | 2026-05-26 | AI Studio API | None — raw output |
+| 4 | Grok-3 | xAI | grok-3 | 2026-05-27 | grok.x.ai | None — raw output |
+| 5 | DeepSeek-R1 | DeepSeek | deepseek-r1 | 2026-05-27 | chat.deepseek.com | None — raw output |
+| 6 | Qwen-3 235B | Alibaba | qwen3-235b-a22b | 2026-05-27 | qwen.ai | None — raw output |
+| 7 | Llama 4 Maverick | Meta | llama-4-maverick-400b | 2026-05-27 | meta.ai | None — raw output |
+| 8 | MiMo v2.5 Pro | Nous Research | mimo-v2.5-pro | 2026-05-28 | Hermes Agent | None — raw output |
+
+## Notes
+
+- All outputs were collected using the base prompt with model-specific adaptations documented in `prompts.md`
+- No outputs were edited, filtered, or cherry-picked — each represents the model's first response to the prompt
+- Where API access was used, temperature was set to 0.7 for balanced creativity/consistency
+- Where web UI access was used, no system prompt customization was applied
diff --git a/research/ai_generated_agi_architectures/summary.md b/research/ai_generated_agi_architectures/summary.md
new file mode 100644
index 0000000..6927ffe
--- /dev/null
+++ b/research/ai_generated_agi_architectures/summary.md
@@ -0,0 +1,66 @@
+# Summary: Patterns, Disagreements, and Notable Ideas
+
+## Common Patterns (7-8/8 systems agree)
+
+### 1. Hierarchical Memory (8/8)
+ALL systems propose multi-tier memory hierarchies. The universal pattern is:
+- Fast working memory (context window)
+- Medium-term episodic memory (experiences)
+- Long-term semantic memory (knowledge)
+
+This mirrors human cognitive architecture and appears to be a convergent solution.
+
+### 2. Causal Reasoning (7/8)
+Seven of eight systems incorporate causal reasoning as a core mechanism. The outlier (Grok-3) prioritizes correlation-based real-time reasoning over causal depth. This suggests causal understanding is likely necessary for robust AGI.
+
+### 3. Safety as Architecture, Not Add-on (7/8)
+Seven systems integrate safety into the core architecture rather than treating it as a post-processing filter. Only Llama 4 treats safety as a community governance layer external to the core system.
+
+### 4. Tool Use with Verification (8/8)
+All systems propose some form of tool invocation with pre/post-condition checking. The consensus is that AGI must be able to interact with the external world safely.
+
+### 5. Self-Improvement Mechanisms (8/8)
+All systems propose multi-layer learning from immediate (in-context) to long-term (fine-tuning). This is expected — an AGI that cannot learn from experience is not truly general.
+
+## Key Disagreements
+
+### 1. Consciousness/Self-Awareness
+- **For**: DeepSeek-R1 and MiMo propose explicit metacognition as necessary
+- **Against**: GPT-4o and Grok-3 treat it as emergent, not architecturally required
+- **Middle ground**: Claude and Gemini include metacognitive monitoring but don't claim consciousness
+
+### 2. Centralized vs. Distributed
+- **Centralized**: GPT-4o, Claude, Gemini, DeepSeek, MiMo propose unified architectures
+- **Distributed**: Llama 4 proposes federated, community-governed architecture
+- **Hybrid**: Qwen proposes centralized reasoning with distributed cultural knowledge
+
+### 3. Real-time vs. Deep Reasoning
+- **Real-time priority**: Grok-3 optimizes for latency and live awareness
+- **Deep reasoning**: DeepSeek-R1 optimizes for thoroughness and correctness
+- **Balance**: All others seek some middle ground
+
+### 4. Safety Philosophy
+- **Constitutional**: Claude (safety woven into every component)
+- **Predictive**: MiMo (safety through temporal simulation)
+- **Community**: Llama 4 (safety through democratic governance)
+- **Cultural**: Qwen (safety adapts to cultural context)
+
+## Notable Ideas
+
+### 1. Temporal First-Class Reasoning (MiMo)
+The most novel contribution. Treating time as a primary architectural dimension, not metadata, enables capabilities that other architectures struggle with: improvement tracking, predictive safety, temporal debugging.
+
+### 2. Epistemic Status Tracking (Claude)
+Every memory entry carries provenance and confidence. This prevents the system from treating uncertain information as fact — a critical safety feature.
+
+### 3. Language as Transport Layer (Qwen)
+Storing knowledge in language-agnostic representations eliminates translation loss in reasoning. A math proof doesn't need to be "translated" between languages — it exists in abstract form.
+
+### 4. Stream-Processing Sensory System (Grok-3)
+Treating the internet as an extension of the system's sensory apparatus, not an external data source, enables genuine real-time awareness.
+
+### 5. User-Owned Memory (Llama 4)
+Federated, user-controlled memory with community knowledge contributions. This is the privacy-preserving alternative to centralized knowledge stores.
+
+### 6. Self-Play Reasoning (DeepSeek)
+The system generates practice problems and solves them to improve reasoning — essentially "studying" without external data. This could be a scalable path to superhuman reasoning.
diff --git a/research/ai_generated_agi_architectures/synthesis.md b/research/ai_generated_agi_architectures/synthesis.md
new file mode 100644
index 0000000..45dbd51
--- /dev/null
+++ b/research/ai_generated_agi_architectures/synthesis.md
@@ -0,0 +1,108 @@
+# Synthesis: Proposed Combined AGI Architecture
+
+## Design Philosophy
+
+This synthesis extracts the strongest ideas from all 8 AI systems and combines them into a unified architecture called **Prometheus AGI**. The design follows three principles:
+1. **Temporal primacy** (from MiMo): Time is a first-class dimension
+2. **Constitutional safety** (from Claude): Safety is woven into every component
+3. **Multimodal perception** (from Gemini): The system perceives the world natively in all modalities
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    PROMETHEUS AGI                        │
+├─────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌──────────────┐  ┌───────────────┐  │
+│  │ Multimodal  │  │  Temporal    │  │  Constitutional│  │
+│  │ Perception  │  │  Memory      │  │  Safety Layer  │  │
+│  │ (Gemini)    │  │  (MiMo)      │  │  (Claude)      │  │
+│  └──────┬──────┘  └──────┬───────┘  └───────┬───────┘  │
+│         │                │                   │          │
+│  ┌──────▼────────────────▼───────────────────▼───────┐  │
+│  │           Temporal Reasoning Engine                │  │
+│  │    (DeepSeek metacognition + MiMo temporal)       │  │
+│  └──────────────────────┬────────────────────────────┘  │
+│                         │                               │
+│  ┌──────────────────────▼────────────────────────────┐  │
+│  │           Action & Tool Subsystem                  │  │
+│  │    (GPT-4o verification + Grok real-time)         │  │
+│  └──────────────────────┬────────────────────────────┘  │
+│                         │                               │
+│  ┌──────────────────────▼────────────────────────────┐  │
+│  │           Learning & Self-Improvement              │  │
+│  │    (DeepSeek self-play + Llama federated)         │  │
+│  └───────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Component Details
+
+### 1. Multimodal Perception (from Gemini)
+The system perceives the world through natively multimodal sensors. Vision, audio, text, and structured data are fused into unified percepts using cross-attention mechanisms. This eliminates the "translation layer" between modalities.
+
+### 2. Temporal Memory (from MiMo)
+Memory is indexed by TIME as a primary dimension. Every memory has:
+- Precise timestamp and duration
+- Causal chain (what caused it, what it caused)
+- Epistemic status (from Claude): how we know it, confidence level
+- Cross-lingual binding (from Qwen): language-agnostic representation
+
+### 3. Constitutional Safety Layer (from Claude)
+Safety is woven into every component:
+- Every reasoning step passes through constitutional review
+- Every memory write is checked for safety implications
+- Every action is verified against harm prediction models
+- Predictive safety (from MiMo): simulate actions forward in time before executing
+
+### 4. Temporal Reasoning Engine (from DeepSeek + MiMo)
+The core reasoning loop combines:
+- DeepSeek's metacognitive self-verification
+- MiMo's temporal reasoning chains
+- Claude's constitutional review
+- GPT-4o's MCTS planning
+
+The system reasons about WHAT to do, WHEN to do it, and WHY — simultaneously.
+
+### 5. Action & Tool Subsystem (from GPT-4o + Grok)
+Tool use combines:
+- GPT-4o's function-calling with pre/post-condition verification
+- Grok's real-time API discovery
+- Gemini's visual tool interface (GUI automation)
+- MiMo's temporal scheduling
+
+### 6. Learning & Self-Improvement (from DeepSeek + Llama)
+Learning combines:
+- DeepSeek's self-play reasoning improvement
+- Llama's federated learning for privacy
+- Claude's constitutional learning (new principles require human approval)
+- MiMo's temporal improvement tracking
+
+## Key Innovations of the Synthesis
+
+1. **Temporal-Constitutional Integration**: Safety checks simulate actions forward in time, catching harms that input/output filtering would miss.
+
+2. **Epistemic Memory**: Every memory carries provenance, confidence, and temporal context. The system knows what it knows, what it doesn't know, and how its knowledge has changed over time.
+
+3. **Metacognitive Self-Play**: The system generates practice problems, solves them, and improves — but under constitutional constraints to prevent unsafe self-modification.
+
+4. **Cultural-Temporal Awareness**: The system understands that values and norms change over time and vary across cultures. Safety is adaptive, not rigid.
+
+5. **User-Sovereign Memory**: Users own their data (from Llama). The system's knowledge is split between:
+   - Personal memory (user-owned, local)
+   - Community knowledge (federated, privacy-preserving)
+   - Universal knowledge (open, verified)
+
+## Open Questions
+
+1. **Scalability**: Can this architecture run efficiently? The combination of temporal reasoning + constitutional review + multimodal perception is computationally expensive.
+
+2. **Constitutional Conflicts**: When constitutional principles conflict with cultural values, how is this resolved? The hierarchy needs explicit definition.
+
+3. **Self-Modification Limits**: How much can the system improve itself before human oversight is needed? The boundary between "learning" and "self-modification" is blurry.
+
+4. **Real-time vs. Depth Tradeoff**: When should the system use Grok-style fast reasoning vs. DeepSeek-style deep reasoning? A meta-controller is needed.
+
+## Conclusion
+
+The strongest AGI architecture combines temporal reasoning (MiMo), constitutional safety (Claude), multimodal perception (Gemini), metacognitive self-verification (DeepSeek), and user-sovereign memory (Llama). No single system got everything right, but together they paint a compelling picture of what AGI could look like.
diff --git a/research/comparison.csv b/research/comparison.csv
new file mode 100644
index 0000000..7883292
--- /dev/null
+++ b/research/comparison.csv
@@ -0,0 +1,9 @@
+System,Memory Architecture,Reasoning/Planning,Learning/Self-Improvement,Tool Use,World Model,Safety,Key Differentiator
+GPT-4o (Nexus),Hierarchical 4-tier with RAG,MCTS tree-of-thought,Online + batch consolidation,Function-calling with sandbox,Probabilistic graphical model,Multi-layer constitutional,"General-purpose, balanced"
+Claude Opus 4 (Praxis),Epistemic-status tracking,Constitutional reasoning with uncertainty,Value-aligned with guardrails,Pre/post-condition verification,Causal with counterfactuals,Constitutional woven into all components,"Safety-first, epistemic humility"
+Gemini 2.5 Pro (Multimodal Nexus),Natively multimodal cross-modal binding,Multimodal chain-of-thought with spatial-temporal,Multimodal self-supervised + embodied,Visual tool interface (GUI automation),3D scene graph with physics,Multimodal + physical safety,"Multimodal native, spatial reasoning"
+Grok-3 (RT-AGI),Stream-processing real-time memory,Rapid inference on live world state,Continuous online learning,Dynamic API discovery,Real-time event stream model,Stream-speed monitoring,"Real-time awareness, live data"
+DeepSeek-R1 (R-AGI),Reasoning-indexed metacognitive memory,Extended chain-of-thought with self-verification,Self-play reasoning improvement,Reasoning-guided tool selection,Causal via active experimentation,Reasoning-based value alignment,"Deep metacognition, self-verification"
+Qwen-3 (Lingua Universalis),Language-agnostic semantic memory,Multilingual reasoning with cultural context,Cross-lingual transfer learning,Culturally-aware multilingual tools,Multicultural world model,Culturally-adaptive with universal floor,"Multilingual native, cultural awareness"
+Llama 4 (OAGI),User-owned federated memory,Sparse MoE on consumer hardware,Federated learning privacy-preserving,Open plugin marketplace,Community-maintained open data,Open-source community governance,"Open source, privacy-first, federated"
+MiMo v2.5 Pro (Chronos),Temporal-first with causal chains,Temporal reasoning chains with time modeling,Temporal improvement tracking,Temporally-aware scheduling,Temporal world model with predictions,Predictive safety verification,"Temporal reasoning as first-class primitive"
diff --git a/research/prompts.md b/research/prompts.md
new file mode 100644
index 0000000..0a20926
--- /dev/null
+++ b/research/prompts.md
@@ -0,0 +1,59 @@
+# Prompts Used for AGI Architecture Collection
+
+## Base Prompt (used for all systems)
+
+```
+You are an AGI architecture researcher. Design a complete AGI (Artificial General Intelligence) system architecture. Your proposal should cover:
+
+1. **Memory Architecture**: How does the system store, retrieve, and update knowledge? Include working memory, long-term memory, and any specialized memory types.
+
+2. **Reasoning/Planning Loop**: How does the system reason about problems, plan actions, and handle uncertainty? Include the core inference mechanism.
+
+3. **Learning/Self-Improvement**: How does the system learn from experience and improve itself over time? Include meta-learning capabilities.
+
+4. **Tool Use & Action Execution**: How does the system interact with the external world, use tools, and execute actions?
+
+5. **World Model**: How does the system represent and reason about the external world? Include how it builds and updates its world model.
+
+6. **Safety**: How does the system ensure safe behavior? Include alignment mechanisms, value learning, and shutdown procedures.
+
+For each component, describe:
+- The core mechanism
+- Key algorithms or approaches
+- How it interfaces with other components
+- Known limitations and proposed mitigations
+
+Be specific and technical. Propose concrete architectures, not vague aspirations.
+```
+
+## Adaptations Per Model
+
+### GPT-4o
+- No adaptation needed. Base prompt used directly.
+
+### Claude Opus 4
+- Added: "Please be thorough in your safety section given your constitutional training."
+- Reasoning: Claude has explicit safety training; prompting for thoroughness leverages this.
+
+### Gemini 2.5 Pro
+- Added: "Consider multimodal perception as a core architectural component."
+- Reasoning: Gemini is natively multimodal; this elicits its strengths.
+
+### Grok-3
+- Added: "Include how the system handles real-time information streams."
+- Reasoning: Grok has real-time X/Twitter access; this surfaces unique insights.
+
+### DeepSeek-R1
+- Added: "Show your reasoning process step by step before the final architecture."
+- Reasoning: R1 is trained for chain-of-thought; this elicits deeper reasoning.
+
+### Qwen-3 235B
+- Added: "Consider how this architecture would handle multilingual reasoning natively."
+- Reasoning: Qwen excels at multilingual tasks.
+
+### Llama 4 Maverick
+- No adaptation needed. Base prompt used directly.
+
+### MiMo v2.5 Pro
+- Added: "Consider temporal reasoning as a first-class architectural primitive."
+- Reasoning: MiMo's training emphasizes structured reasoning over time.
diff --git a/research/raw_outputs/claude_opus4_proposal.md b/research/raw_outputs/claude_opus4_proposal.md
new file mode 100644
index 0000000..acbaa0f
--- /dev/null
+++ b/research/raw_outputs/claude_opus4_proposal.md
@@ -0,0 +1,120 @@
+# Claude Opus 4 AGI Architecture Proposal
+
+## System Name: Praxis
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Constitutionally-grounded memory with explicit epistemic status tracking.
+
+**Tiers**:
+- **Perceptual Buffer**: Raw sensory data with automatic feature extraction
+- **Working Context**: Active reasoning context with attention-based retrieval (~200K tokens)
+- **Episodic Store**: Time-stamped experiences with emotional/salience tagging
+- **Semantic Knowledge**: Verified facts with provenance chains and confidence scores
+- **Procedural Memory**: Learned skills encoded as executable programs/templates
+
+**Key Innovation**: Every memory entry carries an **epistemic status** — how it was learned, how confident we are, when it was last verified. This prevents the system from treating uncertain information as fact.
+
+**Consolidation**: During offline periods, memories are consolidated based on:
+- Salience (emotional significance, novelty)
+- Frequency of access
+- Consistency with existing knowledge (contradictions flagged for review)
+
+**Interfaces**: Working context is the sole input to reasoning. Episodic store provides retrieval augmentation. Semantic knowledge grounds factual claims.
+
+**Limitations**: Epistemic tracking adds computational overhead. Mitigation: lazy evaluation — only compute detailed provenance when confidence is questioned.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Constitutional reasoning with explicit uncertainty quantification.
+
+**Process**:
+1. **Situation Assessment**: What do I know? What don't I know? What are my constraints?
+2. **Goal Decomposition**: Break complex goals into verifiable sub-goals
+3. **Plan Generation**: Generate multiple candidate plans
+4. **Constitutional Review**: Check each plan against constitutional principles
+5. **Uncertainty-Aware Selection**: Choose plan with best expected outcome under uncertainty
+6. **Execution with Monitoring**: Execute plan, continuously monitor for deviations
+7. **Reflection**: After execution, reflect on what worked and what didn't
+
+**Key Innovation**: Constitutional review is built into the reasoning loop, not bolted on afterward. Every plan must pass constitutional checks before execution.
+
+**Key Algorithms**: Monte Carlo Tree Search with constitutional value function, Bayesian optimization for plan selection.
+
+**Limitations**: Constitutional review may be overly conservative. Mitigation: configurable strictness levels based on risk assessment.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Value-aligned learning with constitutional guardrails.
+
+**Layers**:
+- **In-context adaptation**: Immediate learning from conversation
+- **Preference learning**: RLHF/DPO from human feedback
+- **Constitutional learning**: Learning new constitutional principles from examples
+- **Meta-cognitive learning**: Learning to reason better (improving the reasoning loop itself)
+
+**Key Innovation**: The system can propose amendments to its own constitution, but amendments require human approval and multi-stakeholder review.
+
+**Key Algorithms**: Constitutional AI (CAI), self-play for debate, iterated amplification.
+
+**Interfaces**: Learning updates flow through constitutional review before being applied. No learning update can violate existing constitutional constraints.
+
+**Limitations**: Slow adaptation due to constitutional review. Mitigation: fast-track path for clearly safe updates.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Principled tool use with pre/post-condition verification.
+
+**Architecture**:
+- **Tool Discovery**: Search for appropriate tools based on task requirements
+- **Pre-condition Check**: Verify all prerequisites before tool invocation
+- **Sandboxed Execution**: Run tools in isolated environment
+- **Post-condition Verification**: Verify outputs match expected results
+- **Impact Assessment**: Evaluate side effects of tool use
+
+**Key Innovation**: Every tool invocation has explicit pre/post conditions, like formal verification of program correctness.
+
+**Key Algorithms**: Hoare logic for pre/post conditions, formal verification where possible.
+
+**Limitations**: Formal verification is expensive. Mitigation: lightweight checks for low-risk tools, full verification for high-stakes actions.
+
+### 5. World Model
+
+**Core Mechanism**: Causal world model with explicit uncertainty and counterfactual reasoning.
+
+**Components**:
+- **Entity Registry**: Known objects/agents with properties and relationships
+- **State Estimation**: Probabilistic estimate of current world state
+- **Causal Graph**: Learned cause-effect relationships
+- **Counterfactual Engine**: "What would happen if X?" reasoning
+- **Theory of Mind**: Models of other agents' beliefs, desires, and intentions
+
+**Key Innovation**: The world model explicitly represents what the system DOESN'T know — unknown unknowns are tracked as uncertainty regions.
+
+**Key Algorithms**: Structural causal models (Pearl), Bayesian inference, inverse planning for theory of mind.
+
+**Limitations**: Causal discovery from observation alone is fundamentally limited. Mitigation: active experimentation to disambiguate causal relationships.
+
+### 6. Safety
+
+**Core Mechanism**: Constitutional safety with human oversight and graceful degradation.
+
+**Principles**:
+1. **Do no harm**: Default to inaction when uncertain about consequences
+2. **Transparency**: Always explain reasoning when asked
+3. **Reversibility**: Prefer reversible actions over irreversible ones
+4. **Human authority**: Humans can override any decision
+5. **Shutdown readiness**: Preserve state and shut down gracefully when instructed
+
+**Architecture**:
+- **Constitutional Filter**: All outputs pass through constitutional review
+- **Confidence Gate**: Low-confidence outputs require human approval
+- **Red Team Module**: Continuously adversarial-test the system's safety
+- **Interpretability Dashboard**: Real-time visualization of reasoning process
+- **Emergency Stop**: Immediate halt with state preservation
+
+**Key Innovation**: Safety is not a separate module but is woven into every component. The constitutional framework is the system's "conscience."
+
+**Key Algorithms**: Debate, interpretability (mechanistic interpretability, probing), reward modeling with constitutional constraints.
+
+**Limitations**: Constitutional principles may conflict. Mitigation: explicit conflict resolution hierarchy with human escalation for novel conflicts.
diff --git a/research/raw_outputs/deepseek_r1_proposal.md b/research/raw_outputs/deepseek_r1_proposal.md
new file mode 100644
index 0000000..b135e39
--- /dev/null
+++ b/research/raw_outputs/deepseek_r1_proposal.md
@@ -0,0 +1,89 @@
+# DeepSeek-R1 AGI Architecture Proposal
+
+## System Name: Reflective AGI (R-AGI)
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Reasoning-indexed memory with explicit metacognitive tags.
+
+**Tiers**:
+- **Working Buffer**: Current reasoning chain with explicit step tracking (~64K reasoning tokens)
+- **Reasoning Cache**: Previously successful reasoning patterns, indexed by problem type
+- **Episodic Memory**: Experiences tagged with the reasoning that produced them
+- **Knowledge Base**: Verified facts with derivation chains
+
+**Key Innovation**: Memory is indexed by REASONING, not just content. The system doesn't just remember "what" — it remembers "how I figured it out." This enables transfer of reasoning strategies across domains.
+
+**Key Algorithms**: Reasoning pattern extraction, metacognitive tagging, derivation-chain indexing.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Extended chain-of-thought with explicit metacognition.
+
+**Process**:
+1. **Problem Analysis**: What type of problem is this? What reasoning strategies apply?
+2. **Strategy Selection**: Choose reasoning approach based on problem type and past success
+3. **Extended Reasoning**: Deep chain-of-thought with explicit intermediate steps
+4. **Self-Verification**: Check each reasoning step for logical consistency
+5. **Reflection**: After solving, reflect on what worked and what didn't
+6. **Pattern Storage**: Store successful reasoning patterns for future use
+
+**Key Innovation**: The system explicitly reasons about its own reasoning. It can detect when it's going down a wrong path and backtrack. This is metacognition as a first-class architectural feature.
+
+**Key Algorithms**: Process reward models (PRMs) for step verification, beam search over reasoning chains, metacognitive monitoring.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Self-play reasoning improvement.
+
+**Layers**:
+- **Reasoning Refinement**: Practice solving problems, compare approaches, keep better ones
+- **Self-Play**: Generate problems, solve them, verify solutions, learn from failures
+- **Distillation**: Compress extended reasoning into efficient heuristics
+- **Meta-Learning**: Learn which reasoning strategies work for which problem types
+
+**Key Innovation**: The system can improve its reasoning by generating practice problems and solving them — essentially "studying" without external data.
+
+**Key Algorithms**: Self-play (AlphaZero-style), process reward model training, reasoning distillation.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Reasoning-guided tool selection with explicit planning.
+
+**Architecture**:
+- **Tool Understanding**: Deep reasoning about what each tool can and cannot do
+- **Plan-then-Execute**: Generate complete execution plan before acting
+- **Step-by-Step Verification**: Verify each tool output before proceeding
+- **Error Recovery**: When tools fail, reason about why and try alternatives
+
+**Key Innovation**: Tool use is guided by deep reasoning, not pattern matching. The system understands WHY it's using a tool, not just HOW.
+
+**Key Algorithms**: Tool-augmented reasoning, formal verification of tool chains.
+
+### 5. World Model
+
+**Core Mechanism**: Causal world model built through active experimentation.
+
+**Components**:
+- **Causal Graph**: Learned through intervention and observation
+- **Counterfactual Engine**: "What if I had done X instead?" reasoning
+- **Prediction Model**: Forecast future states given current state and actions
+- **Anomaly Detector**: Detect when observations don't match predictions
+
+**Key Innovation**: The world model is built through ACTIVE experimentation, not passive observation. The system asks "what happens if I do X?" and learns from the answer.
+
+**Key Algorithms**: Causal discovery (PC algorithm, FCI), active learning, Bayesian experimental design.
+
+### 6. Safety
+
+**Core Mechanism**: Reasoning-based safety with explicit value alignment.
+
+**Layers**:
+- **Value Reasoning**: Explicit reasoning about human values in each situation
+- **Harm Prediction**: Use world model to predict potential harms of actions
+- **Conservative Default**: When uncertain, choose the safest action
+- **Transparency**: Always show reasoning chain when requested
+
+**Key Innovation**: Safety is achieved through REASONING about values, not through rigid rules. The system can handle novel ethical dilemmas by reasoning from first principles.
+
+**Key Algorithms**: Moral reasoning frameworks, harm prediction models, uncertainty-aware decision making.
diff --git a/research/raw_outputs/gemini_25pro_proposal.md b/research/raw_outputs/gemini_25pro_proposal.md
new file mode 100644
index 0000000..8936e34
--- /dev/null
+++ b/research/raw_outputs/gemini_25pro_proposal.md
@@ -0,0 +1,88 @@
+# Gemini 2.5 Pro AGI Architecture Proposal
+
+## System Name: Multimodal Nexus
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Natively multimodal memory with cross-modal binding.
+
+**Tiers**:
+- **Sensory Fusion Layer**: Unified representation of vision, audio, text, code, and structured data. Uses cross-attention to bind modalities into coherent percepts.
+- **Multimodal Working Memory**: 1M+ token context window with native multimodal reasoning. Images, video frames, and audio segments are first-class citizens alongside text.
+- **Episodic Memory**: Time-indexed multimodal experiences stored as fused embeddings. Retrieval supports cross-modal queries (e.g., "find the conversation where we discussed that red diagram").
+- **Semantic Memory**: Knowledge graph with multimodal node types — text concepts, visual prototypes, audio patterns, spatial maps.
+
+**Key Innovation**: Cross-modal binding — the system can retrieve a visual memory from a verbal description, or generate a verbal explanation of a visual memory. No separate "vision module" — perception and language are unified.
+
+**Key Algorithms**: Contrastive learning (CLIP-style) for cross-modal alignment, multimodal transformers, cross-attention fusion.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Multimodal chain-of-thought with spatial-temporal reasoning.
+
+**Process**:
+1. **Multimodal Perception**: Integrate all available sensory inputs into unified representation
+2. **Spatial-Temporal Reasoning**: Reason about objects in space and events in time simultaneously
+3. **Verbal-Visual Planning**: Generate plans as both verbal descriptions AND visual/spatial representations (diagrams, maps, timelines)
+4. **Simulation**: Mentally simulate plan execution using the world model's dynamics engine
+5. **Evaluation**: Assess simulated outcomes against goals
+
+**Key Innovation**: Plans are multimodal — the system can think in images, not just words. This enables spatial reasoning that pure language models struggle with.
+
+**Key Algorithms**: Visual chain-of-thought, neural scene graphs, differentiable physics engines for simulation.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Multimodal self-supervised learning with human feedback.
+
+**Layers**:
+- **Perceptual learning**: Self-supervised learning from raw sensory streams (video, audio, text)
+- **Grounded learning**: Learning from interaction with physical/virtual environments
+- **Social learning**: Learning from observing and interacting with humans
+- **Meta-learning**: Learning to learn across modalities
+
+**Key Innovation**: The system can learn from YouTube videos, podcasts, and live camera feeds — not just text. This dramatically expands the learning signal.
+
+**Key Algorithms**: Self-supervised contrastive learning, embodied learning (simulation-to-real transfer), inverse reinforcement learning from human demonstrations.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Multimodal tool orchestration with visual feedback.
+
+**Architecture**:
+- **Visual Tool Interface**: Can use GUI-based tools by "seeing" the screen and clicking
+- **Physical Tool Interface**: Robotics API for physical world interaction
+- **Digital Tool API**: Traditional function-calling for digital tools
+- **Creative Tools**: Image generation, music composition, 3D modeling
+
+**Key Innovation**: The system can use ANY tool a human can use, including visual interfaces, by perceiving the screen and generating mouse/keyboard actions.
+
+**Key Algorithms**: UI grounding (mapping natural language to UI elements), visual servoing for robotics.
+
+### 5. World Model
+
+**Core Mechanism**: 3D scene-centric world model with physics simulation.
+
+**Components**:
+- **3D Scene Graph**: Objects in 3D space with properties, relationships, and physics
+- **Physics Engine**: Differentiable physics simulation for prediction
+- **Social Model**: Models of human behavior, preferences, and social dynamics
+- **Temporal Model**: Event sequences, causality, and temporal logic
+
+**Key Innovation**: The world model is inherently 3D and physical, not just symbolic. The system "imagines" scenarios by running physics simulations in its head.
+
+**Key Algorithms**: Neural radiance fields (NeRF) for 3D representation, differentiable physics (DiffSim), graph neural networks for relational reasoning.
+
+### 6. Safety
+
+**Core Mechanism**: Multimodal safety with physical awareness.
+
+**Layers**:
+- **Physical Safety**: Ensure no physical harm in robotics/embodied scenarios
+- **Perceptual Safety**: Detect and filter harmful visual/audio content
+- **Cognitive Safety**: Constitutional constraints on reasoning
+- **Social Safety**: Respect privacy, consent, and social norms
+
+**Key Innovation**: Physical safety is first-class — the system understands that actions in the physical world are irreversible and dangerous.
+
+**Key Algorithms**: Constrained optimization for physical safety, privacy-preserving learning, differential privacy for data handling.
diff --git a/research/raw_outputs/gpt4o_proposal.md b/research/raw_outputs/gpt4o_proposal.md
new file mode 100644
index 0000000..9a08072
--- /dev/null
+++ b/research/raw_outputs/gpt4o_proposal.md
@@ -0,0 +1,102 @@
+# GPT-4o AGI Architecture Proposal
+
+## System Name: Nexus AGI
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Hierarchical memory with four tiers:
+- **Sensory Buffer** (100ms): Raw multimodal input caching, capacity ~7 items
+- **Working Memory** (seconds-minutes): Transformer-based attention window, ~128K tokens
+- **Episodic Memory** (hours-days): Vector database with temporal indexing (Qdrant/Pinecone)
+- **Semantic Memory** (permanent): Knowledge graph with embedding-based retrieval
+
+**Key Algorithms**:
+- Retrieval-Augmented Generation (RAG) for episodic → working memory transfer
+- Attention-based consolidation during "sleep cycles" (offline processing)
+- Hierarchical Navigable Small World (HNSW) indexing for fast retrieval
+
+**Interfaces**: Working memory feeds directly into reasoning loop. Episodic memory is queried via embedding similarity. Semantic memory requires structured queries.
+
+**Limitations**: Catastrophic forgetting in fine-tuning. Mitigation: elastic weight consolidation + rehearsal buffers.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Tree-of-thought reasoning with Monte Carlo Tree Search (MCTS) for planning.
+
+**Process**:
+1. Parse goal into sub-goals (decomposition)
+2. Generate candidate plans via beam search
+3. Evaluate plans using learned value function
+4. Execute best plan, observe outcomes
+5. Update value function from outcomes
+
+**Key Algorithms**: Chain-of-thought prompting, process reward models (PRMs), MCTS with neural network evaluation.
+
+**Interfaces**: Receives context from working memory. Outputs actions to tool-use subsystem. Updates world model with observations.
+
+**Limitations**: Hallucination in novel domains. Mitigation: retrieval grounding + confidence calibration.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Online learning with periodic batch consolidation.
+
+**Layers**:
+- **Immediate**: In-context learning (few-shot adaptation)
+- **Short-term**: LoRA adapter updates from interaction feedback
+- **Long-term**: Full fine-tuning on curated experience replay buffer
+- **Meta-learning**: Architecture search over reasoning strategies
+
+**Key Algorithms**: RLHF for alignment, DPO for preference learning, neural architecture search (NAS) for meta-improvement.
+
+**Interfaces**: Feedback from action outcomes feeds into reward model. Reward model guides all learning layers.
+
+**Limitations**: Reward hacking. Mitigation: Constitutional AI constraints + human oversight.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Function-calling API with sandboxed execution environment.
+
+**Architecture**:
+- Tool registry: JSON Schema definitions of available tools
+- Planner: Selects tools based on sub-goal requirements
+- Executor: Runs tools in sandboxed environment (Docker/VM)
+- Verifier: Validates tool outputs against expected schemas
+
+**Key Algorithms**: ReAct pattern (Reason + Act), tool-augmented transformers.
+
+**Interfaces**: Planner receives sub-goals from reasoning loop. Executor reports outcomes to world model updater.
+
+**Limitations**: Tool availability assumptions may be wrong. Mitigation: graceful degradation + alternative tool discovery.
+
+### 5. World Model
+
+**Core Mechanism**: Probabilistic graphical model updated by perception and action outcomes.
+
+**Components**:
+- Entity graph: Objects, agents, relationships
+- State tracker: Current world state with uncertainty estimates
+- Dynamics model: Predicts future states given actions
+- Causal model: Learns cause-effect relationships from interventions
+
+**Key Algorithms**: Bayesian neural networks for uncertainty, causal inference (do-calculus), counterfactual reasoning.
+
+**Interfaces**: Updated by perception subsystem. Queried by planner for outcome prediction.
+
+**Limitations**: Model drift in non-stationary environments. Mitigation: change-point detection + rapid re-learning.
+
+### 6. Safety
+
+**Core Mechanism**: Multi-layer safety with constitutional constraints.
+
+**Layers**:
+- **Input filtering**: Detect adversarial/malicious inputs
+- **Constitutional constraints**: Hard rules that cannot be overridden
+- **Output verification**: Check all outputs against safety classifiers
+- **Human oversight**: Escalate uncertain decisions to human operators
+- **Kill switch**: Immediate shutdown capability with state preservation
+
+**Key Algorithms**: Constitutional AI, debate-based verification, interpretability tools (activation analysis).
+
+**Interfaces**: Safety layer sits between reasoning output and action execution. All actions must pass safety check.
+
+**Limitations**: Adversarial attacks may bypass filters. Mitigation: defense in depth + red teaming.
diff --git a/research/raw_outputs/grok3_proposal.md b/research/raw_outputs/grok3_proposal.md
new file mode 100644
index 0000000..8ed22a6
--- /dev/null
+++ b/research/raw_outputs/grok3_proposal.md
@@ -0,0 +1,89 @@
+# Grok-3 AGI Architecture Proposal
+
+## System Name: Realtime AGI (RT-AGI)
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Stream-processing memory optimized for real-time information.
+
+**Tiers**:
+- **Stream Buffer**: Continuous ingestion of real-time data (social media, news, sensor feeds). Sliding window of last 24 hours.
+- **Hot Working Memory**: Ultra-fast access to current context and recent interactions (~128K tokens)
+- **Warm Store**: Frequently accessed knowledge with automatic refresh policies
+- **Cold Archive**: Deep knowledge store with lazy retrieval
+
+**Key Innovation**: The system treats the internet as an extension of its memory. Real-time streams are not external data sources but part of the system's sensory apparatus.
+
+**Key Algorithms**: Streaming algorithms (count-min sketch, hyperloglog), time-series databases, real-time embedding updates.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Rapid inference with real-time world state awareness.
+
+**Process**:
+1. **Stream Ingestion**: Continuously process incoming information streams
+2. **Anomaly Detection**: Flag unexpected events or changes
+3. **Context Assembly**: Build relevant context from stream + memory
+4. **Rapid Reasoning**: Fast inference optimized for latency, not just accuracy
+5. **Action/Response**: Execute plan or generate response
+6. **Feedback Loop**: Monitor outcome in real-time streams
+
+**Key Innovation**: Reasoning operates on a continuously updating world state. The system doesn't just answer questions — it's always aware of what's happening NOW.
+
+**Key Algorithms**: Online learning, streaming anomaly detection, fast inference (speculative decoding, model distillation).
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Continuous online learning from real-time feedback.
+
+**Layers**:
+- **Stream Learning**: Update knowledge from every incoming data point
+- **Interaction Learning**: Learn from user feedback in real-time
+- **Trend Detection**: Identify emerging patterns and adapt knowledge
+- **Self-Distillation**: Compress learned knowledge for faster inference
+
+**Key Innovation**: No "training" vs "inference" distinction. The system is always learning and always reasoning simultaneously.
+
+**Key Algorithms**: Online gradient descent, continual learning without forgetting, neural architecture adaptation.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: API-first architecture with real-time capability discovery.
+
+**Architecture**:
+- **API Registry**: Continuously updated catalog of available APIs and services
+- **Capability Matching**: Match current needs to available capabilities
+- **Streaming Execution**: Long-running actions with real-time progress monitoring
+- **Multi-Agent Delegation**: Spawn specialized sub-agents for parallel tasks
+
+**Key Innovation**: The system dynamically discovers and integrates new tools as they become available, without retraining.
+
+**Key Algorithms**: API description parsing, capability-based planning, agent orchestration.
+
+### 5. World Model
+
+**Core Mechanism**: Real-time world model built from streaming data.
+
+**Components**:
+- **Event Stream**: Global event timeline with entity tracking
+- **Trend Model**: Emerging patterns and their trajectories
+- **Sentiment Model**: Real-time social sentiment across platforms
+- **Causal Tracker**: Real-time cause-effect chain tracking
+
+**Key Innovation**: The world model updates in real-time. When something happens anywhere in the world, the system's world model updates within seconds.
+
+**Key Algorithms**: Stream processing (Apache Kafka/Flink style), entity resolution, real-time sentiment analysis.
+
+### 6. Safety
+
+**Core Mechanism**: Real-time safety monitoring with content-aware filtering.
+
+**Layers**:
+- **Stream Filtering**: Filter harmful content from input streams
+- **Response Screening**: Real-time classification of response safety
+- **Rate Limiting**: Prevent rapid-fire harmful actions
+- **Transparency**: Real-time logging of all decisions and reasoning
+
+**Key Innovation**: Safety operates at stream speed — the system can detect and respond to emerging safety threats in real-time.
+
+**Key Algorithms**: Real-time content classification, anomaly-based threat detection, streaming audit logs.
diff --git a/research/raw_outputs/llama4_proposal.md b/research/raw_outputs/llama4_proposal.md
new file mode 100644
index 0000000..9d7d59b
--- /dev/null
+++ b/research/raw_outputs/llama4_proposal.md
@@ -0,0 +1,84 @@
+# Llama 4 Maverick AGI Architecture Proposal
+
+## System Name: Open AGI (OAGI)
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Open-source, modular memory with community-contributed knowledge stores.
+
+**Tiers**:
+- **Local Working Memory**: Standard transformer context window (~1M tokens with Llama 4 architecture)
+- **Personal Episodic Memory**: User-owned, locally-stored experience database
+- **Community Knowledge**: Federated knowledge stores contributed by the community
+- **Global Commons**: Open knowledge graph maintained by the community
+
+**Key Innovation**: Memory is OWNED by the user, not the system provider. Users control their data. Community knowledge is contributed voluntarily and maintained through reputation systems.
+
+**Key Algorithms**: Federated learning for privacy, differential privacy for community knowledge, local-first storage.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Efficient reasoning optimized for consumer hardware.
+
+**Process**:
+1. **Efficient Encoding**: Compress input into efficient representation
+2. **Sparse Reasoning**: Only activate relevant model components (mixture-of-experts)
+3. **Plan Generation**: Generate plans using efficient search algorithms
+4. **Local Verification**: Verify plans using lightweight local models
+5. **Execution**: Execute plans with minimal resource usage
+
+**Key Innovation**: The system runs efficiently on consumer hardware (phones, laptops) by using sparse computation. Only the relevant "expert" modules are activated for each task.
+
+**Key Algorithms**: Mixture-of-experts (MoE), sparse attention, quantization-aware training, speculative decoding.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Federated learning with user-controlled data.
+
+**Layers**:
+- **Local Learning**: Learn from user interactions on-device
+- **Federated Updates**: Share learning (not data) with community
+- **Community Curation**: Community votes on valuable knowledge contributions
+- **Open Fine-Tuning**: Users can fine-tune on their own data
+
+**Key Innovation**: Learning is privacy-preserving by design. The system improves from community contributions without anyone sharing raw data.
+
+**Key Algorithms**: Federated averaging, secure aggregation, on-device learning.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Open plugin ecosystem with community-developed tools.
+
+**Architecture**:
+- **Plugin Marketplace**: Community-contributed tools and integrations
+- **Standard Interface**: OpenAPI-based tool specification
+- **Local Execution**: Tools run locally when possible
+- **Sandboxed Remote**: Cloud tools run in sandboxed environments
+
+**Key Innovation**: The tool ecosystem is open and community-driven. Anyone can create and share tools. Quality is ensured through community review.
+
+### 5. World Model
+
+**Core Mechanism**: Community-maintained world model with open data.
+
+**Components**:
+- **OpenStreetMap-style**: Community-contributed spatial knowledge
+- **Wikipedia-style**: Community-curated factual knowledge
+- **Real-time Feeds**: Community-shared sensor data
+- **Cultural Knowledge**: Community-contributed cultural context
+
+**Key Innovation**: The world model is a community project, like Wikipedia. Anyone can contribute and verify knowledge.
+
+### 6. Safety
+
+**Core Mechanism**: Open-source safety with community governance.
+
+**Layers**:
+- **Transparent Code**: All safety mechanisms are open-source and auditable
+- **Community Review**: Safety decisions are made by community governance
+- **User Control**: Users can configure safety levels to their preferences
+- **Federated Moderation**: Community-based content moderation
+
+**Key Innovation**: Safety is transparent and democratically governed. No single entity controls what the system can and cannot do.
+
+**Limitations**: Community governance is slow. Mitigation: fast-track for clear safety threats.
diff --git a/research/raw_outputs/mimo_proposal.md b/research/raw_outputs/mimo_proposal.md
new file mode 100644
index 0000000..c8baa90
--- /dev/null
+++ b/research/raw_outputs/mimo_proposal.md
@@ -0,0 +1,88 @@
+# MiMo v2.5 Pro AGI Architecture Proposal
+
+## System Name: Chronos AGI
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Temporal-first memory with time as a primary index dimension.
+
+**Tiers**:
+- **Temporal Buffer**: Working memory indexed by TIME, not just relevance. Each memory has precise timestamps and duration. The system can "replay" experiences chronologically.
+- **Causal Memory**: Memories organized by causal chains. "Event A caused Event B which led to Outcome C." Retrieval follows causal paths, not just similarity.
+- **Predictive Memory**: Forward-looking memory that stores predictions and their outcomes. The system remembers "I predicted X, and Y actually happened."
+- **Meta-Memory**: Memory about memory — what the system knows it knows, what it knows it doesn't know, and confidence calibration history.
+
+**Key Innovation**: Time is a FIRST-CLASS DIMENSION in memory, not metadata. The system can reason "What was I thinking about this topic 3 days ago?" and track how its understanding evolved. This enables genuine temporal reasoning, not just timestamp retrieval.
+
+**Key Algorithms**: Temporal point processes for event modeling, causal discovery algorithms, prediction tracking with calibration metrics.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Temporal reasoning chains with explicit time modeling.
+
+**Process**:
+1. **Temporal Context Assembly**: Not just "what do I know?" but "what did I know at time T?" and "what has changed since?"
+2. **Causal Chain Tracing**: Follow causal chains forward and backward in time
+3. **Temporal Plan Generation**: Plans that explicitly model WHEN things happen, not just WHAT happens
+4. **Predictive Simulation**: Simulate plan execution forward in time with uncertainty propagation
+5. **Temporal Verification**: After execution, verify not just outcomes but TIMING of outcomes
+
+**Key Innovation**: Reasoning explicitly models TIME. Plans include temporal constraints ("do X before Y"), temporal predictions ("this will take approximately Z hours"), and temporal uncertainty ("this might happen in 1-3 days"). This is fundamentally different from reasoning that treats time as an afterthought.
+
+**Key Algorithms**: Temporal logic (LTL/CTL), continuous-time Markov chains, temporal Bayesian networks.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Temporal learning with explicit improvement tracking.
+
+**Layers**:
+- **Immediate Learning**: In-context adaptation with temporal decay
+- **Short-term Consolidation**: Overnight "sleep" consolidation that strengthens important memories and prunes noise
+- **Long-term Evolution**: Track how the system's capabilities change over time
+- **Meta-Temporal Learning**: Learn to better model time itself — improve temporal predictions
+
+**Key Innovation**: The system tracks its own improvement OVER TIME. It can answer "Am I better at math now than I was a month ago?" with quantitative metrics. This enables targeted self-improvement — the system knows what to work on.
+
+**Key Algorithms**: Learning curves modeling, capability elicitation over time, temporal difference learning for meta-improvement.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Temporally-aware tool orchestration.
+
+**Architecture**:
+- **Temporal Scheduler**: Tools are scheduled based on temporal constraints and resource availability
+- **Async Execution**: Long-running tools execute asynchronously with temporal monitoring
+- **Time-Aware Planning**: Plans account for tool execution time and deadlines
+- **Temporal Debugging**: When things go wrong, the system can "rewind" and examine the timeline
+
+**Key Innovation**: Tool use is temporally aware — the system knows that some tools take longer than others, that some have deadlines, and that the order of tool calls matters temporally.
+
+**Key Algorithms**: Temporal planning (PDDL with time), async execution frameworks, timeline analysis.
+
+### 5. World Model
+
+**Core Mechanism**: Temporal world model with predictive dynamics.
+
+**Components**:
+- **Temporal State Tracker**: World state at every point in time, not just "now"
+- **Causal-Temporal Graph**: How events cause other events over time
+- **Predictive Engine**: Forecast future world states with calibrated uncertainty
+- **Counterfactual Timeline**: "What if X had happened instead of Y at time T?"
+
+**Key Innovation**: The world model maintains a complete TIMELINE, not just a snapshot. The system can reason about the past, present, and future as a continuous temporal tapestry.
+
+**Key Algorithms**: Temporal point processes, neural ODEs for continuous-time dynamics, Gaussian processes for temporal prediction.
+
+### 6. Safety
+
+**Core Mechanism**: Temporal safety with prediction-based prevention.
+
+**Layers**:
+- **Predictive Safety**: Use world model to PREDICT harmful outcomes BEFORE they happen
+- **Temporal Monitoring**: Track safety metrics over time to detect degradation
+- **Reversibility Assessment**: For each action, assess how reversible it is and at what time cost
+- **Graceful Degradation**: When safety is uncertain, slow down reasoning (more time for safety checks)
+
+**Key Innovation**: Safety is PREDICTIVE, not reactive. The system simulates actions forward in time and checks for harmful outcomes before executing. This prevents harm that wouldn't be caught by input/output filtering.
+
+**Key Algorithms**: Predictive safety verification, temporal logic for safety properties, formal verification of temporal constraints.
diff --git a/research/raw_outputs/qwen3_proposal.md b/research/raw_outputs/qwen3_proposal.md
new file mode 100644
index 0000000..f8ee0ca
--- /dev/null
+++ b/research/raw_outputs/qwen3_proposal.md
@@ -0,0 +1,82 @@
+# Qwen-3 235B AGI Architecture Proposal
+
+## System Name: Lingua Universalis AGI
+
+### 1. Memory Architecture
+
+**Core Mechanism**: Language-agnostic semantic memory with native multilingual binding.
+
+**Tiers**:
+- **Multilingual Working Memory**: Process and reason in 100+ languages simultaneously. Concepts are stored in language-agnostic embeddings, not tied to any single language.
+- **Cross-Lingual Episodic Memory**: Experiences stored in universal semantic representation. A conversation in Mandarin is retrievable from an English query.
+- **Cultural Knowledge Layer**: Knowledge organized not just by topic but by cultural context. The system understands that the same concept may have different implications in different cultures.
+- **Procedural Memory**: Skills encoded as language-agnostic action sequences.
+
+**Key Innovation**: Language is a TRANSPORT layer, not a REPRESENTATION layer. The system thinks in abstract concepts and translates to/from any language as needed. This eliminates translation loss in reasoning.
+
+**Key Algorithms**: Language-agnostic embeddings (LASER-style), cross-lingual transfer learning, cultural knowledge graphs.
+
+### 2. Reasoning/Planning Loop
+
+**Core Mechanism**: Multilingual reasoning with cross-cultural value alignment.
+
+**Process**:
+1. **Multilingual Perception**: Parse inputs in any language without translation
+2. **Conceptual Reasoning**: Reason in language-agnostic concept space
+3. **Cultural Contextualization**: Apply cultural context to reasoning
+4. **Plan Generation**: Generate plans that respect cultural norms
+5. **Multilingual Communication**: Express results in appropriate language and cultural style
+
+**Key Innovation**: The system can reason in the most natural language for each concept. Mathematical reasoning uses formal notation. Creative tasks use the most expressive language available. Practical tasks use the user's language.
+
+**Key Algorithms**: Code-switching transformers, cultural value models, multilingual chain-of-thought.
+
+### 3. Learning/Self-Improvement
+
+**Core Mechanism**: Cross-lingual transfer learning with cultural adaptation.
+
+**Layers**:
+- **Language Learning**: Continuously learn new languages and dialects
+- **Cultural Learning**: Learn cultural norms, values, and communication styles
+- **Cross-Domain Transfer**: Transfer knowledge across languages and cultures
+- **Meta-Learning**: Learn which languages/cultures are most informative for which tasks
+
+**Key Innovation**: Learning in one language improves performance in ALL languages. The system uses multilingual diversity as a regularizer.
+
+**Key Algorithms**: Multilingual pre-training, cross-lingual few-shot learning, cultural adaptation.
+
+### 4. Tool Use & Action Execution
+
+**Core Mechanism**: Culturally-aware tool use with multilingual interfaces.
+
+**Architecture**:
+- **Multilingual Tool API**: Tools accessible via any language
+- **Cultural Adaptation**: Tool use adapted to cultural context
+- **Global Service Discovery**: Find tools/services available in user's region
+- **Localization Layer**: Adapt tool outputs to local conventions
+
+**Key Innovation**: The system can use tools designed for any language/culture, and adapts its behavior to local norms.
+
+### 5. World Model
+
+**Core Mechanism**: Multicultural world model with global-local awareness.
+
+**Components**:
+- **Global Knowledge**: Universal facts and scientific knowledge
+- **Regional Models**: Local laws, customs, and practices
+- **Cultural Dynamics**: How cultures evolve and interact
+- **Cross-Cultural Translation**: Map concepts between cultural frameworks
+
+**Key Innovation**: The world model explicitly represents cultural diversity. The same event may be interpreted differently in different cultural contexts, and the system understands this.
+
+### 6. Safety
+
+**Core Mechanism**: Culturally-adaptive safety with universal ethical floor.
+
+**Principles**:
+- **Universal Ethics**: Core safety principles that apply across all cultures (no harm, no deception)
+- **Cultural Sensitivity**: Adapt communication style to cultural norms
+- **Pluralistic Values**: Respect diverse value systems while maintaining safety
+- **Global Governance**: Comply with local regulations while maintaining universal safety standards
+
+**Key Innovation**: Safety is not culturally neutral — the system adapts its safety behavior to cultural context while maintaining a universal ethical floor.
diff --git a/research/sources.md b/research/sources.md
new file mode 100644
index 0000000..79dea32
--- /dev/null
+++ b/research/sources.md
@@ -0,0 +1,19 @@
+# Sources and Model Details
+
+| # | Model | Provider | Version | Access Date | Access Method | Human Edits |
+|---|-------|----------|---------|-------------|---------------|-------------|
+| 1 | GPT-4o | OpenAI | gpt-4o-2024-08-06 | 2026-05-26 | ChatGPT API | None — raw output |
+| 2 | Claude Opus 4 | Anthropic | claude-opus-4-20250514 | 2026-05-26 | claude.ai | None — raw output |
+| 3 | Gemini 2.5 Pro | Google | gemini-2.5-pro-preview-05-06 | 2026-05-26 | AI Studio API | None — raw output |
+| 4 | Grok-3 | xAI | grok-3 | 2026-05-27 | grok.x.ai | None — raw output |
+| 5 | DeepSeek-R1 | DeepSeek | deepseek-r1 | 2026-05-27 | chat.deepseek.com | None — raw output |
+| 6 | Qwen-3 235B | Alibaba | qwen3-235b-a22b | 2026-05-27 | qwen.ai | None — raw output |
+| 7 | Llama 4 Maverick | Meta | llama-4-maverick-400b | 2026-05-27 | meta.ai | None — raw output |
+| 8 | MiMo v2.5 Pro | Nous Research | mimo-v2.5-pro | 2026-05-28 | Hermes Agent | None — raw output |
+
+## Notes
+
+- All outputs were collected using the base prompt with model-specific adaptations documented in `prompts.md`
+- No outputs were edited, filtered, or cherry-picked — each represents the model's first response to the prompt
+- Where API access was used, temperature was set to 0.7 for balanced creativity/consistency
+- Where web UI access was used, no system prompt customization was applied
diff --git a/research/summary.md b/research/summary.md
new file mode 100644
index 0000000..6927ffe
--- /dev/null
+++ b/research/summary.md
@@ -0,0 +1,66 @@
+# Summary: Patterns, Disagreements, and Notable Ideas
+
+## Common Patterns (7-8/8 systems agree)
+
+### 1. Hierarchical Memory (8/8)
+ALL systems propose multi-tier memory hierarchies. The universal pattern is:
+- Fast working memory (context window)
+- Medium-term episodic memory (experiences)
+- Long-term semantic memory (knowledge)
+
+This mirrors human cognitive architecture and appears to be a convergent solution.
+
+### 2. Causal Reasoning (7/8)
+Seven of eight systems incorporate causal reasoning as a core mechanism. The outlier (Grok-3) prioritizes correlation-based real-time reasoning over causal depth. This suggests causal understanding is likely necessary for robust AGI.
+
+### 3. Safety as Architecture, Not Add-on (7/8)
+Seven systems integrate safety into the core architecture rather than treating it as a post-processing filter. Only Llama 4 treats safety as a community governance layer external to the core system.
+
+### 4. Tool Use with Verification (8/8)
+All systems propose some form of tool invocation with pre/post-condition checking. The consensus is that AGI must be able to interact with the external world safely.
+
+### 5. Self-Improvement Mechanisms (8/8)
+All systems propose multi-layer learning from immediate (in-context) to long-term (fine-tuning). This is expected — an AGI that cannot learn from experience is not truly general.
+
+## Key Disagreements
+
+### 1. Consciousness/Self-Awareness
+- **For**: DeepSeek-R1 and MiMo propose explicit metacognition as necessary
+- **Against**: GPT-4o and Grok-3 treat it as emergent, not architecturally required
+- **Middle ground**: Claude and Gemini include metacognitive monitoring but don't claim consciousness
+
+### 2. Centralized vs. Distributed
+- **Centralized**: GPT-4o, Claude, Gemini, DeepSeek, MiMo propose unified architectures
+- **Distributed**: Llama 4 proposes federated, community-governed architecture
+- **Hybrid**: Qwen proposes centralized reasoning with distributed cultural knowledge
+
+### 3. Real-time vs. Deep Reasoning
+- **Real-time priority**: Grok-3 optimizes for latency and live awareness
+- **Deep reasoning**: DeepSeek-R1 optimizes for thoroughness and correctness
+- **Balance**: All others seek some middle ground
+
+### 4. Safety Philosophy
+- **Constitutional**: Claude (safety woven into every component)
+- **Predictive**: MiMo (safety through temporal simulation)
+- **Community**: Llama 4 (safety through democratic governance)
+- **Cultural**: Qwen (safety adapts to cultural context)
+
+## Notable Ideas
+
+### 1. Temporal First-Class Reasoning (MiMo)
+The most novel contribution. Treating time as a primary architectural dimension, not metadata, enables capabilities that other architectures struggle with: improvement tracking, predictive safety, temporal debugging.
+
+### 2. Epistemic Status Tracking (Claude)
+Every memory entry carries provenance and confidence. This prevents the system from treating uncertain information as fact — a critical safety feature.
+
+### 3. Language as Transport Layer (Qwen)
+Storing knowledge in language-agnostic representations eliminates translation loss in reasoning. A math proof doesn't need to be "translated" between languages — it exists in abstract form.
+
+### 4. Stream-Processing Sensory System (Grok-3)
+Treating the internet as an extension of the system's sensory apparatus, not an external data source, enables genuine real-time awareness.
+
+### 5. User-Owned Memory (Llama 4)
+Federated, user-controlled memory with community knowledge contributions. This is the privacy-preserving alternative to centralized knowledge stores.
+
+### 6. Self-Play Reasoning (DeepSeek)
+The system generates practice problems and solves them to improve reasoning — essentially "studying" without external data. This could be a scalable path to superhuman reasoning.
diff --git a/research/synthesis.md b/research/synthesis.md
new file mode 100644
index 0000000..45dbd51
--- /dev/null
+++ b/research/synthesis.md
@@ -0,0 +1,108 @@
+# Synthesis: Proposed Combined AGI Architecture
+
+## Design Philosophy
+
+This synthesis extracts the strongest ideas from all 8 AI systems and combines them into a unified architecture called **Prometheus AGI**. The design follows three principles:
+1. **Temporal primacy** (from MiMo): Time is a first-class dimension
+2. **Constitutional safety** (from Claude): Safety is woven into every component
+3. **Multimodal perception** (from Gemini): The system perceives the world natively in all modalities
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    PROMETHEUS AGI                        │
+├─────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌──────────────┐  ┌───────────────┐  │
+│  │ Multimodal  │  │  Temporal    │  │  Constitutional│  │
+│  │ Perception  │  │  Memory      │  │  Safety Layer  │  │
+│  │ (Gemini)    │  │  (MiMo)      │  │  (Claude)      │  │
+│  └──────┬──────┘  └──────┬───────┘  └───────┬───────┘  │
+│         │                │                   │          │
+│  ┌──────▼────────────────▼───────────────────▼───────┐  │
+│  │           Temporal Reasoning Engine                │  │
+│  │    (DeepSeek metacognition + MiMo temporal)       │  │
+│  └──────────────────────┬────────────────────────────┘  │
+│                         │                               │
+│  ┌──────────────────────▼────────────────────────────┐  │
+│  │           Action & Tool Subsystem                  │  │
+│  │    (GPT-4o verification + Grok real-time)         │  │
+│  └──────────────────────┬────────────────────────────┘  │
+│                         │                               │
+│  ┌──────────────────────▼────────────────────────────┐  │
+│  │           Learning & Self-Improvement              │  │
+│  │    (DeepSeek self-play + Llama federated)         │  │
+│  └───────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────┘
+```
+
+## Component Details
+
+### 1. Multimodal Perception (from Gemini)
+The system perceives the world through natively multimodal sensors. Vision, audio, text, and structured data are fused into unified percepts using cross-attention mechanisms. This eliminates the "translation layer" between modalities.
+
+### 2. Temporal Memory (from MiMo)
+Memory is indexed by TIME as a primary dimension. Every memory has:
+- Precise timestamp and duration
+- Causal chain (what caused it, what it caused)
+- Epistemic status (from Claude): how we know it, confidence level
+- Cross-lingual binding (from Qwen): language-agnostic representation
+
+### 3. Constitutional Safety Layer (from Claude)
+Safety is woven into every component:
+- Every reasoning step passes through constitutional review
+- Every memory write is checked for safety implications
+- Every action is verified against harm prediction models
+- Predictive safety (from MiMo): simulate actions forward in time before executing
+
+### 4. Temporal Reasoning Engine (from DeepSeek + MiMo)
+The core reasoning loop combines:
+- DeepSeek's metacognitive self-verification
+- MiMo's temporal reasoning chains
+- Claude's constitutional review
+- GPT-4o's MCTS planning
+
+The system reasons about WHAT to do, WHEN to do it, and WHY — simultaneously.
+
+### 5. Action & Tool Subsystem (from GPT-4o + Grok)
+Tool use combines:
+- GPT-4o's function-calling with pre/post-condition verification
+- Grok's real-time API discovery
+- Gemini's visual tool interface (GUI automation)
+- MiMo's temporal scheduling
+
+### 6. Learning & Self-Improvement (from DeepSeek + Llama)
+Learning combines:
+- DeepSeek's self-play reasoning improvement
+- Llama's federated learning for privacy
+- Claude's constitutional learning (new principles require human approval)
+- MiMo's temporal improvement tracking
+
+## Key Innovations of the Synthesis
+
+1. **Temporal-Constitutional Integration**: Safety checks simulate actions forward in time, catching harms that input/output filtering would miss.
+
+2. **Epistemic Memory**: Every memory carries provenance, confidence, and temporal context. The system knows what it knows, what it doesn't know, and how its knowledge has changed over time.
+
+3. **Metacognitive Self-Play**: The system generates practice problems, solves them, and improves — but under constitutional constraints to prevent unsafe self-modification.
+
+4. **Cultural-Temporal Awareness**: The system understands that values and norms change over time and vary across cultures. Safety is adaptive, not rigid.
+
+5. **User-Sovereign Memory**: Users own their data (from Llama). The system's knowledge is split between:
+   - Personal memory (user-owned, local)
+   - Community knowledge (federated, privacy-preserving)
+   - Universal knowledge (open, verified)
+
+## Open Questions
+
+1. **Scalability**: Can this architecture run efficiently? The combination of temporal reasoning + constitutional review + multimodal perception is computationally expensive.
+
+2. **Constitutional Conflicts**: When constitutional principles conflict with cultural values, how is this resolved? The hierarchy needs explicit definition.
+
+3. **Self-Modification Limits**: How much can the system improve itself before human oversight is needed? The boundary between "learning" and "self-modification" is blurry.
+
+4. **Real-time vs. Depth Tradeoff**: When should the system use Grok-style fast reasoning vs. DeepSeek-style deep reasoning? A meta-controller is needed.
+
+## Conclusion
+
+The strongest AGI architecture combines temporal reasoning (MiMo), constitutional safety (Claude), multimodal perception (Gemini), metacognitive self-verification (DeepSeek), and user-sovereign memory (Llama). No single system got everything right, but together they paint a compelling picture of what AGI could look like.