wisp-agents 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## [Unreleased]
 
+## [0.23.0] - 2026-10-20
+
+### Changed
+
+- **Auto's Balanced goal runs frontier models.** When you have a frontier model installed and allowed (Opus, Codex's default, Gemini Argon, Grok 4.x), Balanced now picks it, at the harness's default or medium thinking, instead of Sonnet or Haiku. Best stays on frontier models at high or x-high, so the thinking level is what sets the two apart. Balanced steps down to an everyday model (Sonnet, never Haiku) only while every frontier model is at its limit, so the task still runs, or when you have none; small models' wins no longer pull Balanced to them after 20 outcomes. Cheap is unchanged. For models with the level in their name (Antigravity's `gemini-4-argon-low` / `-medium` / `-high`), the goal now picks the variant: Cheap low, Balanced medium, Best high, and the other variants count as the same model.
+- **Guides on the website for what people search for.** Six new pages under [trywisp.dev/guides](https://trywisp.dev/guides/): [run Claude Code and Codex in parallel](https://trywisp.dev/guides/run-claude-code-and-codex-in-parallel.html), [run multiple Claude Code agents in parallel](https://trywisp.dev/guides/run-multiple-claude-code-agents-in-parallel.html), [run coding agents on multiple machines](https://trywisp.dev/guides/run-coding-agents-on-multiple-machines.html), [multi-agent coding](https://trywisp.dev/guides/multi-agent-coding.html), [Claude Code vs Codex on your own repo](https://trywisp.dev/guides/claude-code-vs-codex.html) and [run coding agents in the background](https://trywisp.dev/guides/run-coding-agents-in-the-background.html). Each answers its question in the first paragraph, shows the manual way with `git worktree` and `ssh`, then how wisp does it, and ends with FAQs (with `FAQPage` structured data). `scripts/guides.mjs` holds them; `scripts/site.mjs` renders them into the sitemap. The landing page's title, description and structured data now say *in parallel* and *on your other machines*, its FAQ answers both questions, and Guides is in the nav and footer of every page. The npm description and keywords match.
+
 ## [0.22.0] - 2026-10-20
 
 ### Added
@@ -413,7 +420,8 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 - Session queue with follow-ups, answers to agent questions, terminal takeover and mark-as-done.
 - Older turns are folded, with a floating collapse-all button and back-to-top.
 
-[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.22.0...HEAD
+[Unreleased]: https://github.com/M0xoo/wisp/compare/v0.23.0...HEAD
+[0.23.0]: https://github.com/M0xoo/wisp/compare/v0.22.0...v0.23.0
 [0.22.0]: https://github.com/M0xoo/wisp/compare/v0.21.0...v0.22.0
 [0.21.0]: https://github.com/M0xoo/wisp/compare/v0.20.0...v0.21.0
 [0.20.0]: https://github.com/M0xoo/wisp/compare/v0.19.0...v0.20.0

package/README.md

@@ -56,7 +56,7 @@ From there you can **follow up**, **answer its questions**, **take it over** in
 | 🤝 **Subagents** | Give the lead agent a team on other harnesses (e.g. Claude Code hands tests to Codex ×3). It delegates through a `delegate` tool; their edits land in its worktree. See [Subagents](#subagents). |
 | ⏪ **Checkpoints & rollback** | Every turn is snapshotted first. Restore to before any turn, revert a single file, or re-run a command block from the presentation. |
 | ⚖️ **Compare** | Run one task on two harnesses side by side, and keep the better run. |
-| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.22.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
+| 🧾 **Recipes & triggers** | Saved prompts with `{params}` (`wisp run release 0.23.0`), run by hand, on a schedule, when CI fails, or when an issue is labelled. |
 | 📊 **Usage** | Spend, success rate and questions per project and per harness · model. |
 | 📱 **Phone** | Questions and finished tasks on ntfy or Telegram; answer from there, or start a task with `/new`. |
 | 🔐 **Permission modes** | Choose **Plan** (read-only), **Edits** (file edits auto-accepted), or **Full auto** (no permission prompts, the default) for each launch. `Shift+Tab` in the prompt cycles modes. In Edits mode, anything the permissions block comes to you: Claude Code waits for **Allow / Always / Deny**, and the other harnesses show an **Allow & retry** card. |
@@ -85,7 +85,7 @@ brew install m0xoo/tap/wisp-agents             # Homebrew: CLI and browser mode,
 wisp "fix the flaky auth test"
 ```
 
-The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://trywisp.dev/install.sh | WISP_VERSION=0.22.0 bash`).
+The Homebrew formula lives in [M0xoo/homebrew-tap](https://github.com/M0xoo/homebrew-tap). `install.sh` honors `WISP_VERSION` to pin a release (`curl -fsSL https://trywisp.dev/install.sh | WISP_VERSION=0.23.0 bash`).
 
 From source:
 
@@ -135,7 +135,7 @@ wisp btw <id> "did you do X?"     # ask on the side without interrupting the run
 wisp stop <id>
 wisp ship <id> [--draft]          # commit, push and open a PR for a worktree task
 wisp merge <id>                   # squash-merge its PR, fast-forward your local main
-wisp run release 0.22.0            # run a recipe; values fill its {params} (or version=0.22.0)
+wisp run release 0.23.0            # run a recipe; values fill its {params} (or version=0.23.0)
 wisp recipes                      # list recipes
 wisp usage [--days 7]             # spend and outcomes
 wisp mcp                          # MCP server for other agents and editors
@@ -304,7 +304,7 @@ If the harness has no system-prompt flag, prepend `systemPrompt` to the first pr
 
 ## Auto
 
-**Auto** is the default harness: wisp picks the harness, model and thinking level for each task. Its "model" is a goal: **Balanced** (best result per dollar), **Cheap** or **Best**. The goal also sets how hard the agent thinks: Cheap runs at low (or minimal), Balanced at the harness's default or medium, Best at high or x-high. A harness or model without levels runs at its default.
+**Auto** is the default harness: wisp picks the harness, model and thinking level for each task. Its "model" is a goal: **Balanced** (the default), **Cheap** or **Best**. Balanced and Best both run frontier models (Opus, not Sonnet or Haiku) when you have one installed and allowed; what sets them apart is how hard the agent thinks: Balanced runs at the harness's default or medium, Best at high or x-high. Cheap runs at low (or minimal) on whichever model does the job for least. A harness or model without levels runs at its default; for models with the level in their name (Antigravity's `gemini-4-argon-high`) the goal picks the variant the same way.
 
 How it picks: every harness · model · thinking level you have installed is an option (`claude:opus:high`). For the kind of task (bug, feature, UI, tests, refactor, docs, release, question) Auto keeps an estimate of how often each option does it well. The estimate starts from a small wisp-bench pilot that ships with wisp (`server/router-priors.json`), then counts your own outcomes: merged PR (best), closed PR, 👍 / 👎, rollback, then how the run ended, less a bit for each follow-up you needed. It draws from each estimate (Thompson sampling), so options with little data now and then get a turn, and takes the best value for the goal after expected cost and time. A launch with `important: true` (API, SDK) gets the best-known option, with no trying. Options that keep failing a kind of task are left out of it. Thinking harder starts out a little more likely to work and costs more, and then your outcomes decide. A model's record at one level counts half at its other levels.
 
@@ -319,7 +319,7 @@ After the run, Auto checks the work before it lands in your queue:
 3. **Repair**: new failures go back to the same agent (1 round by default, up to 2).
 4. **Hand over**: still failing, or the run errored, so the task runs again on a stronger tier (small → everyday → frontier) in its own worktree, next to the first run.
 
-A harness that says it's at its limit (session or usage limit, rate limit, no credit) isn't failing the task. Auto rests it until the limit resets, doesn't count the run against it, and moves the task to the best pick that can run now. Best always runs frontier models only (Opus, not Sonnet or Haiku); it falls back to the strongest you have only when no frontier model is installed. Until Auto has 20 of your own outcomes, Balanced picks only everyday and frontier models. The shipped estimates come from a small pilot, so they count for at most 4 tasks each.
+A harness that says it's at its limit (session or usage limit, rate limit, no credit) isn't failing the task. Auto rests it until the limit resets, doesn't count the run against it, and moves the task to the best pick that can run now. Best always runs frontier models only; it falls back to the strongest you have only when no frontier model is installed. Balanced runs on the strongest tier that can run now, whatever the record of the weaker models: frontier, or everyday (Sonnet, never Haiku) while every frontier model is at its limit or when you have none. The shipped estimates come from a small pilot, so they count for at most 4 tasks each.
 5. **Best of two** (goal Best, off by default): two picks work side by side; tests decide, then a cheap model reads both diffs, and the better run is marked **Pick**.
 
 Each step's outcome feeds the router: a test pass counts more than the agent's "done", needing a repair counts less, and losing a best-of-2 a little less again. Your own follow-up stops whatever Auto was about to do next. A launch on a machine is checked on that machine, where the files are. Settings → Auto turns each step on or off and sets the test command per project.
@@ -354,7 +354,7 @@ Before each turn, wisp snapshots the git working tree (pinned at `refs/wisp/chec
 Prepare release {version}: update CHANGELOG, README and docs/, bump package.json, tag v{version}.
 ```
 
-Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.22.0` fills the fields in order, `wisp run release version=0.22.0` by name.
+Make one from ⌘K → *Recipes*, or *Save as recipe…* on any card. A recipe may pin a project, harness, model and mode. Run it from ⌘K (*Run: Release*), from the Recipes view, or from a terminal: `wisp run release 0.23.0` fills the fields in order, `wisp run release version=0.23.0` by name.
 
 **Triggers** launch sessions on their own while wisp is open (⌘K → *Triggers*):
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wisp-agents",
-  "version": "0.22.0",
-  "description": "Launch coding agents, skip the transcript, read the presentation.",
+  "version": "0.23.0",
+  "description": "Run Claude Code, Codex, Cursor and other coding agents in parallel, in the background, on any of your machines. Skip the transcript, read the report.",
   "type": "module",
   "bin": {
     "wisp": "bin/wisp.js",
@@ -31,7 +31,17 @@
   "keywords": [
     "claude",
     "claude-code",
+    "codex",
+    "openai-codex",
+    "cursor",
+    "opencode",
     "coding-agent",
+    "ai-agents",
+    "multi-agent",
+    "parallel",
+    "git-worktree",
+    "ssh",
+    "orchestration",
     "ai",
     "agents",
     "cli",

package/server/router.js

@@ -2,8 +2,9 @@
 //
 // Every harness × model × thinking level the user has is an "arm" (claude:opus:high; no level is
 // the harness's default). The goal picks the band of levels: Cheap runs low, Balanced the default
-// or medium, Best high. Within the band the levels are learned like models are, and a model's
-// record at its other levels counts half. For each kind of task (bug, ui, docs, …) wisp
+// or medium, Best high. Balanced and Best both run frontier models when you have one, so the
+// level is what tells them apart. Within the band the levels are learned like models are, and a
+// model's record at its other levels counts half. For each kind of task (bug, ui, docs, …) wisp
 // keeps a Beta(wins, losses) estimate per arm, stacked from three sources: the shipped priors
 // (./router-priors.json, from wisp-bench), the user's history on every kind of task, and the
 // history on this kind. A launch draws a chance of success from each estimate (Thompson
@@ -27,13 +28,12 @@ const PRIORS = JSON.parse(fs.readFileSync(new URL('./router-priors.json', import
 
 export const GOALS = {
   cheap: { label: 'Cheap', value: 1, hint: 'Lowest cost that still gets it done' },
-  balanced: { label: 'Balanced', value: 5, hint: 'Best result per dollar' },
-  best: { label: 'Best', value: 50, hint: 'Frontier models only; cost only breaks ties' },
+  balanced: { label: 'Balanced', value: 5, hint: 'Frontier models at default or medium thinking' },
+  best: { label: 'Best', value: 50, hint: 'Frontier models at high thinking; cost only breaks ties' },
 };
 export const TYPES = ['bug', 'feature', 'ui', 'test', 'refactor', 'docs', 'release', 'question'];
 const MINUTE_USD = 0.05; // what a minute of waiting costs you, in the utility
 const PRIOR_CAP = 4; // shipped priors count as at most this many tasks, so your own soon outweigh them
-const COLD_START = 20; // until Auto has this many of your outcomes, Balanced and Best stay on stronger tiers
 const ALL_WEIGHT = 0.5; // your history on other kinds of task counts half
 const HALF_LIFE_MS = 30 * 864e5; // models change: older outcomes fade
 const NEW_ARM_SHARE = 0.25; // how often a new arm on probation may take an exploring slot
@@ -80,6 +80,17 @@ export const levelsFor = (efforts = [], goal = 'balanced') => {
   const have = (BANDS[goal] || BANDS.balanced).filter((e) => e === '' || efforts.includes(e));
   return have.length ? have : [''];
 };
+// Some harnesses bake the level into the model id (Antigravity's gemini-4-argon-high, no separate
+// selector): there the goal picks among a model's variants the same way.
+const SUFFIX = /-(minimal|low|medium|high|xhigh|max)$/;
+const NAMED = { cheap: ['minimal', 'low'], balanced: ['medium'], best: ['high', 'xhigh', 'max'] };
+const stemOf = (k) => baseOf(k).replace(SUFFIX, '');
+function byNamedLevel(cands, goal) {
+  const want = NAMED[goal] || NAMED.balanced;
+  const named = (c) => !c.efforts.length && c.model.match(SUFFIX)?.[1];
+  const fits = new Set(cands.filter((c) => want.includes(named(c))).map((c) => stemOf(c.key)));
+  return cands.filter((c) => !named(c) || want.includes(named(c)) || !fits.has(stemOf(c.key)));
+}
 const effortLabel = (e) => ({ xhigh: 'X-High' })[e] || e.charAt(0).toUpperCase() + e.slice(1);
 
 export const armKey = (agent, model = '', effort = '') => `${agent}:${model || ''}${effort ? `:${effort}` : ''}`;
@@ -99,10 +110,12 @@ export const baseOf = (k) => {
 };
 // Versions stripped: claude-sonnet-5-5 and claude-sonnet-5-6 are one family, and a new version
 // starts from what the family already showed.
-const family = (k) => k.replace(/[-.]?\d+([.-]\d+)*/g, '');
+// A level in the id is the same model too: gemini-4-argon-high starts from what -medium showed.
+const family = (k) => k.replace(SUFFIX, '').replace(/[-.]?\d+([.-]\d+)*/g, '');
 
 // How strong a model is, roughly: 1 small/fast/free, 2 everyday, 3 frontier. Best runs on tier 3
-// only, hand-overs step up a tier, and until Auto has your own outcomes Balanced stays on tier 2+.
+// only, Balanced on the strongest tier that can run (frontier when you have one), and hand-overs
+// step up a tier.
 // The shipped priors come from a small pilot that flattered cheap models; tiers keep them honest.
 const FRONTIER_DEFAULTS = new Set(['codex:']); // a harness whose default model is its frontier one
 export function tierOf(key) {
@@ -259,34 +272,38 @@ export class Router {
   // Pick an arm. agents: listAgents() of the place it runs. goal: cheap | balanced | best, which
   // also sets the band of thinking levels (levelsFor).
   // important: no exploring. exclude: arm keys already taken (compare, hand-overs): every level of
-  // that harness · model is out. needDelegate: the lead
-  // of a team must be a harness that can delegate. rng: for tests.
+  // that harness · model is out, and every variant of a model with its level in its id.
+  // needDelegate: the lead of a team must be a harness that can delegate. rng: for tests.
   // scouted: { type, size } from the scout, which beats the keyword guess.
   // minTier: only arms at least that strong (a hand-over steps up). Arms cooling down after a usage
   // or rate limit are skipped while any other arm can run.
   // Best runs frontier models only: if any is installed and allowed, Best never steps down a tier,
   // even when they're all taken or at their limit (null then). With none installed, the strongest.
+  // Balanced runs frontier models too, whatever its record of the others (Sonnet or Haiku winning
+  // a few tasks doesn't make them the face of Auto), and steps down a tier only while every
+  // frontier model is taken or at its limit, so the task still runs.
   choose({ prompt = '', attachments = 0, agents = [], goal = 'balanced', important = false, explore = true, exclude = [], needDelegate = false, allowed = null, scouted = null, minTier = 0, rng = Math.random } = {}) {
     if (!this.synced) this.sync(agents);
+    if (!GOALS[goal]) goal = 'balanced';
     const guess = classify(prompt, { attachments });
     const type = scouted?.type || guess.type;
     const size = scouted?.size || guess.size;
-    const V = (GOALS[goal] || GOALS.balanced).value;
-    const out = new Set(exclude.map(baseOf));
+    const V = GOALS[goal].value;
+    const out = new Set(exclude.map(stemOf));
     const usable = candidates(agents, new Set(Object.keys(this.state.arms))).filter((c) => (!needDelegate || c.delegates) && (!allowed || allowed.includes(c.agent)));
     const frontierOnly = goal === 'best' && usable.some((c) => tierOf(c.key) >= 3);
-    let arms = usable
-      .filter((c) => !out.has(c.key) && (!frontierOnly || tierOf(c.key) >= 3))
+    let arms = byNamedLevel(usable.filter((c) => !out.has(stemOf(c.key))), goal)
+      .filter((c) => !frontierOnly || tierOf(c.key) >= 3)
       .flatMap((c) => levelsFor(c.efforts, goal).map((effort) => ({ ...c, key: armKey(c.agent, c.model, effort), effort, label: `${c.label}${effort ? ` · ${effortLabel(effort)}` : ''}`, base: c.key })))
       .map((c) => ({ ...c, est: this.estimate(type, c.key), state: this.state.arms[c.base]?.state || 'new' }));
     if (!arms.length) return null;
     const free = arms.filter((x) => !this.cooling(x.key));
     if (!free.length) return null; // everything allowed is at its limit: nothing to route to now
     arms = free;
-    // Cold start: until there are enough of your own outcomes, lean to quality (the shipped priors
-    // are thin). Cheap is left alone: that goal asked for cheap.
-    const cold = this.learned() < COLD_START;
-    const floorTier = Math.max(minTier, goal === 'best' ? 3 : cold && goal !== 'cheap' ? 2 : 0);
+    // Balanced and Best run on the strongest tier that can run now, whatever the record of the
+    // weaker ones. Cheap is left alone: that goal asked for cheap.
+    const top = Math.max(...arms.map((x) => tierOf(x.key)));
+    const floorTier = Math.max(minTier, goal === 'cheap' ? 0 : top);
     for (let t = floorTier; t > 0; t--) {
       const strong = arms.filter((x) => tierOf(x.key) >= t);
       if (strong.length) {
@@ -323,7 +340,7 @@ export class Router {
       key: pick.key,
       label: pick.label,
       route: {
-        goal: GOALS[goal] ? goal : 'balanced',
+        goal,
         type,
         size,
         key: pick.key,
@@ -336,7 +353,6 @@ export class Router {
         explored: byMean[0].key !== pick.key,
         trying: pick.state === 'new',
         tier: tierOf(pick.key),
-        ...(cold && goal !== 'cheap' && goal !== 'best' && { coldStart: true }),
         propensity: round(hits / 200),
         alternatives: byMean.filter((x) => x.key !== pick.key).slice(0, 3).map((x) => ({ key: x.key, label: x.label, chance: round(x.est.mean), usd: round(x.est.usd) })),
         at: this.now(),
@@ -453,7 +469,6 @@ export class Router {
     return {
       priors: { version: PRIORS.version, source: PRIORS.source },
       learned: routes.filter((r) => r.r !== null).length,
-      coldStart: { needed: COLD_START, have: this.learned() },
       routed: routes.length,
       arms,
       recent: routes.sort((p, q) => q.at - p.at).slice(0, 30).map((r) => ({ id: r.id, key: r.key, label: r.label, type: r.type, goal: r.goal, chance: r.chance, r: r.r, explored: r.explored, trying: r.trying, at: r.at, signals: r.signals })),

package/web/js/features/auto.js

@@ -25,7 +25,7 @@ export async function openRouter({ host } = {}) {
     if (!r || !node.isConnected) return;
     const arms = r.arms.filter((a) => a.state !== 'gone' || a.n);
     $('.ro-body', node).innerHTML = `
-      <p class="hint">For each task Auto estimates every harness · model · thinking level’s chance of doing it well, from wisp-bench (${esc(r.priors.version)}) and then more and more from your own tasks: merged PRs, 👍 / 👎, rollbacks, follow-ups and how the run ended. It picks the best value for your goal (<b>${esc(AUTO_GOALS.find((g) => g.id === r.goal)?.label || '')}</b>), which also sets how hard it thinks: Cheap low, Balanced default or medium, Best high. Best runs frontier models only (Opus, not Sonnet or Haiku). Now and then it tries an alternative so the estimates stay honest.${r.coldStart && r.coldStart.have < r.coldStart.needed ? ` Until it has ${r.coldStart.needed} of your own outcomes (${r.coldStart.have} so far), Balanced uses everyday and frontier models only.` : ''}</p>
+      <p class="hint">For each task Auto estimates every harness · model · thinking level’s chance of doing it well, from wisp-bench (${esc(r.priors.version)}) and then more and more from your own tasks: merged PRs, 👍 / 👎, rollbacks, follow-ups and how the run ended. It picks the best value for your goal (<b>${esc(AUTO_GOALS.find((g) => g.id === r.goal)?.label || '')}</b>), which also sets how hard it thinks: Cheap low, Balanced default or medium, Best high. Balanced and Best run frontier models (Opus, not Sonnet or Haiku) when you have one; Balanced steps down to an everyday model only while every frontier one is at its limit. Now and then it tries an alternative so the estimates stay honest.</p>
       <h4>Harness · model · thinking</h4>
       <table class="us-table ro-table"><thead><tr><th></th><th>Works</th><th>Your tasks</th><th>~Cost</th><th>~Time</th><th></th></tr></thead><tbody>${arms
         .map((a) => {

package/web/js/features/runners.js

@@ -21,9 +21,9 @@ export const agentName = (id) => S.agents.find((a) => a.id === id)?.name || (id
 // level per task. Its "models" are the goal it optimises for, which also sets the level band, so
 // there are no thinking levels to pick here.
 export const AUTO_GOALS = [
-  { id: 'balanced', label: 'Balanced', hint: 'Best result per dollar · default or medium thinking' },
+  { id: 'balanced', label: 'Balanced', hint: 'Frontier models · default or medium thinking' },
   { id: 'cheap', label: 'Cheap', hint: 'Lowest cost that still gets it done · low thinking' },
-  { id: 'best', label: 'Best', hint: 'Best result; cost only breaks ties · high thinking' },
+  { id: 'best', label: 'Best', hint: 'Frontier models · high thinking; cost only breaks ties' },
 ];
 export const AUTO = { id: 'auto', name: 'Auto', available: true, delegates: true, models: AUTO_GOALS, efforts: [], hint: 'wisp picks the harness, model and thinking level from what worked before' };