AI providers

JustWrite uses AI for several features: writing assistance (the scene-strip AI dropdown — Rewrite, Expand, Tighten, Continue, Describe, plus Line edits), critique, entity sweeps, and “Ask the book” chat. None of them are required — you can write an entire novel in JustWrite with zero AI calls.

If you do want AI features, you choose the provider. JustWrite isn’t locked to any vendor. It works with anything that speaks the OpenAI chat-completions protocol — cloud: OpenAI, Anthropic Claude, Google Gemini, DeepSeek, OpenRouter (one key, every major model), or any other OpenAI-compatible endpoint; local: Ollama, LM Studio, llama.cpp, vLLM, or your own deployment.

You can have several providers configured at once and route different features to different providers.

The big picture

There are two kinds of provider you might set up:

Provider kind	What it does	Examples
LLM (chat)	Writing assistance, critique, entity sweeps	OpenAI, Claude, Gemini, DeepSeek, OpenRouter, Ollama, LM Studio
Embedding	“Ask the book” chat — indexes your manuscript for question answering	OpenAI embeddings, any local embedding model

A provider can speak more than one of these. OpenAI, for example, provides LLM + embeddings in one. Anthropic, Google Gemini, DeepSeek, and OpenRouter provide LLM only. Ollama provides LLM and embeddings (locally).

Keeping content out of AI context

Every scene’s Links panel and every character / location / object / group / worldbuilding article has an Exclude from AI checkbox. Tick it and that item is left out of what the AI is sent: Ask the book and Talk to a character stop pulling it in — their search from the index’s next refresh, which Auto-rebuild does for you — and AI drafting leaves it out of the story context. Use it for spoilers you haven’t planted yet, drafts you don’t want surfaced in chat answers, or sensitive backstory the model shouldn’t read. Its name can still reach the AI where something else mentions it: your prose, another character’s relationships, a group’s member list. The flag stays with the item; nothing else changes about how you write it.

Where to set this up

Open the AI page — the Sparkle icon in the sidebar (from Settings, the “writing-AI settings live in the AI menu” note points here too). It’s organized into tabs across the top:

Providers & models — your built-in (local) provider at the top, then any providers you’ve added (where you add, edit, test, and remove), plus the Quick setup wizard, the Model catalog, and the hardware/tuning libraries. Each provider row shows a Default tag when it’s your current default, with a Set as default button.
Routing by feature — the one routing surface. Every feature points at a preset (the saved engine config: model + temperature + samplers + the Reasoning dial); features with the same settings share one, so editing a preset retunes everything that uses it. The Lab under each feature is where presets are created, tuned, and put in production.
Usage — cost and call tracking (see AI usage and cost tracking below).
Server console — the built-in engine’s live log, for troubleshooting.

Add your first provider

Most users start with one provider and add more later as needed.

Open the AI page (Sparkle icon in the sidebar).
Click Add provider.
Choose a preset (see below for the common ones) or configure manually.
Paste any API key required.
Click Test to confirm the connection works.
Save.

The connection test shows green (Online), yellow (Checking), or red (Offline). Offline usually means a wrong URL, a wrong key, or a local server that isn’t running.

Every provider also has a Timeout (seconds): how long JustWrite waits for an answer before giving up. A local model thinking at High can take several minutes, so the built-in provider’s is 900; raise a provider’s if long answers from it fail.

Want local AI with zero decisions? The Quick Setup wizard (AI page → Providers & models, the band on the Local tab) checks your machine, picks the best model that actually runs fast on it, installs the bundled llama.cpp engine, and makes it your default — nothing to install first, no Ollama, no LM Studio, no terminal (both remain fully supported as providers below if you prefer running your own server). The whole story — what it picks and why, the confirm step, parallel downloads, re-running it safely — is one section: Models → Quick Setup.

Provider walkthroughs

OpenAI (cloud)

The full-fat option. LLM + embeddings, all in one provider. Pay-as-you-go.

Sign up at openai.com and get an API key from the API keys page.
In JustWrite, Add provider → Preset: OpenAI.
Paste your API key.
Click Fetch models to populate the chat-model dropdown — common picks: gpt-5.4-mini for routine work, gpt-5.4 or gpt-5.5 for harder reasoning.
Test. Save.

You’re now wired up for every JustWrite AI feature.

Cost notes. gpt-5.4-mini and gpt-5.4-nano are inexpensive enough for routine writing assistance; step up to gpt-5.4 or gpt-5.5 for critique and entity sweeps where reasoning quality matters.

Anthropic Claude (cloud)

Excellent for writing tasks — particularly critique and longer prose work. JustWrite speaks Anthropic’s own native API. LLM only.

Sign up at anthropic.com and get an API key.
Add provider → Preset: Claude (Anthropic).
Paste your sk-ant-… key.
The default model is claude-haiku-4-5. Step up to claude-sonnet-4-6 (best price-per-quality for prose work) or claude-opus-4-8 (top of class on coding and reasoning, ~1.7× Sonnet’s input cost) for tougher tasks.
Test. Save.

When to pick Claude. Long-form prose work, structural critique, anything where you want a model that handles nuance and length well. Claude tops the major creative-writing leaderboards in 2026 (EQ-Bench, Hemingway-bench), and many writers prefer it for critique even when they use OpenAI for everything else — set Claude as the routing for “Critique” in Settings. If budget matters more than that prose edge, see Gemini below — it scores nearly as well at roughly a third the per-token cost.

Google Gemini (cloud)

Gemini through Google’s OpenAI-compatible endpoint. LLM only. Long context window — useful for whole-manuscript reads.

Get an API key from aistudio.google.com.
Add provider → Preset: Gemini (Google).
Paste your key.
The default model is gemini-2.5-flash. Swap to gemini-2.5-pro for harder tasks.
Test. Save.

When to pick Gemini. Two cases. Cost-conscious general use — Gemini 2.5 Pro is roughly a third the per-token price of Claude Sonnet 4.6 with prose scores nearly as good, so it’s the strongest value play in the cloud tier. Large-context tasks where the whole manuscript needs to be in the prompt — reverse outline, plot-hole audit, full-book sweeps. Gemini’s context window is generous compared to most peers.

DeepSeek (cloud)

DeepSeek’s native API speaks OpenAI shape. LLM only. Strong reasoning quality at a fraction of the cost of GPT-4-class models.

Get an API key from platform.deepseek.com.
Add provider → Preset: DeepSeek.
Paste your key.
The default model is deepseek-chat (V3). Switch to deepseek-reasoner (R1) for slower-but-stronger reasoning.
Test. Save.

When to pick DeepSeek. Routine writing assistance at low cost, or deepseek-reasoner for structural / critique work where you’d otherwise reach for Claude. Notably cheap per token.

OpenRouter (cloud aggregator)

One API key, OpenAI-shaped, routes to virtually every major model on the market — Claude, Gemini, DeepSeek, Mistral, Llama, GPT, and dozens more. Useful as a “single key for everything” alternative to seeding each provider individually.

Get an API key from openrouter.ai.
Add provider → Preset: OpenRouter (aggregator).
Paste your key.
Click Fetch models — the live catalogue populates the dropdown. Model ids take the form vendor/model-name, e.g. anthropic/claude-sonnet-4-6, google/gemini-2.5-pro, meta-llama/llama-3.1-70b-instruct.
Pick a chat model. Test. Save.

When to pick OpenRouter. You want to compare several models side-by-side without managing five separate API keys and billing accounts. Or you want a model that doesn’t ship with a built-in preset (Mistral, Together, Fireworks, …) — OpenRouter probably proxies it. Routing per feature (the Routing by feature tab) lets you point Critique at Claude, Writer actions at DeepSeek, and Entity sweep at Gemini, all through one key.

Ollama (local, free)

Runs entire LLMs on your own computer. No API key, no monthly bill, no data leaving your machine.

⚠ Stick with Ollama v0.24.x for now. Ollama v0.30.0 (May 2026) swapped to a new llama.cpp backend that auto-allocates GPU layers more conservatively. On cards where a model partially offloads to CPU — most commonly Qwen3:14B on an 8 GB card like the 2070 Super — this halves throughput compared to v0.24. Speaker analysis runs that took ~2 min on v0.24 take ~3.5 min on v0.30.7, and there’s no client-side knob (OLLAMA_FLASH_ATTENTION, OLLAMA_KV_CACHE_TYPE, num_gpu) that meaningfully recovers it for this workload. Verified 2026-06-10 against issue ollama/ollama#16610. Grab the v0.24.0 Windows installer from https://github.com/ollama/ollama/releases/tag/v0.24.0 if you’ve already upgraded. Revisit when a 0.31+ release notes a fix.

Install Ollama from ollama.com (pick v0.24.x — see warning above).
Open a terminal and pull a model: ollama pull llama3.1 (or qwen2.5, mistral, etc.). For embeddings: ollama pull mxbai-embed-large.
Make sure the Ollama service is running.
In JustWrite, Add provider → Preset: Ollama (native).
Base URL: http://localhost:11434 (Ollama’s default — no /v1; JustWrite speaks Ollama’s native API).
API key: leave blank.
Click Fetch models — your pulled models appear.
Pick a chat model and an embedding model.
Test. Save.

When to pick Ollama. Privacy-critical work, no internet access, no API costs. The trade-off is quality — local 7B–13B models are noticeably weaker than GPT-4-class cloud models, though they’ve improved dramatically. Try a model on a sample passage before committing.

Recommended models (as of 2026): see Choosing a local model for your hardware below for picks by VRAM tier — covers Ollama and LM Studio alike.

LM Studio (local, free, GUI)

A graphical alternative to Ollama. Same engine family (llama.cpp under the hood) but with a built-in model browser that filters by VRAM, one-click downloads, and a server tab that flips on an OpenAI-compatible endpoint. The easiest path for users who’d rather not touch a terminal.

Install LM Studio from lmstudio.ai (Windows / macOS / Linux installers).
Open the Discover tab. Browse or search for a model — LM Studio shows a green “Will fit” / yellow “Partial GPU” / red “Won’t fit” badge against your detected VRAM, so you don’t need to guess. See Choosing a local model below for picks.
Click Download on the chosen GGUF variant (e.g. Q4_K_M for the best size/quality tradeoff on most cards).
Open the Developer tab (older builds: Local Server) and click Start Server. Default port is 1234.
In JustWrite, Add provider → Preset: OpenAI-compatible (local).
Base URL: http://localhost:1234/v1.
API key: leave blank.
Click Fetch models — every model you’ve loaded in LM Studio appears.
Test. Save.

Embeddings. LM Studio can serve an embedding model on the same endpoint. Download an embedding model (nomic-embed-text-v1.5, bge-m3, or mxbai-embed-large — see the table below), load it from the Developer tab alongside your chat model, and pick it in JustWrite’s embedding-model dropdown for “Ask the book”.

When to pick LM Studio over Ollama. You want a GUI for browsing and downloading models, you’d like at-a-glance VRAM compatibility, or you want a Settings panel that exposes GPU offload / context length / KV-cache quant without editing config files. Functionally interchangeable with Ollama from JustWrite’s perspective — the choice is purely about UX preference.

Choosing a local model for your hardware

The biggest variable for local LLM quality is the model size you can fit in VRAM at a reasonable quantization. The table below is a starting point; LM Studio’s compatibility badges will give you the exact answer for your card.

Quantization quick reference. Q4_K_M is the standard size/quality sweet spot — sub-1pp MMLU loss vs full precision at ~30% of the file size. Drop to Q3_K_M only if a model otherwise won’t fit; step up to Q5_K_M or Q6_K if you have headroom and want a small quality bump.

Honest framing for the 8B tier

Older guidance (including earlier versions of this page) told 8 GB-card users that an 8B model was “fine for writer actions.” Current benchmark evidence and user testing say that’s too generous:

The Qwen3 technical report (arXiv 2505.09388) shows Qwen3-14B = 7.02 vs Qwen3-8B = 5.42 on WritingBench — a ~30% gap.
Neither dense 8B nor dense 14B Qwen3 models appear in Arena’s Creative Writing top 182 (of 363 models, June 2026) — the 8B tier isn’t competitive on prose leaderboards.
Community reports document 8B failure modes — rushing scenes, phrase repetition, voice drift — that show up within standard chapter-length generation, not just long context.

What 8B is genuinely fine for: brainstorming, outlining, single-sentence rewrites, structural one-off prompts, short-input/short-output utility calls.

What 8B underdelivers on: Continue-a-scene, Expand-with-sensory-detail, voice consistency, multi-paragraph rewrites. All of these benefit meaningfully from stepping up to 14B even if it costs partial CPU offload on an 8 GB card.

What you actually want at the prose threshold: 32B+. 14B is a meaningful step up from 8B but still not what a novelist would call “great.” For full-chapter critique and plot-hole work, route to cloud regardless of local card size.

LLM (writing assistance, critique, entity sweep)

Your hardware	VRAM	Primary pick	Notes
RTX 2060 / 3050 / 4050, RX 6600	6–8 GB	`qwen3:14b` (Q4_K_M) with partial CPU offload	8B fits cleanly but underdelivers on prose. 14B (~9 GB) needs CPU offload here, runs ~6–12 tok/s — slower but the prose quality justifies it. Keep 8B around for Brainstorm’s preset only.
RTX 2070 / 3060Ti / 3070 / 4060	8 GB	`qwen3:14b` (Q4_K_M) with partial CPU offload	Same logic. 14B at ~10–20 tok/s with offload is the honest default; route Brainstorm and Resume briefing to 8B if you want snappy responses there (see Routing heavier features below).
RTX 3060 12 GB / 4070 / 5070, RX 6700XT / 7700XT	12 GB	`qwen3:14b` (Q4_K_M) ~9 GB full-GPU	14B fits cleanly on GPU here — no offload, ~40–60 tok/s. The 24B at Q3 is a stretch option for tough analysis.
RTX 4060Ti 16GB / 5060Ti 16GB / 4080, RX 7800XT	16 GB	`qwen3:14b` (Q6_K) or `mistral-small3:24b` (Q4_K_M) ~14 GB	Either better quality on a 14B or a meaningfully stronger 24B at standard quant.
RTX 3090 / 4090 / 7900XTX	24 GB	`qwen3:32b` (Q5_K_M) ~22 GB, or `gpt-oss:20b` (Q6_K)	At this tier you’re approaching cloud-class quality for prose work.
RTX 5090	32 GB	`llama3.3:70b` (Q4_K_M) ~42 GB partial offload, or `qwen3:32b` (Q6_K) ~27 GB full	70B fits comfortably with KV-cache headroom. Genuinely competitive with `gpt-5.4-mini` on writing tasks.
CPU only, 16+ GB RAM	n/a	`qwen3:8b` (Q4_K_M) — the only realistic local option here	Expect 3–8 tok/s. Adequate for short utility calls and brainstorming; painful for prose generation, unusable for critique on long chapters. Route prose-heavy features to cloud.
Apple Silicon (M2/M3/M4)	unified RAM	Same picks as the matching VRAM tier — Macs share RAM with the GPU	On an M-series with 16 GB RAM, treat it like a 12 GB GPU (the OS reserves some). Metal acceleration is excellent in both Ollama and LM Studio.

Embedding (“Ask the book” / RAG)

Built-in — no setup needed. JustWrite’s bundled llama.cpp engine now serves embeddings itself. The first time you Build the manuscript index (or ask a question in Ask the book), it downloads qwen3-embedding-0.6b (~0.6 GB) and keeps it loaded alongside your chat model. So local “Ask the book” works out of the box — you no longer need Ollama or LM Studio just to supply an embedding model. The picks below still apply if you’d rather point embeddings at a different provider (set it in Settings → AI → Default embedding).

Embedding models are tiny (sub-1 GB) and run alongside your chat model without meaningful VRAM impact. Solid picks:

Model	Size	Context	Notes
`qwen3-embedding-0.6b`	0.6 B (~0.6 GB)	32K	Built-in default. Strong multilingual + English (higher MTEB than nomic); still tiny. Last-token pooling, set automatically.
`nomic-embed-text`	137 M (~270 MB)	8K	Lightweight English-first alternative — smallest + fastest; mean pooling.
`bge-m3`	568 M (~1.2 GB)	8K	Best multilingual quality. Pick this if your manuscript isn’t English, or for long chapters where the 8K window matters.
`mxbai-embed-large`	335 M (~670 MB)	512	Highest English quality at the price of a short context window — JustWrite chunks chapters before embedding, so the small window is usually fine.

For an 8 GB GPU running an 8B chat model: the built-in qwen3-embedding-0.6b (or nomic-embed-text if you want the smallest) is a safe choice. For 12 GB+: any of them.

Routing heavier features to a stronger model

The hardware table above tells you which model your card can run. This section is about which features deserve a stronger (or cloud) model than your local default.

All of it happens under Routing by feature on the AI page: every feature points at a preset (provider + model + settings), so “routing a feature elsewhere” means pointing its preset at the other provider and model — or tuning it its own preset in the feature’s Lab and clicking Use in production. (Quick Setup only sets your local default model; it never routes individual features.)

The pattern that works, whatever your card:

Keep short, structured tasks on your local default — Brainstorm, Resume briefing, Session recap. They’re quick calls where a local model is instant and free.
Prose generation (Writer actions) runs on the best local model you can fit — see the table above. On an 8 GB card that’s a 14B with partial CPU offload: slower tokens, meaningfully better prose (Qwen3’s own numbers put 14B ~30% above 8B on WritingBench).
Give the heavy analysis features a cloud preset when quality matters — Critique, Plot-hole audit, Reverse outline, Multi-reader panel, Character audit, Foreshadowing scan. They read long context and reward strong reasoning; on cards up to ~16 GB, cloud is meaningfully better and full-chapter runs on an offloaded local model get painfully slow. From ~24 GB up (a 32B-class local model), running them locally becomes a genuine option and cloud turns into a taste call — Claude’s editorial tone for critique, say.
CPU-only machines: keep the short tasks local and route everything prose- or analysis-heavy to cloud — CPU inference is too slow to be enjoyable there.

A worked example of exactly this setup — features, presets, and why — is in Routing features to specific providers below.

Routing features to specific providers

The default model is convenient but limiting. Once you have two or more providers, you may want to send different features to different ones.

JustWrite routes AI with one rule: every feature points at a preset (the model plus all its settings), and a feature with no assignment falls to the default preset. Features that should run the same simply share a preset — the app ships with ten, grouped by the kind of work (prose generation, editing, judgment, extraction, chat, …).

So the usual flow is: set your default provider, and on Routing by feature load a preset into the Lab to retune it (every feature sharing it follows) or Use in production to point one feature at a different preset. These are the twenty routable features:

Feature	What it does
Manuscript chat	“Ask the book” — natural-language questions about your manuscript
Critique	The structural critique modal in the editor and chapter Versions menu
Entity sweep	The AI scan that proposes new characters, locations, and objects from chapter text
Writer actions	The scene strip’s AI dropdown — Rewrite, Expand, Tighten, Continue, Describe, plus all Line edits
Brainstorm	The standalone Brainstorm workbench — ideation and short-form drafting
Resume briefing	The Home “Previously on your novel” card that orients you after a break
Session recap	The Home “Wrap up session” end-of-day recap that summarises what you wrote and pins open threads
Foreshadowing scan	The Markers view “Find dangling threads” scan that surfaces setups that may not have paid off
Reader knowledge	The Reader knowledge view’s per-chapter dramatic-irony analysis (reader vs. POV knowledge)
Voice drift explainer	The Analysis dashboard “Explain” button that diagnoses why a hot chapter’s voice differs from the baseline
Unstuck moves	The AI dropdown’s “Unstuck — five ways out” diagnostic that proposes goal shift / interrupt / setting change / reveal / time cut
Sensory research	The AI dropdown’s “Research feel…” modal — a structured sensory pack for the selected subject
Character audit	The Characters view “Audit consistency” sweep — flags actions inconsistent with each main character’s established psychology
Reverse outline	The Analysis dashboard “Reverse outline” modal — reads the whole draft and produces the act structure the book actually has
Beat sheet overlay	The Analysis dashboard “Map to beat sheet” modal — maps the draft to Save the Cat, Hero’s Journey, or 7-Point Story Structure
Plot-hole audit	The Analysis dashboard “Plot-hole audit” modal — flags contradictions, timeline issues, continuity drift, and character-knowledge errors across the manuscript
Character chat	The chat panel’s “Talk to a character” mode — first-person, in-voice answers from your cast, grounded in the manuscript
Relationship arc	The Characters view “Relationship arc” modal — chapter-by-chapter warmth / tension / power tracking for a pair of characters
Marketing pack	The Analysis dashboard “Marketing pack” modal — logline, three back-cover blurbs, one-page synopsis, three-paragraph elevator pitch
Multi-reader panel	The chapter editor’s “Multi-reader panel” critique — four reader personas (genre reader / literary critic / agent intern / book-club reader) react to a chapter in parallel

A feature with no assigned preset follows the default preset.

A common routing setup:

Default LLM: Ollama (free, local, fast for routine work)
Critique: its preset points at Claude (better at structural reasoning)
Entity sweep: on its own preset pointing at gpt-5.4-mini (cheap and reliable for this specific job)
Writer actions: inherits default (Ollama)
Manuscript chat: inherits default
Resume briefing: inherits default (a fast local model is fine here — it’s a short, structured task)
Session recap: inherits default (same reasoning — short structured output, no need for the heavy provider)
Foreshadowing scan: its preset points at Claude (long-context structural reasoning helps catch subtler setups; runs once per chapter so the per-call cost adds up — pick your battle)
Reader knowledge: same preset as the scan above (sequential per-chapter calls benefit from strong reading comprehension; a smaller model produces noisier facts)

This pattern keeps day-to-day cost near zero and only spends on the two features where cloud quality genuinely matters.

AI usage and cost tracking

If you use cloud providers, the AI page’s Usage tab tracks what you’ve spent (the command palette’s AI usage opens it):

Aggregate counters: total calls, total tokens, estimated cost in USD
Breakdown by feature (chat, critique, entity sweep, writer actions)
Breakdown by provider
A searchable log of recent calls with timestamps, models, and token counts

Local providers always show $0. The cost figures for cloud providers come from a built-in price table — they’re estimates, not invoices.

A Reset ledger button clears the log so you can start a fresh accounting period.

Engine parameters and advanced settings

When editing a provider, you can:

Add a custom system prompt — overrides JustWrite’s default system message for that provider. Advanced.
Adjust temperature and other generation parameters through the engine parameters block.

These are optional refinements. The defaults are reasonable for almost every case.

Loaded models & GPU memory (built-in engine)

The bundled engine can keep more than one model in GPU memory at once — for example your chat model and the small embedding model that powers Ask the book — so it doesn’t have to reload a model every time you switch tasks. When you Edit the Built-in provider, the Local engine card shows a Loaded models panel with:

What’s loaded right now — each model the engine is holding and its state: loaded and ready, sleeping after sitting idle, or an error if a model failed to start (a failed model stays listed here so you can see what went wrong instead of it vanishing silently), plus how much context and GPU memory each one is using.
GPU memory in use — how much of your graphics card’s memory is currently committed versus free, so you can see how much headroom is left for another model. (Shown only when a GPU with detectable memory is present.)

Two settings let you tune this to your card:

Models kept loaded at once — how many models may share GPU memory together. On a small card, set this to 1 so only one model is loaded at a time (each new one replaces the last); on a card with plenty of memory, a higher number lets your chat and embedding models stay ready side by side. Default: 2. (If you enter less than 1 it’s raised to 1 — the engine always keeps at least one model available.)
Unload an idle model after (seconds) — how long a model sits unused before the engine frees its memory. Set it to 0 to keep models loaded until something else needs the room. Default: 900 (15 minutes).

Change either value, then click Save; the new limits apply the next time a model loads.

Seeing which model a feature runs on

“I’m in the Critique modal — which model is this actually about to use?”

Every AI page has a small chip in its header showing the current provider · model for that feature. Critique, Brainstorm, every analysis modal, Reader knowledge, the chat panel — same chip in each. In the chapter editor, the chip sits at the top of each scene’s AI dropdown, so writer actions (Rewrite, Expand, Tighten, Continue, Line edits) show their routing right above the menu items they apply to.

On most surfaces the chip is read-only — a “runs on” indicator; clicking it opens the AI page, where Routing by feature is the routing editor. The two chat chips (Ask the book / Talk to character) go one further: clicking them opens a small edit popover where you can change that feature’s model and Reasoning level in place — the popover names the preset it edits and how many features share it before you save.

Analysis modals wait for you. When you open Multi-reader, Entity sweep, Foreshadowing, Plot-hole audit, Reverse outline, Marketing pack, Character audit, Sensory research, Session recap, Stuck diagnostic, or AI-tell scan, the modal opens to an empty-state with a primary “Run” button instead of firing the AI call immediately. That gives you a chance to check the routing chip first — and change it on the AI page if you want a different model — before spending tokens. Click the Run button when you’re ready.

Watching AI calls

“I asked for a critique five minutes ago. Is it still working, or did it freeze? I switched to another chapter to keep writing and now I can’t tell what’s going on.”

Anything in JustWrite that calls an AI — critique, brainstorm, plot-hole scan, “Ask the book”, every writer-assist rewrite — registers as a task that you can monitor from anywhere in the app. The sparkle icon in the title bar is the doorway.

The header chip. A small sparkle icon sits in the title bar. When no calls are in flight it’s quiet. When something is running, it gets a pulsing dot and a number showing how many tasks are active. Click it to open the full AI task panel from any screen.

What the panel shows you, per task:

The task’s name (e.g. “Chapter critique notes · Ch. 7”) and feature.
Status phase — Connecting before the first token arrives, Thinking while a thinking model reasons before its answer (on the built-in and OpenAI-compatible providers, since 2026-10-06), Streaming once the answer comes.
Elapsed time — live, in seconds.
First-token latency — how long the model took to respond at all. Useful for local models that sometimes need to load before the first token; a 30-second first-token delay on a small model usually means it’s still warming up.
Tokens — exact count once the call completes, approximate during streaming. A thinking model’s reasoning counts too — the model’s own count includes it.
Tokens per second — how fast the model is producing output.
A freshness indicator — the single best signal for “is this stuck, or still working?” It calibrates to the model’s own measured pace rather than a fixed clock, so a slow local model’s healthy multi-second gaps don’t read as trouble:
- Live (green) — tokens arriving at this model’s usual rhythm.
- Stalling (gold, blinking) — the current silence is running well past this model’s usual gap.
- Stuck (red, blinking) — far past it. Almost always means cancel and try again.
A preview toggle — expand to see the assistant’s streaming text in real time as it’s produced.
Cancel — abort the call immediately. Cleaner than closing a modal mid-stream.

Tasks survive navigation. This is the headline. Start a critique on Chapter 7, navigate over to Worldbuilding to check a fact, hop into the Plot Board — the call keeps running. When it finishes, the result lands wherever it was supposed to (the critique on the chapter, the entity sweep proposals, etc.). Closing a modal that was waiting for an AI call no longer cancels the call — the call decouples from the modal’s lifecycle.

Finished tasks stick around to be read. A task that ends doesn’t vanish — it moves to the panel’s Recent section and stays visible for a moment: a completed task for about five seconds, a cancelled one for about three. A failed task stays until you dismiss it with its ✕ — the error text sits right on the row, so a failure can’t slip past you just because you weren’t looking when it happened. (The red count on the sparkle chip clears when you open the panel; the failed row itself waits for you.)

Recent history. Below the just-finished rows, the panel lists the last 50 completed (or cancelled, or failed) tasks with duration, tokens used, and outcome. Useful for spot-checking which model produced which result, or for noticing that your local Ollama keeps timing out on the same feature.

Dismissing the panel. Esc, the Close button in the panel header, clicking the chip again, or clicking anywhere outside the panel.

Why this matters for a writer. Long AI calls — especially on local models, especially on the bigger analysis features — used to be opaque. You’d click Re-analyze, wait, and have no idea whether to keep waiting or give up. The freshness indicator answers that question directly: a green “live” dot means trust the wait; a red “stuck” dot means cancel and try a different model. And because the calls survive navigation, you’re not penalised for switching screens mid-call to check something else.

Something not working? Provider tests, slow models, surprise bills, hung calls — the answers live on Troubleshooting (moved there 2026-08-08 so the family has one troubleshooting page per app).