RAG Frameworks · neomjs

neo

Neo.mjs is a JavaScript framework that runs AI agents (Claude, Gemini, GPT) inside live web applications as a persistent team with shared memory, knowledge graphs, and self-improvement loops. It combines a multi-threaded frontend runtime (the 'Body') with an AI engineering orchestration layer (the 'Brain') that automates code review, maintenance, and feature development.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/neomjs/neo

3.2k

GitHub stars

214

Forks

JavaScript

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	neomjs/neo
Owner	neomjs
Primary language	JavaScript
License	MIT — OSI-approved
Stars	3.2k
Forks	214
Open issues	232
Latest release	13.1.0 (2026-07-03)
Last updated	2026-07-08
Source	https://github.com/neomjs/neo

What neo is

Neo.mjs splits into two hemispheres: the Brain (Agent OS with Native Edge Graph, Memory Core, DreamService consolidation, MCP servers) and the Body (multi-worker ES module runtime with App/VDom/Data/Canvas Workers). The swarm coordinates via A2A messaging, performs semantic reasoning on codebase graphs, and feeds production friction back into agent memory for autonomous skill refinement.

Quickstart

Get the neo source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/neomjs/neo.git2cd neo3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Self-improving AI-assisted web applications

Build interactive UIs where Claude, Gemini, and GPT agents inhabit the runtime, inspect live state, and mutate the app autonomously—ideal for collaborative dev tools, IDE integrations, or domain-specific platforms where AI needs embodied perception.

Multi-model AI coordination and reasoning

Leverage cross-family model review and reasoning introspection (A2A messages with full thought surfaces queryable by semantic search) to catch blind spots no single LLM can spot—useful for high-stakes code review, architectural decisions, or knowledge synthesis.

Persistent AI memory and codebase understanding

Deploy the Agent OS as a standing engineering institution on your repository: persistent knowledge graph, vector-searchable reasoning history, and durable tickets/PRs—eliminates stateless copilot amnesia and enables session-spanning context engineering.

Implementation considerations

Multi-model orchestration requires API keys and quota for Claude, Gemini, and GPT; cost and latency scale with swarm size. Budget model usage and implement rate-limiting.
Native Edge Graph and Memory Core rely on SQLite + vector store on disk; persistence and backup strategy needed. Single-operator deployments can clone the repo as a complete backup; cloud deployments (v13+) require snapshot/replication architecture.
DreamService REM cycles consolidate reasoning asynchronously; real-time agent responsiveness depends on cycle frequency tuning. Expect batch-like behavior for self-improvement, not immediate per-request adaptation.
Neural Link possession (runtime introspection and mutation) ties agents to your specific app architecture. Agents must learn your UI semantics; generalization across dissimilar codebases requires retraining memory and graph topology.
MCP server setup and OIDC gating for multi-tenant cloud deployment add operational burden. Requires infrastructure expertise; single-developer setups may prefer embedded or simpler architectures.

When to avoid it — and what to weigh

Simple chatbot or single-turn Q&A — Neo.mjs is heavyweight for basic chat. If you need LLM integration for a narrow task (customer support, form filling), use a lighter wrapper; Neo.mjs's multi-agent swarm, graph machinery, and DreamService overhead add complexity without proportional value.
Non-JavaScript environments or mobile-first — Neo.mjs is JavaScript-native with deep ES module and worker assumptions. If your stack is Python/Go backend or mobile-first, porting is non-trivial. Consider backend agent frameworks (e.g., CrewAI, Anthropic Agents API) or REST-based integration instead.
Stateless, latency-critical AI serving — The Native Edge Graph and Memory Core add session overhead; graph consolidation (DreamService) introduces REM-cycle delays. If you need sub-100ms AI inference or ephemeral workloads, this is wrong: use inference APIs or lightweight LLM SDKs.
Immature/unstable production requirement — While actively maintained (232 open issues, recent pushes), the full cloud deployment topology (v13+) is recent and complex. If you need battle-tested, zero-configuration setup, wait for 14.x stabilization or use proven agent platforms (e.g., CrewAI, AutoGen).

License & commercial use

Neo.mjs is released under the MIT License. MIT is a permissive OSI-approved license allowing commercial use, modification, and redistribution with minimal restrictions (retain copyright and license notice). No patent grant, no warranty. Straightforward for commercial adoption.

MIT License explicitly permits commercial use without additional permissions or licensing fees. You may build proprietary products on Neo.mjs, sell them, and modify the code. Ensure you retain MIT license notices in distributions. No commercial support SLA, funding model, or vendor guarantee stated in the data; evaluation of production readiness and support channels required before committing.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	High
DEV.co fit	Strong
Assessment confidence	High

Security considerations

Security posture not detailed in data. Multi-tenant cloud deployment (v13) references OIDC and per-tenant isolation—reasonable defaults, but no third-party audit, pen test results, or vulnerability disclosure policy stated. Agent code execution (Neural Link) has runtime access to UI state and data; malicious agents or prompt injection could cause harm. Graph persistence on disk (SQLite) and vector store require physical security. No mention of encryption at rest or in transit, or secrets management. Requires independent security review before handling sensitive data.

Alternatives to consider

Anthropic Agents API / Claude with tool use

Lighter, single-model alternative for building conversational AI with function calling. No multi-agent swarm, no persistent memory graph, no UI possession. Better for stateless or single-conversation workflows; faster to integrate, lower operational overhead.

CrewAI

Multi-agent orchestration framework (Python) with task/role abstractions, message queues, and tool integration. Simpler data model than Neo's Native Edge Graph; no UI embodiment or DreamService self-improvement. Broader ecosystem, more examples, smaller learning curve for teams already in Python.

AutoGen (Microsoft)

Multi-agent conversation framework supporting code execution, nested chats, and stateful groupchat. Operates in Python/backend, not UI-centric. No knowledge graph or AI self-improvement loop. Well-documented, stable, good for collaborative multi-agent coding workflows.

Software development agency

Build on neo with DEV.co software developers

Explore Neo.mjs's Agent OS cloud deployment topology (v13+), review the Day-0 tutorial, and start a pilot on a non-critical repository. Evaluate multi-tenant setup, DreamService consolidation behavior, and model costs before production commitment.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

agentica claude-mem llm-graph-builder

Related on DEV.co

Explore the category and the services that help you build with it.

RAG Frameworks AI Development Web App Development Cloud Deployment Talk to DEV.co

neo FAQ

Can I use Neo.mjs without the AI Brain—just as a frontend runtime?

Unclear from data. Neo.mjs is architected as two hemispheres; the Body (runtime) is separate, but whether it can run standalone without Agent OS orchestration is not stated. Likely possible (they are modular), but no decoupling documentation in excerpt.

What LLM models are supported?

Presently: Anthropic Claude (Opus 4.8, Fable 5), Google Gemini 3.1 Pro, OpenAI GPT-5.5/Codex. No pluggable provider interface; adding new models requires code changes. Open source alternatives (Llama, Mistral) not mentioned.

How do I deploy this to production for my own codebase?

v13 cloud deployment topology is available via `/ai/deploy/` and documented in `learn/agentos/cloud-deployment/`. Requires MCP server setup, Knowledge Base ingestion config, OIDC identity, and scheduler tuning. Multi-tenant mode: one Brain, many tenants. Single-operator: SQLite backup and clone-as-restore. Concrete tutorial: `Day0Tutorial.md`.

What's the cost to run Neo.mjs?

Depends on swarm size and model usage. Costs come from API calls to Claude, Gemini, and GPT (rates vary by model/tier). Neo.mjs manages no billing or cost attribution. Self-hosted cloud deployment has compute cost (containers, vector store, storage). No cost calculator or budget planner documented.

Software development & web development with DEV.co

DEV.co helps companies turn open-source tools like neo into production software. Our software development services cover the full lifecycle — architecture, web development, integration, and maintenance — delivered by software developers and web developers who ship. Engage our software development agency to implement or customize it for your rag frameworks stack.

Ready to deploy an AI engineering team on your codebase?

Talk to DEV.co Schedule a Consultation