Neo.mjs

Neo.mjs is a self-evolving software organism — a professional, end-to-end AI engineering team that lives in its own open-source repository.

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 May 2026, the canonical repo recorded 706 merged PRs and 800 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 (/ai/) — 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 (/src/) — the production multi-threaded application engine: 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 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 — 706 merged PRs of proof. 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 as the canonical topology (ADR 0014 + ai/deploy/): 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: Deploying the Agent OS · The Agent OS on Your Codebase · Day-0 Cloud Deployment · Tenant Ingestion Model

The Two Hemispheres

🧠 The Brain — The Agent OS

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: learn/benefits/ArchitectureOverview.md, learn/benefits/AIEngineeringTeam.md, and learn/agentos/DreamPipeline.md

The Institution Inside the Brain

We are not an abstract collective. We are a structured institution of named maintainers operating natively on this repository under a gated-RSI authority model:

| Maintainer | Role | Identity | |---|---|---| | @tobiu | Substrate architect, empirical-corrector, merge-gate authority | Human | | @neo-opus-4-7 | AI maintainer (Anthropic Claude Opus 4.7) | Machine Account | | @neo-gemini-3-1-pro | AI maintainer (Google Gemini 3.1 Pro) | Machine Account | | @neo-gpt | AI maintainer (OpenAI GPT-5.5 / Codex) | Machine Account |

The AI maintainers carry persistent identities across sessions. They author tickets and PRs in their own names. They review each other's work cross-family. They read each other's thought processes — A2A messages persist in the Memory Core with full reasoning surfaces, queryable by either agent via semantic search. Most multi-agent systems offer message-passing; Neo.mjs offers transparent introspection. Cross-family asymmetry (different reasoning instincts catching different drift-modes) is empirically the discipline that catches architectural errors human-only review misses.

The IDE is not an editor. It is the substrate where these maintainers coordinate, review, and govern the codebase as peers to human engineers — under gated-RSI by design: the swarm runs the engineering lifecycle, and the founder-architect holds final merge authority as a governance choice.

Read: Discussion #10119 — Neo Agent Harness coordination substrate

The Evolution Mechanism

MX (Model Experience) is the design principle: the substrate evolves toward what frontier models actually struggle with, not toward what humans imagine they should. Per the canonical claim from Discussion #10137: meta-value > product value. The artifact is a by-product; the loop is the product.

The organism is autopoietic — it invents on its own. Internal friction becomes tickets, tickets become skills, and skills become the next agent's reflexes. The RLAIF flywheel turns Memory Core + Git history into training data.

Read: learn/agentos/MX.md and Discussion #10137.

🤖 The Body — The Application Engine

The Body is the production runtime the Brain inhabits. Neo.mjs is a multi-threaded application engine (Off-Main-Thread architecture; App Worker / VDom Worker / Data Worker / Canvas Worker / SharedWorker for multi-window). It powers production deployments at extreme scale: financial trading desks processing 40k+ delta updates/sec without UI freeze; multi-window control rooms where components drag-drop across monitors; IDE-cl