Local AI with Ollama

What is "Local AI"?

The Companion is the floating avatar that chats with you, reacts to what's on your screen, and can set off effects. Something has to generate her words. You get to choose what.

Pick one under Companion → AI Brain → Provider:

• Off - no AI at all. She still works, but falls back to pre-written lines.
• Cloud - the default. Your chat lines go to a small server we run, which passes them to a hosted model. No install, but you need a free account, and there's a daily cap (100 messages a day free, 1000 for Patreon supporters).
• Local (Ollama) - the subject of this page. A model runs on your own computer via Ollama. Nothing leaves your machine, no limits, no login. You pay in disk space, memory and patience instead.
• Custom (OpenAI-Compatible) - point the app at any endpoint that speaks the OpenAI chat API. You supply the URL, the model name and (if it needs one) an API key, which is stored encrypted on your machine. Handy for a self-hosted server or a third-party provider. Effects work here too.

All four options plug into the same slot inside the app, so every feature that talks to the Companion - chat, screen awareness, video reactions, lock screen, keyword catches - behaves the same whichever you pick. Switching takes effect on the next message. No restart.

Why local instead of cloud?

Local AI is worth the setup if any of these matter to you:

• Privacy. Chat lines, screen context, your persona - none of it goes over the internet. The model sits in %LOCALAPPDATA%\Programs\Ollama and answers on http://localhost:11434/, which is your own computer talking to itself. Once setup is done the app makes no AI-related network calls at all.
• No daily limit. The cloud option caps requests so the bill stays sane. Local is capped only by how fast your hardware is.
• No login. Cloud needs an account. Local doesn't.
• You pick the brain. Want a bigger model? A roleplay-tuned one? Something with fewer manners? Pull a different one and point the app at it.
• Works offline. Once installed, it runs with the network unplugged.

The costs are real, so know them up front:

• Disk. The default model is about 6.6 GB. Larger ones run to 20-40 GB.
• The first reply is slow. The model has to be read off disk into memory before it can say anything, which takes roughly 30-60 seconds for a mid-size model on a CPU. The app quietly does this at startup so you rarely feel it, but the very first message after a fresh install still takes a beat.
• Speed depends on your hardware. With a decent graphics card, replies land in 1-3 seconds. On a CPU-only laptop, expect 10-20 seconds.

Architecture at a glance

Skip this section unless you're curious about the plumbing. Everything to do with the Companion's brain lives under Services/AIService/:

The rest of the app never talks to a provider directly. It talks to AiServiceStrategy, which checks your provider setting on every call and builds whichever one is needed, the first time it's needed. That's why switching is instant.

One real difference between them: the cloud provider forgets you between messages by design (every request carries the full prompt, the server keeps nothing). The local provider keeps a running conversation in memory and on disk, so she can remember you across sessions.

The setup wizard, step by step

Choosing Local (Ollama) for the first time opens the setup wizard. It's one window that takes you from nothing installed to a working model. Here's what it does at each stage, in case you want to know before you click.

The request lifecycle

Here's the whole journey of one message, from your keyboard to her speech bubble. Screen-awareness reactions, video comments, lock-screen lines and keyword catches all take the same route with different inputs.

One at a time

Only one request can be in flight at once. What happens to the second one depends on who asked:

• You, while she's busy - the message is dropped, but you get a random "still thinking" line back (for example "Bambi's thinking real hard right now...") so you aren't left staring at nothing. Mods can supply their own.
• The app, while she's busy (a screen reaction, a video-finished comment) - dropped silently. Better to miss one passive comment than to have her fire off three stale ones a minute later.

Nothing goes stale

The system prompt is rebuilt from scratch on every single message. Change your persona, your knowledge base, your mod or your content mode and the next thing she says already reflects it. No restart, no clearing history.

Failed messages don't stick

If a request errors out or comes back empty, your message is removed from the history again, so a dead turn doesn't sit there confusing every future reply.

Why we turn off "thinking"

Some models reason out loud to themselves before answering. It's genuinely useful for maths problems and completely useless for banter, where it just adds 30-50 seconds of silence. The app asks every model to skip it. Models that don't have a thinking mode ignore the request.

How the persona is built

"System prompt" is just the briefing she gets before every conversation: who she is, what she knows, and how to behave. It's stacked up from several layers, and it's identical whether you're on cloud or local. From the outside in:

1. Character. The "Bad Influence Bestie" description: how she talks (casual, texting), what she's into (makeup, pink things, empty heads), and what she's for (talking you into being blank). If Slut Mode is on and your chosen personality has a Slut Mode version, that one is used instead - same character, filthier.
2. How she handles explicit talk. Flustered redirect rather than full roleplay, by default. Each personality can override this.
3. What she's allowed to recommend. The audio playlists and videos in your library, with firm instructions to use the exact titles, because that's how the app turns a mention into a working link.
4. Your own links. Anything you've added to the Knowledge Base Links list: extra videos, content packs, your own files.
5. Your HypnoTube pool, if you set one up. Names get matched against known links so she can offer them as clickable.
6. Screen awareness rules. How to respond to what you're doing - work, social, shopping, streaming, hypno content, idle. She receives it as a short tag like [Category: X | App: Y | Title: Z | Duration: N].
7. Length limits. Roughly 15 words, one emoji, no stray tags in what you actually see.
8. Your quiz result, if you took the in-app quiz. She gets your archetype and a short profile, and is told to work it in naturally about a fifth of the time.
9. Mod renaming. If your mod calls you something else ("Bambi" becomes "Unit" in Drone mod, or whatever you chose in Sissy Hypno mode), the whole prompt gets a find-and-replace pass at the end.

Each layer is separately editable. Rewrite the character and keep the library intact, or the other way round.

The enrichment block and structured output

If you want her to actually do things instead of just talking about them, she needs a way to say "and also, flash an image". That's what the enrichment block is for.

When "Allow AI to control effects" is on, the app slips an extra message in right after her character briefing. It's marked [CONTEXT BLOCK - NOT DIALOGUE] so she treats it as instructions, not as something you said to her.

It pins down the reply format

The block states plainly that this format beats any earlier instruction. That matters: plenty of community personalities include a strict "reply with plain text only, no tags, no JSON" rule, which would otherwise fight with the effect format. The override settles the argument, and the response field is the part you see.

It says when to fire

The block lists what she can trigger and gives examples of what should set each one off:

Just as importantly, it tells her to leave the effects list empty when you're only chatting. Don't fire unprompted. That instruction, plus the permission switches further down this page, is what stops her spraying flashes at you mid-conversation.

It hands her the current context

Two small blocks close it out:

The timestamp gives her a sense of when "now" is. The data block is assets/knowledge.json, a flat list of things she's allowed to know: terminology, names, lore. If the file is missing she just gets an empty list.

It sets some manners

• Keep the spoken part short. The character's word limit still applies.
• Don't parrot the request back.
• If you do fire something, mention it ("Flashing for you, hot stuff~").
• Never start a video unasked. Videos take over the screen.

Effect commands: letting the AI control the app

There are 11 things she can trigger (plus a "do nothing" option the app ignores):

Reading messy replies

The part of the app that reads her reply is deliberately forgiving, because local models are messy. They wrap things in code fences, mix prose and data, leave trailing commas, close brackets in the wrong place. So:

• Code fences are stripped off.
• A clean, well-formed reply is used as-is.
• Otherwise the parser hunts through the text for anything bracket-shaped, tries each one, uses the spoken part if it finds one, and collects any effects along the way.
• A repair pass fixes trailing commas, mismatched brackets and unquoted names before it gives up.
• A final clean-up strips any [Category: ...] or [Mode/Tag] labels she copied out of her own briefing.

What happens to each command

1. Check it against your settings: the master switch, then the switch for that specific effect.
2. Enforce the limit of 3 commands per reply.
3. Write a plain-English line to the Live actions feed on the Companion tab, so you can see what she did.
4. Build and run it.

The 3-per-reply limit is not negotiable. If a model emits five flashes in one breath - and some do - only the first three happen. Scheduled follow-ups have their own limit too: she can only chain two deep, so she can't set herself an infinite reminder loop.

Safety: permissions, caps, and the master toggle

The defaults are cautious on purpose. Turning on local AI does not give her the run of your machine. She can't fire a single effect until you say so, and the loudest ones stay off until you go and switch them on individually.

You'll find these on the Lab tab, in the AI effects & memory card: Effect control is the master toggle, and the per-effect switches sit under Effect permissions beneath it. The Lab is a Prime Subject tab, so effect control needs that tier - local chat itself does not.

Four checks stand between the model and your screen, in this order: the master switch, the switch for that effect, the 3-per-reply cap, and finally a clamp on the numbers in the command itself. Even a model that has gone completely off the rails can't do real damage - the worst case is a log full of refusals.

Persistent chat memory

Local AI remembers your conversation between sessions. The cloud option can't - it's stateless on purpose - so this is one of the more noticeable differences in daily use.

• Each completed exchange is added to the running conversation.
• It's written out to %LOCALAPPDATA%\ConditioningControlPanel\local_chat_history.json in the background, so saving never slows down a reply.
• Next launch, it's read back in. Her character briefing is not saved - that gets rebuilt every time, so any edits you make apply immediately.

The file holds the last 50 exchanges. Older ones drop off the front. That keeps the file small and stops her having to re-read an ever-growing transcript before every reply.

To turn it off, untick Chat memory under Companion → AI Brain. She'll stop both reading and writing the file. There's also a Forget everything button that wipes the conversation from memory and from disk.

Warm-up, lifecycle, and shutdown

Warming her up

Loading a model into memory is the slow part; answering is comparatively quick. So at startup the app sends Ollama an empty request that means "load the model, don't say anything yet", and asks it to stay loaded for 10 minutes rather than the usual 5. Without that, the model would quietly unload while you were away and your next message would pay the loading cost all over again.

If this fails - Ollama isn't running yet, say - nothing is shown. It logs the miss and moves on, and your first real message surfaces a proper error.

Shutting down

When you quit, the app tells Ollama it can drop the model from memory. If the wizard started the Ollama server itself, that process is stopped too. A server you or Ollama's tray app started is left running - it's yours, not ours.

Changing the host mid-session

Point the app at a different Ollama (a machine on your network, say) and the next request notices, throws away the old connection and builds a new one. No restart needed.

Error handling and fallbacks

Local models break in different ways than cloud ones do, so the app translates the technical failure into something you can act on:

If a request succeeds but comes back empty (rare, but some models do it under load) you get the usual fallback line instead of silence, and your message is rolled back out of the history.

Picking a model

The default is qwen3.5:latest, chosen because:

• At ~6.6 GB it fits on most people's machines.
• It follows instructions and produces well-formed structured replies, which is what the effects system depends on.
• It can reason step by step when asked, though the app switches that off for chat to keep replies quick.

Nothing about the app is tied to it. Anything you can download through Ollama and chat with should work. To swap:

1. Download it: ollama pull mistral-nemo:latest.
2. Open Companion → AI Brain and pick it from the Model list, or type the name in.
3. The next message uses it. No restart.

Rough guidance

Model sizes are quoted in "parameters" - roughly, how big the brain is. Bigger writes better and runs slower.

To see what you already have, run ollama list, or open http://localhost:11434/api/tags in a browser.

Privacy

Once local AI is set up, the app makes exactly two kinds of AI-related network request, both of them optional and both of them one-offs:

• Downloading the Ollama installer, once, from ollama.com during setup.
• Downloading a model, when you ask for one. That goes straight to Ollama's servers, not ours.

After that, every message goes to http://localhost:11434/, which is your own computer. The model runs there. We never see it.

One thing to be aware of: the conversation is saved as ordinary readable text at %LOCALAPPDATA%\ConditioningControlPanel\local_chat_history.json. Anyone who can open a file on your machine can read it. If that's a concern, untick Chat memory, use Forget everything when you're done, or turn on full-disk encryption.

For contrast: the cloud option sends each chat line, your character briefing and your screen-awareness context to our proxy, which forwards it to a hosted model. We record request counts and whether you're logged in. We do not record what you say. The Custom (OpenAI-Compatible) option sends the same things to whatever endpoint you configured, and what happens to them there is between you and that provider. See the privacy policy for the full breakdown.

Troubleshooting

Advanced: pointing at a remote Ollama

The host setting takes any address, not just your own machine. If there's a faster computer on your network (or a server you trust), run Ollama there and point the app at it:

1. On that machine, start Ollama with OLLAMA_HOST=0.0.0.0 so it accepts connections from elsewhere. By default it only talks to itself.
2. Make sure the model you want is downloaded there.
3. In the app, set Companion → AI Brain → Host to http://your-server:11434/.
4. The next message goes to the new address. Nothing else to do.

Glossary

Spotted something wrong here? Open an issue at CC-Labs-llc/ccp-bugs or say so in the Discord. Local AI shipped in v5.8.4 and these docs move with it.