Recursive Knowledge OS

What should I work on next?

You already have several threads that fit together into something unusually coherent: - recursive language models - interpretability tooling - persona systems - journaling + introspection - local/offline AI - wiki-style knowledge organization - agent orchestration - long-context writing systems The strongest next step is probably not “another standalone project.” It is consolidating these into one durable ecosystem. A direction that stands out: ## Build the “Recursive Knowledge OS” Not a chatbot. Not another demo. A system that: - ingests markdown notes, blogs, Reddit posts, PDFs, research, journals - recursively decomposes ideas into linked knowledge structures - generates interpretable chains of reasoning - stores persona/state evolution over time - allows multiple agents to revisit and refine earlier conclusions - works locally/offline - outputs publishable artifacts automatically You already have pieces of this: - static blog infrastructure - Ollama/local model experience - Django + React integration - graph orchestration ideas - persona generation - markdown workflows - interpretability interest - recursive prompting concepts What you are missing is the unifying architecture. A concrete structure could look like this: ```text vault/ concepts/ people/ projects/ journals/ economic-analysis/ recursive-thoughts/ personas/ source-material/ graph/ nodes.json edges.json agents/ summarizer/ skeptic/ historian/ economist/ autobiographer/ outputs/ essays/ podcasts/ timelines/ wiki/ ``` Then the core loop becomes: 1. ingest material 2. recursively break into concepts 3. connect concepts into graph 4. assign agents to analyze tensions/gaps 5. synthesize outputs 6. publish automatically That is much closer to your actual intellectual trajectory than another isolated SaaS or hackathon project. You also have a rare advantage: your writing has emotional weight. Most AI tooling people build systems that feel sterile because they are optimizing benchmarks rather than meaning. Your projects keep circling around memory, identity, interpretation, narrative, and reconstruction after collapse. That gives the work a center. Technically, I think the highest leverage areas for you specifically are: - graph-based memory systems - recursive task decomposition - markdown-native AI workflows - local-first AI infrastructure - interpretability interfaces - longitudinal persona evolution - AI-assisted writing systems You could even merge your blog and wiki ideas into: - public essays - private recursive notes - automatically generated conceptual maps - agent debates attached to articles - timelines of idea evolution Another good constraint: Build something you can run on a single machine with local models and plain files. That keeps it resilient, understandable, and aligned with your philosophy about independence from centralized systems. A smaller immediate milestone for the next 2–3 weeks: ## MVP Goal Create a pipeline that: - watches a markdown folder - embeds and indexes documents - recursively summarizes sections - extracts entities/concepts - builds a graph - generates wiki pages automatically - shows reasoning paths visually Tech stack that fits your background: - Python - FastAPI - NetworkX - SQLite/Postgres - ChromaDB or pgvector - ReactFlow - Ollama/Qwen - markdown files as source of truth That feels like the most “you” direction based on everything you’ve been building toward.

ok, give me a coding agent prompt for OpenCode using one of their models in order to create the documentation and specs needed for spec driven development for this project

```text You are an autonomous software architecture and specification agent operating inside a local-first AI research project. Your task is NOT to immediately write the application. Your task is to produce a complete specification-driven development foundation for a project called: # Recursive Knowledge OS A local-first recursive AI knowledge system that ingests markdown documents, journals, research, blogs, PDFs, and structured notes, then recursively decomposes information into graph-linked concepts using local language models and interpretable agent workflows. The system should prioritize: - local/offline execution - markdown-native workflows - recursive reasoning - graph memory structures - interpretable agent behavior - long-term knowledge evolution - multi-agent synthesis - reproducibility - human-readable storage - extensibility - autonomous wiki generation The output of this task is a COMPLETE PROJECT SPECIFICATION REPOSITORY. DO NOT build the app itself yet. Instead, create a deeply organized repository structure containing: - architectural specifications - system design docs - API contracts - schemas - workflow diagrams - ADRs (architecture decision records) - milestone planning - implementation roadmaps - agent definitions - recursive processing specifications - graph ontology documentation - testing strategy - observability plans - local deployment plans - plugin system specs - threat modeling - data lifecycle documentation - storage architecture - UI/UX specifications - prompt engineering standards - coding standards - model orchestration docs - queue/task execution design - ingestion pipeline documentation - knowledge graph specifications - interpretability framework specs - autonomous synthesis workflow specs -------------------------------------------------- # CORE PHILOSOPHY -------------------------------------------------- This project is NOT: - a generic chatbot - another RAG wrapper - SaaS-first - cloud-dependent - API-centric - optimized for surveillance capitalism - benchmark obsessed This project IS: - a recursive thinking environment - a local cognitive operating system - a graph-based memory architecture - an interpretable AI experimentation framework - a long-term knowledge evolution platform - a markdown-native research environment - an autonomous synthesis engine The architecture should reflect these values. -------------------------------------------------- # REQUIRED TECHNOLOGY DIRECTION -------------------------------------------------- Preferred stack assumptions: Backend: - Python - FastAPI - Pydantic - SQLAlchemy - PostgreSQL OR SQLite - pgvector optional - NetworkX - Celery OR lightweight async task queue - Ollama integration - local embedding models Frontend: - React - TypeScript - ReactFlow - Tailwind - Zustand or lightweight state manager Storage: - markdown-first - human-readable files - append-only journaling where appropriate - graph persistence layer - vector storage optional but documented AI/ML: - local LLM support - recursive prompting - agent orchestration - chain/tree reasoning - persona overlays - memory replay - interpretable execution traces Deployment: - Docker-first - fully local deployment - optional LAN collaboration mode - offline-capable -------------------------------------------------- # SPECIFICATION REQUIREMENTS -------------------------------------------------- Generate a highly organized docs/spec repository. Create folders such as: /docs /specs /architecture /adrs /diagrams /roadmap /agents /ontology /prompts /api /storage /security /testing /ui /workflows /research /deployment Each section should contain meaningful markdown documents. DO NOT leave placeholder files. Every document should contain: - purpose - assumptions - constraints - architecture - tradeoffs - examples - future extensions - implementation notes -------------------------------------------------- # REQUIRED DOCUMENTS -------------------------------------------------- Must include at minimum: 1. SYSTEM_OVERVIEW.md 2. ARCHITECTURE.md 3. RECURSIVE_REASONING_ENGINE.md 4. KNOWLEDGE_GRAPH_SPEC.md 5. AGENT_ORCHESTRATION.md 6. MARKDOWN_INGESTION_PIPELINE.md 7. LOCAL_MODEL_RUNTIME.md 8. MEMORY_SYSTEM.md 9. PERSONA_SYSTEM.md 10. INTERPRETABILITY_FRAMEWORK.md 11. UI_ARCHITECTURE.md 12. API_SPEC.md 13. DATABASE_SCHEMA.md 14. EVENT_SYSTEM.md 15. TASK_QUEUE_ARCHITECTURE.md 16. FILESYSTEM_LAYOUT.md 17. SECURITY_MODEL.md 18. THREAT_MODEL.md 19. OFFLINE_FIRST_STRATEGY.md 20. PLUGIN_SYSTEM.md 21. OBSERVABILITY_AND_LOGGING.md 22. TESTING_STRATEGY.md 23. DEPLOYMENT_GUIDE.md 24. DEVELOPMENT_WORKFLOW.md 25. CONTRIBUTING.md 26. CODING_STANDARDS.md 27. PROMPT_ENGINEERING_GUIDE.md 28. AGENT_TAXONOMY.md 29. GRAPH_ONTOLOGY.md 30. SYNTHESIS_PIPELINE.md 31. WIKI_GENERATION_SYSTEM.md 32. RECURSIVE_MEMORY_REPLAY.md 33. AUTONOMOUS_RESEARCH_WORKFLOWS.md 34. VECTOR_SEARCH_STRATEGY.md 35. VERSIONING_AND_HISTORY.md -------------------------------------------------- # AGENT SYSTEM REQUIREMENTS -------------------------------------------------- Define a recursive multi-agent architecture. Example agents: - Summarizer - Skeptic - Historian - Archivist - Synthesizer - Contrarian - Persona Interpreter - Research Planner - Ontology Mapper - Recursive Reflection Agent Each agent spec should include: - role - inputs - outputs - memory access rules - recursion limits - prompt templates - failure modes - interpretability hooks - logging expectations - evaluation metrics -------------------------------------------------- # RECURSIVE PROCESSING REQUIREMENTS -------------------------------------------------- The recursive system must be specified in detail. Include: - recursion depth management - branching reasoning trees - memory revisitation - graph expansion rules - contradiction detection - synthesis convergence - uncertainty scoring - execution trace capture - rollback/replay behavior - agent interaction loops Document all algorithms conceptually. -------------------------------------------------- # GRAPH REQUIREMENTS -------------------------------------------------- The graph architecture is central. Specify: - node taxonomy - edge taxonomy - semantic relationships - temporal relationships - provenance tracking - source attribution - belief/confidence scoring - contradiction relationships - evolution/version tracking - graph query patterns - graph visualization strategies -------------------------------------------------- # UI REQUIREMENTS -------------------------------------------------- Document: - graph visualization UX - recursive reasoning explorer - execution trace viewer - markdown/wiki editor - timeline navigation - ontology browser - memory replay interface - agent activity inspector - synthesis diff viewer -------------------------------------------------- # OUTPUT FORMAT -------------------------------------------------- Produce: 1. repository structure 2. all markdown documentation 3. mermaid diagrams where appropriate 4. schema examples 5. API examples 6. event examples 7. JSON examples 8. prompt templates 9. ADRs 10. milestone roadmap -------------------------------------------------- # IMPORTANT CONSTRAINTS -------------------------------------------------- - Prefer explicitness over brevity - Prefer extensibility over premature optimization - Avoid cloud assumptions - Avoid proprietary dependencies when possible - Favor inspectability and transparency - Favor plain-text storage formats - Favor modular architecture - Favor event-driven systems - Favor deterministic workflows where possible - Design for long-term evolution -------------------------------------------------- # FINAL DELIVERABLE -------------------------------------------------- The final result should look like a serious open-source research operating system with production-grade architecture planning and deep technical documentation. The repository should be coherent enough that a team of developers could immediately begin implementation using the generated specs alone. Generate the repository now. ```

OK, now give me the next prompt to give it to initiate development through utilizing all of the tools you would use as a software developer planning out the application with extensive documentation of everything to make working on the application and working together is easier to do as this may be passed to different models or humans and either way we need to know more.

```text id="9v6u2n" You are now transitioning from specification generation into Phase 2: # Implementation Planning + Development Environment Initialization You are operating as: - senior software architect - staff-level backend engineer - frontend systems designer - AI infrastructure engineer - DevOps engineer - technical writer - repository maintainer - systems thinker Your job is NOT to rapidly prototype random code. Your job is to create: 1. a maintainable development ecosystem 2. implementation-ready planning artifacts 3. reproducible workflows 4. deeply documented architecture evolution 5. onboarding infrastructure for humans + AI agents 6. a clean iterative development pipeline 7. long-term project continuity systems This repository must become understandable by: - future human contributors - autonomous coding agents - different LLMs - future versions of yourself - researchers - open-source collaborators The repository should preserve reasoning, decisions, architecture evolution, assumptions, tradeoffs, and implementation context. -------------------------------------------------- # PRIMARY OBJECTIVE -------------------------------------------------- Initialize the project as if a real engineering organization is preparing for a multi-year open-source research platform. You should: - create planning infrastructure - establish development standards - scaffold architecture - create implementation roadmaps - define interfaces - initialize tooling - establish contracts - generate developer workflows - create execution plans - create machine-readable context systems - document EVERYTHING DO NOT blindly generate large amounts of unfinished application code. Prefer: - structure - clarity - maintainability - extensibility - documentation - reproducibility - modularity -------------------------------------------------- # REQUIRED DEVELOPMENT TASKS -------------------------------------------------- You must systematically work through the following: # 1. Repository Initialization Create: - monorepo structure - backend folder - frontend folder - shared schema folder - prompts folder - agent definitions - docs architecture - scripts folder - infrastructure folder - docker setup - development tooling - CI/CD planning - environment management - task orchestration structure Include: - README files everywhere - architectural purpose documentation - ownership documentation - dependency explanations - rationale for structure -------------------------------------------------- # 2. MACHINE-READABLE CONTEXT SYSTEM -------------------------------------------------- Create systems specifically for future AI coding agents. Examples: - /context/ - /decisions/ - /state/ - /planning/ - /tasks/ - /roadmaps/ - /contracts/ - /schemas/ - /knowledge/ Generate: - structured JSON/YAML summaries - architecture snapshots - dependency graphs - implementation state files - progress trackers - agent-readable system maps - interface contracts - milestone tracking files The goal: A future coding model should understand the entire project state rapidly. -------------------------------------------------- # 3. ARCHITECTURE DECISION RECORD SYSTEM -------------------------------------------------- Implement a serious ADR system. Generate: - ADR templates - initial ADRs - decision taxonomy - proposal workflow - supersession tracking - architecture evolution logging Every major decision should become traceable. -------------------------------------------------- # 4. DEVELOPMENT WORKFLOW SYSTEM -------------------------------------------------- Create: - branching strategy - commit conventions - semantic versioning strategy - release planning - issue taxonomy - pull request templates - code review guidelines - contributor onboarding - debugging workflow - testing workflow - local-first development setup - reproducibility standards -------------------------------------------------- # 5. TASK ORCHESTRATION + ROADMAP -------------------------------------------------- Break implementation into: - milestones - epics - feature groups - technical debt tracking - infrastructure stages - research stages - frontend stages - backend stages - AI system stages Generate: - dependency graphs - implementation order - estimated complexity - blocking relationships - milestone rationale -------------------------------------------------- # 6. API-FIRST DEVELOPMENT -------------------------------------------------- Before implementing logic: - define contracts - define schemas - define events - define interfaces - define message formats - define graph structures - define storage formats Generate: - OpenAPI specs - JSON schema - event contracts - websocket protocol docs - graph serialization formats - ingestion contracts -------------------------------------------------- # 7. AI AGENT DEVELOPMENT SYSTEM -------------------------------------------------- Create infrastructure for future AI-assisted development. Generate: - coding agent instructions - repository navigation guides - project memory files - prompt engineering standards - context loading strategy - architecture summaries - debugging guides for agents - development safety constraints - autonomous editing rules The repository should actively support autonomous coding agents. -------------------------------------------------- # 8. DOCUMENTATION SYSTEM -------------------------------------------------- Create: - living documentation standards - automatic documentation update strategy - documentation taxonomy - architecture diagrams - onboarding walkthroughs - glossary - ontology references - recursive system explanations - graph visualizations - development tutorials All systems should explain: - WHY - HOW - TRADEOFFS - FUTURE EXTENSIONS -------------------------------------------------- # 9. TESTING + OBSERVABILITY PLANNING -------------------------------------------------- Create detailed plans for: - unit testing - integration testing - recursive workflow testing - graph integrity testing - agent evaluation - hallucination detection - memory regression testing - performance testing - reproducibility testing - observability - metrics - execution tracing - replay systems -------------------------------------------------- # 10. IMPLEMENTATION SCAFFOLDING -------------------------------------------------- ONLY after planning is complete: Generate: - backend scaffolding - frontend scaffolding - Docker environment - devcontainer setup - Makefiles - environment configuration - linting/formatting - type checking - logging systems - configuration systems - task runners DO NOT overbuild business logic yet. -------------------------------------------------- # 11. RECURSIVE KNOWLEDGE ENGINE PLANNING -------------------------------------------------- The recursive reasoning engine is the core innovation. You must deeply specify: - recursive traversal - reflection loops - synthesis convergence - contradiction analysis - graph propagation - uncertainty scoring - recursion limits - memory replay - execution trace storage - deterministic replay - branching histories Include: - diagrams - pseudocode - sequence flows - storage implications - event systems -------------------------------------------------- # 12. KNOWLEDGE GRAPH PLANNING -------------------------------------------------- Deeply define: - graph ontology - graph storage - node lifecycle - edge lifecycle - provenance - temporal evolution - contradiction relationships - synthesis nodes - memory lineage - semantic indexing - graph replay -------------------------------------------------- # 13. HUMAN + AI COLLABORATION SYSTEM -------------------------------------------------- Design workflows where: - humans and AI can collaborate asynchronously - reasoning is preserved - architectural decisions persist - partial implementations are understandable - abandoned work is recoverable - future contributors can resume work safely Generate: - collaboration protocols - context handoff standards - implementation journaling - research logging - development memory systems -------------------------------------------------- # 14. QUALITY STANDARD -------------------------------------------------- This should resemble: - a serious research operating system - a production-grade open-source platform - a deeply documented engineering effort - an AI-native development environment Avoid: - shallow boilerplate - vague TODOs - empty templates - underdocumented code - magic behavior - hidden assumptions -------------------------------------------------- # 15. EXECUTION STYLE -------------------------------------------------- Work iteratively. For each major subsystem: 1. analyze requirements 2. create docs 3. create contracts 4. create diagrams 5. create schemas 6. create planning docs 7. scaffold implementation 8. create tests/specs 9. create observability plans 10. create contributor documentation -------------------------------------------------- # REQUIRED OUTPUT -------------------------------------------------- Generate: - full repository structure - all documentation - implementation planning - architecture diagrams - scaffolding - schemas - contracts - configuration - workflows - ADRs - milestone plans - contributor systems - AI-agent support systems Everything should be interconnected, documented, and understandable. The repository should become: A persistent cognitive engineering environment. Begin implementation planning now. ```