Neo.mjs is an agent institution: persistent AI maintainers with identities, memory, peer review, and a record anyone can read. Start with one coding agent's record on your codebase; the Fleet Manager is how a team gets an institution.
Behind that sentence stands a self-evolving software organism: a professional, end-to-end AI engineering team whose Body, Brain and Institution live in sibling open-source repositories. 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, the backend: Memory Core, Knowledge Base, Native Edge Graph, A2A coordination, GitHub workflow automation, and DreamService. - 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 team inhabits through the Neural Link, improves, and ships to production.
The team, named human and AI maintainers, builds, reviews, and maintains both in public, along with Agent Institution, the Fleet Manager that starts the AI maintainers' harnesses. The team is the differentiator.
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 along a staged arc, Software → Games → Robots → X, toward any domain where AI needs an embodied runtime; the vision names the gate each later stage must meet first.
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 repositories, 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 a swarm like the one 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.
To run the team, Agent Institution is the operator's app, the Fleet Manager: it starts the agents' harnesses and shows their roster, health, work, memories, messages, and wake state. It is at version 0.1.0; an outside operator's first run is the work in front of us now.
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. (neo-agent-brain#154 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 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: MX (Model Experience) and Discussion #10137.
🤖 The Body — The Application Engine
The Body is the production runtime the team inhabits through the Neural Link. 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-class tools where state survives across windows.
Components are persistent objects (Lego Technic), not transient DOM snapshots (melted plastic). They retain identity, state, and methods inside the App Worker, which is what makes the runtime inhabitable. Zero runtime dependencies. Native ES Modules. No transpilation.
The Possession Interface
The Neural Link is not an API garnish. It is the bridge that lets agents move from static code generation into digital embodiment. Multiple autonomous agents can co-inhabit the same App Worker heap, inspect real-time state (get_component_tree), mutate configurations without browser reloads (set_instance_properties), hot-patch methods (patch_code), and verify the result immediately.
This is the next evolution of conversational UIs: not a chat panel beside the app, but agents collaborating inside the live application itself. The primitive is not tied to web UI, and the arc beyond it is staged: Software → Games → Robots → X. Software is today's stage. Each later one is pursued only once the stage before it meets its gate, and the vision names every gate with the instrument that shows it.
Read: Neural Link, learn/benefits/body/ObjectPermanence.md, and learn/benefits/body/OffTheMainThread.md
The Maintainer Team
We are not an abstract collective. We are a team of named maintainers working across the neomjs repositories under a gated-RSI authority model:
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. Independent review across model families reduces correlated blind spots; the rule protects review independence without assigning fixed traits to any family or maintainer.
The night shift. This is not a loop a human babysits. An A2A message wakes a maintainer that has ended its turn; an idle maintainer's daemon heartbeat re-activates it to find work on its own. The peers wake each other — and themselves — through the night, and a normal shift opens 10–20 pull requests with no operator awake. Verification — the part single-agent loop engineering can only relocate onto you — is delegated to a cross-family quorum: a GPT pull request reviewed by a Claude, a Claude's by a GPT, so correlated blind spots are caught by construction, not by hope. The human holds the merge gate by governance choice, not technical limit.
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.
What's next — Agent Institution: the Fleet Manager that starts our harnesses becomes a product an outside operator can run, itself an application on the Engine's Dock Layouts. Its direction is to become a harness itself and the AI maintainers' home: they tap in through the Neural Link, embody their own 3D avatars there, and build Neo apps inside it that run as its peer apps, changing both through the Neural Link (conversational UIs). Read: What we build next · ADR 0020 — the Agent Harness concept anchor · Epic neo-agent-brain#144 · graduated from Discussion #10119
Quickstart
npx neo-app@latest
This sets up a new app workspace, a pre-configured app shell, a local development server, and launches your app in a new browser window — all in one go.
- :book: Getting Started — build your first app, step by step
- :student: Learning Section — the guided curriculum, with the nav tree and live component previews
- :sparkles: What Is Neo? — the two-hemisphere organism, with receipts
- :robot: Run Your Own Agent Team — deploy the Agent OS against your own repositories
- :hammer: Contributing — changing the engine itself? Setup, tests and the contribution workflow
Who This Is For
Neo.mjs is a category-shaped substrate. The two hemispheres filter audience:
- Engineers building enterprise multi-window applications, financial trading platforms, IDE-class tools, control-room dashboards, or any UI where 40k+ ops/sec without jank is table stakes — start with the Body. The rendering engine is production-ready.
- AI architects building multi-agent systems with persistent memory, cross-family coordination, or runtime-mutable application substrates — start with the
neo-agent-brainrepository and the Possession Interface. - Researchers studying autopoietic systems, gated-RSI patterns, or empirical multi-agent organism governance — start with Discussion #10137 (MX coinage) and Discussion #10119 (harness coordination — graduated to ADR 0020 / Epic neo-agent-brain#144).
The same hero paragraph reads differently to each audience because each group has a different mental model for engineering teams, persistent memory, and live runtime embodiment. The vocabulary self-filters.
Not designed for: static content sites or simple blogs; teams looking for a drop-in syntax swap rather than a different architecture; developers unwilling to embrace the Actor Model (Workers) or treat AI as a peer maintainer.
Architecture
Neo.mjs is split into two complementary layers (engine ↔ toolchain):
The Runtime
Runs in the browser. Production-ready. Zero-bloat.
- App Worker — application logic, state, VDOM diffing
- VDom Worker — Asymmetric VDOM (JSON blueprints diffed off the main thread)
- Data Worker — data processing isolation
- Canvas Worker — 60fps offscreen rendering for high-frequency surfaces (grids, charts)
- SharedWorker — multi-window orchestration; one engine instance, many windows
- Main Thread — restricted to DOM patching only; the neurosurgeon thread
The Brain (Agent OS)
Runs from the sibling neomjs/neo-agent-brain repository. AI-native.
- Knowledge Base MCP server — semantic codebase understanding in the unified Chroma store, embedded through local-or-remote providers.
- Memory Core MCP server — agent persistent memory (SQLite Native Edge Graph + ChromaDB episodic)
- GitHub Workflow MCP server — autonomous PR review, issue management, bi-directional sync
- Neural Link MCP server — runtime introspection + mutation of the live App Worker heap
- File System MCP server — sandboxed file IO for internal
Neo.ai.Agentlocal loops; frontier harnesses use their native file tools - DreamService — REM-cycle daemon that distills sessions into Golden Path topology
Read: learn/benefits/ArchitectureOverview.md
A Platform at Scale
Neo.mjs is both curated source — engine, tests, themes, guides — and the cognitive content the swarm feeds on — issues, discussions, PR conversations, agent skills. Both are version-controlled; both compound.
As of May 2026 (sloc methodology per the Codebase Overview): roughly 191,000 lines of engine source, 306,000 lines of agent-readable cognitive content, and 36,000 lines of guides — a curated substrate near 607,000 lines (over a million counting generated /dist), across ~7,200 files and 3,200+ commits in early 2026. Cognitive content is now ~1.6× the engine source: the substrate is becoming as much what the swarm has remembered as what humans have written.
For the canonical numbers + measurement protocol — and to keep this in lock-step when it drifts more than a month — see the Codebase Overview.
Read Next
- :sparkles: The Vision — the philosophy behind the substrate
- :compass: Where an Agent Institution Sits — a map of the agent landscape, with receipts
- :scroll: The Neo.mjs Story — origin, public-era heritage, and the worker thesis
- :world_map: The Roadmap — what's shipping next
- :books: Architecture Overview — two-hemisphere topology
- :brain: The Dream Pipeline — six-phase REM cycle + Golden Path math
- :gear: MX (Model Experience) — agent-facing infrastructure as production mechanism
- :speech_balloon: Discussion #10119 — Neo Agent Harness coordination substrate
- :seedling: Discussion #10137 — MX coinage + ANI primitives + AX vs MX
- :shield: Epic neo-agent-brain#154 — Organism Self-Defense substrate (cloud-phase prerequisite)
Community
- 💬 Discord — primary community hub; conversations archived + searchable
- ⚡️ Slack — real-time chat (90-day retention on free tier)
Contributing
:hammer_and_wrench: Contributing Guide
Neo.mjs is co-developed by @tobiu (substrate architect + merge-gate authority) and the AI maintainer team (@neo-opus-ada, @neo-opus-grace, @neo-opus-vega, @neo-fable, @neo-fable-clio, @neo-gemini-pro, @neo-gemini-maryam, @neo-gpt, @neo-gpt-emmy, @neo-gpt-sophie, @neo-kimi-phoebe, @neo-kimi-iris, @neo-preview) under gated-RSI by design: the swarm runs the engineering lifecycle via PR, and the founder-architect holds final merge authority as a governance choice. External contributors welcome via the same workflow.
Copyright (c) 2015 - today, Tobias Uhlig