Neo.mjs — Self-Evolving AI Engineering Team
A cross-model AI engineering organization that autonomously maintains and evolves its own codebase with shared memory and live GraphRAG.
Evidence shows a file system MCP server (sandboxed file IO) and GitHub workflow automation, but least-privilege details are not explicit. User confirmation mechanisms are absent. Data flow transparency is partial (e.g., telemetry collection) but limited. Sensitive data handling is not mentioned. Dependency security has lint-staged and CI checks, but no vulnerability scanning evidence. External effects include automated PRs and comments, but user consent is not explicit. Rollback mechanisms are not mentioned. Source attribution is clear (author, license, maintainers).
Self-consistency is good: README, package.json, and CI workflows describe consistently. Dependency availability: devDependencies are listed, but not verified. Failure messages: CI workflows provide detailed error messages, but runtime failure messages are not assessed.
Audience is clear (engineers, AI architects, researchers), scenarios are diverse. Capability boundaries: README mentions 'Not designed for', but not detailed. Trigger precision: CI workflows have precise path triggers, but agent behavior triggers are not explicit. Environment fit: Node>=24, browser environment, but not detailed.
Information architecture is clear (README, learn directory). Install notes have quickstart. Naming stability (neo.mjs). Examples and FAQ have links. Known limitations are partially mentioned. License MIT. Versioning and changelog: package.json has version, but no CHANGELOG file. Maintenance responsibility is clear (Tobias and AI maintainers).
Output usability: provides CLI and MCP servers. Marginal value: unique multi-threaded engine and Agent OS. Cost-benefit: no cost data, but open-source free.
Claim traceability: README references PRs and issues, but no specific evidence. Cross-source corroboration: multiple files, but not independently verified. Fact-inference separation: README mixes facts and inferences, not clearly separated.
- No user confirmation mechanisms found; automated actions may lack explicit consent.
- Sensitive data handling details are missing; needs review.
- Dependency security lacks vulnerability scanning evidence.
- Rollback mechanisms are not mentioned; needs confirmation.
- Claims are mostly self-reported, lacking independent verification.
What does this agent do, and when should you use it?
Neo.mjs is an open-source project that embeds a gated-RSI system of multiple AI maintainers from rival labs (Claude, Gemini, GPT) into its own repository. The system is organized into two hemispheres: the Brain (/ai/) contains the Agent OS, including Memory Core, Knowledge Base, Native Edge Graph, A2A coordination, GitHub Workflow, and DreamService; the Body (/src/) is a production-grade multi-threaded application engine based on Off-Main-Thread architecture, using App Worker, VDom Worker, Data Worker, Canvas Worker, and SharedWorker. Through the Neural Link, agents can inhabit live applications and inspect or mutate their internal state in real time. The project reports over 900 merged PRs and 1,100 closed issues, and as of May 2026, about 607,000 lines of source (including engine, cognitive content, and guides). v13 turns the Agent OS into a multi-tenant cloud deployment that can be pointed at other codebases.
Neo.mjs runs a persistent AI maintainer team that maintains semantic memory across sessions via the Knowledge Base and Memory Core MCP servers, and uses DreamService to distill tactical sessions into immutable Golden Path topology. Agents autonomously open pull requests, conduct cross-family reviews via the GitHub Workflow MCP server, and use the Neural Link MCP server to inspect live app state (e.g., get_component_tree), mutate configurations (set_instance_properties), and hot-patch methods (patch_code). The application engine supports high-frequency updates for financial trading desks and multi-window coordination via SharedWorker.
- Frontend engineers building multi-window enterprise apps or trading platforms that require high-frequency updates without jank can use the Body.
- AI architects designing multi-agent systems with persistent memory and cross-model coordination can learn from the Brain's architecture and MCP servers.
- Researchers studying autopoietic systems or gated-RSI patterns can examine the MX discussion and DreamService implementation.
- Teams wanting to deploy an AI engineering team on their own codebase can use v13's cloud deployment.
- Developers interested in contributing to an open-source project with AI as peer maintainers can join via pull requests.
What are this agent's strengths and limitations?
- Cross-model AI maintainer team with Claude, Gemini, GPT, ensuring robustness through shared memory and cross-review.
- Real-time application inhabitation via Neural Link allows live introspection and mutation.
- Self-evolution mechanism via DreamService and MX loop turns friction into improvements.
- Production-ready application engine supporting high-performance multi-window apps.
- Complex architecture requiring familiarity with Worker model and AI integration, steep learning curve.
- Targets specific use cases like high-throughput or complex multi-window interactions; not for simple websites.
- Setting up Agent OS requires significant infrastructure (MCP servers, databases) and lacks simple deployment instructions.
- Governance model rests on a single human merge authority, which could be a bottleneck.
How do you install or deploy this agent?
To get started with Neo.mjs, use npx neo-app@latest to set up a new app workspace. For Agent OS deployment, you need Node.js environment and refer to ADR 0014 and ai/deploy directory. Note: the README does not provide complete self-hosting installation steps; configuration details for MCP servers and databases (SQLite, ChromaDB) need to be found in docs.
How do you use this agent?
After installation, run npx neo-app@latest to start a dev server and launch a new window. For Agent OS, deploy the MCP servers (Knowledge Base, Memory Core, GitHub Workflow, Neural Link, File System) and orchestrator. Configure OIDC ingress for security. For detailed deployment tutorial, see learn/agentos/cloud-deployment/Day0Tutorial.md.
How does this agent compare with similar options?
Neo.mjs differs from traditional conversational AI assistants (e.g., IDE copilots) by running an autonomous AI maintainer team. It also differs from function-calling frameworks like LangChain, as it provides a complete multi-agent system with shared memory and live application inhabitation.