A self-aware, self-verifying, self-evolving cognitive AI agent.
It reads its own source code. It fixes its own bugs. It builds its own features.
It verifies its own output programmatically. It thinks while you're away.
It feels the consequences of its actions. It pursues goals autonomously.
It learns what works for its specific model.
Genesis is not a framework for building agents. Genesis is the agent.
It's a self-contained Electron application that reads its own source code, modifies itself, verifies its own output programmatically, and learns from every interaction. It runs locally on your machine — no cloud platform required, no YAML configs, no SDK. Install, start, talk.
Think of it as an AI developer that lives on your desktop: it has a codebase (its own), a memory (episodic + semantic), emotions (that influence its decisions), and goals (that survive restarts). When idle, it dreams — consolidating memories into reusable schemas. When frustrated, it escalates to larger models. When curious, it explores its own architecture.
You: "Build a REST API module for Genesis with tests"
Genesis: [PLAN] 6 steps via FormalPlanner (preconditions checked against WorldState)
[EXPECT] P(success)=0.78 based on 47 prior code-gen outcomes
[SIMULATE] Best path: direct (risk=0.22), vs. incremental (risk=0.31)
[STEP 1/6] Analyzing existing code... ✓ verified programmatically
[STEP 2/6] Generating module (87 lines)... ✓ AST parse valid, imports resolve
[STEP 3/6] Writing tests... ✓ file created, syntax verified
[STEP 4/6] Running npm test... ✓ exit 0, 12/12 passing
[STEP 5/6] Git snapshot... ✓ committed
[STEP 6/6] Wiring into AgentCore...
[VERIFY] Goal complete. VerificationEngine: 5/5 PASS, 0 AMBIGUOUS.
[SURPRISE] Low (0.12) — outcome matched expectation
[SIGN] Module signed: HMAC-SHA256 (abc12def...)
[LEARN] MetaLearning recorded: json-schema prompt @ temp 0.3 → success
"Done. Module + 12 tests, all passing."
Every step is verified by the machine, not the LLM. AST parsing, exit codes, file validation, import resolution — the LLM proposes, deterministic checks verify. Only ambiguous quality judgments fall back to LLM evaluation.
| Capability | What Genesis does | What typical AI tools do |
|---|---|---|
| Self-modification | Reads its own AST, plans changes, tests in sandbox, snapshots with git, applies only if tests pass | Run user-provided code |
| Verification | 66 programmatic checks — AST, exit codes, imports, signatures — LLM is last resort | Trust the LLM output |
| Memory | 5-layer system — episodic, semantic, vector, conversation, knowledge graph — with intelligent forgetting | Chat history window |
| Planning | FormalPlanner with preconditions, mental simulation, probabilistic branching, failure taxonomy | Sequential function calling |
| Learning | Tracks success rates by model/prompt/temperature, auto-optimizes — A/B tests its own prompts | Static prompts |
| Autonomy | Pursues multi-step goals, survives restarts, graduates its own trust level (0–3) | Single-turn responses |
| Cognition | Expectations, surprise, dreams, working memory, autobiographical identity, emotional steering | None |
Autonomous execution — FormalPlanner with typed action steps, precondition checking against live WorldState, mental simulation with probabilistic branching, goal persistence across restarts, failure taxonomy with 4 recovery strategies, cooperative cancellation, working memory per goal.
Self-modification — reads its own source via SelfModel, plans changes via SelfModificationPipeline, tests in dual-mode sandbox (VM + process), snapshots with git, HMAC-SHA256 module signing, hot-reloads without restart.
Verification — 66-test VerificationEngine covering AST syntax, import resolution, dangerous patterns, test exit codes, file integrity, module signatures. The LLM proposes — the machine verifies.
Memory & learning — 5-layer memory (conversation, episodic, vector, unified, knowledge graph), adaptive forgetting (surprise amplifies retention 5×), DreamCycle consolidation during idle time, MetaLearning prompt optimization, PromptEvolution A/B testing, OnlineLearner real-time feedback (streak detection, model escalation, temperature tuning), LessonsStore cross-project persistent learning.
Cognition & consciousness — ExpectationEngine (quantitative predictions), SurpriseAccumulator (information-theoretic), PhenomenalField (unified awareness every 2s), TemporalSelf (past/future continuity), IntrospectionEngine (3-level meta-awareness), CognitiveWorkspace (9-slot transient working memory).
Organism — 5 emotional dimensions, homeostasis (6 vitals), 4 needs (social, mastery, novelty, rest), metabolism (500 AU energy pool), heritable genome (6 evolvable traits), epigenetic conditioning, immune system (anomaly detection).
Infrastructure — 13-phase DI boot, EventBus (279 events), MCP with adaptive discovery, CircuitBreaker per connection, CorrelationContext tracing, PeerNetwork (AES-256-GCM), 10-layer defense-in-depth security.
For the full feature list with version history, see CAPABILITIES.md.
New to Genesis? Read the Quick Start Guide — it walks you through your first conversation, your first goal, and self-modification in under 5 minutes.
Option A — Cloud API (recommended for best results):
git clone https://github.com/Garrus800-stack/genesis-agent.git
cd genesis-agent
npm install
npm startThen open Settings → paste your Anthropic API key or OpenAI API key. Genesis auto-detects and selects the best available model.
Option B — Local with Ollama (fully offline, private):
ollama pull qwen2.5:7b # or gemma2:9b, deepseek-r1:8b, llama3.1:8b, etc.
ollama serve
git clone https://github.com/Garrus800-stack/genesis-agent.git
cd genesis-agent
npm install
npm startOption C — Hybrid (best of both):
Run Ollama locally AND configure a cloud API key. Genesis uses cloud for complex reasoning tasks and auto-failovers to local when cloud is unavailable.
Genesis supports three boot profiles for different complexity levels:
npm start # Full — all 113 services, all cognitive systems
npm start -- --cognitive # Cognitive — skip consciousness (~90 services)
npm start -- --minimal # Minimal — core agent loop only (~50 services)Use --minimal to learn the architecture without cognitive overhead. Use --cognitive for development. Use --full (default) for production.
Requires Node.js 20+ (tested on 20, 22) and Git. Ollama is optional if a cloud API is configured. On Windows, double-click Genesis-Start.bat instead.
| Backend | Models | Config |
|---|---|---|
| Anthropic | Claude Opus 4, Sonnet 4, Haiku 4.5 | Settings → models.anthropicApiKey |
| OpenAI-compatible | GPT-4o, GPT-4, o1, or any compatible API | Settings → models.openaiApiKey + models.openaiBaseUrl |
| Ollama (local) | Any model Ollama supports (gemma2, qwen2.5, deepseek, llama, mistral, ...) | Auto-detected on 127.0.0.1:11434 |
Genesis automatically selects the best model: user-preferred → cloud → local. Override via Settings → models.preferred.
Thirteen layers with clear boundaries — star topology where every layer depends only on core/ and ports/, never on each other. The kernel is immutable. Critical safety files are hash-locked. Everything else is fair game for self-modification. v5.3.0: zero cross-layer violations, zero orphans, zero phantom late-bindings.
┌─────────────────────────────────────────────────────────────┐
│ 🖥️ UI Layer Chat + Monaco Editor + Dashboard │
├─────────────────────────────────────────────────────────────┤
│ 🌌 Consciousness [P13] PhenomenalField · TemporalSelf │
│ IntrospectionEngine · AttentionalGate│
│ ConsciousnessExtension (6 subsystems)│
├─────────────────────────────────────────────────────────────┤
│ 🔮 Hybrid [P12] GraphReasoner · AdaptiveMemory │
├─────────────────────────────────────────────────────────────┤
│ 🌐 Extended [P11] TrustLevels · Effectors · WebPercept │
│ SelfSpawner · GitHubEffector │
├─────────────────────────────────────────────────────────────┤
│ 🏛️ Agency [P10] GoalPersistence · FailureTaxonomy │
│ DynamicContextBudget · LocalClassifier│
│ EmotionalSteering · FitnessEvaluator │
├─────────────────────────────────────────────────────────────┤
│ 🧠 Cognitive [P9] Expectations · Simulation · Surprise │
│ DreamCycle (phase delegates) v5.2 │
│ SelfNarrative · PromptEvolution v5.2 │
│ CognitiveWorkspace (SA-P6) v5.3 │
│ OnlineLearner (SA-P5) v5.3 │
│ LessonsStore (SA-P7) v5.3 │
├─────────────────────────────────────────────────────────────┤
│ ⚡ Revolution [P8] FormalPlanner · AgentLoop + Cancel │
│ ModelRouter · VectorMemory v5.2 │
├─────────────────────────────────────────────────────────────┤
│ 🧬 Organism [P7] Emotions (5D) · Homeostasis (6 vitals)│
│ Genome · Epigenetic · Fitness │
│ NeedsSystem (4 drives) · Metabolism │
├─────────────────────────────────────────────────────────────┤
│ 🛡️ Autonomy [P6] IdleMind · Daemon · HealthMonitor │
│ HealthServer (optional) v5.2 │
├─────────────────────────────────────────────────────────────┤
│ 🔗 Hexagonal [P5] ChatOrchestrator · SelfModPipeline │
│ EpisodicMemory · PeerNetwork │
├─────────────────────────────────────────────────────────────┤
│ 📋 Planning [P4] GoalStack · MetaLearning · SchemaStore│
├─────────────────────────────────────────────────────────────┤
│ 🔧 Capabilities [P3] ShellAgent · MCP (CodeExec delegate) │
│ PluginRegistry · HotReloader v5.2 │
├─────────────────────────────────────────────────────────────┤
│ 🧩 Intelligence [P2] VerificationEngine · CodeSafetyScanner│
│ IntentRouter · ContextManager (table) │
│ CircuitBreaker v5.2 │
├─────────────────────────────────────────────────────────────┤
│ 📦 Foundation [P1] ModelBridge · Sandbox · WorldState │
│ KnowledgeGraph · ModuleSigner · Cache │
│ CorrelationContext v5.2 │
├─────────────────────────────────────────────────────────────┤
│ 🔗 Ports LLM · Memory · KG · Sandbox · │
│ CodeSafety (hexagonal boundary) v5.2 │
├─────────────────────────────────────────────────────────────┤
│ 🔒 KERNEL (immutable) SafeGuard · IPC Contract · Hashes │
│ + 🔐 Hash-Locked Scanner · Verifier · Constants │
└─────────────────────────────────────────────────────────────┘
Kernel (immutable): main.js, preload.js, src/kernel/. SHA-256 hashed at boot, verified periodically.
Critical Safety Files (hash-locked): CodeSafetyScanner, VerificationEngine, Constants, EventBus, Container — locked via SafeGuard.lockCritical(). The agent cannot weaken the modules that enforce its own safety.
Agent Core: Self-modifiable modules — read, analyze, modify, hot-reload — but only after sandbox testing, safety scanning, and git snapshots.
Cognitive Layer (v4.0+v5.2): Expectation formation, mental simulation, surprise-driven learning, memory consolidation (with phase delegates), autobiographical identity, prompt evolution via A/B testing.
Every autonomous step follows a five-phase cycle:
Perceive (WorldState) → Plan (FormalPlanner) → Act (AgentLoop)
→ Verify (VerificationEngine) → Learn (MetaLearning + EpisodicMemory)
The VerificationEngine returns PASS, FAIL, or AMBIGUOUS. Only AMBIGUOUS falls back to LLM judgment. Everything else is deterministic.
| What's checked | How | LLM? |
|---|---|---|
| Code syntax | AST parse (acorn) | No |
| Imports | Filesystem check | No |
| Dangerous patterns | AST walk + regex | No |
| Test results | Exit code + assertion count | No |
| Shell commands | Exit code + timeout + patterns | No |
| File writes | Existence + non-empty + encoding | No |
| Plan preconditions | WorldState API | No |
| Module integrity | HMAC-SHA256 signature v4.0 |
No |
| Subjective quality | — | AMBIGUOUS only |
Expect → Simulate → Act → Surprise → Learn → Dream → Schema → better Expect
ExpectationEngine — Quantitative predictions using MetaLearning statistics and SchemaStore patterns. No LLM calls.
MentalSimulator — Plan sequences in-memory against cloned WorldState with probabilistic branching and risk scoring.
SurpriseAccumulator — Prediction error via information-theoretic surprise (−log₂P). High surprise amplifies learning up to 4×.
DreamCycle — Idle-time memory consolidation. Phases 1-4 are heuristics; Phase 5 uses one batched LLM call. v5.2: Schema extraction, value crystallization, and DreamEngine corroboration extracted to phase delegates.
SelfNarrative — Autobiographical identity summary injected into every LLM call (~200 tokens of metacognitive context).
PromptEvolution v5.2 — A/B testing framework for prompt sections. Runs controlled experiments (25+ trials per arm), auto-promotes variants with statistically significant improvement (≥5%). Identity and safety sections are immutable by design.
Goals that survive reboots. Errors that get classified. Context that adapts. Emotions that steer.
Goal created → Checkpoint → [Restart] → Resume → Continue
Error caught → FailureTaxonomy.classify() → Strategy (retry | replan | escalate | update-world)
Intent detected → DynamicContextBudget.allocate() → Optimized token distribution
Emotion shifts → EmotionalSteering.getSignals() → ModelRouter / FormalPlanner / IdleMind adjusts
LLM fallback → LocalClassifier.addSample() → Next time: no LLM needed (2-3s saved)
GoalPersistence — Active goals serialized to disk after every step. Crash recovery via step-level checkpoints. Resume prompt on boot.
FailureTaxonomy — Four error categories with distinct recovery strategies. Transient errors get exponential backoff. Deterministic errors trigger immediate replan. Environmental errors update WorldState. Capability errors escalate to a larger model.
DynamicContextBudget — Intent-based token allocation replaces fixed budgets. Code-gen gets 55% code context. Chat gets 40% conversation. Learns from MetaLearning success rates.
EmotionalSteering — Emotions become functional control signals. Frustration > 0.65 → ModelRouter tries larger model. Energy < 0.30 → FormalPlanner caps plans at 3 steps. Curiosity > 0.75 → IdleMind prioritizes exploration.
LocalClassifier — TF-IDF + cosine similarity classifier trained from IntentRouter's own LLM fallback log. After ~30 samples, handles 60-80% of classifications without LLM calls.
Genesis sees beyond the filesystem. Acts beyond its project directory. Graduates its own autonomy.
TrustLevelSystem — Four trust levels: Supervised (everything needs approval), Assisted (safe actions auto-execute), Autonomous (only high-risk needs approval), Full Autonomy (only safety invariants block). MetaLearning data can suggest auto-upgrades for specific action types with >90% success over 50+ attempts.
EffectorRegistry — Typed, verifiable, approval-gated actions for the outside world. Built-in: clipboard, OS notifications, browser open, external file write. Plugin: GitHubEffector (issues, PRs, comments). Each effector has risk level, preconditions, optional verification and rollback.
WebPerception — Lightweight HTTP fetch with HTML parsing (cheerio optional). Headless browser mode via Puppeteer (optional). Results cached, fed into WorldState.external for prompt context.
SelfSpawner — Fork-based worker processes for parallel sub-tasks. Each worker gets minimal context (ModelBridge config, focused goal) and runs independently with timeout and memory limits. Up to 3 concurrent workers.
Not everything needs an LLM. Graph reasoning and intelligent forgetting.
GraphReasoner — Deterministic queries over the KnowledgeGraph without LLM calls. Transitive dependency chains, impact analysis ("if I change EventBus, what breaks?"), cycle detection, shortest path between concepts, contradiction detection. Integrated into ReasoningEngine — structural questions are answered in milliseconds instead of seconds.
AdaptiveMemory — Differentiated forgetting based on emotional valence, surprise magnitude, and access frequency. High-surprise memories decay 5× slower. Routine conversations decay quickly. Frequently accessed memories are reinforced. Consolidation runs during DreamCycle.
┌──────────────────────────────────────────────────────────────────┐
│ KERNEL (immutable) — SHA-256 hashes, periodic integrity checks │
├──────────────────────────────────────────────────────────────────┤
│ CRITICAL FILE HASH-LOCK — Scanner, Verifier, Constants, Bus │
├──────────────────────────────────────────────────────────────────┤
│ TRUST LEVEL SYSTEM — graduated autonomy (0-3) v4.1 │
├──────────────────────────────────────────────────────────────────┤
│ MODULE SIGNING — HMAC-SHA256 for self-modified files v4.0 │
├──────────────────────────────────────────────────────────────────┤
│ AST CODE SAFETY SCANNER — acorn AST walk + regex fallback │
│ └─ CodeSafetyPort — hexagonal adapter (DI-injected) v5.2 │
├──────────────────────────────────────────────────────────────────┤
│ VERIFICATION ENGINE — programmatic truth, 66 tests │
├──────────────────────────────────────────────────────────────────┤
│ SANDBOX — dual-mode isolation (Process + VM) v4.0 │
│ └─ WORKER THREAD — MCP code exec in resource-limited v5.1 │
│ worker_thread (64MB heap, hard-kill on timeout) │
├──────────────────────────────────────────────────────────────────┤
│ CIRCUIT BREAKER — per-MCP-connection failure isolation v5.2 │
│ └─ CLOSED → OPEN → HALF_OPEN → CLOSED state machine │
├──────────────────────────────────────────────────────────────────┤
│ IMMUNE SYSTEM — self-modification anomaly detection v5.0 │
├──────────────────────────────────────────────────────────────────┤
│ EFFECTOR REGISTRY — risk-gated external actions v4.1 │
├──────────────────────────────────────────────────────────────────┤
│ CORRELATION CONTEXT — causal tracing via AsyncLocalStorage v5.2 │
├──────────────────────────────────────────────────────────────────┤
│ UI ERROR BOUNDARY — global error/rejection handler v4.0 │
├──────────────────────────────────────────────────────────────────┤
│ IPC RATE LIMITER — per-channel token bucket (kernel-space) │
├──────────────────────────────────────────────────────────────────┤
│ SHELL AGENT — 4 tiers, blocklist, rate limiter, no injection │
├──────────────────────────────────────────────────────────────────┤
│ PEER NETWORK — AES-256-GCM, PBKDF2 600K iterations │
└──────────────────────────────────────────────────────────────────┘
npm test # All tests (135 suites)
npm run test:coverage # With coverage report (c8)
npm run ci # Full CI: tests + event audit + channel audit + fitness gateAll tests run without external dependencies (no Ollama, no API keys, no internet). Tested on Node 18, 20, 22. CI runs on Ubuntu + Windows via GitHub Actions.
| Layer | Files | LOC | Purpose |
|---|---|---|---|
| Core | 13 | ~4,000 | EventBus, Container, Constants, Logger, CorrelationContext, CircuitBreaker, CancellationToken |
| Foundation | 29 | ~8,400 | ModelBridge, Backends, Sandbox, KG, WorldState, TrustLevels, Telemetry, LLMCache |
| Intelligence | 16 | ~6,200 | Verification, Safety Scanner, Intent, Reasoning, ContextManager, PromptBuilder, PromptEvolution |
| Capabilities | 18 | ~5,400 | Shell, MCP (Client + Transport + CodeExec + Worker + Server), HotReload, Skills, Plugins, WebPerception |
| Planning | 9 | ~2,900 | Goals, GoalPersistence, MetaLearning, SchemaStore, ValueStore |
| Hexagonal | 14 | ~5,700 | ChatOrchestrator, SelfModPipeline, Memory (Unified + Episodic + Adaptive), PeerNetwork, PeerConsensus |
| Autonomy | 6 | ~2,600 | IdleMind, Daemon, HealthMonitor, HealthServer, CognitiveMonitor, ErrorAggregator |
| Organism | 12 | ~4,600 | Emotions (5D), Homeostasis (6 vitals), Needs (4 drives), Metabolism, ImmuneSystem, Genome, Epigenetic, Fitness |
| Revolution | 14 | ~5,600 | AgentLoop (+ Steps/Planner delegates), FormalPlanner, HTN, VectorMemory, NativeToolUse, ModelRouter |
| Cognitive | 9 | ~3,900 | DreamCycle (+ phase delegates), ExpectationEngine, SurpriseAccumulator, MentalSimulator, SelfNarrative, CognitiveWorkspace |
| Consciousness | 13 | ~6,000 | PhenomenalField (+ Computation delegate), TemporalSelf, IntrospectionEngine, AttentionalGate, EchoicMemory, DreamEngine |
| Ports | 6 | ~800 | Hexagonal adapters (LLM, Memory, Knowledge, Sandbox, CodeSafety) |
| Total | 196 | ~68,700 | (all src/, incl. UI + kernel) |
| Metric | Value |
|---|---|
| Source modules | 196 JS files in src/ |
| Lines of code | ~67k src + ~28k test |
| Manifest phases | 13 (+ Phase 0 bootstrap) |
| DI services | 107 (manifest + auto-discovery) |
| Late-bindings | 174 (150 optional, 24 required) |
| Test suites | 135 files, 2500 tests (coverage gates: 60/50/55) |
| Dependencies | 4 production + 3 optional + 5 dev |
| LLM backends | 3 (Anthropic, OpenAI-compatible, Ollama) |
| Anthropic models | 3 (Opus 4, Sonnet 4, Haiku 4.5) |
| IPC channels | 39 invoke + 1 send + 6 receive (rate-limited) |
| Event types | 275 across 76 namespaces (catalogued in EventTypes.js) |
| Cross-layer event flows | 42 (via EventBus, no direct imports) |
| Hexagonal ports | 5 (LLM, Memory, Knowledge, Sandbox, CodeSafety) |
| Cognitive modules | 8 (ExpectationEngine, MentalSimulator, SurpriseAccumulator, DreamCycle, SelfNarrative, CognitiveHealthTracker, CognitiveWorkspace, OnlineLearner, LessonsStore) |
| Consciousness modules | 13 (PhenomenalField, TemporalSelf, IntrospectionEngine, AttentionalGate, EchoicMemory, PredictiveCoder, NeuroModulators, SalienceGate, DreamEngine, ConsciousnessState + 3 adapters/delegates) |
| Organism | 5 emotional dimensions + homeostasis + allostasis + 4 needs + steering + metabolism + immune system + heritable genome + epigenetic conditioning + fitness evaluation |
| Safety layers | 10 (kernel lock → AST scan → port → sandbox → worker → circuit breaker → immune → trust → validateWrite → blocklist) |
| Trust levels | 4 (supervised → full autonomy) |
| Languages | EN primary (+ DE, FR, ES via i18n) |
| Architectural fitness | Cross-layer: 0, Orphans: 0, Phantoms: 0, CC>30: 21 |
Genesis has a five-layer memory system, unified through a facade:
┌─────────────────────────────────────────────────────────┐
│ UnifiedMemory (read facade over all layers) │
├─────────────────────────────────────────────────────────┤
│ AdaptiveMemory [P12] Retention scoring + smart decay │
│ VectorMemory Embedding-based semantic search │
│ EpisodicMemory Timestamped experiences + causality │
│ ConversationMemory Chat history + episode extraction │
│ KnowledgeGraph Concept nodes + typed relations │
│ WorldState Live snapshot of system state │
├─────────────────────────────────────────────────────────┤
│ SchemaStore [P9] Abstract patterns from DreamCycle │
└─────────────────────────────────────────────────────────┘
All persistence goes through StorageService (write-queued, atomic JSON writes). The EmbeddingService is optional — without it, search degrades to keyword matching.
- No TypeScript —
types/core.d.tsandtypes/cognitive.d.tsexist for IDE support, but the codebase is pure CommonJS JS. Type-safety relies on JSDoc and convention. TypeDoc config is provided for API doc generation. - VM sandbox is not a true sandbox —
vm.createContextprovides isolation for quick evals but is explicitly NOT security-grade for untrusted code. Untrusted code must use process-modeexecute()or Linux namespace isolation. sandbox: falseon Electron <35 — CJS preload requiresrequire()which is blocked by sandbox:true.contextIsolation:trueis the primary security boundary. Seepreload.mjsfor ESM preload implementation.- Single-instance storage — StorageService serializes writes but all autonomous systems share the same
.genesis/directory. - Consciousness metrics are heuristic — Phi (integrated information) in PhenomenalField is a simplified proxy, not a rigorous IIT implementation.
{
"acorn": "^8.16.0",
"chokidar": "^3.6.0",
"electron": "^33.0.0",
"monaco-editor": "^0.44.0",
"tree-kill": "^1.2.2"
}No LangChain. No LlamaIndex. Everything self-written.
| Document | What it covers |
|---|---|
| QUICK-START.md | Start here — first conversation, first goal, self-modification, boot profiles |
| ARCHITECTURE-DEEP-DIVE.md | Technical deep-dive — boot sequence, DI container, service lifecycle, data flows |
| EVENT-FLOW.md | EventBus event map — which modules emit/consume which events |
| CAPABILITIES.md | Complete feature overview — what Genesis can do, organized by category |
| COMMUNICATION.md | How Genesis instances communicate — IPC, EventBus, PeerNetwork, MCP |
| DEGRADATION-MATRIX.md | What breaks if each service is missing — auto-generated |
| Document | What it covers |
|---|---|
| phase9-cognitive-architecture.md | Phase 9 design — DreamCycle, Expectations, SelfNarrative, MentalSimulator |
| phase9-integration-review.md | Integration review and test results for Phase 9 |
| consciousness-extension-architecture.md | Phase 12-13 — closed perceptual loop, EchoicMemory, PredictiveCoder, NeuroModulators, DreamEngine |
| Document | What it covers |
|---|---|
| TROUBLESHOOTING.md | Common problems and solutions — install, boot, LLM, self-modification, platform-specific |
| ROADMAP-v6.md | Development roadmap — completed phases, open items, deferred proposals |
| AUDIT-BACKLOG.md | Architectural health tracking — resolved issues, monitor items, fitness metrics |
| SELF-REVIEW-v5.0.0.md | Cross-reference of Genesis's self-reflection against code-level evidence |
| Document | What it covers |
|---|---|
| CONTRIBUTING.md | How to contribute — conventions, security rules, PR process, service templates |
| SECURITY.md | Security policy — 7-layer defense model, threat model, vulnerability reporting |
| CHANGELOG.md | Version history with detailed per-release notes |
| Document | What it covers |
|---|---|
| schemas/skill-manifest.schema.json | JSON Schema for third-party skill/plugin manifests |
| typedoc.json | TypeDoc config — run npx typedoc to generate API docs |
See CONTRIBUTING.md for the full guide — architecture, conventions, security rules, and PR process.
MIT © Daniel (Garrus800-stack)
Genesis doesn't just answer questions. It persists its goals, reasons over its own graph, feels the consequences of failure, and graduates its own autonomy.