1667 review 2026: honest scoring on the branching take-tree, local-first privacy, model support, terminal UX, cost, and fit for fiction writers.
For its narrow purpose, 1667 is one of the more thoughtful AI writing tools to appear in a while: a free, open-source terminal app that keeps every AI take on a branching tree, runs on your own keys, and stores everything locally with no telemetry. It earns its lead as a private, branch-first drafting environment. Its limits are scope and maturity: it produces a text manuscript only — no graphics, video, or publishing — and it is early software below 1.0. For a novelist who wants to draft, it is a strong, low-risk pick; for anyone who needs to turn writing into a published audience, it is only the first step.
1667 is the tool a certain kind of writer will love on sight and everyone else will scroll past, and that's fine — it's built for the first group on purpose. Posted to Hacker News on August 17, 2026, it is a free, open-source terminal app for writing fiction with language models. Instead of a chat box, it gives you a full-screen keyboard-driven workspace where you ask a model for the next paragraph and it keeps every take on a branching tree you can walk back through. This review scores it as what it is: a private, local drafting environment for fiction, not a content or publishing tool, because grading it against the wrong job would be unfair.
The core idea is genuinely good. Most AI writing tools make you accept or regenerate a suggestion in place; 1667 treats the story as a tree, so you can try "what if the detective takes the case" and "what if he doesn't" and keep both, following one path while the alternates stay parked as siblings to revisit and re-branch. Around that sit a set of decisions that reflect a writer's real anxieties — "your keys, your endpoint, your files on your disk," no analytics or account, local files with optional vault-password encryption, and OS-level locking per project. It is model-agnostic (any OpenAI- or Anthropic-compatible endpoint, plus local runtimes like Ollama and LM Studio), imports from Markdown, SillyTavern, and character cards, and exports the chosen path to Markdown.
I score it on the dimensions that fit a fiction-drafting tool: the branching take-tree, privacy and local-first design, model flexibility, the terminal writing experience, import/export, value, and maturity — plus, honestly, format range and distribution, where it scores low because it makes a manuscript and doesn't publish it. Where it competes — a private, branch-first place to draft — it competes well and cheaply. Where it frustrates — early-software rough edges, a terminal-only learning curve, and a hard stop at exported Markdown — I mark it down.
Everything below reflects 1667's public state as of 2026-08-17, drawn from 1667.ai and its GitHub project. It is early software with sub-1.0 version numbers, so features and stability are still moving; verify current details before relying on it.
1667 is a free, open-source, full-screen terminal application (a TUI) for writing long-form fiction with language models. You ask a model for the next paragraph and it keeps every take side by side on a tree you can walk back through, letting you branch a scene into alternates, follow one path, and return to the others later. Navigation is entirely keyboard-driven — space to continue, Enter to compose, arrow keys to flip between takes — and the story can be viewed as a single path, a full tree, or a "mass" map weighted by word count. It is built around author control and privacy: your own model keys and endpoint, files stored locally in a .1667/ directory with optional at-rest encryption, no telemetry or account, and one-writer-per-project locking. It is model-agnostic, working with any OpenAI-compatible or Anthropic Messages endpoint and shipping presets for OpenAI, Anthropic, OpenRouter, Ollama, LM Studio, llama.cpp, and KoboldCpp, so drafting can run on a hosted frontier model or a local one at no per-word cost. It imports from Markdown, SillyTavern chats, and character cards and exports the chosen path to Markdown, and it is Apache-2.0 licensed with installers for macOS, Linux, and Windows plus an npm package. What it deliberately does not do is anything after the manuscript: no graphics, carousels, or images; no video; no captioning or per-platform sizing; no scheduler; and no publishing to any channel.
1667 fits novelists and hobbyist fiction writers who are comfortable in a terminal and want a private, branch-first way to draft with AI — especially those wary of their original writing leaving their machine, since it runs on their own keys with local files and no telemetry. If your deliverable is the manuscript and you value exploring alternate story paths without losing any of them, it's an excellent, essentially free fit. It's a weak fit for content marketers, non-fiction operators, or anyone whose real job is publishing across feeds: the output is a Markdown file, there's no media generation or governed marketing copy, and there's no scheduler or publishing. Writers who want a polished GUI or a gentle onboarding will also find the terminal-only, early-software nature a barrier.
| Dimension | Score | Why |
|---|---|---|
| Branching take-tree drafting | 4.5 / 5 | Keeping every AI continuation as a sibling you can revisit and re-branch is a genuinely novel, well-considered model for exploring a story. |
| Privacy & local-first design | 4.7 / 5 | Your own keys and endpoint, local files, optional at-rest encryption, and no telemetry or account make it a strong fit for original work. |
| Model flexibility | 4.5 / 5 | Any OpenAI- or Anthropic-compatible endpoint, plus local runtimes like Ollama and LM Studio, means no lock-in and a zero-marginal-cost local option. |
| Terminal writing experience | 3.9 / 5 | Keyboard-first and distraction-free for command-line writers, but the TUI carries a learning curve and won't suit everyone. |
| Import & export | 3.6 / 5 | Imports Markdown, SillyTavern, and character cards and exports the chosen path — useful, but export is Markdown-only, so formatting and publishing happen elsewhere. |
| Value for money | 4.8 / 5 | Free and open source with no server; you pay only your model provider, or nothing running locally — hard to beat on cost. |
| Maturity & stability | 3.0 / 5 | Early software with sub-1.0 version numbers; the core works but features and polish are still settling. |
| Format range & distribution | 1.8 / 5 | Produces a text manuscript only — no video, images, carousels, captions, scheduler, or publishing. |
1667's pricing is the easy part: there isn't any. It is Apache-2.0 open source with no paid tier, because there is no hosted service to fund — you run it on your own machine, against your own model keys, and pay only whatever your provider charges for the drafting tokens. Run a local model via Ollama or LM Studio and even that cost disappears, making a full first draft achievable at zero marginal spend. For a category where subscriptions of $20–$60/mo are common, that's a genuinely strong value position, and the open-source license means no vendor can revoke access or change the terms out from under you.
The honest caveat is that "free" here buys a drafting tool, not a content stack. The price reflects the scope: 1667 does one thing and stops at a Markdown file. A writer who also wants their work formatted into a book, cut into video, designed into launch graphics, or published to feeds is looking at additional tools — some paid — layered on top. So the real cost of going from a 1667 draft to a launched, marketed book isn't the app; it's everything downstream of it.
Judged on its own terms — a private, local, AI-assisted fiction drafting environment — 1667 is priced perfectly, which is to say generously. Judged as the whole toolkit a working author needs, it's the free first component, and the rest of the stack is where the money and effort go. The fair read is that 1667 removes cost as a reason not to try AI-assisted drafting, and the value question moves entirely to the parts it doesn't touch.
| Use case | Fit | Why |
|---|---|---|
| Drafting a novel with AI | Strong | The branching take-tree and keyboard-first canvas are exactly what the tool is built for. |
| Private, local writing on your own models | Strong | Your own keys, local files, optional encryption, and no telemetry suit writers protecting original work. |
| Exploring alternate story paths | Strong | Keeping every take as a sibling on the tree lets you branch scenes without losing any version. |
| Running a local model at zero per-word cost | Strong | Presets for Ollama, LM Studio, llama.cpp, and KoboldCpp make free local drafting straightforward. |
| Formatting and publishing a finished book | Weak | Export is Markdown-only; ePub/print formatting and store publishing are separate jobs. |
| Turning writing into multi-format social content | Weak | No video, carousels, quote cards, or governed marketing copy — the output is plain text. |
| Scheduling and publishing across platforms | Weak | There's no captioning, no scheduler, and no publishing — the workflow ends at a Markdown export. |
It's tempting to line 1667 up against Kompozy head-to-head, but they're measured with different sticks and it's more useful to say so plainly. 1667 is a fiction drafting environment: its unit is a manuscript, written privately and locally on a branching tree, and at that specific job — cheaply, with a real respect for author control — it's a well-made tool. If your deliverable is the writing itself, it's a good pick and I won't dress that up.
Kompozy is a content generation and publishing engine, and the two barely overlap: Kompozy doesn't draft novels, and 1667 doesn't make media or publish. The connection is sequential, not competitive. Where 1667 stops — an exported Markdown chapter — is where Kompozy starts: it atomizes that writing into a brand-exact Carousel, Quote Graphics from your best lines, an Infographic, native Text Posts, and an Email Newsletter drop, and — because it generates rather than just writes — turns an excerpt into a Persona Short or Persona Frames video where a face-locked author avatar reads it to camera. Then it schedules and publishes the set across the eight social platforms plus blog and email, each post held to an author-brand Persona Brief. So the honest read isn't "which is better," it's "which job." For drafting the fiction, 1667. For building the audience that reads it, Kompozy. A writer could happily do both — write in the terminal, then publish everywhere — and there's a deeper side-by-side at /alternatives/1667.
For drafting fiction with AI in a private, local, branch-first way, yes — and since it's free and open source, the only cost is your model provider (or nothing running locally), so the risk is minimal. It's not worth it if what you actually need is to format, market, or publish the writing, because it makes a Markdown manuscript only, with no graphics, video, scheduler, or publishing.
Branch-first drafting. Its standout is keeping every AI take on a tree you can walk back through, so you can explore alternate story paths — kill a character in one branch, spare them in another — without losing any version. Paired with local-first privacy and model-agnostic support, that makes it a strong private novel-drafting environment.
It produces text only — no video, images, carousels, or launch graphics; there's no captioning, scheduler, or publishing; and export is Markdown-only, so book formatting and distribution happen elsewhere. It's also terminal-only with a learning curve and early software below version 1.0, so polish and stability are still settling.
Nothing for the app — it's Apache-2.0 open source with no paid tier and no server. You pay only whatever your chosen model provider (OpenAI, Anthropic, OpenRouter, etc.) charges for drafting, or nothing at all if you run a local model via Ollama or LM Studio.
Any OpenAI-compatible or Anthropic Messages endpoint. It ships presets for OpenAI, Anthropic, and OpenRouter, plus local runtimes Ollama, LM Studio, llama.cpp, and KoboldCpp, and a custom endpoint — so you can use a hosted frontier model or run one locally.
That's a core design goal. It runs on your own keys and endpoint, stores files locally with optional vault-password encryption, uses per-project locking, and ships with no analytics, telemetry, or account in the source. Your drafts stay on your machine unless you send them to a hosted model you've chosen.
No. It exports the chosen path to Markdown and stops there. To turn a finished chapter into launch content — teaser carousels, quote cards, an excerpt-reading video, and a newsletter, published across nine platforms — bring the exported text into Kompozy, which is built for exactly that second half.
For the drafting itself, NovelCrafter is a browser-based peer, and general assistants like ChatGPT or a local model via LM Studio can draft too. For creators whose real need is a published, multi-format week rather than a manuscript, Kompozy is the alternative: it repurposes the writing into video, images, and carousels and publishes across nine platforms. There's a deeper side-by-side at /alternatives/1667.