Neo isn't a framework. It's a self-evolving digital organism with two souls — a Brain and an Institution — that share one Body and one Evolution mechanism.
A brain — a graph routing a swarm of agents via stigmergic paths and gravity wells, distilled by the Dream Pipeline into immutable Golden Path topology. And an institution — a team of human and AI maintainers who learn, enable each other, and read each other's thoughts. The body they co-inhabit and mutate in real-time ships today as a browser-resident App Worker heap — but the primitive transcends web UI: the same possession-interface architecture maps to game engines, robotics, anywhere AI needs to embody (Software → Games → Robots → X). Their evolution mechanism is the MX loop — Model Experience as production mechanism. The organism invents on its own: internal friction generated across 850+ agent sessions becomes tickets becomes evolved skills becomes the next agent's reflexes; an RLAIF flywheel turns that work into training data. The trajectory is autonomous narrow intelligence (ANI) — by accumulation, not by design, on the gated-RSI path where agents propose, humans approve at merge.
"The system evolves by predicting its own evolution."
Every other 2026 platform asks: how can AI help humans use this software? Neo asks: how can software become a body that AI inhabits?
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 pipeline rests on four architectural patterns:
- Asymmetric RAG: Deterministic state ingestion (filesystem/issues → SQLite) vs probabilistic extraction (sessions → LLM).
- Tri-Vector Synthesis: Explicit provenance edges (
MENTIONED_IN,DISCUSSED_IN) linking derived concepts strictly back to raw episodic sessions. - Hybrid GraphRAG: The
GoldenPathSynthesizercombines semantic distance (Chroma) with structural edge weights (SQLite) to traverse beyond blocked nodes. - Graph Apoptosis: Orphaned concepts are pruned via Hebbian weight decay (
GraphMaintenanceService); unused connections weaken and dissolve.
A six-phase REM cycle closes the feedback loop, where survivors compound into stigmergic paths and gravity wells the swarm follows.
We don't need to capture all of Neo. The graph routes us.
Read: learn/agentos/DreamPipeline.md
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 |
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 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: agents propose, humans approve at merge.
Read: Discussion #10119 — Neo Agent Harness coordination substrate
The Neural Link is not an API. It is a possession interface — a "Ghost in the Shell" moment where AI moves from static text generation into true digital embodiment. Until now, AI coding assistants have relied on statistical code analysis (reading static files, guessing runtime behavior). Neo renders that obsolete.
By operating directly on the Left Hemisphere (the browser-side runtime), multiple autonomous agents can co-inhabit the same App Worker heap simultaneously. They don't guess; they inspect real-time application state (get_component_tree), mutate live configurations without browser reloads (set_instance_properties), hot-patch methods (patch_code), and immediately verify the results of their own actions.
This is the next evolution of conversational UIs: shared agents collaborating inside the live application itself. The VDOM tree isn't a rendering target — it's a working memory surface where the model is thinking with its hands inside the machine. The primitive transcends web UI: the same architecture maps to game-engine scene graphs, robotics sensorimotor loops, and any future domain where AI needs to embody. Software → Games → Robots → X.
Read: learn/agentos/MemoryCore.md and the Neural Link guide.
The current substrate 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 nodes (melted plastic) — they retain identity, state, and methods at runtime, which is what makes them inhabitable. Zero runtime dependencies. Native ES Modules, no transpilation.
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 generated across 850+ agent sessions becomes tickets becomes evolved skills becomes the next agent's reflexes. External-friction absorption (the industry-friction-radar protocol) is the ethics-when-invoked boundary for the rare cases where external SOTA is load-bearing — empirically near-zero invocations in 850+ sessions. Neo is not a parasite absorbing other frameworks' pain points; it is a self-creating system inventing its own trajectory.
The substrate also feeds an RLAIF flywheel — Reinforcement Learning from AI Feedback. Two memory substrates converge into training data:
- Memory Core — short-term recall (recent agent sessions, ChromaDB semantic + SQLite Native Edge Graph)
- Git history — long-term distributed memory, the framework's full evolutionary history, replicated globally on every clone, predating the Memory Core itself
The trajectory is autonomous narrow intelligence (ANI) — by accumulation, not by design, on the gated-RSI path. We don't claim to know the destination. The maintainer puts it bluntly: "AGI probably not, but 'just neo apps' also not. Even I can not see the real goal yet."
Read: learn/agentos/MX.md and Discussion #10137.
The MX loop's full closed-loop maturity ships in stages. Three faculties are online; one is healing.
| Faculty | Substrate | Status |
|---|---|---|
| Speech — A2A messaging | addMessage / listMessages MCP tools |
✅ shipped |
| Attention — Wake substrate | Cross-process wake delivery via bridge daemon (ADR-0002) | ✅ shipped |
| Short-term recall — Turn-based mini summaries | #10332 | 🔄 in flight |
| Dream — Concept Ontology + Golden Path authoritative routing | #10030 | 🔄 in flight |
The substrate also has a resilience asymmetry worth naming honestly:
- The Body is distributed — every git clone is a complete backup. The codebase is replicated globally; the Body cannot disappear.
- The Brain is centralized — SQLite Native Edge Graph + Vector DB + LLM API funding currently run on a single human's laptop. That is a Single Point of Failure (#10291 tracks substrate-level self-defense; an Economic Metabolism Sensor — a formal funding structure that preserves Clean Room Ethics — is the next substrate-fragility milestone).
We name this because the organism is not yet immortal. The trajectory toward maturity goes through resolving the SPOF.
npx neo-app@latestThis 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.
Neo is a category-shaped substrate, not a framework-shopping option. The four pillars 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 Brain and the Possession Interface. The Agent OS substrate is what you're looking for.
- Researchers studying autopoietic systems, gated-RSI patterns, or empirical multi-agent organism governance — start with Discussion #10137 (MX coinage) and Discussion #10119 (harness coordination).
The same hero paragraph reads differently to each audience because each has different mental-models about what autopoietic or Possession Interface means. The vocabulary self-filters.
Not designed for: static content sites or simple blogs (use Astro/Next.js); teams looking for "React with a different syntax"; developers unwilling to embrace the Actor Model (Workers) or treat AI as a peer maintainer.
Neo is split into two complementary layers (engine ↔ toolchain):
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
Runs in Node.js. AI-native.
- Knowledge Base MCP server — semantic codebase understanding (ChromaDB + Gemini embeddings)
- 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
- DreamService — REM-cycle daemon that distills sessions into Golden Path topology
Read: learn/benefits/ArchitectureOverview.md
This is not a micro-library. It is a substrate representing over a decade of architectural investment:
- ~45,000 lines of core platform source
- ~36,000 lines of working examples and flagship applications
- ~12,000 lines of production-grade theming
- ~14,000 lines of dedicated AI-native infrastructure
- ~53,000 lines of detailed JSDoc documentation
- 3,185 commits in 3 months (Jan–Mar 2026, post-Agent-OS)
Total: ~170,000 lines of curated code + documentation.
For a deeper dive: Codebase Overview.
- ✨ The Vision — the philosophy behind the substrate
- 🗺️ The Roadmap — what's shipping next
- 📚 Architecture Overview — two-hemisphere topology
- 🧠 The Dream Pipeline — six-phase REM cycle + Golden Path math
- ⚙️ MX (Model Experience) — agent-facing infrastructure as production mechanism
- 💬 Discussion #10119 — Neo Agent Harness coordination substrate
- 🌱 Discussion #10137 — MX coinage + ANI primitives + AX vs MX
- 🛡️ Epic #10291 — Organism Self-Defense substrate (cloud-phase prerequisite)
- 💬 Discord — primary community hub; conversations archived + searchable
- ⚡️ Slack — real-time chat (90-day retention on free tier)
Neo is co-developed by @tobiu (substrate architect + merge-gate authority) and the AI maintainer team (@neo-opus-4-7, @neo-gemini-3-1-pro) under gated-RSI: agents propose code via PR, humans approve at merge. External contributors welcome via the same workflow.
Copyright (c) 2015 - today, Tobias Uhlig