Choose a model

Maisnie ships no model of its own and resells no tokens. This step is where you point it at one you already have — and you can change your mind here at any time; nothing about this choice is permanent. It’s a two-page flow: first you choose how Maisnie should reach an AI, then a second page asks only for that one choice’s own fields.

How should Maisnie reach an AI?

The step’s own page, “Connect an AI model”, asks that one question and offers five answers, each its own choice with a one-line explanation:

Pick one and press Next. “Decide later” is a real, complete answer, not an unfinished step — the box runs fine with no model connected, and anything that would need one, like Ask, says so plainly instead of failing.

Choosing any of the first four takes you to that choice’s own page — headed “Use your subscription’s app”, “Use an API key”, “Use an aggregator”, or “Use a model on this computer” — which shows only the fields that choice actually needs, with sensible defaults already filled in where there are any. There’s no id to invent: Maisnie names the connection for you, from its provider and how you reach it.

Your AI subscription’s app

This only works through the provider’s own, official command-line program — not a browser session, not a token lifted from one — and you should check that provider’s own terms of service before relying on this for anything you care about, since whether a consumer subscription may be used this way is the provider’s decision and it can differ, and change, by provider.

Alongside a Provider field (free text, just your own label, prefilled “Anthropic”), this page needs one thing that actually matters: Where the app is installed — the app’s full file path, not just its name: a bare name such as claude is never looked up for you, so a typo fails here instead of quietly running something else. A “How do I find it?” disclosure gives the command per operating system — where claude on Windows (Command Prompt), which claude on macOS or Linux (Terminal) — and says to paste whatever it prints back in as the path; if your provider’s command isn’t claude, run its own command instead.

An API key

Provider (free text, just a label for you) and Service address are both prefilled — “Anthropic” and its own API endpoint, https://api.anthropic.com — since that’s the only provider this door talks to directly today; if you have a key from another provider, use the aggregator choice instead. Paste your API key in the field below it — like every secret on this page, once saved it’s never shown back, only a note that a value is already stored.

An aggregator

One key, many models, from a service that exposes an OpenAI-compatible endpoint in front of several providers’ models — this is how you use a non-Anthropic API key today. Give Maisnie a Provider name (the aggregator’s own name, for example OpenRouter), the aggregator’s Service address (check that service’s own docs for the exact URL and model ids it expects — it typically ends in /v1), and your API key.

A model on this computer

A model running on your own machine or network, through any server that speaks the same OpenAI-compatible protocol — Ollama, llama.cpp, and LM Studio all do. The Name field is just a label shown on Home (prefilled “This computer”); the Server address is where it’s actually reached, prefilled with Ollama’s own default, http://127.0.0.1:11434/v1.

What actually leaves your machine with this choice depends entirely on what you type in Server address. If the endpoint is on this machine (127.0.0.1 or localhost), nothing leaves it. If it’s another device on your network, your prompts and the vault text Maisnie sends with them cross your network to reach it — plain HTTP unless that endpoint serves https://. Maisnie does not check where the endpoint actually is, or that it’s really on your own network at all: it accepts any http:// or https:// address here, so “local” describes the shape of the protocol, not a guarantee about where the bytes go. Point it at a server you actually control if the “nothing leaves my machine or network” property is the reason you’re choosing this door.

A cold local model can take a while to load and answer its first request — well past what a quick web request would tolerate. If you’re using the deep tier (the one reserved for hard, multi-step questions) with a local model, raise that connection’s time limit in More options (below); a page waiting on a slow first answer checks back on its own rather than giving up.

Which models to use

Every one of these pages ends with the same fieldset, “Which models to use”: three fields, one per tier — Quick jobs (small, cheap and fast work), Everyday (what Ask uses most), and Hard questions (the most capable, for rare, multi-step work). You’re not asked to pick “the model” for Maisnie overall — everything Maisnie does asks for a tier, never a model by name — and you only have to fill in the tiers this connection will actually be asked to serve; at least one is required. For the subscription and API doors, a suggested model is already filled in for each tier; change any of them if you’d rather use a different one.

More options, folded shut until you open it, holds the rest: an optional time limit per question (raise this for a slow local model), an optional monthly spending limit in US dollars (not shown for the subscription and local doors, since neither is billed this way), an API version field (the API door only, for a provider that needs one), and a checklist of what this connection can do beyond answering questions (using tools, searching the web, and so on) — most connections need none of this, which is why it starts closed.

Save and test

Each way’s own page ends with one primary button, Save and test — it saves what you typed and runs one real, live call in the same press, and shows the result right there. Nothing is saved as a working connection until this passes. While it runs, the page says “Testing the connection…” and checks back on its own every couple of seconds; a cold local model or a subscription CLI’s first run can take a while, and the fields stay locked (showing what’s being tested) until the result is in.

A pass reads “Connected”, with what the connection actually did underneath: which model answered, how long it took, what the call cost, and its reply — never trusted blindly for cost, since a model with no known price reads “not tracked” rather than a wrong number, and a free call reads “free”. A Continue button appears once you’re connected, to move on to the next step.

A failure leads with one plain sentence, never the provider’s own raw error — “The provider did not accept the key or sign-in.” (a wrong or revoked key, or a subscription CLI that isn’t signed in); “Maisnie could not reach it. Check the address, and that it is running.” (a wrong address, or nothing listening there); “The provider is limiting requests right now. Wait a minute and try again.”; “The account has run out of credit or quota.”; “The subscription has reached its usage limit for now.”; “The provider turned the request down. Check the model names.” A “Technical details” disclosure underneath, folded shut, carries whatever more specific fact could be picked out of the raw error (an HTTP code, a timeout, a refused connection) in plain words — so the plain sentence is always there, and the detail is one click away rather than missing. Whatever you typed stays saved either way; the page tells you to fix what’s wrong and press Save and test again.

Once at least one connection has passed its test, the “Connect an AI model” page itself changes shape: it opens on “Your connection(s)” instead of the five choices, each with its own status — Connected, Not tested yet, or Not working — and its own Test again and Change buttons, with Continue as the page’s primary action. The five choices are still there, folded under “Another way”, for setting up a second connection. Change on a saved connection re-opens its own way’s page with what you already typed (never a saved key or app password itself), and that page’s own Remove this connection? step — reachable from there — explains plainly what removing deletes (its details, and any key) and warns you first if it’s the only connection Ask currently has to answer with.

Saving a connection again for any reason resets it to Not tested — even an edit that has nothing to do with the key, address, model, or app path (changing only the provider label, a time limit, or a capability checkbox). There’s no way to change one field without re-arming the test.

Local-only mode and budget

Each connection can carry its own optional monthly budget (budget_usd) and time limit per call (timeout_s), both set in that connection’s own More options — though a subscription or local connection’s budget is never enforced (both are exempt from spend limits by design; only the API and aggregator doors are metered this way). Two things exist only in the configuration document today, not yet on this page:

• llm.privacy.local_only (true/false) — restricts every call to connections set up through the local model door. It does not check where that connection’s endpoint actually points, the same way the door itself doesn’t — so it only keeps a call on your machine if the local connection’s endpoint is 127.0.0.1/localhost; a local-door connection pointed at another device satisfies local-only mode without keeping the call on your machine.
• llm.budget.monthly_usd and llm.budget.on_exceed — a global monthly ceiling and what happens once it’s hit: notify (warn and keep going), degrade (the default — drop the over-budget connection, and every later paid connection in that tier too, but still fall back to a local or subscription connection if one is left, since neither is metered against this ceiling; refuses the call outright if none is), or fallback (drop only the over-budget connection and try the next one in that tier’s order, paid or not).

Setting either of these means editing config/majordomo.json directly for now — merge these keys into the existing llm object your connections already live under, for example:

"llm": {
  "privacy": { "local_only": true },
  "budget": { "monthly_usd": 20, "on_exceed": "fallback" }
}

You don’t need to restart the box for either of these two keys specifically: Ask starts a fresh python -m gateway subprocess for every question and that subprocess reads the document from disk each time, so a hand-edit here takes effect on your very next question. The Settings page (linked from every step’s masthead) already has one toggle of its own (remote-session capability, see daily use); it’s expected to grow both of these controls in a later release.

What each door sees

Regardless of which door you choose, the same rule holds: Maisnie never logs the content of what you ask or what a model answers, only which connection handled a call, how long it took, and what it cost. What the provider itself sees differs by door — see security for exactly what crosses your network for each one.

Next

Continue to remote access.