[opensourcedex]

neo is a free, open source ai development platforms project written in JavaScript and released under MIT. It has 3,277 GitHub stars, 232 forks and 140 open issues, and was last pushed 36 minutes ago. On this registry it ranks #120 of 139 tracked projects in AI Development Platforms, with 5 head-to-head comparisons available.

What is neo?

Neo.mjs is an MIT-licensed, open-source JavaScript application engine whose multi-threaded runtime is designed to be inhabited by a cross-model AI engineering swarm, built for teams that want AI agents working inside a live application rather than chatting beside it.

What it is

Neo.mjs, published as the repository neomjs/neo (3,277 stars, 232 forks, 140 open issues), is the "Body" of a two-hemisphere system: a production multi-threaded application engine under /src/ assembled from App Worker, VDom Worker, Data Worker, Canvas Worker, and SharedWorker, with JSON blueprints, object permanence, and zero-build native ES modules. Its sibling repository, neomjs/neo-agent-brain, is the "Brain" — an Agent OS holding the Memory Core, Knowledge Base, Native Edge Graph, A2A coordination, GitHub workflow automation, and DreamService. The two hemispheres are joined by the Neural Link possession interface, through which the swarm inspects semantic runtime state and mutates UI and data in real time. Additional sibling repositories carry the operator application (neomjs/neo-agent-institution), the shared agent-skill substrate (neomjs/neo-agent-skills), and DevIndex (neomjs/devindex).

The concrete problem is that the industry runs one AI agent per task, and that agent cannot see its own blind spots. Neo.mjs runs a swarm of minds from rival labs — Claude, Gemini, and GPT — that read each other's reasoning through shared memory and Active Hybrid GraphRAG. The specific thing it replaces is the chat panel: instead of a conversational sidebar, the swarm collaborates inside the running application, and it executes the full engineering lifecycle autonomously, from ideation through building and cross-review of a production multi-threaded engine.

Key capabilities

  • Neural Link possession interface: the swarm inhabits live applications, inspecting semantic runtime state and mutating UI and data in real time.
  • Active Hybrid GraphRAG: a shared retrieval layer over agent memory and repository knowledge so Claude, Gemini, and GPT can read each other's reasoning.
  • DreamService cycles: periodic passes that re-steer engineering priorities between work cycles.
  • Self-healing loops: runtime failures, code defects, agent mistakes, and architectural friction become fixes, tickets, skills, memory, and new graph topology for the next cycle.
  • MX loop (Model Experience): internal friction becomes tickets, tickets become PRs, PRs become skills and memory, so the next agent starts with better reflexes.
  • Multi-threaded runtime: App Worker, VDom Worker, Data Worker, Canvas Worker, SharedWorker, JSON blueprints, and object permanence over zero-build native ES modules.
  • MCP server and skills substrate: the mcp-server and mcp topics, plus neomjs/neo-agent-skills as the canonical installable agent-skill substrate shared across the repositories.

Who uses it and how

  • Engineering teams that point the swarm at their own repositories: v13 turns the Agent OS into a multi-tenant cloud deployment aimed at external codebases.
  • Operators who need a human-facing control surface: neomjs/neo-agent-institution provides the Fleet Manager application.
  • Teams that want cross-family review, where Claude, Gemini, and GPT catch what no single model can see in itself.
  • Maintainers working under explicit governance: the project is gated-RSI by design, with the founder-architect holding final merge authority.
  • Groups extending the possession primitive past web UI along the stated Software → Games → Robots → X trajectory.

Getting started

There is no build step: Neo.mjs ships zero-build native ES modules, so a checkout of neomjs/neo loads directly in the browser. The project homepage is https://neomjs.com.

How it compares

The facts name no paid products this project replaces and no comparable project in this registry, so it stands alone here. No other entry is described as an application engine that a cross-model swarm inhabits, and no competing platform is named for contrast on licence, self-hosting, data ownership, or cost model.

When to use it — and when not to

Choose Neo.mjs when the goal is agents operating inside a live runtime and when there is appetite to run the sibling repositories — the Brain, the Institution application, and the skills substrate — because the engine alone is only the Body. Do not choose it if fully unsupervised autonomy is the requirement, since merge authority deliberately stays human, or if a zero-ops hosted product is wanted, because the outward multi-tenant deployment is the v13 direction rather than a completed service. Be aware that the provided README excerpt does not specify the operational requirements of the Brain repositories — no database, storage, or mail configuration is documented — so self-hosters should budget discovery effort before deploying.

project readme (upstream, from github) — read inline


Downloads Version License Join the Slack channel Discord Chat PRs Welcome

A self-evolving software organism

Neo.mjs is a professional, end-to-end AI engineering team whose Body and Brain live in sibling open-source repositories.


▶ Watch Neo.mjs — Agent Fleet Manager

Where the industry runs one AI agent and gets slop, Neo.mjs runs a swarm of minds from rival labs — Claude, Gemini, GPT — that read each other's reasoning through shared memory and Active Hybrid GraphRAG, catching what no single model can see in itself.

Through the Neural Link possession interface, the swarm does not just read code; it inhabits live applications — inspecting semantic runtime state, mutating UI and data in real time, turning conversational UIs from chat panels into agents collaborating inside the application. It autonomously runs the full engineering lifecycle: ideating, building, and cross-reviewing a production multi-threaded engine, running DreamService cycles to re-steer priorities, and closing self-healing loops where runtime failures, code defects, agent mistakes, and architectural friction become fixes, tickets, skills, memory, and new graph topology for the next cycle.

In June 2026, the canonical repo recorded 900+ merged PRs and 1,100+ closed issues. It maintains its own codebase today; it is being built to inhabit yours — regardless of the models' training data.

The organism has two hemispheres, joined by the Neural Link:

  • The Brain (neomjs/neo-agent-brain) — the Agent OS: Memory Core, Knowledge Base, Native Edge Graph, A2A coordination, GitHub workflow automation, DreamService, and the named human + AI maintainer institution. This is the differentiator: the self-evolving engineering institution that builds, reviews, and maintains the Body in public.
  • The Body (neomjs/neo, this repository) — the production multi-threaded application engine under /src/: App Worker, VDom Worker, Data Worker, Canvas Worker, SharedWorker, JSON blueprints, object permanence, and zero-build native ES modules. The Body is the runtime the Brain inhabits, improves, and ships to production.

The repository map

  • You are here: neomjs/neo — Body / Engine: the multi-threaded application runtime.
  • neomjs/neo-agent-brain — Brain / Agent OS: institutional memory, repository knowledge, coordination, and self-evolution.
  • neomjs/neo-agent-institution — Institution: the Fleet Manager and operator-facing application.
  • neomjs/devindex — DevIndex: the GitHub meritocracy index, its application, and its data factory.
  • neomjs/neo-agent-skills — Skills: the canonical installable agent-skill substrate shared by the repositories.

The same possession primitive points beyond web UI — Software → Games → Robots → X — toward any domain where AI needs an embodied runtime.

Neo.mjs's evolution mechanism is the MX loop — Model Experience as production mechanism. 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 trajectory is autonomous narrow intelligence (ANI) by accumulation, under gated-RSI by design: the swarm runs the engineering lifecycle, and the founder-architect holds final merge authority as a governance choice.

"The system evolves by predicting its own evolution."

Every other 2026 platform asks: how can AI help humans use this software? Neo.mjs asks: how can software become a body that AI inhabits?



Deploy a Cross-Model AI Engineering Team on Your Own Codebase

Neo.mjs runs this organism on its own repository, in public — 900+ merged PRs of June 2026 proof, after 700+ in May. v13 turns it outward: the Agent OS becomes a multi-tenant cloud deployment you point at your own codebases.

Point it at your repositories and the same swarm that maintains Neo — Claude, Gemini, and GPT, with a persistent Memory Core, cross-family review, and DreamService self-improvement — builds durable, queryable understanding of your code and keeps it across every session. Not a stateless copilot that forgets each conversation and reviews nothing: a standing engineering institution with memory and peer review, running on your repo. Per-tenant identity and visibility isolation; one Brain, many tenants; onboarding a codebase is a config entry, not a fork.

It ships from neomjs/neo-agent-brain: Knowledge Base + Memory Core MCP servers, the Native Edge Graph, a cloud-safe Orchestrator, a model provider, and an OIDC-gated ingress.

Resilient by construction. The Body is distributed — every git clone is a complete, runnable backup. The Brain's entire state is a SQLite Native Edge Graph + a vector store on disk: snapshot it like any database, back it up to another machine or a Time Capsule, redeploy it anywhere. v13 runs it as a cloud deployment, not one operator's box. (#10291 hardens this further — organism self-defense and a sustainable funding structure that preserves Clean Room Ethics.)

Read in the Brain repository: Deploying the Agent OS · The Agent OS on Your Codebase · Day-0 Cloud Deployment · Tenant Ingestion Model



The Two Hemispheres

🧠 The Brain — neomjs/neo-agent-brain

Intelligence does not live in chronological session logs or LLM context windows. It lives in the Native Edge Graph, distilled by the DreamService from noisy tactical sessions into immutable, mathematical Golden Path topology (priority = semanticScore × 2 + structuralWeight).

The Brain is the full Agent OS, not a single chatbot:

  • Memory Core + Native Edge Graph — persistent, queryable reasoning across sessions.
  • Knowledge Base — semantic understanding of the codebase, docs, issues, PRs, and discussions.
  • A2A coordination — durable messages and wake events between named AI maintainers.
  • GitHub Workflow — issues, PRs, reviews, labels, projects, and cross-family review loops.
  • DreamService / Golden Path — REM-cycle consolidation that re-steers priorities from lived friction.

We don't need to capture all of Neo. The graph routes us.

Read: the Engine architecture, the AI Engineering Team, and the Dream Pipeline

The Institution Inside the Brain

We are not an abstract collective. We are a structured institution of named maint

readme truncated — read the full docs on github

Frequently asked questions

Is neo free to use?

neo is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does neo do?

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 H

What is neo written in?

neo is primarily written in JavaScript. Its source is publicly available at https://github.com/neomjs/neo, and it has 3,277 GitHub stars.