Agents

Magnum Router

Magnum Router picks the model and effort for each message you send in a session, among its agent's own models: a quick question goes to a fast model, a wide change to the strongest. You turn it on per session; new sessions start without it unless Settings → Magnum Router → New sessions start with it is on.

Turning it on

In the model picker, choose Auto, under Magnum. The picker then shows Magnum Auto, and the effort picker Auto. Or press ⌘P and choose Magnum Router: pick the model and effort for each turn. A session keeps it across restarts.

To have it pick only the effort, choose Auto in the effort picker and keep your model.

Pausing and resuming

A model you pick yourself pauses it for the model, and an effort you pick, for the effort: yours stands. So does one asked for with /model (or Pi's /thinking). Choose Auto (under Magnum) again to resume both, or Auto in the effort picker for the effort. ⌘P → Pause Magnum Router keeps the session on the model it's on. A pause is kept with the session across restarts, as the Router is.

What it decides from

It reads what you typed in the message box, how many files you attached, and the line counts of the project's files your message names, never their text. For a project on another machine, they're counted there, through its node; a machine that doesn't answer within 3 seconds leaves them out, and the card says so. A model it asks when unsure (see When the rules can't tell, below) is also told how many commits in the last 90 days touched each of those files, and Why lists them.

It decides each message you send, before its turn starts. A message that joins a running turn keeps that turn's model, and Magnum's own messages to a session aren't decided. A worker's first turn is decided from its task (Balanced).

It picks among the agent's newest model of each family: for Claude Code, Haiku (fast), Sonnet (balanced) and Opus (strong). For Pi, only models of the provider Pi is on.

How it picks

Its rules, roughly:

• A short question, with no files or code: fast, low effort.
• Wide work (refactoring, migrating, a change across the code, four or more files named, or over 2,000 lines in them): strong, high effort.
• A change to one or two files your message names (400 lines or fewer in them, and a short message): fast, medium effort.
• A stack trace, a question about code, or another change to the code: balanced.
• A command, or a reply that goes on with what's under way ("continue", "try again"): the model it's on.
• A short or unclear message: the model it's on, unless you chose a model to ask (below).

When it isn't sure, it never steps down, and steps up at most to balanced. It picks models billed beyond your plan (Claude Code's Fable) only once Settings → Magnum Router → Models billed extra is on, and never long-context models. While the agent's account is near its usage limit, it doesn't step up. After the first turn, another model has to rebuild the agent's prompt cache, so, except to step up, it switches only when that costs less this turn, cache and all, at list prices. Magnum reads models' prices from Pi, the agent, when it's on this computer and signed in to the same provider; without Pi, it doesn't switch down after the first turn.

Decision cards

Under each message it decided, a card says what it chose and why, how it read the message, and how sure it was. A card reads like "Magnum Router: Haiku 5.5, low effort — a question, no files or code (fast tier; rule “question”, 75% sure)". "stays on" in a card means it kept the model. Why, under the card, opens how it was read: by which rule or model, how sure (and, where a model decided, how sure before Magnum adjusted it), each question a model was asked with its answer, and the tier the session was on. If the agent refuses part of a switch, the session says so and the turn runs on what it had. The cards come back with the session after a restart.

When the rules can't tell

Settings → Magnum Router → When unsure chooses who decides a message the rules can't tell:

• Keep the model (the default).
• Ask Claude Code (Haiku): a short call on your own subscription, for sessions of any agent.
• Ask Codex: a short call on Codex's fastest model with your own sign-in, for sessions of any agent; about 12 seconds. It needs Codex on this computer and a Codex session opened here once (that's how Magnum learns its fastest model).
• Ask d1-2B in Ollama: a small decision model on this computer that also sees the pictures you attach; choosing it offers to set up what's missing.
• Use Magnum's own model: learned here from the decision log; it decides once it does better than staying on the model.
• Ask a System One server: your message goes to the server at the address you give.

The second choice, Else, picks who's asked when the first gives no answer (Magnum's own model before it's in use, say, or a server that's down). While it's asked, your message leaves the box and goes once decided. With no answer in time, the turn keeps its model, and the card says why. The ? beside the Deciding heading explains each choice. The page's decision log, kept on this computer, compares the Router's rules with always staying on one model.

Refused models

A provider can list models your account can't use. When the agent refuses one, the Router leaves it out on that machine for a month, across restarts, and says so once, as in "Magnum Router won't pick GPT-6.1 Terra here again: Pi refused it." A session on that model moves off it at its next turn.

If the agent hasn't listed any models, the Router says it couldn't decide, and the turn stays on its model.

See Magnum Router in practice for what it does with the messages you'd really send.