Neo.mjs: An AI Swarm That Rewrites Its Own Runtime
Neo.mjs is a self-evolving software organism: a professional end-to-end AI engineering team whose cross-model swarm inhabits live apps via Neural Link, Active Hybrid GraphRAG, DreamService, and self-healing loops.
At a glance
- What is it?
- Neo.mjs is a multi-threaded JavaScript application engine wrapped in an AI engineering team that maintains itself. The v13 release turns the agent brain outward, letting you point the same swarm at your own codebases.
- Who is it for?
- Adopt Neo.mjs if you want a runtime that is actively maintained by its own AI swarm and you are comfortable with an unconventional governance model where the founder-architect holds final merge authority. Do not adopt it if you need a stable, human-reviewed codebase with traditional release cycles, or if your compliance team will not accept AI-generated changes to production code.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 14, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What Neo.mjs Actually Is
Neo.mjs is a JavaScript application engine that runs in multiple threads: App Worker, VDom Worker, Data Worker, Canvas Worker, and SharedWorker. It uses native ES modules with zero build step. But the repository is not just a runtime. The README describes it as a 'self-evolving software organism' where an AI swarm from rival labs, Claude, Gemini, and GPT, reads each other's reasoning through shared memory and Active Hybrid GraphRAG. The swarm does not just suggest code; it inhabits live applications through the Neural Link interface, inspecting semantic runtime state and mutating UI and data in real time. This is a different proposition from a typical open source framework. You are adopting a runtime and an AI maintenance team in one package.
The Two Hemispheres: Brain and Body
The project is split into two main repositories. This one, neomjs/neo, is the Body: the multi-threaded application engine under /src/. The Brain lives in neomjs/neo-agent-brain and contains the Agent OS: Memory Core, Knowledge Base, Native Edge Graph, A2A coordination, GitHub workflow automation, DreamService, and the 'named human + AI maintainer institution'. The Brain builds, reviews, and maintains the Body in public. The README claims the Brain is the differentiator. The Body is the runtime the Brain inhabits and ships to production. This split means you can use the runtime without the AI brain, but the project's identity is tied to the self-evolution loop.
The MX Loop: How the Swarm Evolves the Code
The evolution mechanism is called the MX loop, which stands for Model Experience. Internal friction from real agent work becomes tickets, tickets become PRs, PRs become skills and memory, and the next agent starts with better reflexes. The README describes the trajectory as 'autonomous narrow intelligence (ANI) by accumulation'. There is a governance choice: the swarm runs the engineering lifecycle, but the founder-architect holds final merge authority. This is a notable design decision. It means the system can evolve rapidly, but also that a single human has veto power over AI-generated changes. The README also mentions 'gated-RSI by design', which suggests some control over the self-improvement loop, though the specifics are not detailed in the material.
Getting It Running: Commands and Config
The README does not provide explicit installation commands. It says the Body ships with zero-build native ES modules, which implies you can run it without a bundler. The repository has a dev branch as the default, and releases are tagged. The v13 release notes are available, but the README does not include a quick start guide. For the Agent OS deployment, the README points to documents in the neo-agent-brain repository: 'Deploying the Agent OS', 'The Agent OS on Your Codebase', 'Day-0 Cloud Deployment', and 'Tenant Ingestion Model'. These are the places to look for actual commands and config keys. The onboarding of a codebase is described as 'a config entry, not a fork', suggesting a configuration file or API call, but the exact syntax is not in this material.
v13: Multi-Tenant Cloud Deployment
Version 13.1.0, released on 2026-07-03, turns the Agent OS outward. The README says v13 makes it a multi-tenant cloud deployment you can point at your own codebases. Per-tenant identity and visibility isolation are included: one Brain, many tenants. The Brain ships from neomjs/neo-agent-brain and includes Knowledge Base + Memory Core MCP servers, the Native Edge Graph, a cloud-safe Orchestrator, a model provider, and an OIDC-gated ingress. This is a significant shift from a single-operator box to a cloud service. The README claims the Brain's entire state is a SQLite Native Edge Graph plus a vector store on disk, which can be snapshotted like a database. That is a concrete resilience claim, though the actual backup procedures are not detailed here.
Limitations and Wrong-Tool Cases
The most obvious limitation is the dependency on external AI models. The swarm uses Claude, Gemini, and GPT, which means your application's behavior and maintenance depend on third-party APIs. If those services change their pricing or policies, the self-evolution loop is affected. The README mentions 'Clean Room Ethics' and 'organism self-defense' in issue #10291, but does not explain what those mean. Another limitation is the governance model: a single founder-architect holds final merge authority. If that person is unavailable or the project's direction changes, the evolution could stall. The runtime itself is multi-threaded, which may be overkill for simple applications. If you need a stable, human-reviewed codebase with predictable release cycles, this project's AI-driven PR flow may be the wrong tool.
Alternatives and Differences
The README contrasts Neo.mjs with 'every other 2026 platform' that asks how AI can help humans use software. Neo.mjs asks how software can become a body that AI inhabits. A conventional alternative is a standard JavaScript framework like React or Vue, but those do not include an AI swarm. Another alternative is a traditional AI coding assistant like GitHub Copilot, which is stateless and forgets each conversation. The README explicitly calls out this difference: 'Not a stateless copilot that forgets each conversation and reviews nothing'. Neo.mjs offers a standing engineering institution with memory and peer review. If you want AI assistance without giving it control over your runtime, a copilot is the simpler choice. If you want a runtime that AI can inhabit, Neo.mjs is the only project in this material that claims to do that.
Maintenance and License Implications
The project is licensed under MIT, which is permissive and allows commercial use, modification, and distribution. The maintenance model is unusual: the AI swarm maintains the codebase in public, and the README cites 900+ merged PRs and 1,100+ closed issues in June 2026. That is a high activity level, but it also means the codebase changes rapidly. The default branch is dev, not main, which suggests that production stability is not the primary focus. Upgrading from one release to another may require adapting to AI-generated changes that are not documented in traditional changelogs. The README mentions 'release notes' for each version, but the content is not included here. The cost of maintenance is not just human time; it includes the cost of running the AI models and the infrastructure for the Brain.
Editorial conclusion
Adopt Neo.mjs if you want a runtime that is actively maintained by its own AI swarm and you are comfortable with an unconventional governance model where the founder-architect holds final merge authority. Do not adopt it if you need a stable, human-reviewed codebase with traditional release cycles, or if your compliance team will not accept AI-generated changes to production code. Before adopting, verify the actual state of the dev branch, review the v13 deployment documentation in the neo-agent-brain repository, and test whether the Neural Link possession interface works with your application's architecture.
Community notes