Where your prose goes

Every serious writer has a version of the same question — if I put my manuscript into this thing, does my manuscript stop being mine? Is an AI provider going to steal my work or use it to train their AI?

If that's you, this page is for you. It contains enough detail that you can decide what's right for you.

The short version: nothing about your writing leaves your computer until you use an AI feature. Reading, editing, saving, exporting, backing up — that's all local. The AI features are the interesting case, and they're what the rest of this page is about.

DIfferent kinds of AI work, different answers

When you invoke an AI feature — asking the Muse a question, having the Coach draft an outline, running the Editor over a scene — Mythos sends the AI what it needs to do the job. But there are different kinds of jobs, and they share different amounts of your text.

Generation Jobs. The AI reads text and writes text back. The Muse's answers, the Coach's proposed outlines, the Editor's flags, the timeline / Codex / Atlas scans, and the AI grammar pass are all this. For each of these, Mythos sends only what the feature needs to reason about: a scene, a chapter, a paragraph, a Codex entry — never your whole project or manuscript all at once. What comes back is what shows up in the app.

Indexing, Knowledge Base Jobs. For the Muse to answer questions about your project, the app automatically builds a Knowledge Base, unless AI services have been turned off. The Knowledge base is a searchable and queryable index of what you've written. That exists as a set of fingerprints stored as large sets of numbers; one fingerprint per chunk of prose. The fingerprints are what Mythos stores and what your computer and the AI understand. The chunks of text themselves — roughly a paragraph at a time — are what it briefly sends to have the fingerprints created. This happens once when you first open a project, and again quietly as you edit. The fingerprints stay on your computer. The chunks pass through whichever AI provider you have configured to compute them.

The difference matters because you configure the two jobs independently, per service, in Settings → Muse. It's completely reasonable to pair, say, Anthropic's Claude for chat with a local model for indexing — so your prose is never sent over the network just to be turned into search fingerprints.

How the knowledge base is built

The first time you open a project, and again whenever you edit meaningfully, Mythos rebuilds its knowledge base:

• Your chapters get split into small chunks — roughly a paragraph at a time — on your computer. Nothing crosses the network here.
• Each chunk is sent, one at a time, to your embedding provider. The provider returns a fingerprint — a list of numbers. One chunk per request; your work is never uploaded in its entirety or as a single file.
• The chunk and its fingerprint are written to your project's local knowledge base. From that point on, when the Muse needs to find passages relevant to your question, it searches those fingerprints locally.
• Nothing about the chunk lives at the provider afterward, except whatever their standard API terms retain — typically a few weeks for abuse monitoring, then deleted. See the provider policies below.

Cumulatively, over an initial index of a full novel, every paragraph passes through your embedding provider one at a time, spread over a few minutes or hours depending on how long your manuscript is. That's the honest description — it's not "your whole manuscript is uploaded," but "every paragraph is briefly seen" by the AI provider so it can be converted, one piece at a time, into mathematical fingerprints your computer can search.

If that's not acceptable for your project, use a local embedding model (see Locking things down below) — no prose ever crosses your network or leaves your machine at all when the knowledge base is built.

One reassurance about the fingerprints themselves: they're just numbers. Given only the fingerprint, no outsider can reconstruct the text it was created from. That's why the fingerprint can safely live in your local knowledge base for years without becoming a risk.

What each AI feature actually sends

Once the knowledge base is built, day-to-day use sends much less than the initial indexing did. Here's what each feature sends when you invoke it:

• The Muse (chat). Your question, the passages the app found relevant (up to 10 chunks; the model asks for what it needs), and the recent chat conversation.
• The Muse (inline commands like @chat). The paragraphs immediately around your cursor, your instructions, and any Codex entries you referenced.
• The Coach. The chapter or scene you're asking about, plus the Codex entries and beat notes it needs to reason about them.
• The Editor. The scene it's reviewing, plus the small window of Codex / timeline context that lets it check for continuity.
• Summaries / Craft Passes. If you trigger a craft pass from the top-level AI menu, the document you're on is split into paragraph-aligned chunks of ~5,000 to 6,000 words, and each chunk is sent in turn until the whole document has been reviewed. If your manuscript is one document per chapter, this may send an entire chapter.
• Timeline / Codex / Atlas scans. The chapter being scanned. One chapter per request. Never automatic — you press the button.
• Corrections. The rule you're teaching and the sentence it applies to.
• The AI grammar pass in Proofing. The paragraph you asked to be checked.
• Image generation. Your text prompt only. Not your prose.
• The Game Table (RPG mode). Current game state — dice rolls, moves — not your novel.

The pattern: generation features send enough context to do the specific job you asked for, and never anything else.

The one background exception

There is one AI feature that runs without you explicitly pressing a button: the Editor's craft-pass reviewer. When you pause writing for about twenty seconds inside a chapter, the Editor can quietly perform one of its review passes on the document you're actively working on — never anything else, never your whole project. Each recipe has a long cooldown so it doesn't repeat itself, and the whole thing is gated on the AI subsystem being enabled.

If you'd rather it never fire, disable the Editor's specific services under Settings → Muse — or flip the AI kill switch and the whole subsystem stands down.

AI providers, and what they say they do

You pick your providers in Settings → Muse. Each provider has its own published policy for how it treats data sent to its API — an API is a program on a remote computer that other applications talk to, over an encrypted connection, in a language both understand.

These are honest, current summaries as of July 2026. Policies change; the linked pages are always the source of truth if you need to be sure.

Anthropic (Claude) +

Anthropic's API terms state that inputs and outputs are not used to train Anthropic's models by default. Data is held for up to 30 days for abuse detection, then discarded. Enterprise Zero Data Retention agreements are available for organisations that need it.

This applies to API access — different terms apply to the consumer claude.ai product. Anthropic does not currently offer an embedding endpoint, so if you use Claude for chat you'll need a second provider (or a local model) for indexing.

Current terms: anthropic.com/legal and privacy.anthropic.com.

OpenAI +

OpenAI's API terms state that traffic is not used to train OpenAI's models by default — a policy in place since March 2023. Data is held for up to 30 days for abuse detection; Zero Retention is available for eligible customers.

This is the API — ChatGPT (the consumer product) has different, more permissive terms unless you opt out in its Data Controls, so a ChatGPT subscription is not equivalent to an API key.

Current terms: openai.com/policies.

Google (Gemini) +

Google's Gemini API distinguishes between the free tier and the paid tier. On the free tier, prompts and responses may be used to improve Google products. On the paid tier they are not. If you're on the free tier, treat everything you send as material Google may retain.

Current terms: ai.google.dev/gemini-api/terms.

xAI (Grok) +

xAI's stated policy is not to train on API inputs or outputs without explicit permission, and to hold data 30 days for auditing before deletion. xAI also offers a Zero Data Retention option available to all customers; enabling ZDR does not affect Mythos in any way.

To enable ZDR: sign in to console.x.ai, click the settings cog at the bottom-left, open the General page under Team, and toggle Zero Data Retention (ZDR) on.

Current terms: x.ai/legal/privacy-policy. ZDR details: docs.x.ai · Zero Data Retention.

Local (Ollama, LM Studio, any local endpoint) +

These AI models run entirely on your machine. None of your data — none of your writing — gets sent anywhere, for any Mythos AI service configured to use a local model. There's no policy to explore because there's no service — you are the operator.

The trade-off is speed and quality: local models are usually smaller and slower than frontier cloud models, and this shows up most in the Coach's structural work and the timeline / Codex / Atlas / Editor scans. But for indexing — turning chunks into fingerprints — local models are often close to indistinguishable from cloud ones.

Locking things down

The controls, from strongest to weakest:

Use a local model for everything

Install Ollama or LM Studio, download a chat model (Llama, Qwen, Mistral — for RPG designers we recommend a larger coder model like Qwen 2.5 Coder 32B) and an embedding model (nomic-embed-text, bge-m3, bge-large, mxbai-embed-large — the model library will offer several), add it in Settings → Muse, and configure every Mythos AI service to use that local provider. In this configuration, no prose ever leaves your computer for any AI job. This is the most privacy-conservative way to use Mythos, and the app was designed to support it.

Use a local model for indexing, cloud for chat

This is the sweet spot for many writers. Cloud models are noticeably sharper for structural work, but indexing sends much more prose over the wire than chat does. Pair Claude, GPT, or Grok for the chat agents with local extraction and embedding models, and you get the best of both worlds — sharp reasoning where you need it, no prose crossing the network for the routine fingerprint work.

Pick your provider deliberately, and turn on No Fallback

For each AI service, enable No Fallback in Settings → Muse to prevent Mythos from silently routing to a different provider if the configured one is unavailable. If you do this, Mythos never routes behind your back — whatever you've selected is what gets used. If you only trust one provider, only add that one's key and disable the rest.

Prefer paid keys on any provider whose free tier trains

Gemini is the main one to watch.

Only invoke what you need

The AI grammar pass, image generation, and the timeline / Codex / Atlas scans all trigger from a specific action you take. If you don't invoke them, they don't run.

What Mythos itself does and does not do

Independent of which provider you pick:

Your projects are local files on your disk. If you want them on multiple machines, that's your Dropbox / iCloud / Google Drive choice, not something Mythos manages. Please note that storing a Mythos project on a cloud drive that continually syncs changes to the cloud, like Dropbox/iCloud/Google Drive or OneDrive is likely to result in poor Mythos performance.

If none of this is enough

The most privacy-conservative configuration is this: install local models, don't add any cloud provider keys, and optionally disable image generation which sends only your typed prompt and does not share any of your data. In this configuration, no project data ever leaves your computer. Some testers use Mythos exclusively this way, and every feature that can work with a local model still works, but will be slower than using a cloud hosted model.

If you enable the iPad companion, your data will travel over your local network from the desktop Mythos app to the iPad. The iPad app connects to the Mythos app running on your computer and uses the same application and AI configuration as the desktop application, so if you've configured a local-only setup, nothing leaves your local network.

If you're still not sure what a specific feature sends, the fastest way to find out is to run it against a tiny throwaway project — one chapter, three Codex entries — while watching your provider's API dashboard. Whatever shows up there is exactly what left your computer.

Last reviewed July 2026. If you spot something out of date, please open an issue.