# AI (/features/ai)



**Settings → AI** is the one place you choose where AI runs on this Mac. Set it
up once, and everything that uses AI runs there: the [Playground](#playground),
where you talk to your models yourself, and every
[extension that uses AI](#extensions-that-use-ai). Nothing is sent anywhere you
did not set up, and you can see what was used on the [Usage](#usage) page.

AI needs no account and no licence to start. On macOS 26 with Apple
Intelligence turned on, it works as soon as Lumi is installed, and what you
send never leaves the Mac. A provider on a key of your own needs
[Pro](/pro#ai).

These settings are the same in every [profile](/features/profiles).

## The switch [#the-switch]

The switch at the top of the pane turns AI on and off. Off, every AI action is
refused, Lumi asks no engine whether it is there, and the provider list is not
checked. Everything under the switch stays as you left it, dimmed, and comes
back as it was when you turn it on again.

## Where AI runs [#where-ai-runs]

The pane's first page shows providers as three rows, one per group, each with
how many of its providers are ready. A row opens the group's providers, or
straight onto the provider's page when the group holds only one — as **With
your Claude plan** always does:

| Group                     | Providers                                                                                    | Cost                                                               |
| ------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| **On this Mac**           | Apple Intelligence, Apple Speech, Lumi Models, Ollama, LM Studio                             | Free. What you send never leaves this Mac.                         |
| **With your Claude plan** | Claude Code                                                                                  | Your Claude subscription. Requests count toward your plan's usage. |
| **Bring your own key**    | Anthropic, OpenAI, Google Gemini, OpenRouter, Groq, and any service that speaks OpenAI's API | Paid per use, billed by each provider. Needs [Pro](/pro#ai).       |

Each row says where the provider stands:

| Status        | Means                                                               |
| ------------- | ------------------------------------------------------------------- |
| **Ready**     | It answers, and its models can run.                                 |
| **Not ready** | Something is missing. Its page says what, with the way to fix it.   |
| **Add key**   | No key saved for it yet.                                            |
| **Pro**       | It needs Lumi Pro, and this copy has none.                          |
| **Paused**    | A key you saved under Pro, kept in your Keychain until Pro is back. |

Click a row to open the provider's page.

### Models [#models]

A provider's page lists its models. **Turn on the ones you want** — only those
can be chosen as the [default model](#default-model), in the Playground, or by
an extension. A provider with no model on cannot be used. Apple Intelligence is
the exception: it has one model, always on.

* A list of more than eight models has a search field, and **All** / **On** to
  show every model or only the ones that are on.
* LM Studio lists its models in two groups: **Loaded**, in memory now, and
  **Downloaded**.
* **Refresh** asks the provider for its list again.
* A model marked **Thinks** can reason before it answers. How much it does is
  chosen per request, up to [Most thinking](#limits).
* Models under **Retiring** still work, until the day shown. Turn on a newer one
  before then.

### On this Mac [#on-this-mac]

**Apple Intelligence** comes with macOS 26. It must be turned on in **System
Settings › Apple Intelligence & Siri**; until it is, its page says so, with a
button that opens that pane. It reads at most 6,000 characters at a time, and
**About this model** lists the languages it answers in. It suits short
rewrites and fixes best.

**Apple Speech** comes with macOS 26 too, and turns speech into text for the
extensions that ask. It hears dozens of languages; **About this model** says
which are on this Mac. macOS downloads another when an extension needs it,
once you agree in the panel Lumi shows.

**Lumi Models** are models Lumi downloads and runs itself, from a list Lumi
signs, with no other app to install. Its page lists them together, each
tagged with its kind, and chips narrow the list — press several kinds to see
each of them:

* **Text**: models that write — Qwen3 4B, Gemma 3 4B, Qwen3 1.7B and Gemma 3
  1B. The Qwen3 models can think before they answer.
* **Speech to Text**: Whisper models, for the extensions that hear.
* **Speaker Recognition**: a model that tells voices apart.
* **Speech Detection**: Silero VAD, which hears where speech starts and
  stops. It comes built into Lumi — tagged **Built-In**, and on from the
  start — and while it is on, every live recording is cut into sentences by
  it rather than by loudness alone, so fewer words are lost under a fan or
  music in the room. Switched off, Lumi goes by loudness as before.

Each row says how big the model is and how much memory it uses while it runs;
**Download** fetches it, checks every byte against the list, and turns it on.
A model whose licence asks to be accepted — Gemma's — shows it first. The
switch beside a downloaded model turns it off without removing it, and
**Remove** frees the disk. A built-in model is kept up to date the same way:
when Lumi's list names a newer copy, its row offers **Update…**, and **Remove**
deletes only the update you downloaded, going back to the copy Lumi came
with. Lumi needs Apple silicon to run them, and offers
only the ones that fit this Mac. When an extension asks for a model and none
is ready, Lumi offers the one it would download, in a panel at the pointer;
nothing downloads until you agree.

**Ollama** and **LM Studio** run the models you downloaded in them. Lumi looks
for each only at its default address on this Mac:

| App           | Where Lumi looks  | When it is not ready                                                        |
| ------------- | ----------------- | --------------------------------------------------------------------------- |
| **Ollama**    | `127.0.0.1:11434` | Open Ollama, and download a model that chats.                               |
| **LM Studio** | `127.0.0.1:1234`  | Start its server under LM Studio's **Developer** tab, and download a model. |

The page offers **Get** when the app is not installed and **Open** when it is,
and checks again by itself, so the warning goes as soon as the app answers.
**Server** shows the address and the version that answered there.

### With your Claude plan [#with-your-claude-plan]

**Claude Code** uses the `claude` command on this Mac, signed in with your own
Claude account. Install it, then run `claude` in Terminal and sign in. Its page
offers both, and checks again until it is ready.

* Signed in with a **Claude plan**, it is free in Lumi, and requests count
  toward your plan's usage.
* Signed in with an **API key** or a cloud such as Amazon Bedrock, it is a key
  of your own, and needs [Pro](/pro#ai).

Its models are **haiku**, **sonnet**, **opus** and **fable**, and each runs the
latest model of its line. **Account** shows the email and organisation Claude
Code is signed in with. Lumi shows them only — it never signs anyone in, and
never reads or keeps Claude Code's sign-in.

### Bring your own key [#bring-your-own-key]

Paste a key from your account with the provider. Lumi checks it by listing your
models, then keeps it in your Keychain. The pane only ever shows its last four
characters, and no extension ever sees it.

A key is sent only to the address it was checked against. If a provider moves
to a new address, its key stops working until you press **Verify Again…**.
**Replace…** changes a key, and **Remove Key…** takes it out of your Keychain.

**Other (OpenAI-compatible)** works with any service that speaks OpenAI's API:
give it the **Base URL** its API answers at, up to `/v1`, and a key.

**OpenAI** and **Groq** turn speech into text too, on the same key. Their page
lists the speech models with the others under **Models**, each tagged
**Speech**, with a switch. The chips above the list filter it, alone or
together: **Text** and **Speech to text** show their kind — both of them when
both are pressed — and **On** only the ones turned on. The speech model the list suggests is on once you add a key. A model marked **Text
while it is said** gives an extension the words as they are spoken; the
others give them when each pause comes, and a file once it has been heard. Groq is offered for
speech alone for now — its page says so — and its row shows **Speech** only.

## The provider list [#the-provider-list]

Which providers Lumi offers, and what Lumi knows about them, comes from a list
Lumi checks at most once a day while AI is on. The list is signed, so Lumi uses
only a list it can verify. The refresh button beside **Providers** checks at
once, and its tooltip says when the list was last checked.

The list lets Lumi add a provider, or turn one off, without an update to Lumi
itself. A provider turned off this way disappears from the pane, or, if you
saved a key for it, says **Turned off by Lumi**.

## Default model [#default-model]

Each extension can choose a model for each of its actions. The **default
model** runs when it doesn't, and in the Playground under **Default Model**.
Left on **The first one that is ready**, Lumi picks one for you. The defaults
have a page of their own, **Default models**, one for each kind of task; its
row on the pane's first page names the text default.

When a request cannot run on the model it asked for — the model was switched
off, its app is not open, it needs Pro — Lumi tries, in order:

1. the default model;
2. a model on this Mac: one you downloaded in Lumi Models, then Apple
   Intelligence, then Ollama, then LM Studio;
3. each other provider in the pane's order, on the first model you turned on.

The extension is told that its request ran on another model. A default model
that needs Pro on a copy without it says **Paused**, and requests run on the
first free model that is ready until Pro is back.

## Playground [#playground]

**Playground**, at the top of the pane, opens a chat beside the settings. Use it
to try a model, compare two, or check that a provider is set up. It runs
through everything an extension's request would: the model chosen, your plan,
your [limits](#limits).

* Choose the model and how hard it thinks on the chips under the message. A
  model that cannot think answers without thinking.
* **⌘↩** sends, from anywhere in the Playground. **Return** starts a new line,
  and **⌘.** stops an answer.
* Each answer shows the model that gave it, its thinking folded away, and what
  it cost. **Copy** copies it. **Run Again** sends the same message on the model
  and options chosen now, which is how you compare two models.
* It is a conversation: each message goes with the ones before it, so the model
  remembers what you told it. A stopped or refused exchange is left out, and the
  oldest are left out when the whole would pass [Longest input](#limits). **New
  Chat** starts over.
* **Escape** or ✕ puts it away. What you wrote stays while you visit other panes,
  and goes when Lumi quits. None of it is written to disk.

The Playground never asks before sending: you typed the message and chose where
it goes.

## Extensions that use AI [#extensions-that-use-ai]

An extension that uses AI says so when you install it, and is listed under
**Extensions & Privacy**, one row each. Its row opens its page: the switch at
the top turns its AI on or off, and its choices are below. Off, Lumi refuses
everything it asks.

Only what the extension sends goes — its instructions and its text, typically
what you selected. It never sees your keys, and it can only use the providers
you set up here.

An extension that turns speech into text is listed here too, with a choice for
speech beside its choice for text: it hears with the speech model you chose
under **Default models** — Apple Speech, one you downloaded in Lumi Models, or
OpenAI's or Groq's on your key. It gets the
text, never the sound. While it records the microphone or what your Mac plays,
Lumi's icon in the menu bar shows a dot, and its menu has a row naming the
extension with a **Stop**. A recording also stops at your **Longest
recording**, when the extension is switched off, and when your Mac sleeps or
its screen locks.

An extension can also ask which voice said what. That takes a second model,
one that tells voices apart: download it in Lumi Models (its **Speaker
Recognition** chip shows it), and choose it under **Default models › Speaker
recognition**. It runs on
this Mac, so nothing of the sound leaves it for that. A recording's voices are
numbered as they are first heard — a call's two sides are always told apart —
and a file's are found once it has been heard.

An extension with the **audio-levels** permission is told how loud what it
records is, so it can draw it moving — never the sound itself. Lumi keeps what
it sends coarse on purpose: a reading about every 128 ms of the loudness and a
few pitch bands, eased so slowly that neither the words nor the voice can be
made back from them — Lumi measured it with the speech and speaker models it
runs itself.

An extension can also keep the audio of what it heard, as a file, to play back
beside the transcript. Keeping a recording is not AI — an extension may record
with no AI at all — so it is described on its own:
[Recordings](/privacy#recordings).

### Voices an extension remembers [#voices-an-extension-remembers]

An extension with the **voices** permission can ask Lumi to remember a voice
from one of its recordings, so it can name that person the next time they
speak. Lumi asks you first, at the pointer, with a few seconds of their voice
to play — at least five seconds of it, and only while the recording is fresh.
Remember only people who know you are doing it.

Lumi keeps the voice, not the extension: a voiceprint, a measure of how
somebody sounds, and those seconds of them speaking, encrypted and on this Mac
only, never in a backup. The extension gets a name and an id, never the sound,
and no other extension recognizes the people it remembers. In **Settings ›
AI › Extensions & Privacy**, open the extension and then **Voices** to play
each one, rename it or forget it — one at a time or all of them — whether the
extension is switched on or not. An extension that no longer asks for voices
still shows them there until you forget them. Removing the extension forgets
its voices too.

### Asking before text goes online [#asking-before-text-goes-online]

With **Ask before sending online › Text** on, at the top of
**Extensions & Privacy** and the default, Lumi asks you
before an extension's text leaves this Mac. The question names the provider and
the extension, and shows the text and its length:

| Answer                      | Key    | Does                                                                  |
| --------------------------- | ------ | --------------------------------------------------------------------- |
| **Send**                    | Return | Sends it.                                                             |
| **Don't Send**              | Escape | Sends nothing, and the extension is told.                             |
| **Use** a model on this Mac |        | Runs it on a model on this Mac instead. Shown only when one is ready. |

The question stays up until you answer it: clicking elsewhere does not send
the text or refuse it. Text that goes to a model on this Mac is never asked
about.

**Don't ask again for** *the extension* remembers your answer. It is checked to
begin with, so each extension is asked about once. Uncheck it to answer for
this text alone: Lumi asks about that extension each time from then on, and
the box comes unchecked, as you left it — as it does once you pick **Ask Each
Time** on the extension's row. Each extension's row shows what Lumi does with
its text, and you can change it there:

| Choice               | Does                                                                                       |
| -------------------- | ------------------------------------------------------------------------------------------ |
| **Ask Each Time**    | Asks, as above.                                                                            |
| **Always Allow**     | Sends without asking.                                                                      |
| **Keep On This Mac** | Never sends its text off this Mac. A model on this Mac answers instead, when one is ready. |

### Asking before speech goes online [#asking-before-speech-goes-online]

What is said is asked about apart from text, with **Ask before sending online ›
Speech** and a choice for speech on each extension's page: an extension you let
send text has not been let send what a room says. Lumi asks once per recording,
before any of it is heard, when the speech model is OpenAI's or Groq's. The
question names the provider, the model and the extension, and says what would
be heard — the microphone, what your Mac plays, both in a call, or a file and
how long it is — never which app; you pick that afterwards, when the extension
asked for one. Its answers are the text question's: **Send**, **Don't Send**,
and **Use** a speech model on this Mac when one is ready.

## Limits [#limits]

Limits hold for every request, from an extension or from the Playground. They
have a page of their own, **Limits**, where **Restore Defaults** puts them back;
each field's range is its tooltip.

| Limit                | Default           | Range                  | Does                                                                                                                |
| -------------------- | ----------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------------- |
| **Longest input**    | 20,000 characters | 1,000 – 200,000        | Longer text is refused before anything is sent. Apple Intelligence reads at most 6,000.                             |
| **Longest answer**   | 1,024 tokens      | 256 – 16,384           | A token is about ¾ of a word. Extensions may ask for less, never more.                                              |
| **Give up after**    | 60 seconds        | 15 – 300               | A request with nothing back — no thinking, no text — for this long is stopped.                                      |
| **Requests at once** | 5                 | 1 – 10                 | For each extension. More wait their turn.                                                                           |
| **Most thinking**    | Medium            | Off, Low, Medium, High | The most a model may think before it answers. Thinking helps on hard requests, but is slower and costs more tokens. |

## Usage [#usage]

**Usage** shows what AI was used for, month by month: requests and tokens, how
they compare with the month before, and each provider's share. It is counted
on this Mac from what each provider reports, and none of it leaves the Mac.

## Privacy [#privacy]

Lumi keeps no copy of a request or an answer. Keys stay in your Keychain. The
network is used only to check the provider list, and to reach a provider when
you or an extension asks it something. See [Privacy](/privacy#ai).