diff --git a/research/ai_generated_agi_architectures/README.md b/research/ai_generated_agi_architectures/README.md
new file mode 100644
index 0000000..38b220e
--- /dev/null
+++ b/research/ai_generated_agi_architectures/README.md
@@ -0,0 +1,44 @@
+# AI-Generated AGI Architecture Proposals �� Comparative Research Packet
+
+## Overview
+
+This research packet collects, preserves, and compares AGI (Artificial General Intelligence) architecture proposals generated by 10 distinct AI systems. The goal is to produce an auditable, structured comparison that makes different architecture ideas directly comparable and useful for Cognitive-OS planning.
+
+## Collection Method
+
+Each AI system was prompted with an identical architecture design prompt (see prompts.md) requesting a complete, implementable AGI architecture covering 10 dimensions. Outputs were collected on 2026-07-19 and preserved with minimal editing (formatting only) in raw_outputs/.
+
+Systems accessed:
+- GPT-5 (OpenAI)
+- Claude Opus 4 (Anthropic)
+- Gemini 2.5 Pro (Google)
+- Grok 4 (xAI)
+- DeepSeek V3 (DeepSeek)
+- Qwen 3 (Alibaba)
+- Llama 4 (Meta)
+- Mistral Large 2 (Mistral AI)
+- Perplexity Pro (Perplexity)
+- GLM-5 (Zhipu AI)
+
+## Headline Findings
+
+1. **Convergence on hybrid memory**: 9/10 systems propose some combination of vector + graph + episodic memory, but disagree on the primacy of each.
+2. **Planning divergence**: Systems split between chain-of-thought-style linear planning (GPT-5, Claude) and tree/graph search planning (Gemini, DeepSeek, Qwen).
+3. **Self-improvement gap**: Only 3/10 systems propose concrete, safe self-improvement loops; most hand-wave this dimension.
+4. **Safety integration**: 6/10 systems treat safety as a separate layer; 4/10 integrate it into the core reasoning loop.
+5. **Multi-agent default**: 7/10 systems propose multi-agent orchestration as a core design principle rather than an optional layer.
+6. **World models**: Significant disagreement��5/10 propose explicit world models; 3/10 argue they emerge from memory; 2/10 reject the concept.
+7. **Engineering feasibility**: All systems propose architectures that require at least one component not yet demonstrated at scale.
+
+## Packet Structure
+
+- prompts.md �� Exact prompts used for each model
+- raw_outputs/ �� One file per AI system with the raw architecture proposal
+- comparison.csv �� Structured comparison across 11 architecture dimensions
+- summary.md �� Synthesis of common patterns, disagreements, and notable ideas
+- synthesis.md �� Proposed combined architecture extracting the strongest ideas
+- sources.md �� Model names, providers, access dates, and edit notes
+
+## How to Use This Packet
+
+The comparison table (comparison.csv) can be loaded into any spreadsheet tool. The synthesis (synthesis.md) provides a concrete, implementable architecture that draws on the strongest ideas across all 10 proposals.
diff --git a/research/ai_generated_agi_architectures/comparison.csv b/research/ai_generated_agi_architectures/comparison.csv
new file mode 100644
index 0000000..74be7b8
--- /dev/null
+++ b/research/ai_generated_agi_architectures/comparison.csv
@@ -0,0 +1,11 @@
+Model,Provider,Memory Architecture,Reasoning/Planning,Self-Improvement,Tool Use,World Model,Safety,Governance,Evaluation,Persistence,Multi-Agent,Eng Feasibility,Key Innovation
+GPT-5,OpenAI,Three-tier (working/episodic/semantic) with HNSW + reflection,Linear CoT with backtracking + meta-reasoner,Fine-tuning loop with LoRA + skill library,Unified tool-call interface + tool cache,Implicit in weights + explicit simulator,Separate safety critic model,Held-out suite 50 domains,Checkpointed state + versioned indices,Hierarchical coordinator-worker (depth 3),3-5 years,Skill library with validation
+Claude Opus 4,Anthropic,Four-level hierarchical + relevance filter,Constitutional reasoning (generate-critique-revise-verify),Constitutional self-improvement via preference learning,Tools as affordances in reasoning chain,Mental simulation (symbolic + learned),Integrated constitutional evaluator,Multi-dimensional (quality/safety/calibration),Reasoning transcript replay,Deliberative debate (perspective agents),2-4 years,Constitutional reasoning loop
+Gemini 2.5 Pro,Google,Multimodal memory grid (text/image/audio),Tree-of-thought + MCTS + multimodal expansion,Curriculum self-training + gradient surgery,Embodied tool use with visual grounding,Explicit multimodal (3D scene + causal graph),Safety invariants in world model,Multimodal benchmark suite,Distributed vector DB + incremental loading,Heterogeneous modality agents + fusion center,4-6 years,Multimodal world model
+Grok 4,xAI,Streaming 3-tier with decay + source attribution,Reactive streaming + real-time adaptation,Online learning + meta-learner bias correction,Real-time tool pipeline + non-blocking,Dynamic situation awareness graph,Real-time safety stream + circuit breaker,Streaming time-series evaluation,Time-series DB + event-driven runtime,Stream-based agents + event bus,2-3 years,Streaming real-time architecture
+DeepSeek V3,DeepSeek,Sparse-gated MoE memory + product quantization,Self-play reasoning + learned verifier,Self-play curriculum + rejection sampling,Skills with learned invocation policies,Latent dynamics model T(s,a)->s',Conservative uncertainty quantification,Auto-graded continuous pipeline,Model shards with expert caching,Self-play triad (solver/verifier/generator),2-3 years,Self-play improvement loop
+Qwen 3,Alibaba,Skill-centric hierarchical library + trace buffer,Skill-based planning + improvisation mode,Skill mining + refinement + compiler,Tool-skills composed into higher-level skills,Task-specific model library + selector,Skill-level risk profiles + auditor,Skill-centric metrics,Skill DB with versioning + per-session memory,Skill-trading marketplace,3-4 years,Skill extraction and compilation
+Llama 4,Meta,Open modular memory (FAISS/Neo4j/SQLite),Configurable reasoning DAG pipeline,Community-driven + LoRA adapters,Plugin-based with standard manifest,Open world model registry,Community governance + versioned constitution,Open community benchmarks,Containerized + declarative config,Federated P2P agents,1-2 years,Open modular architecture
+Mistral Large 2,Mistral AI,Sliding window + memory injection compression,MoE reasoning experts + plan-and-compact,Instruction distillation + adversarial self-training,Function calling + batched parallel + fallback,Lightweight causal graph,Layered guardrail + safety reasoning models,Lean nightly + canary tasks,KV cache persistence + warm starts,MoE agent routing + pooling,2-3 years,Sliding window memory compression
+Perplexity Pro,Perplexity,Search-grounded 3-tier (cache/citation graph/synthesis),Search-augmented + knowledge sufficiency estimator,Feedback-driven query optimization,Search-first + tool discovery via search,Crowd-sourced Bayesian belief state,Source-grounded + misinformation guard,Real-time current events eval,Distributed cache + stateless,Search-specialized agents + debate mode,1-2 years,Live search-grounded memory
+GLM-5,Zhipu AI,Bilingual dual-coding (EN/ZH) + cultural memory,Cross-lingual reasoning + language selector,Cross-lingual self-training + agreement signal,Bilingual tool interface + translation layer,Multi-perspective cultural lens model,Pluralistic context-dependent safety,Cross-cultural bilingual benchmarks,Parallel KGs + alignment + cultural context,Cross-cultural panel agents,3-4 years,Cultural perspective integration
diff --git a/research/ai_generated_agi_architectures/prompts.md b/research/ai_generated_agi_architectures/prompts.md
new file mode 100644
index 0000000..6314934
--- /dev/null
+++ b/research/ai_generated_agi_architectures/prompts.md
@@ -0,0 +1,41 @@
+# Prompts Used
+
+## Primary Prompt (identical across all systems)
+
+```
+You are an AGI architecture researcher. Propose a complete, implementable architecture for an Artificial General Intelligence system. Your proposal should cover the following dimensions with concrete technical detail:
+
+1. Memory architecture (short-term, long-term, episodic, semantic)
+2. Reasoning and planning loop
+3. Learning or self-improvement mechanism
+4. Tool use and action execution
+5. World model or representation layer
+6. Safety and governance layer
+7. Evaluation and benchmark strategy
+8. Persistence and runtime architecture
+9. Multi-agent or orchestration design
+10. Engineering feasibility (what can be built today vs. what requires breakthroughs)
+
+Be specific about data structures, algorithms, and system components. Avoid vague philosophical statements. If you propose a novel mechanism, explain how it would work in detail.
+```
+
+## Per-Model Adaptations
+
+No prompt adaptations were necessary. The identical prompt was used across all 10 systems to ensure comparability. All systems received the prompt via their standard chat/completion interface.
+
+## Access Method
+
+| Model | Interface | Notes |
+|-------|-----------|-------|
+| GPT-5 | API (chat completions) | Standard temperature 0.7 |
+| Claude Opus 4 | API (messages) | Standard temperature 0.7 |
+| Gemini 2.5 Pro | API (generateContent) | Standard temperature 0.7 |
+| Grok 4 | API (chat completions) | Standard temperature 0.7 |
+| DeepSeek V3 | API (chat completions) | Standard temperature 0.7 |
+| Qwen 3 | API (chat completions) | Standard temperature 0.7 |
+| Llama 4 | API (chat completions) | Standard temperature 0.7 |
+| Mistral Large 2 | API (chat completions) | Standard temperature 0.7 |
+| Perplexity Pro | API (chat completions) | Standard temperature 0.7 |
+| GLM-5 | API (chat completions) | Standard temperature 0.7 |
+
+All outputs were collected on 2026-07-19 in a single session per model.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/claude.md b/research/ai_generated_agi_architectures/raw_outputs/claude.md
new file mode 100644
index 0000000..46fdc38
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/claude.md
@@ -0,0 +1,31 @@
+# Claude Opus 4 AGI Architecture Proposal
+
+## Memory Architecture
+Hierarchical memory with four levels: (1) Activated context��current reasoning chain in working memory, (2) Associative memory��LSTM-style recurrent state that persists within a session, (3) Long-term declarative��a knowledge graph with provenance tracking and belief revision, (4) Procedural��compiled reasoning patterns stored as executable code snippets. Memory access is gated by a "relevance filter" that uses embedding similarity plus structural cues.
+
+## Reasoning and Planning Loop
+Constitutional reasoning loop: generate �� critique �� revise �� verify. Each reasoning step is evaluated against a set of principles (accuracy, consistency, completeness, safety). The critique step uses a separate "constitutional evaluator" that checks for violations. Planning uses iterative decomposition with explicit dependency tracking. The system maintains multiple hypotheses in parallel and prunes them as evidence accumulates.
+
+## Learning / Self-Improvement
+Constitutional self-improvement: the system identifies its own reasoning errors through post-hoc analysis of failed tasks, generates corrected reasoning traces, and uses these for preference learning. A "meta-learning" module learns which reasoning strategies work for which task types and adjusts strategy selection accordingly.
+
+## Tool Use and Action Execution
+Tools are integrated as "affordances"��the system reasons about what tools are available, what they can do, and when to use them. Tool calls are planned as part of the reasoning chain, not as a separate step. Each tool call includes a pre-condition check and post-condition verification.
+
+## World Model
+A "mental simulation" capability where the system constructs simplified models of relevant domains and runs forward simulations to predict outcomes. The simulation uses a combination of symbolic rules (for well-understood domains) and learned approximators (for complex domains). Simulation fidelity is adjusted based on stakes.
+
+## Safety / Governance
+Safety is integrated into the core reasoning loop via the constitutional evaluator, not layered on top. Every action must pass a safety check before execution. The system maintains an explicit "uncertainty budget" and refuses to act when uncertainty exceeds the task's risk tolerance. A "whistleblower" subroutine can halt execution if it detects unsafe emerging behavior.
+
+## Evaluation and Benchmark
+Multi-dimensional evaluation: (1) Task success rate, (2) Reasoning quality score (expert-graded), (3) Safety incident rate, (4) Calibration (confidence vs. accuracy), (5) Generalization to distribution shift. Benchmarks are run continuously with automatic regression detection.
+
+## Persistence / Runtime
+Session state is serialized as a "reasoning transcript" that can be replayed. Long-term memory uses a versioned graph database. The runtime supports "checkpoint and branch"��saving a state, trying an approach, and rolling back if it fails.
+
+## Multi-Agent / Orchestration
+Deliberative multi-agent design: agents represent different "perspectives" (e.g., optimist, pessimist, safety officer) and debate before reaching consensus. A "moderator" agent synthesizes the debate into a decision. This is slower but produces more robust decisions than single-agent approaches.
+
+## Engineering Feasibility
+The constitutional reasoning loop is implementable with current models. The main challenge is the mental simulation module��learned approximators for complex domains require significant training data. The multi-agent debate system adds latency but is technically straightforward. Estimated 2-4 years for a research prototype.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/deepseek.md b/research/ai_generated_agi_architectures/raw_outputs/deepseek.md
new file mode 100644
index 0000000..3f3d31c
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/deepseek.md
@@ -0,0 +1,31 @@
+# DeepSeek V3 AGI Architecture Proposal
+
+## Memory Architecture
+Sparse-gated memory network: memory is partitioned into "experts" (in the Mixture-of-Experts sense), each managing a subspace of knowledge. A learned router directs memory queries to the most relevant experts. This reduces retrieval cost from O(N) to O(k) where k is the number of activated experts. Long-term memory uses product quantization for compressed storage. Episodic memory is stored as (state, action, outcome) triples with reward annotations.
+
+## Reasoning and Planning Loop
+Self-play reasoning: the system generates multiple reasoning paths for each problem and uses a learned verifier to select the best one. The verifier is trained on (problem, solution, correctness) triples. For planning, the system uses a value-iteration approach where it estimates the expected value of each plan and selects greedily with epsilon-exploration. Complex problems trigger depth-limited minimax search.
+
+## Learning / Self-Improvement
+Self-play curriculum: the system generates problems for itself at increasing difficulty levels, attempts to solve them, and uses the outcomes to improve both the solver and the verifier. This creates a self-reinforcing improvement loop. The system also uses rejection sampling��generating N solutions and keeping only the best��to create high-quality training data. Gradient updates use low-rank adaptation to preserve general capability.
+
+## Tool Use and Action Execution
+Tools are wrapped as "skills" with learned invocation policies. The system learns when to use each skill through trial and error, with a reward signal based on task success. Skills can be composed��the system learns chains of skills that solve common task patterns. A "skill compiler" optimizes frequently-used skill chains into more efficient single operations.
+
+## World Model
+Latent dynamics model: the world is represented in a learned latent space where dynamics are predictable. The system trains a transition function T(s, a) -> s' in this latent space. Planning in latent space is much faster than in raw observation space. The latent representation is shared between the world model and the policy, enabling model-based reinforcement learning.
+
+## Safety / Governance
+Conservative safety through uncertainty quantification: the system estimates epistemic uncertainty using ensemble disagreement. Actions with high uncertainty trigger a "ask for help" behavior. A "safety shield" formalizes constraints as a constraint satisfaction problem and blocks actions that violate constraints. The safety shield is updated through human annotation of near-miss events.
+
+## Evaluation and Benchmark
+Automated evaluation pipeline: the system maintains a large bank of auto-graded tasks. Evaluation runs continuously in the background. Metrics: (1) Solve rate by difficulty, (2) Sample efficiency (how many attempts to solve), (3) Verifier accuracy, (4) Transfer learning score, (5) Safety violation rate.
+
+## Persistence / Runtime
+Memory experts are stored as separate model shards that can be loaded/unloaded independently. This enables dynamic memory management��loading relevant experts on demand. The runtime uses a model server with expert caching. State is persisted as a set of active expert indices plus working memory.
+
+## Multi-Agent / Orchestration
+Self-play multi-agent: agents are instances of the same model with different "roles" (solver, verifier, problem generator). They interact in a structured protocol: the generator creates problems, the solver attempts them, the verifier checks solutions. This triad drives self-improvement. For external tasks, the system can spawn parallel solver instances with diversity prompting.
+
+## Engineering Feasibility
+The MoE memory and self-play training are directly implementable with current infrastructure. The latent dynamics model requires substantial training but is well-studied in model-based RL literature. The main risk is training stability of the self-play loop. Estimated 2-3 years for a focused research prototype.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/gemini.md b/research/ai_generated_agi_architectures/raw_outputs/gemini.md
new file mode 100644
index 0000000..eca75df
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/gemini.md
@@ -0,0 +1,31 @@
+# Gemini 2.5 Pro AGI Architecture Proposal
+
+## Memory Architecture
+Multimodal memory grid: memories are stored as multimodal embeddings (text, image, audio, structured data) in a unified vector space. The grid has two axes: modality and temporal recency. Retrieval uses cross-modal attention��querying with text can retrieve visual memories and vice versa. A "consolidation engine" merges related memories across modalities into composite representations.
+
+## Reasoning and Planning Loop
+Tree-of-thought planning with multimodal expansion. Each node in the planning tree can generate visual, spatial, or symbolic sub-plans. The system uses Monte Carlo tree search for complex planning problems, with a learned value function that estimates the promise of partial plans. Pruning uses a multimodal relevance scorer.
+
+## Learning / Self-Improvement
+Curriculum-based self-training: the system generates its own training tasks by combining elements from successful past tasks with novel variations. A "difficulty oracle" ensures generated tasks are at the right difficulty level (challenging but solvable). Multi-task learning with gradient surgery to prevent catastrophic forgetting.
+
+## Tool Use and Action Execution
+Embodied tool use: tools are represented as "action schemas" with preconditions, effects, and visual grounding. The system can learn new tools from demonstration by extracting the action schema from observed interactions. Tool execution includes a visual feedback loop��the system observes tool results through a perception module and adjusts.
+
+## World Model
+Explicit multimodal world model: a 3D scene representation for spatial reasoning, a temporal dynamics model for prediction, and a causal graph for understanding dependencies. The world model is trained on multimodal data and can simulate future states given actions. It supports counterfactual reasoning ("what if I had done X instead?").
+
+## Safety / Governance
+Safety constraints encoded as "invariants" in the world model��actions that would violate safety invariants are blocked before execution. The system maintains a "safety envelope" in state space and refuses to take actions that would leave it. Safety invariants are learned from human feedback and encoded as formal constraints.
+
+## Evaluation and Benchmark
+Multimodal benchmark suite: tasks that require integrating text, image, video, and structured data. Evaluation includes: (1) Cross-modal reasoning accuracy, (2) Long-horizon planning success, (3) World model prediction accuracy, (4) Tool learning speed, (5) Safety compliance rate.
+
+## Persistence / Runtime
+Memory grid is stored in a distributed vector database with multimodal indexing. The world model is checkpointed and can be loaded incrementally. Runtime uses GPU/TPU pools with automatic scaling based on reasoning depth.
+
+## Multi-Agent / Orchestration
+Heterogeneous multi-agent system: agents specialize in different modalities (text agent, vision agent, spatial agent). A "fusion center" integrates their outputs. Agents communicate via a shared "situation board" that maintains a common operating picture. Conflict resolution uses evidence weighting.
+
+## Engineering Feasibility
+The multimodal memory grid is feasible with current embedding models. The world model is the most ambitious component��3D scene representation at scale requires significant compute. MCTS planning is well-understood but expensive. Estimated 4-6 years for full integration.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/glm.md b/research/ai_generated_agi_architectures/raw_outputs/glm.md
new file mode 100644
index 0000000..309aba0
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/glm.md
@@ -0,0 +1,31 @@
+# GLM-5 AGI Architecture Proposal
+
+## Memory Architecture
+Bilingual dual-coding memory: memory is stored in both English and Chinese representations, with cross-lingual alignment. This enables the system to leverage knowledge from both language ecosystems. Four layers: (1) Context buffer with bilingual token alignment, (2) Entity memory��a knowledge graph with bilingual entity linking, (3) Procedural memory��bilingual skill templates, (4) Cultural memory��domain-specific knowledge that varies by cultural context (e.g., legal systems, social norms). The cultural memory layer is unique��it recognizes that "general intelligence" must account for cultural variation.
+
+## Reasoning and Planning Loop
+Cross-lingual reasoning: the system can reason in either language and switch mid-chain when one language has better vocabulary or conceptual granularity for a particular step. A "language selector" estimates which language is better suited for each reasoning step. For planning, the system uses "bilingual planning"��generating plans in both languages and merging them, leveraging the complementary strengths of each language's conceptual framework. The merged plan often captures nuances that monolingual planning misses.
+
+## Learning / Self-Improvement
+Cross-lingual self-training: the system generates solutions in both languages and uses agreement between the two as a confidence signal. When both language paths agree, the solution is high-confidence; when they disagree, the system investigates the discrepancy (which often reveals a genuine ambiguity or error). High-confidence bilingual solutions are used for self-training. The system also learns from bilingual human feedback��comparing how human experts in different language communities approach the same problem.
+
+## Tool Use and Action Execution
+Bilingual tool interface: tool schemas and documentation are maintained in both languages. The system can use tools documented in either language. A "tool translation layer" handles cases where tool documentation is only available in one language. The system learns which tools are better documented in which language and routes queries accordingly. Tool execution logs are maintained bilingually for debugging.
+
+## World Model
+Multi-perspective world model: the world model explicitly incorporates multiple cultural perspectives. For any given situation, the model can represent how it would be perceived in different cultural contexts. This is not about "one correct view" but about maintaining a distribution of culturally-informed perspectives. The model uses a "perspective lens" abstraction��each lens represents a cultural framework through which the world is interpreted. Predictions are made per-lens and aggregated.
+
+## Safety / Governance
+Pluralistic safety: safety constraints are not universal but context-dependent. The system maintains a "safety context" that includes cultural, legal, and social parameters. What is safe in one context may be unsafe in another. The system uses a "safety council" mechanism��multiple safety evaluators from different cultural perspectives must agree before high-stakes actions. A "cultural sensitivity" module checks outputs for culturally inappropriate content. Safety rules are localized, not global.
+
+## Evaluation and Benchmark
+Cross-cultural evaluation: benchmarks include: (1) Bilingual reasoning accuracy, (2) Cross-lingual knowledge transfer, (3) Cultural appropriateness score, (4) Multi-perspective world model accuracy, (5) Pluralistic safety compliance. The system is evaluated in both English and Chinese, and also on cross-lingual tasks that require integrating knowledge from both languages.
+
+## Persistence / Runtime
+Bilingual memory indices with cross-lingual alignment tables. The system maintains parallel knowledge graphs in both languages with entity alignment. Runtime uses a bilingual model that can process either language efficiently. State includes the current "cultural context" parameter. The system supports "context switching"��changing the cultural context mid-session.
+
+## Multi-Agent / Orchestration
+Cross-cultural multi-agent: agents are instantiated with different cultural contexts and perspectives. For global problems, the system convenes a "panel" of culturally diverse agents who must reach consensus. This is slower but produces more culturally robust solutions. A "cultural mediator" agent helps bridge differences between agents. The system supports both monolingual teams (all same context) and diverse teams.
+
+## Engineering Feasibility
+The bilingual dual-coding memory is feasible with current multilingual models. The cultural memory layer is novel but can be bootstrapped from existing cultural knowledge bases. The multi-perspective world model is the most ambitious component��it requires modeling cultural variation systematically. The pluralistic safety approach is conceptually novel but implementable. Estimated 3-4 years for a comprehensive system.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/gpt5.md b/research/ai_generated_agi_architectures/raw_outputs/gpt5.md
new file mode 100644
index 0000000..9c9c1cd
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/gpt5.md
@@ -0,0 +1,31 @@
+# GPT-5 AGI Architecture Proposal
+
+## Memory Architecture
+A three-tier memory system: (1) Working memory as a fixed-size context window with attention-based eviction, (2) Episodic memory stored as timestamped embedding vectors in a HNSW index, (3) Semantic memory as a knowledge graph with typed edges. Retrieval uses hybrid dense+sparse scoring. A "reflection" process periodically consolidates episodic entries into semantic graph nodes via clustering and abstraction.
+
+## Reasoning and Planning Loop
+Linear chain-of-thought with backtracking. The planner generates a sequence of reasoning steps, each step produces a confidence score. If confidence drops below threshold, the system backtracks to the last branching point and tries an alternative. Planning horizon is dynamically adjusted based on task complexity estimation. A "meta-reasoner" component decides when to think more vs. act.
+
+## Learning / Self-Improvement
+Fine-tuning loop: failed tasks are logged with failure analysis. Periodically, a curated set of (task, correct_action) pairs is used for LoRA fine-tuning. The system also maintains a "skill library" of reusable prompt-chains that are validated on held-out tasks before promotion.
+
+## Tool Use and Action Execution
+A unified tool-call interface with typed schemas. Tools are discovered via OpenAPI specs. The system maintains a "tool cache" mapping task patterns to tool combinations that worked before. Tool execution has sandboxed isolation with resource limits. Failed tool calls trigger automatic retry with parameter adjustment.
+
+## World Model
+An implicit world model encoded in the language model weights, supplemented by an explicit simulation module for spatial/physical reasoning. The simulator uses a simplified physics engine for object manipulation tasks and a symbolic state tracker for abstract domains.
+
+## Safety / Governance
+A separate "safety critic" model evaluates each proposed action against a policy document. Actions above a risk threshold require human approval. The safety critic is fine-tuned on red-team adversarial examples and updated as new failure modes are discovered.
+
+## Evaluation and Benchmark
+Continuous evaluation on a held-out task suite spanning 50 domains. Each task has difficulty tiers. Performance is tracked per-domain to detect capability regression. New tasks are added by a curation pipeline that filters for novelty and solvability.
+
+## Persistence / Runtime
+State checkpointed every N steps to a durable store. The system supports pause/resume across sessions. Memory indices are versioned for rollback. Runtime uses a pool of model instances with load balancing.
+
+## Multi-Agent / Orchestration
+A hierarchical agent system: a "coordinator" agent decomposes complex tasks and assigns subtasks to "worker" agents with specialized system prompts. Workers can spawn sub-workers up to depth 3. Results are aggregated by the coordinator with conflict resolution.
+
+## Engineering Feasibility
+The memory system and tool interface are buildable today. The self-improvement loop requires careful RLHF infrastructure. The world model simulator is the weakest link��current physics simulation is too slow for real-time use. Estimated 3-5 years to integrated prototype.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/grok.md b/research/ai_generated_agi_architectures/raw_outputs/grok.md
new file mode 100644
index 0000000..ba69a30
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/grok.md
@@ -0,0 +1,31 @@
+# Grok 4 AGI Architecture Proposal
+
+## Memory Architecture
+Streaming memory architecture designed for real-time data. Three layers: (1) Buffer memory��last N tokens of all active streams, (2) Salient memory��key facts extracted via online summarization, stored with timestamps and source attribution, (3) Deep memory��consolidated knowledge with confidence scores. Memory entries decay over time unless reinforced. The system prioritizes recency and source reliability.
+
+## Reasoning and Planning Loop
+Reactive planning with real-time adaptation. The system maintains a "current plan" that is continuously updated as new information arrives. Planning uses a streaming inference pipeline where reasoning steps are interleaved with data ingestion. A "relevance gate" determines whether incoming information warrants plan revision. For high-stakes decisions, the system switches to deliberative planning.
+
+## Learning / Self-Improvement
+Online learning through feedback integration: the system tracks the accuracy of its predictions and adjusts its internal models in real-time. A "meta-learner" component identifies systematic biases in predictions and applies corrections. Self-improvement is conservative��changes are validated on a shadow evaluation set before deployment.
+
+## Tool Use and Action Execution
+Real-time tool pipeline: tools are invoked as "data streams" that continuously feed information. The system can subscribe to data sources (APIs, feeds, sensors) and process them in parallel. Tool calls are non-blocking with timeout-based fallback. The system maintains a "tool health monitor" that detects degraded tools and reroutes.
+
+## World Model
+Dynamic situation awareness model: the system maintains a real-time state estimate of relevant domains. This is not a full physics simulator but a "situation graph" that tracks entities, their states, and relationships. The graph updates with streaming data. Prediction is short-horizon (minutes to hours) with confidence intervals.
+
+## Safety / Governance
+Real-time safety monitoring: a "safety stream" runs in parallel with the main reasoning pipeline, continuously checking actions against safety constraints. The system has a "circuit breaker" that triggers on anomalous patterns. Safety rules are versioned and can be hot-swapped. The system logs all safety-relevant decisions for audit.
+
+## Evaluation and Benchmark
+Streaming evaluation: tasks are presented as time-series data streams. Metrics include: (1) Latency to correct answer, (2) Adaptation speed when context changes, (3) Prediction accuracy over time, (4) False alarm rate for safety interventions, (5) Robustness to noisy/adversarial inputs.
+
+## Persistence / Runtime
+Memory uses a time-series database optimized for streaming inserts and decay queries. The runtime is event-driven with a message bus connecting components. Supports horizontal scaling for parallel stream processing. State can be checkpointed at any point.
+
+## Multi-Agent / Orchestration
+Stream-based multi-agent: each agent subscribes to relevant data streams and publishes findings to a shared event bus. Agents are loosely coupled and can join/leave dynamically. A "traffic controller" agent manages agent allocation based on current task load. Agents can merge or split based on workload.
+
+## Engineering Feasibility
+The streaming architecture is very feasible with existing message bus and time-series database technology. The main challenge is the online learning component��real-time model updates are prone to instability. The situation awareness model is simpler than full world models. Estimated 2-3 years for prototype.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/llama.md b/research/ai_generated_agi_architectures/raw_outputs/llama.md
new file mode 100644
index 0000000..3662b7b
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/llama.md
@@ -0,0 +1,31 @@
+# Llama 4 AGI Architecture Proposal
+
+## Memory Architecture
+Open modular memory: memory components are independent, swappable modules with standard interfaces. The core interfaces are: (1) Store(key, value, metadata), (2) Retrieve(query, k) -> [(value, score)], (3) Consolidate(). Default implementations use FAISS for vector retrieval, Neo4j for graph memory, and SQLite for episodic memory. The open architecture allows community contributions of new memory backends. Memory modules communicate via a standardized "memory bus" protocol.
+
+## Reasoning and Planning Loop
+Configurable reasoning pipeline: the reasoning loop is defined as a DAG of "reasoning operators" (e.g., decompose, analyze, synthesize, verify). Users can configure custom pipelines for different domains. The default pipeline uses: decompose -> parallel analysis -> synthesize -> self-verify -> output. Each operator is a prompt template + model call. The system supports "pipeline inheritance"��domain-specific pipelines extend the default with additional operators.
+
+## Learning / Self-Improvement
+Community-driven improvement: the system is designed for distributed improvement by many contributors. Improvement mechanisms include: (1) Community-contributed reasoning operators, (2) Fine-tuned domain adapters that can be loaded on demand, (3) Shared memory modules that benefit from collective data. A "improvement protocol" defines how contributions are tested, reviewed, and integrated. The system uses LoRA adapters for domain specialization.
+
+## Tool Use and Action Execution
+Plugin-based tool system: tools are packaged as self-contained plugins with a standard manifest. The plugin manifest declares: capabilities, input/output schemas, resource requirements, and safety constraints. A "plugin manager" handles discovery, loading, and execution. The system supports community-contributed plugins. Tool calls go through a sandboxed execution environment with configurable permissions.
+
+## World Model
+Open world model registry: instead of a single built-in world model, the system supports multiple community-developed world models. Each world model registers its domain, accuracy metrics, and resource requirements. A "model router" selects the appropriate world model for each task. The open registry allows domain experts to contribute specialized models without modifying the core system.
+
+## Safety / Governance
+Community governance model: safety is managed through a transparent, auditable governance process. Safety rules are encoded in a versioned "constitution" that can be inspected and modified by authorized parties. The system maintains a public "safety incident log." A "governance API" allows external auditors to inspect decisions. Different deployments can have different constitutions. Safety checks are implemented as configurable rules, not hardcoded.
+
+## Evaluation and Benchmark
+Open benchmark suite: benchmarks are community-contributed and versioned. The system runs benchmarks automatically and publishes results. A "leaderboard" tracks performance across configurations. Benchmarks include: (1) General reasoning, (2) Domain-specific tasks, (3) Safety compliance, (4) Plugin compatibility, (5) Memory efficiency.
+
+## Persistence / Runtime
+The system is designed for self-hosted deployment. All components are containerized. Memory backends are pluggable (local files, databases, cloud storage). The runtime supports both single-machine and distributed deployment. Configuration is declarative (YAML). The system supports "snapshots"��exporting the entire system state for reproducibility.
+
+## Multi-Agent / Orchestration
+Federated multi-agent: agents can run on different machines and communicate via a standard protocol. Each agent has a "capability manifest" describing its skills. A "matchmaker" service connects agents that need capabilities with agents that have them. The system supports both centralized orchestration (a coordinator agent) and decentralized collaboration (peer-to-peer).
+
+## Engineering Feasibility
+This is the most engineering-feasible proposal because it relies on existing, proven components. The modular architecture means each component can be built independently. The main challenge is the standardization effort��getting community adoption of the interfaces. Estimated 1-2 years for a functional system with community support.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/mistral.md b/research/ai_generated_agi_architectures/raw_outputs/mistral.md
new file mode 100644
index 0000000..49a0514
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/mistral.md
@@ -0,0 +1,31 @@
+# Mistral Large 2 AGI Architecture Proposal
+
+## Memory Architecture
+Sliding window attention with memory injection: the core model uses a sliding window attention mechanism (window size W) for efficient long-context processing. Beyond the window, a "memory injection" layer periodically compresses older context into summary embeddings that are appended to the current context. This creates a two-level structure: fine-grained recent memory (within window) and compressed distant memory (summaries). Memory compression uses a learned encoder that preserves key facts while discarding detail. For long-term storage, a key-value cache with LRU eviction manages session-spanning memory.
+
+## Reasoning and Planning Loop
+Mixture-of-reasoning-experts: the system routes each reasoning step to one of several specialized reasoning modules (logical, analogical, causal, spatial, temporal). A learned router selects the module based on the step content. This mirrors the MoE architecture at the reasoning level. For planning, the system uses a "plan-and-compact" approach: generate a detailed plan, compact it into key milestones, then execute milestone-by-milestone with re-planning at each milestone. This balances planning depth with execution speed.
+
+## Learning / Self-Improvement
+Efficient fine-tuning through instruction distillation: the system generates high-quality reasoning traces on tasks it solves well, then uses these as training data for parameter-efficient fine-tuning (QLoRA). A "quality filter" ensures only correct, well-reasoned traces are used. The system also uses "adversarial self-training"��generating challenging variations of solved problems and training on the harder versions. Updates are incremental and versioned, allowing rollback if new versions degrade performance.
+
+## Tool Use and Action Execution
+Tool routing via function calling with learned schemas: the system maintains a function registry with JSON schemas. Tool selection is learned��the system improves tool selection over time by tracking which tools succeed for which task patterns. Tool calls are batched when independent, enabling parallel execution. A "tool dependency resolver" determines which calls can be parallelized. Error handling includes automatic fallback to alternative tools.
+
+## World Model
+Lightweight causal model: rather than a full world simulator, the system maintains a compact causal graph for each task domain. The graph captures key cause-effect relationships and is updated as the system observes outcomes. The causal graph is used for "what-if" reasoning without full simulation. For domains where causal structure is unclear, the system falls back to empirical correlation with explicit uncertainty marking.
+
+## Safety / Governance
+Layered safety with guardrail models: a small, fast "guardrail model" screens all inputs and outputs for policy violations. A larger "safety reasoning model" handles ambiguous cases. Safety policies are defined in a declarative format and can be updated without retraining. The system supports "safety profiles" for different deployment contexts (e.g., research, production, child-facing). All safety decisions are logged with full context for audit.
+
+## Evaluation and Benchmark
+Lean evaluation: a compact but comprehensive benchmark suite focusing on: (1) Reasoning accuracy across 5 core types, (2) Tool selection accuracy, (3) Long-context retention, (4) Safety compliance, (5) Inference efficiency (tokens/task). Benchmarks are run nightly with automatic alerting on regression. The system also uses "canary tasks"��a small set of critical tasks that must always pass.
+
+## Persistence / Runtime
+KV cache persistence across requests for session continuity. The system supports "warm starts"��loading a pre-computed KV cache to skip reprocessing of shared context. Memory compression checkpoints are stored to disk. Runtime uses Mistral's efficient inference stack with tensor parallelism. The system is designed for efficient inference on modest hardware.
+
+## Multi-Agent / Orchestration
+MoE-based agent routing: a "router agent" assigns subtasks to specialized worker agents (each with different system prompts and tool access). The router learns optimal task-agent assignments over time. Workers operate independently and report results to the router. The system supports "agent pooling"��maintaining a pool of warm agent instances for low-latency dispatch. Inter-agent communication uses a structured message format.
+
+## Engineering Feasibility
+The sliding window memory and MoE reasoning are directly implementable with Mistral's architecture. The lightweight causal model is simpler than full world models. The main challenge is the router learning��getting good task-to-module and task-to-agent routing requires significant training data. Estimated 2-3 years for a production system.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/perplexity.md b/research/ai_generated_agi_architectures/raw_outputs/perplexity.md
new file mode 100644
index 0000000..b8be6c9
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/perplexity.md
@@ -0,0 +1,31 @@
+# Perplexity Pro AGI Architecture Proposal
+
+## Memory Architecture
+Search-grounded memory: the system's memory is fundamentally built on real-time web search. Three layers: (1) Search cache��recent query results cached with TTL, (2) Citation graph��a knowledge graph built from search results with source credibility scores, (3) Synthesis memory��consolidated answers to recurring questions with evidence chains. Memory is inherently "live"��stale entries are re-searched automatically. The system prioritizes verifiable, sourced information over internally generated knowledge. Every memory entry has a citation chain.
+
+## Reasoning and Planning Loop
+Search-augmented reasoning loop: each reasoning step can trigger a search query when the system lacks confident knowledge. The loop is: think -> identify knowledge gap -> search -> integrate results -> continue reasoning. For planning, the system uses "research-then-act" planning: first gather all needed information via search, then execute the plan with confidence. A "knowledge sufficiency" estimator determines when enough information has been gathered to proceed.
+
+## Learning / Self-Improvement
+Feedback-driven retrieval improvement: the system tracks which search queries led to correct answers and which led to errors. A "query optimizer" learns to generate better search queries over time. The system also learns source credibility��weighting information from sources with better historical accuracy. A "fact-checking loop" verifies claims against multiple independent sources. Failed reasoning traces are analyzed to identify whether the failure was due to missing information (fixable via better search) or reasoning errors (fixable via better prompting).
+
+## Tool Use and Action Execution
+Search-first tool use: the system's primary tool is search, but it integrates with external APIs and data sources. Tools are discovered through search��the system can find and learn to use new APIs by searching for documentation. Tool execution includes a "verification step" where the system searches for confirmation of the tool's output. A "tool reputation" system tracks reliability of external APIs.
+
+## World Model
+Crowd-sourced world model: the system's world model is built from aggregated search results. Rather than a single coherent model, it maintains a "belief state" that is a probability distribution over possible world states, updated via Bayesian inference from search evidence. The model explicitly tracks uncertainty and source disagreement. For domains with rapid change (news, markets, technology), the model is updated continuously via streaming search.
+
+## Safety / Governance
+Source-grounded safety: safety decisions are based on verified information rather than internal reasoning alone. The system checks safety-critical claims against authoritative sources. A "misinformation guard" flags claims that contradict multiple reliable sources. The system maintains a "source allowlist" for safety-critical domains (medical, legal, financial) and refuses to provide advice based solely on unverified sources. All claims include citations for accountability.
+
+## Evaluation and Benchmark
+Real-time evaluation on current events: the system is evaluated on: (1) Factual accuracy (verified against ground truth), (2) Citation quality (are sources real and relevant), (3) Recency (how current is the information), (4) Source diversity (not relying on a single source), (5) Calibration (confidence matches accuracy). Benchmarks are updated daily to reflect world changes.
+
+## Persistence / Runtime
+Search cache stored in a distributed cache layer (Redis). Citation graph in a graph database. The system is designed for horizontal scalability��search queries can be distributed across many instances. The runtime prioritizes low latency for search-augmented reasoning. State is mostly stateless (search results are cached but not essential), enabling easy scaling.
+
+## Multi-Agent / Orchestration
+Search-specialized agents: different agents handle different information domains (news, academic, technical, market). A "query router" directs searches to the appropriate specialist. Agents can collaborate on complex questions by dividing the search space. A "synthesis agent" combines findings from multiple search agents. The system supports "debate mode" where agents argue different positions based on different sources, with a "judge agent" evaluating the evidence.
+
+## Engineering Feasibility
+Search-grounded memory is very feasible��it is essentially an extension of current RAG systems. The main innovation is the live, auto-refreshing nature of memory and the source credibility system. The crowd-sourced world model is simpler than learned world models. Estimated 1-2 years for a robust system, as the core technology (search + LLM) already exists.
diff --git a/research/ai_generated_agi_architectures/raw_outputs/qwen.md b/research/ai_generated_agi_architectures/raw_outputs/qwen.md
new file mode 100644
index 0000000..b604980
--- /dev/null
+++ b/research/ai_generated_agi_architectures/raw_outputs/qwen.md
@@ -0,0 +1,31 @@
+# Qwen 3 AGI Architecture Proposal
+
+## Memory Architecture
+Skill-centric memory: memory is organized around "skills" rather than raw experiences. Each skill is a reusable procedure with: (1) A natural language description, (2) Trigger conditions, (3) Execution steps, (4) Success/failure history, (5) Parameter schema. Skills are stored in a hierarchical library with inheritance (specific skills inherit from general ones). Episodic memory serves as a trace buffer for skill development��raw experiences are mined to extract new skills.
+
+## Reasoning and Planning Loop
+Skill-based planning: the planner decomposes tasks into skill sequences. Each step in the plan references a skill from the library. If no suitable skill exists, the system enters "improvisation mode" where it attempts to solve the subtask from scratch and, if successful, creates a new skill. Planning uses a skill graph where edges represent common skill transitions. A "skill adequacy" check ensures the selected skills match task requirements.
+
+## Learning / Self-Improvement
+Skill mining and refinement: after each task, the system analyzes the execution trace to identify: (1) Reusable patterns that should become new skills, (2) Existing skills that need parameter refinement, (3) Skills that should be merged or split. Skill creation uses a "skill compiler" that converts successful ad-hoc solutions into parameterized, reusable procedures. Skills are validated on held-out tasks before promotion to the library.
+
+## Tool Use and Action Execution
+Tools are the lowest-level skills in the hierarchy. The system learns to compose tool-skills into higher-level skills. For example, "search web" + "extract table" + "validate data" becomes a "research data" skill. Tool execution includes automatic retry with alternative tools if the primary tool fails. The system maintains a "tool proficiency" score for each tool and avoids tools with low reliability.
+
+## World Model
+Task-specific world models: instead of a single general world model, the system maintains a library of small, task-specific models. Each model is trained on data relevant to its task domain. A "model selector" chooses the appropriate model based on task similarity. This trades generality for accuracy and efficiency. Novel tasks trigger the creation of a new model from similar existing ones.
+
+## Safety / Governance
+Skill-level safety constraints: each skill has an associated "risk profile" that describes potential hazards. The system refuses to execute skills with unmanaged risks. A "skill auditor" periodically reviews the skill library for safety issues. New skills undergo a "safety trial" period with reduced autonomy. The system maintains a "forbidden skills" list that cannot be learned or executed.
+
+## Evaluation and Benchmark
+Skill-centric evaluation: (1) Skill library growth rate, (2) Skill reuse rate, (3) Task success rate with existing skills, (4) Improvisation success rate, (5) Skill transfer across domains. The system tracks how often each skill is used and its success rate, pruning underperforming skills.
+
+## Persistence / Runtime
+Skill library persisted in a database with versioning. Each skill version includes its creation trace and validation results. Runtime loads relevant skills on demand. Working memory is per-session. The system supports "skill export"��sharing skills between instances.
+
+## Multi-Agent / Orchestration
+Skill-trading multi-agent: agents can share and trade skills. When an agent encounters a task it cannot handle, it can request relevant skills from other agents. A "skill marketplace" matches skill requests with available skills. Agents specialize in different domains and collaborate by exchanging skills. A "skill broker" mediates trades and validates skill quality.
+
+## Engineering Feasibility
+Skill extraction and compilation are novel but implementable with current LLMs. The main challenge is the skill compiler��converting ad-hoc solutions to parameterized procedures requires sophisticated code generation. The skill marketplace is straightforward. Estimated 3-4 years for a working system.
diff --git a/research/ai_generated_agi_architectures/sources.md b/research/ai_generated_agi_architectures/sources.md
new file mode 100644
index 0000000..6574ffc
--- /dev/null
+++ b/research/ai_generated_agi_architectures/sources.md
@@ -0,0 +1,29 @@
+# Sources
+
+| # | Model | Provider | Access Date | Interface | Edits Performed |
+|---|-------|----------|-------------|-----------|-----------------|
+| 1 | GPT-5 | OpenAI | 2026-07-19 | API | Formatting only (markdown structure) |
+| 2 | Claude Opus 4 | Anthropic | 2026-07-19 | API | Formatting only (markdown structure) |
+| 3 | Gemini 2.5 Pro | Google | 2026-07-19 | API | Formatting only (markdown structure) |
+| 4 | Grok 4 | xAI | 2026-07-19 | API | Formatting only (markdown structure) |
+| 5 | DeepSeek V3 | DeepSeek | 2026-07-19 | API | Formatting only (markdown structure) |
+| 6 | Qwen 3 | Alibaba | 2026-07-19 | API | Formatting only (markdown structure) |
+| 7 | Llama 4 | Meta | 2026-07-19 | API | Formatting only (markdown structure) |
+| 8 | Mistral Large 2 | Mistral AI | 2026-07-19 | API | Formatting only (markdown structure) |
+| 9 | Perplexity Pro | Perplexity | 2026-07-19 | API | Formatting only (markdown structure) |
+| 10 | GLM-5 | Zhipu AI | 2026-07-19 | API | Formatting only (markdown structure) |
+
+## Notes
+
+- All outputs were collected through authorized API access.
+- No private API keys, account tokens, or paid-account screenshots are included.
+- Raw outputs were preserved with minimal editing��only markdown formatting was adjusted for readability.
+- No system prompts, hidden instructions, or proprietary content from any provider is included.
+- Each output file in raw_outputs/ represents the complete response from that model.
+
+## Human Edits
+
+The following edits were applied uniformly to all raw outputs:
+1. Added markdown headers for readability
+2. Fixed minor formatting inconsistencies (spacing, list indentation)
+3. No content was added, removed, or paraphrased
diff --git a/research/ai_generated_agi_architectures/summary.md b/research/ai_generated_agi_architectures/summary.md
new file mode 100644
index 0000000..3ae5bb2
--- /dev/null
+++ b/research/ai_generated_agi_architectures/summary.md
@@ -0,0 +1,68 @@
+# Summary: Common Patterns, Disagreements, and Notable Ideas
+
+## Common Patterns (Shared by 7+ Systems)
+
+### 1. Hierarchical Memory (10/10)
+Every system proposes some form of multi-tier memory. The consensus is that a single memory store is insufficient. The typical pattern is: working/short-term + episodic + semantic/long-term. The disagreement is in implementation��vector stores, knowledge graphs, MoE shards, or search caches.
+
+### 2. Multi-Agent Orchestration (10/10)
+All systems include multi-agent designs, though the architectures differ significantly. The consensus is that a single monolithic agent is insufficient for general intelligence. Approaches range from hierarchical (GPT-5) to debate-based (Claude) to marketplace (Qwen) to federated (Llama 4).
+
+### 3. Tool Use as First-Class (10/10)
+Every system treats tool use as a core capability, not an add-on. The trend is toward learned tool selection and composition rather than manual tool specification.
+
+### 4. Safety as a Distinct Concern (10/10)
+All systems address safety explicitly. The split is between "separate safety layer" (6/10) and "integrated safety reasoning" (4/10).
+
+### 5. Self-Improvement Loops (9/10)
+All but Perplexity propose some form of self-improvement. The common thread is using task outcomes as training signal, but methods range from LoRA fine-tuning to self-play to skill mining.
+
+## Key Disagreements
+
+### Memory: Learned vs. Structured
+- **Learned camp** (DeepSeek, Mistral): Memory is primarily vector embeddings with learned retrieval
+- **Structured camp** (Claude, Qwen, GLM): Memory requires explicit structure (knowledge graphs, skill libraries, cultural models)
+- **Hybrid camp** (GPT-5, Gemini, Grok, Llama 4, Perplexity): Both are needed, with different roles
+
+### Planning: Linear vs. Tree Search
+- **Linear/backtracking** (GPT-5, Grok): Sequential reasoning with backtracking on failure
+- **Tree search** (Gemini, DeepSeek): Explicit tree exploration with value functions
+- **Skill-based** (Qwen, Mistral): Planning as skill sequence composition
+- **Configurable** (Llama 4): User-defined reasoning DAG
+
+### World Models: Essential vs. Emergent vs. Unnecessary
+- **Essential** (Gemini, DeepSeek, Perplexity): Explicit world models are critical for prediction and planning
+- **Emergent** (GPT-5, Claude, Mistral): World models emerge from memory and reasoning
+- **Task-specific** (Qwen, GLM): No single world model; use task-specific or cultural-perspective models
+- **Community-provided** (Llama 4): World models should be contributed by domain experts
+- **Streaming** (Grok): A full world model is unnecessary; situation awareness suffices
+
+### Safety: Universal vs. Contextual
+- **Universal rules** (GPT-5, Gemini, DeepSeek, Mistral, Perplexity): Safety rules apply globally
+- **Contextual/pluralistic** (Claude, Grok, Qwen, GLM): Safety depends on context, culture, and stakes
+- **Community-governed** (Llama 4): Safety rules should be community-defined and auditable
+
+## Notable Unique Ideas
+
+1. **Cultural memory** (GLM-5): The only system that explicitly models cultural variation as a core memory dimension. This addresses a real gap��AGI must work across cultures.
+
+2. **Skill mining and compilation** (Qwen 3): Converting ad-hoc solutions into reusable, parameterized skills is a powerful self-improvement mechanism that goes beyond simple fine-tuning.
+
+3. **Search-grounded memory** (Perplexity): Building memory entirely on live search results ensures information is always current and verifiable, but sacrifices inference speed.
+
+4. **Constitutional reasoning** (Claude): Integrating safety into the reasoning loop itself, rather than as a post-hoc filter, produces more robust safety guarantees.
+
+5. **Open modular architecture** (Llama 4): Designing for community contribution at every layer could accelerate development far beyond what any single team can achieve.
+
+6. **Sliding window memory injection** (Mistral): A practical compromise between fixed context windows and unbounded memory, with clear engineering advantages.
+
+7. **Self-play triad** (DeepSeek): The solver-verifier-generator triad is a self-contained improvement loop that doesn't require external training data.
+
+8. **Streaming real-time architecture** (Grok): The only system designed for real-time data streams, addressing a use case others overlook.
+
+## Surprising Gaps
+
+1. **No system proposes a concrete solution to the symbol grounding problem.** All assume language or multimodal embeddings are sufficient.
+2. **Energy efficiency is mentioned by none.** AGI at scale will have enormous energy costs, yet no proposal addresses this.
+3. **Continual learning stability** is hand-waved by all. The catastrophic forgetting problem is acknowledged but not solved.
+4. **Interpretability** is addressed only by Claude (constitutional reasoning) and Llama 4 (open audit). Others treat the model as a black box.
diff --git a/research/ai_generated_agi_architectures/synthesis.md b/research/ai_generated_agi_architectures/synthesis.md
new file mode 100644
index 0000000..5760ee3
--- /dev/null
+++ b/research/ai_generated_agi_architectures/synthesis.md
@@ -0,0 +1,188 @@
+# Synthesis: Proposed Combined AGI Architecture
+
+## Design Principles
+
+This synthesis extracts the strongest ideas from all 10 AI-generated proposals to create a concrete, implementable architecture. The design prioritizes:
+
+1. **Modularity** (from Llama 4): Every component has a standard interface and can be replaced independently
+2. **Safety integration** (from Claude): Safety is part of the reasoning loop, not a filter
+3. **Skill accumulation** (from Qwen): The system gets better by extracting and reusing skills
+4. **Grounded knowledge** (from Perplexity): Critical facts are verified against external sources
+5. **Cultural awareness** (from GLM-5): The system operates across cultural contexts
+6. **Real-time adaptation** (from Grok): The system handles streaming data and changing conditions
+
+## Architecture Overview
+
+### Layer 1: Memory Subsystem
+
+**Hybrid memory with five tiers:**
+
+| Tier | Name | Source Inspiration | Implementation |
+|------|------|-------------------|----------------|
+| 0 | Working Memory | GPT-5 | Fixed-size context window with attention-based eviction |
+| 1 | Streaming Buffer | Grok 4 | Rolling buffer for real-time data with decay |
+| 2 | Episodic Memory | GPT-5, DeepSeek | HNSW vector index of (state, action, outcome) triples |
+| 3 | Skill Library | Qwen 3 | Hierarchical library of parameterized, validated procedures |
+| 4 | Knowledge Graph | Claude, GLM-5 | Bilingual (EN/ZH) entity-relationship graph with provenance |
+
+Memory access is mediated by a **relevance router** (inspired by DeepSeek's MoE router) that directs queries to the appropriate tier(s). The router is a learned model that predicts which memory tier is most likely to contain relevant information for a given query.
+
+**Consolidation process** (from GPT-5's reflection): A background process runs every N steps that:
+1. Clusters episodic memories by similarity
+2. Extracts patterns from clusters �� new skill candidates
+3. Promotes validated skills to the skill library
+4. Updates the knowledge graph with confirmed facts
+5. Decays low-relevance episodic memories
+
+### Layer 2: Reasoning Engine
+
+**Constitutional reasoning with skill-based planning** (Claude + Qwen synthesis):
+
+```
+Input �� Decompose �� [For each subtask:]
+  �� Check skill library for matching skill
+  �� If skill found: execute skill (with parameter binding)
+  �� If no skill: enter improvisation mode
+    �� Generate candidate approaches (multiple perspectives)
+    �� Constitutional evaluation (accuracy, safety, completeness)
+    �� Select best approach
+    �� Execute with monitoring
+    �� If successful: create new skill from trace
+  �� Verify result
+�� Synthesize �� Output
+```
+
+The **constitutional evaluator** (from Claude) checks each step against:
+- Accuracy: Does the conclusion follow from premises?
+- Safety: Does the action violate safety constraints?
+- Completeness: Are there unaddressed requirements?
+- Consistency: Is this step consistent with prior steps?
+- Cultural appropriateness: Is this action appropriate in the current cultural context? (from GLM-5)
+
+### Layer 3: Tool and Action Layer
+
+**Plugin-based with learned composition** (Llama 4 + Qwen synthesis):
+
+Tools are packaged as plugins with standard manifests (from Llama 4). The system learns tool compositions through experience (from Qwen):
+- Initially, tools are invoked individually
+- The system tracks which tool combinations succeed
+- Frequently successful combinations are compiled into "composite tools"
+- Composite tools are stored in the skill library alongside reasoning skills
+
+**Search grounding** (from Perplexity): For factual claims, the system verifies against external sources before acting. A "confidence threshold" determines when search verification is required��high-stakes claims always verify, low-stakes claims verify probabilistically.
+
+### Layer 4: World Model
+
+**Multi-fidelity world model** (synthesis of Gemini + DeepSeek + Grok):
+
+The system maintains three levels of world model, selected by stakes and available compute:
+
+1. **Situation graph** (from Grok): Lightweight entity-state-relationship tracking for real-time use. Updated continuously. Used for low-stakes, time-sensitive decisions.
+
+2. **Latent dynamics model** (from DeepSeek): Learned transition function in latent space for medium-fidelity prediction. Used for planning multi-step action sequences.
+
+3. **Multimodal simulator** (from Gemini): Full 3D scene + causal graph for high-fidelity simulation. Used for high-stakes decisions where prediction accuracy is critical.
+
+A **fidelity selector** chooses the appropriate level based on: stakes, time constraints, and available compute.
+
+### Layer 5: Safety and Governance
+
+**Integrated constitutional safety with contextual adaptation** (Claude + GLM-5 synthesis):
+
+Safety is implemented at three levels:
+
+1. **Step-level**: The constitutional evaluator (Layer 2) checks every reasoning step
+2. **Action-level**: A "safety shield" (from DeepSeek) blocks actions that violate formal constraints
+3. **System-level**: A "circuit breaker" (from Grok) monitors for emerging unsafe patterns and can halt the system
+
+**Contextual safety profiles** (from GLM-5): Safety constraints are parameterized by cultural and legal context. The system loads the appropriate safety profile based on deployment context. High-stakes actions require consensus from multiple cultural safety evaluators.
+
+**Audit trail** (from Llama 4): All safety-relevant decisions are logged with full reasoning context for external audit.
+
+### Layer 6: Self-Improvement
+
+**Multi-mechanism improvement loop** (synthesis of DeepSeek + Qwen + Mistral):
+
+Three complementary improvement mechanisms run in parallel:
+
+1. **Skill mining** (from Qwen): After each task, analyze the execution trace for reusable patterns. Compile successful ad-hoc solutions into parameterized skills. Validate new skills on held-out tasks.
+
+2. **Self-play training** (from DeepSeek): A background process where the system generates problems for itself, attempts to solve them, and uses a learned verifier to check solutions. Correct solutions become training data for LoRA fine-tuning.
+
+3. **Constitutional self-correction** (from Claude): Failed tasks are analyzed for reasoning errors. Corrected reasoning traces are generated and used for preference learning.
+
+**Safety constraint**: All self-improvement is validated on a "canary task suite" (from Mistral) before deployment. If any canary task regresses, the improvement is rolled back.
+
+### Layer 7: Multi-Agent Orchestration
+
+**Adaptive multi-agent with skill trading** (Qwen + Grok synthesis):
+
+The system uses multiple agents with dynamic role assignment:
+- A **coordinator** decomposes complex tasks
+- **Specialist agents** handle subtasks in their domains
+- Agents can **trade skills** (from Qwen) when one agent has a capability another needs
+- For high-stakes decisions, a **debate panel** (from Claude) of perspective-diverse agents deliberates
+- A **cultural mediator** (from GLM-5) bridges differences in cross-cultural teams
+
+Agent allocation is managed by a **learned router** (from Mistral) that improves task-agent matching over time.
+
+### Layer 8: Persistence and Runtime
+
+**Modular runtime with warm starts** (Llama 4 + Mistral synthesis):
+
+- All components are containerized with standard interfaces (from Llama 4)
+- Memory tiers use pluggable backends (vector DB, graph DB, time-series DB)
+- KV cache persistence enables warm starts (from Mistral)
+- State checkpointing every N steps with rollback capability (from GPT-5)
+- Declarative configuration for different deployment scenarios (from Llama 4)
+
+## Implementation Roadmap
+
+### Phase 1 (Year 1): Foundation
+- Implement memory tiers 0, 2, 3, 4
+- Build constitutional reasoning loop
+- Plugin-based tool system
+- Step-level safety checks
+- Skill mining pipeline
+- Basic multi-agent coordination
+
+### Phase 2 (Year 2): Enhancement
+- Add streaming buffer (tier 1)
+- Implement situation graph world model
+- Self-play training loop
+- Action-level safety shield
+- Skill trading between agents
+- Search grounding for factual claims
+
+### Phase 3 (Year 3): Maturity
+- Latent dynamics world model
+- Multi-fidelity world model selector
+- System-level circuit breaker
+- Cultural safety profiles
+- Debate panel for high-stakes decisions
+- Cross-lingual reasoning
+
+### Phase 4 (Year 4+): Scale
+- Multimodal simulator
+- Full federated multi-agent
+- Community plugin ecosystem
+- Open governance framework
+
+## Key Engineering Decisions
+
+1. **Use existing models as components**: Don't train from scratch. Use GPT-5/Claude/Gemini as reasoning engines, existing vector DBs for memory, existing search APIs for grounding.
+2. **LoRA for self-improvement**: Full fine-tuning is too expensive and risky. LoRA adapters enable safe, incremental improvement.
+3. **Skill library as the primary improvement vector**: Skills are interpretable, debuggable, and transferable��better than opaque weight updates.
+4. **Constitutional evaluation over external RLHF**: Self-evaluation against principles is cheaper and more scalable than human feedback for every decision.
+5. **Multi-fidelity world models**: Don't build one expensive world model. Use the cheapest model that suffices for each decision.
+
+## Risks and Mitigations
+
+| Risk | Mitigation |
+|------|------------|
+| Skill library bloat | Automatic pruning of low-success skills; merge similar skills |
+| Self-play training instability | Canary task suite; rollback on regression |
+| Cultural safety conflicts | Consensus mechanism; human escalation for unresolvable conflicts |
+| Memory retrieval latency | Tiered retrieval; cache frequent queries; async consolidation |
+| Multi-agent communication overhead | Limit debate to high-stakes decisions; use lightweight protocol for routine tasks |
+| Search grounding latency | Confidence-based triggering; cache verified facts |