NeuroBook: an AI writing IDE that treats a novel like a codebase
An AI-powered IDE for long-form fiction writing, combining software engineering workflows, modern storytelling methodologies, and multi-agent systems.
At a glance
- What is it?
- NeuroBook is an AGPL-3.0 TypeScript desktop and container app that stores a long-form fiction project as Markdown and SQLite, then layers a state engine, a foreshadowing ledger and a 360-rule prose linter on top. It is built for writers who want agents to execute inside a bounded workspace rather than improvise a whole novel.
- Who is it for?
- Adopt NeuroBook if you are writing a long work with continuity you cannot hold in your head, and you are willing to keep your project as local Markdown and SQLite. Do not adopt it if you need a stable interface now, since every recent release is a canary build, or if you want an agent to produce chapters unattended.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The failure mode NeuroBook is aimed at: settings drift past chapter 100
The README names four problems that a chat window does not solve for a novel-length project. Settings live in the model's conversation memory and drift as the text grows, so an arm lost in one volume grows back in the next. Planted foreshadowing is forgotten, and it disappears entirely when the conversation closes. The prose carries recognisable machine habits: filler words, mechanical transitions, formulaic parallelism. And the tooling is split across a word processor, a note vault and a browser tab, three datasets that do not know about each other.
NeuroBook's answer is to treat those as engineering problems rather than prompting problems. Settings, plot, prose and world state are files inside a workspace, and the author and the agents maintain them under explicit permissions. The stated audience is a writer with a long project and a tolerance for unfinished software: the README opens with a warning that both the application and its interfaces may be unstable during rapid development.
World Engine: event sourcing with timeline slices
The World Engine is the part with the clearest mechanism. It uses a timeline plus slices as event sourcing. Each significant point in time records a state change, and the world state at any moment is derived by computing forward from earlier slices. According to the README, this means a wound taken three months ago or a kingdom's treasury a decade back can be queried at any time without drift. Adding a setting later means inserting a slice at the right point, which is also how flashbacks and recollection are supported.
The world's structure is user-defined. People, sects, kingdoms and continents can all be stateful subjects, and the engine can return any subject's state at any point in time. Calendars are configurable, including real Gregorian dates, simplified eras, fully invented chronologies and dates before the common era. Every change is a timestamped, auditable record, so when a character acquired a particular sword is a query rather than a guess.
Permission is split by role: a leader agent can write to the world, a writer agent gets read-only access. That is the design detail that keeps prose generation from silently editing the setting it is supposed to respect. The trade-off is that the author has to model the world before writing benefits from it. A slice-based engine only pays off once you have decided which subjects exist and what their state looks like; a writer who never formalises a kingdom's finances gets nothing from the treasury query.
Plot Workbench: two trees and a ledger of promises
The Plot Workbench separates structure from causality. A carrier tree holds where the story is told, from volumes down to chapters. A causal tree holds why it happens, from plot lines down to scenes. Flashbacks, inserted sequences and multiple threads can be arranged freely while the causal chain stays traceable.
The promise system is the concrete mechanism. Each piece of foreshadowing is recorded as a promise to the reader, with a lifecycle of plant, advance and fulfil. Beats hang off scenes and update as the plot moves, and when the writing reaches the target chapter the promise enters the writing instruction. The README extends this beyond plot: a romance thread that should deliver every few chapters can also be registered, and the system will report that it has gone thirty chapters without a payoff. The Chekhov's gun framing is the README's own.
Decision records cover the other direction. When you cannot remember why a character was turned villainous three months ago, the Decision entry stores the decision at the time, requires a risk field, and keeps a trace even when the decision is overturned. Chapter information control turns reader knowledge, protagonist knowledge, required concealment and permitted hints into fields. Scenes anchor to world timeline, location and cast, which is what couples plot planning to world state instead of leaving them as two documents.
Multi-agent roles, three modes, and Inline AI
The agent layer is called NeuroAgentHarness, and the README is explicit about the metaphor: the harness is tack, and the reins stay with the author. It also states plainly that current AI cannot independently write a good novel, and argues the useful roles are research, verification, brainstorming and pushback.
Roles are separated. A leader plans plot and dispatches work, a writer produces prose, and retrieval and researcher agents look up settings and references. The claim is that numbers are not invented because the engine holds the ledger, and material is not guessed because the researcher goes and checks. The default chain runs from idea exploration through project and lorebook initialisation, World Engine record creation, plot planning and state advancement, chapter writing, and a post-write backfill step.
Three modes govern how much the agent may do. Discussion mode produces ideas without touching the manuscript. Plan mode returns a complete plan that must be approved before execution. Every mode switch requires confirmation. Inline AI in the editor works on a selection with streaming preview, and the README notes it does not interrupt the main editing flow or occupy the main session. That last point matters more than it sounds: an inline edit that shares the main conversation would drag the whole project context into a sentence rewrite.
llmlint: 360 rules, static and model-based
llmlint is the prose-linting layer, and it is also published separately as notnotype/llmlint. The README describes 360 rules covering filler words, mechanical transitions, formulaic rhetorical questions, binary contrasts, empty summaries and monotonous rhythm. Static rules scan the whole manuscript in seconds, model-based rules make contextual judgements, and mechanical problems can be fixed automatically. It ships both as a polishing skill inside the editor and as a standalone CLI.
The split between static and model-based checks is the interesting design decision. Static rules are cheap and deterministic, so running them on every save is plausible. Model rules cost tokens and are slower, so they belong at a different point in the workflow. The README does not state where that boundary sits in the default configuration, and it does not list which of the 360 rules fall on each side. If rule-level control matters to you, that is something to inspect in the repository rather than assume.
Installing it: three entry points and a manager
On Windows the README points to the Releases page for a zip named exactly neuro-book-windows-x64.zip, extracted and started with Start Neuro Book.cmd. That is the no-install path.
For multiple instances, Docker or building from source, the documented route is NeuroBook Manager. On Windows:
irm https://raw.githubusercontent.com/notnotype/neuro-book/master/scripts/install/install.ps1 | iex
On Linux or macOS:
curl -fsSL https://raw.githubusercontent.com/notnotype/neuro-book/master/scripts/install/install.sh | sh
If Bun is already present on any platform:
bunx --bun @notnotype/neuro-book-manager@canary
The installer walks through directory, port, update channel and authentication method, and runs an environment check before you confirm. The README says six deployment paths are documented, including multi-instance management, Docker and source builds, along with a SHA256 audit method for the bootstrap scripts. Note the canary tag on the Bun command: it matches the release list, where the three most recent entries are all canary builds dated within days of each other.
For agent-assisted setup or troubleshooting, the project documents an operator bridge file intended to be handed to another AI agent.
Data ownership, billing, and the AGPL-3.0 boundary
A project is stored as lorebook/, manuscript/ and world-engine/ directories holding local Markdown and TypeScript files plus a project-level SQLite database. The README's claim is no cloud lock-in, whole-project migration at any time, and openability in any editor. That is the strongest practical argument for the design: the world engine's derived state is computed, but the inputs are text you can read and diff.
Billing is itemised by input, output, cache creation and cache hit tokens, converted to dollars or renminbi, so the cost of a chapter is visible. Models come from multiple providers with your own API keys.
Licensing is AGPL-3.0. Without giving legal advice: if you only write fiction with it, the licence's copyleft obligations attach to distribution and, under the network clause, to offering a modified version as a service. If you intend to build a hosted product on top of NeuroBook, or to fork it into a commercial writing service, read the licence text and take your own advice before you start. Maintenance cost is the other side of the ledger. The release cadence shown here is days apart and every listed release is canary, so pinning to a specific build and reading the notes before upgrading is the realistic posture. There is also a SillyTavern character card import path documented as inspect, unpack, import, with the original card and worldbook archived and stable settings migrated into the lorebook.
Where NeuroBook is the wrong tool, and what to use instead
The README concedes the central limitation itself: current AI cannot independently write a good novel. If what you want is unattended chapter production, NeuroBook is the wrong shape, because its default chain assumes a human approving plans and mode switches. The same applies if you write short pieces. A world engine, a promise ledger and a decision archive are overhead that only amortises across a long work; for a 5,000-word story you are maintaining bookkeeping for nothing. The rapid-development warning is a third boundary: interfaces may change between canary builds, so anyone who needs a frozen API should wait.
The obvious alternative for the setting-management problem is Obsidian with a static vault, or a wiki-style static setting library. The difference in approach is that those store what you wrote down, while World Engine derives state from timestamped slices, so a character's condition at chapter 40 is computed rather than looked up in a note you remembered to update. The cost of that difference is modelling effort up front and a query surface you have to learn.
For prose quality alone, the narrower alternative is llmlint itself, which the README lists as an independent CLI. If the AI-flavour problem is your only complaint and you already have an editor you like, running the linter over your Markdown gets you that piece without adopting the IDE, the world engine or the agent harness.
Editorial conclusion
Adopt NeuroBook if you are writing a long work with continuity you cannot hold in your head, and you are willing to keep your project as local Markdown and SQLite. Do not adopt it if you need a stable interface now, since every recent release is a canary build, or if you want an agent to produce chapters unattended. Before committing, install through NeuroBook Manager, create a throwaway project, and check three things in the resulting workspace: whether lorebook/, manuscript/ and world-engine/ read sensibly to you as plain files, whether a World Engine subject can be rolled back to an earlier slice, and what the AGPL-3.0 network clause would mean for your own distribution.
Community notes