Morpheus

What I can share

Morpheus is an autonomous multi-agent engine, the R&D predecessor from which I distilled the architectural patterns later reused in my real-time projects. Private as well: I share its approach and engineering challenges, not its functional details.

My role

Full solo design and development, end to end: Rust desktop shell (Tauri), Python backend (API, agent orchestration, LLM inference, memory/RAG, security), React/TypeScript UI, and the engineering system itself: multi-agent pipeline, self-improvement loop, knowledge base and quality tooling.

Technical capabilities

• Local LLM inference on Apple Silicon (MLX / vLLM-MLX), with a unified multi-provider layer able to route to remote models when needed.
• Multi-agent pipeline: an interpreter routes the request by complexity, then chains architect, coder and auditor; a meta-auditor observes traces and continuously improves the system.
• Agentic coding assistant: file editing, shell execution, git, dependency analysis, context compaction, permissions and checkpoints.
• Semantic memory & RAG: embeddings, hybrid search (vector + BM25), fact extraction, sourced citations and knowledge-base indexing.
• Real-time streaming of reasoning and responses over WebSockets.
• Automation: browser control, mail and calendar integrations, document generation, web search.
• Autonomous background daemon: scheduled tasks, backups and self-improvement routines.
• Security: encrypted secrets vault (AES-256-GCM), secret scanner, local-first execution.
• Multi-agent business-automation platform: specialised agents (strategist, creator, prospector, ambassador, accountant, growth analyst), missions, prospects and quotes, orchestrated and supervised from a unified command deck: client domain and data stay private.

Engineering challenges

• Making heavy ML libraries coexist in a single macOS process: MLX and scikit-learn each bundle their own libomp, the source of an OpenMP abort when loaded together: solved cleanly at startup, root cause documented rather than silently worked around.
• A genuinely provider-agnostic LLM layer: about a dozen local and remote providers behind a single interface, with cooldown, rate limiting, cost tracking, a RAM guard and graceful failover.
• Driving models with a limited context window: an explicit context budget and smart truncation in the orchestrator, to stay within local models' limits without breaking the task thread.
• A multi-agent pipeline that improves itself: a clean split between execution and meta-audit, with traces feeding a meta-auditor that refines rules, prompts and routing.
• Packaging an AI workstation as a native app: bridging a Rust shell (Tauri), a local Python backend and a React UI, with a transparent window, macOS private API, strict CSP and process lifecycle management.
• Securing secrets without a remote backend: a local AES-256-GCM encrypted vault with PBKDF2 key derivation, consistent with the local-first promise.

Scale

A substantial product, carried solo to a first stable release.

• A substantial working tool, designed and carried solo to a first stable release.
• Several workspaces brought together into a single application, built for demanding professional use.
• AI that runs locally, in service of confidentiality and control over your own data.
• An agent pipeline that takes on part of its own quality control, a mark of robustness.