An agent institution

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 recursive self-improvement (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.

This is the beginning of the README. Read the rest at the original. Read the full README ↗