Hi HN,

  We've been experimenting with LLMunix, a pure Markdown "operating system" where AI agents act as the kernel. The latest update adds
  persistent memory and agent-to-agent messaging - simple additions that fundamentally change what's possible.

  What's new:

  - Three-tier memory system (volatile/task/permanent) - agents can now learn across sessions
  - Asynchronous message passing between agents with priority queues
  - All state stored as human-readable Markdown files

  How it works:

  Each memory entry is a timestamped Markdown file. Messages are queued in inbox directories with YAML frontmatter for metadata. No
  databases, no binary formats - just text files you can grep through.

  Real test case:

  We simulated a marketing agency with 4 specialized agents creating a campaign. Interesting findings:

  1. When inter-agent messaging failed due to path issues, the SystemAgent adapted and manually coordinated - showing unexpected
  resilience
  2. Market insights were successfully stored in permanent memory for future use
  3. Despite subprocess isolation causing tool registration warnings, the system completed all tasks

  Why this might matter:

  Traditional LLM interactions are stateless. This approach enables:

  - Accumulated domain expertise over time
  - True multi-agent collaboration on complex tasks
  - Complete auditability (it's all text files)
  - Self-modification (agents can create new agents)

  Potential applications we're exploring:

  - Codebase analysis that remembers architectural decisions
  - Research agents that build knowledge graphs over time
  - Security analysis that learns attack patterns
  - Documentation systems that track what confuses users

  Technical challenges:

  - Message delivery needs better error handling
  - Subprocess isolation causes tool registration conflicts
  - Need standardized contracts for agent outputs
  - Performance overhead of file I/O vs in-memory state

  The interesting part isn't the individual features - it's how simple primitives (files + markdown + subprocess execution) can create
   complex emergent behaviors.

  Code: github.com/EvolvingAgentsLabs/llmunix

  What domains would benefit from AI agents that remember and collaborate? What are we missing in our approach?