# Pick Your Model Provider in One Screen: Octomind 0.70.1

> Octomind 0.70.1 adds a setup screen for every supported LLM provider, compacts idle sessions when that saves money, and keeps the rules you state verbatim.

![Animated Octomind icon — purple pixel-art octopus](/octomind-icon-animated.gif)

Until now, using Octomind with your own API key meant reading a docs page, exporting a variable and editing three model names in a TOML file. Forget one of the three and part of your session still went to the default model.

**Octomind 0.70.1 asks which LLM provider to use the first time you start it, and `octomind configure` brings the same screen back at any time.** It also tidies long sessions when you return from a break, keeps the rules you state in your own words, and checks multi-part requests one requirement at a time. The visible work landed in 0.70.0; 0.70.1 is a small follow-up released the same day. There were no 0.69 or 0.70.0 posts, so this one covers everything since [the 0.68.0 post](/blog/octomind-0-68-0-release). The open-source update is available today.

## Set up an LLM provider in one screen

Run `octomind` in a terminal with no config yet and this screen appears on its own. To open it any time later:

```bash
octomind configure
```

You get one list. Type to filter it, press Enter to choose:

| Choice                     | What happens                                                                            |
| -------------------------- | --------------------------------------------------------------------------------------- |
| Octomind hub (recommended) | One browser sign-in. All three models become `octohub:auto`, paid with credits you buy. |
| A provider from the list   | Asks for any missing key with hidden input, then lets you pick a model.                 |
| Skip for now               | An existing config stays as it is. On a first run you get the default config.           |

The three models are the main agent, the supervisor that checks its work, and the compression model that summarizes old conversation. After you pick the main model, setup asks:

```text
Use <model> for the supervisor and compression too? [Y/n]
```

Enter keeps one model for all three. Answer `n` to choose a cheaper model for each of the other two.

What you can count on:

- **Octomind finds the keys you already have.** It looks in your shell, in `./.env` and in its own `.env`. Those providers move to the top of the list, and each row says where its key came from, such as `key in shell environment`. A provider with no key shows the variable it needs.
- **A key you type stays out of your config.** It goes to `<data-dir>/config/.env`, with owner-only permissions on Unix, and never into `config.toml`.
- **Nothing else in your config moves.** Only the three model names change. Your comments and other settings stay.
- **When the provider's catalog says so, the list hides models that can't call tools.** An agent can't work without tools. OpenRouter and Ollama Cloud lists come from their public catalogs, and if that fetch fails you type the model ID. The "other" row takes any ID at any time.
- **Esc goes back one step.** On the first screen it means Skip. Ctrl-C quits.

The screen never interrupts a script. Piped input, `--format` and `--daemon` runs never see it and get the default config. To set a model from a script, use `octomind config --model provider:model`. To change models for one session, use `/model provider:model`.

The [CLI reference](/docs/reference/01-cli-reference#octomind-configure) has every detail. If you are weighing the hub against your own keys, [BYOK AI](/blog/byok-ai-no-model-markup) lays out the difference.

## Long sessions can cost less to resume after a break

Providers keep a [prompt cache](/blog/prompt-caching-explained), a short-lived copy of your conversation that makes the next request cheaper to send. Step away long enough and it expires, so your next message pays to write the whole conversation into the cache again.

Octomind now uses that moment. If the cache is known to have expired and the math favors it, Octomind runs [context compaction](/blog/octomind-0-42-1-release) first, meaning it replaces the older part of the conversation with a summary. Then it sends your message. The rewrite you were going to pay for anyway gets shorter, and so does every later request.

Idle compaction is on by default. To turn it off:

```toml
[compression]
idle = false
```

Compaction runs only when the numbers work out. The numbers below are invented and round, in units where 1 token of normal input to your main model costs 1. Assume a cache write costs 1.25, a cache read costs 0.1, and output costs 5.

Your conversation is 200,000 tokens. Compaction would bring it down to 120,000, which is 80,000 fewer. The summarizing call reads 100,000 tokens and writes a 3,000-token summary.

| If you expect…   | Saved on the next write | Saved on later reads      | Summarizing call, same model | Decision |
| ---------------- | ----------------------- | ------------------------- | ---------------------------- | -------- |
| 10 more calls    | 80,000 × 1.25 = 100,000 | 9 × 80,000 × 0.1 = 72,000 | 100,000 + 15,000 = 115,000   | Compact  |
| Only 1 more call | 80,000 × 1.25 = 100,000 | 0                         | 100,000 + 15,000 = 115,000   | Skip     |

A cheaper compression model lowers the last cost column, which is one more reason to answer `n` in the setup screen.

The limits:

- **No guessing about the cache.** If Octomind doesn't know the cache is gone, it doesn't compact. It counts as gone after the cache has sat idle for its known lifetime, or when it belongs to a different model because you switched.
- **At most one of these compactions per turn.**
- **Cancelling is safe.** If you cancel during this compaction, the turn stops and your conversation is left as it was.
- **It needs real prices and a cache.** Octomind skips this step when your main model has no prompt caching, or when it doesn't know the price of your main or compression model.

New configs also start with higher limits: compaction at 105,000 tokens instead of 70,000, and a session ceiling of 300,000 instead of 200,000. Existing configs keep the values they have. The [LLM context compression guide](/docs/usage/08-compression) explains those two settings.

## The rules you state stay in your own words

When you tell the agent something like "never push to main", Octomind's learning system can carry that into later sessions. Learning is on by default. A rule that passes verification against what you said is now stored with your original quote, where you said it, and the scope it applies to.

What that changes:

- **Your rules are labeled as yours.** Verified rules reach the model in their own block with your original quotes. Other lessons are marked as having no verified source.
- **A failed task can't weaken them.** Bad outcomes can lower the score of a lesson, but not of a verified rule.
- **The permission check sees them too.** The model that does the work and the check that authorizes tool calls get the same rules, with quotes, scope and conditions. A remembered preference doesn't grant permission for anything unrelated, and what you say now overrides what you said before.
- **Rules are never cut in half.** A rule goes in whole or stays in storage. When context runs short, optional memories are dropped first and verified rules stay. If the required context still can't fit, Octomind doesn't send the request.
- **A rule is replaced only on purpose.** A new rule has to name the old one by ID. Sounding similar is never enough to delete a short rule.

One limit to know about: the memory sent with each request has a 2,000-token budget, so a long list of rules may not all appear on every request. The docs put it plainly: "This is bounded retrieval, not a guarantee of perfect recall." Run `/learning show` to inspect what is stored, and read the [learning guide](/docs/usage/13-learning) for how recall chooses.

## "Done" is checked against every part of your request

The verify gate compares an agent's "done" with what it did.

- **The gate keeps every numbered or bulleted requirement whole,** with all its clauses, and there is no limit on how many it tracks. Write "1. fix login 2. add a test 3. update the docs" and all three stay on the list.
- **The gate's advisory names everything still unproven.** Once per turn, it can point out conditions it could not settle. That note never blocks the agent and never certifies the work as correct.
- **Claims without evidence don't pass as settled.** A match with no citation stays unsettled.
- **Old findings stop lingering.** A clean run replaces stale findings, and findings now belong to your latest message.

With the supervisor's evaluation model on (`[decision] supervisor = true`, off by default), the advisory leaves out conditions that a recorded action already exercised, so you see fewer false alarms. If that check refuses or isn't available, the conditions stay.

The `unsettled_confidence_threshold` setting under `[supervisor.gate]` is gone, and the config upgrade removes it for you. The [supervisor guide](/docs/usage/14-supervisor) covers the gate in full.

## Unattended runs no longer wait for compaction

If a one-shot `octomind run` exits with a compaction still in progress, a background process now finishes it. Your next `--resume` picks up the result, and the usage isn't billed twice. Daemons don't use this path, and there is nothing to enable.

One optional addition for long coding sessions: summaries are fine for what happened, but poor for the exact lines of a file. With this setting on, compression keeps selected file regions as exact text across compactions, and checks them again when a later tool changes the file. It is off by default:

```toml
[compression.attention]
enabled = true
```

The [compression guide](/docs/usage/08-compression) covers the rest.

## Connecting to providers and tools

| If you…                                       | What changed                                                                                                                                  |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| Sit behind a corporate CA or inspecting proxy | Certificates your OS trusts now count, which fixes `invalid peer certificate: UnknownIssuer`.                                                 |
| Want more model providers                     | `reflection:` (Reflection AI) and `isoquant:` (Isoquant) are available, and appear in the setup screen.                                       |
| Run Ollama                                    | Ollama prompt caching and TTL keepalive are supported.                                                                                        |
| Use MCP server OAuth in unattended runs       | With no token and nobody to sign in, the server shows as unreachable and offers no tools, instead of failing with a generic error.            |
| Build MCP servers                             | Session metadata now includes a `shell` value, so a server can offer command-running features only when the session may use its `shell` tool. |

## Other fixes since 0.68.0

- **Agents stop polling background work (0.70.0).** They are told that results arrive on their own, so they send a short status and end the turn while they wait.
- **Specialists launched in parallel no longer crash (0.70.0).** Two launched in the same second could die with `must define at least one new [[roles]] entry`.
- **`--format jsonl` survives a `/role` switch to a tap role (0.70.0).** It used to fall back to plain output.
- **Spawned processes yield to the agent (0.70.0).** MCP servers, tools and monitors start at a lower priority. On Linux they also ask to be killed first when memory runs out, where the system allows it.
- **Keepalive pings stop after a cache miss (0.70.0).**
- **Editor integrations (ACP):** cancelling during compaction now reports as cancelled (0.70.0), and the protocol moved to agent protocol v1 (0.69.0).
- **Delegated specialists get their own instructions (0.69.0),** so they answer as a tool result.
- **Workflow loop steps reject `max_iterations = 0` (0.70.0).**
- **`/learning list bogus` now reports the bad argument (0.70.0)** instead of showing page 1.
- **`/skill *review* 2` pages through a filtered list (0.68.1).**

## Before you update

- **Your config migrates to version 29 on first start.** It adds `idle = true` under `[compression]` unless you set `idle` yourself, and removes `unsettled_confidence_threshold`. A config at version 29 won't load in an older Octomind.
- **The first compaction after a break may run sooner than you are used to.** Set `idle = false` to keep the old behavior.
- **Existing configs keep their token limits.** Only new configs get 105,000 and 300,000.

## Update to Octomind 0.70.1

On macOS and Linux:

```bash
curl -fsSL https://octomind.run/install.sh | bash -s -- --version 0.70.1
octomind --version
```

On Windows, in PowerShell:

```powershell
$env:OCTOMIND_VERSION = "0.70.1"
irm https://raw.githubusercontent.com/muvon/octomind/master/install.ps1 | iex
```

Or run `scoop update octomind`. See the [installation guide](/docs/usage/01-installation) for other methods, the [full changelog](https://github.com/muvon/octomind/blob/0.70.1/CHANGELOG.md), and [the 0.68.0 notes](/blog/octomind-0-68-0-release) if you're coming from 0.67 or earlier.

Then try it: run `octomind configure`, look at which keys it found, and press Esc to leave without changing anything.

— DK