# Neurite: Fractal Mind-Mapping Workspace with Multi-Agent AI

> Neurite is a browser-based and desktop workspace that places mind-mapping nodes inside a navigable Mandelbrot set, combining Zettelkasten note-taking with a multi-agent AI interface. The last push to the repository was on 2026-03-16.

**satellitecomponent/Neurite** — Fractal Graph-of-Thought. Rhizomatic Mind-Mapping for Ai-Agents, Web-Links, Notes, and Code.

- Repository: https://github.com/satellitecomponent/Neurite
- Website: https://neurite.network/
- Stars: 2,141 · Forks: 171
- Language: JavaScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/satellitecomponent-neurite

## What Neurite Does and Who It Is For

Standard note-taking tools and mind-mapping applications operate on flat canvases or hierarchical trees. Neurite takes a different structural premise: the workspace is the Mandelbrot set, and nodes are placed within it. Zooming in and out navigates the fractal in real time, and nodes persist at their spatial positions within that geometry. The result is a workspace that is, in the README's description, virtually limitless.

Nodes in Neurite can hold text, images, video, audio, webpages, PDFs, and AI agents. They are physics-simulated, meaning they fall toward the fractal visualization when released, giving the workspace a kinetic quality that standard tools do not have. The tool targets researchers, writers, artists, and developers who want to map non-linear connections between ideas and who find the constraints of hierarchical or flat tools limiting. The README warns that the interface contains flashing lights and colors that may affect people with photosensitive epilepsy.

## The Fractal Foundation and Why It Differs from Standard Canvases

Most mind-mapping tools use a flat infinite canvas, where nodes can be placed anywhere but the space itself carries no structure. Neurite's canvas is the Mandelbrot set, rendered in real time as you navigate it. The README supports fractal customisation: users can switch between the Mandelbrot set, the Burning Ship fractal, the Julia set, and others, and can adjust colour, quality, and generation speed. One documented control generates the fractal according to the current mouse position.

The Mandelbrot set is not merely decorative here. The fractal provides a spatial framework for organising nodes. Because the set has infinite self-similar structure at every scale, groups of related nodes can be placed at any zoom level and revisited by navigating back to that position. This is the mechanism behind the claim of a virtually limitless workspace: the fractal itself provides inexhaustible spatial address space. The physics simulation then causes nodes to cluster dynamically around points of gravitational attraction within the fractal rendering.

## FractalGPT and Zettelkasten-Style Memory

Neurite includes a component called FractalGPT, which the README describes as a Zettelkasten AI that responds as a graph of thoughts. Rather than treating a conversation as a linear sequence, FractalGPT stores AI responses as nodes in the workspace graph and retrieves them using graph search. The README describes this as non-linear memory access: AI memories and conversation histories are retrievable by traversing the graph rather than scrolling back through a chat log.

The Zettelkasten synchronisation feature keeps the fractal workspace and a text-based note archive in bi-directional sync. Changes to visual graph representations propagate to text notes and vice versa. Custom tags define note headings, and reference brackets link notes to each other. Text nodes support code highlighting and code execution, letting users define and test custom nodes without leaving the workspace. Neurite does not lock users into a specific note format; custom tag structures can be defined per workspace.

## Multi-Agent UI and Connecting Multiple AI Providers

Neurite's multi-agent UI allows connecting multiple AI nodes within the same workspace and enabling graph-based conversation between them. Agents can communicate with each other and with the user simultaneously, with the conversation structure visible as edges in the graph. The README describes this as collaborative communication between multiple AI and the user via graph-based multi-agent conversation.

The workspace also exposes a Neural API for programmatic interaction with the node graph. The README mentions the API as a pathway for extending Neurite's capabilities beyond its built-in node types. The package.json confirms the project uses Vite for bundling; the development server runs with npm start and a production build is produced with npm run build. Developers wanting to extend the tool or run it locally can build from source using the repository's Vite configuration.

The multi-agent model is distinct from tools that provide a single AI chat panel alongside notes. Because each AI agent is a node that can be connected to other nodes by graph edges, the conversation topology is visible and editable within the workspace itself. A user can draw an edge from one AI node to another, and to a text note, constructing a flow where each agent has access to specific pieces of the workspace context rather than all of it.

## Getting Started: Web App, Desktop, and Local Development

Neurite is accessible at neurite.network as a web application with no installation required. The README presents this as the primary access route. A Desktop application built on Electron is also available; the most recent Desktop release in the repository is tagged electron-2025.06.18.233853 and was published on 2025-06-18.

For local development or self-hosting, the repository uses Vite as the build tool. The package.json scripts section shows two relevant commands:

```bash
npm start
```

This starts the Vite development server. The build script runs vite build and then copies the js, resources, and wiki directories into the dist folder:

```bash
npm run build
```

The production build output lands in dist/. The workspace state, including node positions and content, is stored locally in the browser. The photosensitivity warning applies from the first load.

## Limitations and Cases Where Neurite Is Not the Right Tool

The fractal canvas is designed for non-linear, exploratory knowledge work. Users who need a structured, hierarchical knowledge base with reliable search, version history, and team collaboration will find Neurite a poor fit. The interface is visually complex and has an acknowledged learning curve; the README notes the project itself continues to have some bugs.

The workspace persistence model is browser-based. There is no built-in synchronisation across devices or users, no access control, and no server-side storage for collaborative use. For teams that need shared knowledge graphs with concurrent editing, Neurite is not designed for that scenario.

The Electron Desktop application has not received a release since 2025-06-18. Users who prefer a native application over a browser window are working with a release that is now more than a year old.

## Maintenance Status and License

The repository is not archived, but the last push to the main branch was on 2026-03-16. This is more than six months before the current date. The most recent tagged releases are the Desktop Electron build from 2025-06-18 and the Frontend build from 2025-05-02. The README states the project is open source and in active development, but the commit history does not reflect that claim as of the available data.

The project is licensed under the MIT license. There are no restrictions on forking, modification, or redistribution. For users who encounter bugs or missing features, the MIT license allows them to apply fixes and run a custom build without restriction. The npm dependency tree is managed with standard Vite tooling, which means the build environment is straightforward to set up.

## Conclusion

Researchers, writers, and developers who want an infinite, spatially organised workspace and are comfortable with experimental software will find Neurite genuinely unusual. Its fractal canvas is not a gimmick applied to an otherwise standard note tool; the spatial organisation of nodes within Mandelbrot geometry is the central design decision. Users who need reliable, well-maintained software for production knowledge management should note that the last push to the repository was on 2026-03-16, and the Desktop Electron release has not been updated since 2025-06-18. The photosensitivity warning in the README is also worth heeding before first use.

## FAQ

### What does Neurite do?

Neurite is a workspace that places mind-mapping nodes inside a navigable Mandelbrot set fractal. Nodes hold text, code, images, video, webpages, PDFs, and AI agents. The workspace also includes FractalGPT, a Zettelkasten AI that stores responses as graph nodes for non-linear retrieval.

### Does Neurite require installation?

No installation is required to use the web version at neurite.network. A Desktop Electron app is also available in the repository releases. For local development or self-hosting, the project uses Vite and requires Node.js with npm.

### Can Neurite be used for team collaboration?

The README does not document multi-user synchronisation, shared workspaces, or access control. The workspace state is stored in the browser locally. Neurite does not appear to be designed for concurrent team collaboration.

## Sources

- [License: MIT](https://github.com/satellitecomponent/Neurite/blob/main/LICENSE)
- [Project website](https://neurite.network/)
- [README](https://github.com/satellitecomponent/Neurite/blob/main/README.md)
- [Releases](https://github.com/satellitecomponent/Neurite/releases)
- [satellitecomponent/Neurite on GitHub](https://github.com/satellitecomponent/Neurite)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/satellitecomponent-neurite