Balancing the Anvil

These are the models on the anvil, the frontier. Each runs with a simple riff command, so you can focus on the model and the work at hand.

Model Coverage

Default Harness

Alternate Harness

Unavailable

Which model each CLI runs, and the riff command that launches it.
Model	Claude	Junie	Codex	Antigravity
Anthropic / Claude
Fable 5.1	default harnessriff fable	alternate harness	unavailable	unavailable
Opus 5.5	default harnessriff opus	alternate harness	unavailable	unavailable
Sonnet 5	default harnessriff sonnet	alternate harness	unavailable	unavailable
Haiku 4.5	default harnessriff haiku	unavailable	unavailable	unavailable
OpenAI / GPT
GPT-6 Astra	unavailable	alternate harness	default harnessriff astra	unavailable
GPT-6 Sol	unavailable	alternate harnessriff junie	default harnessriff sol	unavailable
GPT-6 Luna	unavailable	alternate harness	default harnessriff luna	unavailable
Google / Gemini
Gemini 3.1 Pro	unavailable	unavailable	unavailable	default harnessriff gemini-pro
Gemini 3.8 Flash	unavailable	alternate harness	unavailable	default harnessriff gemini-flash

Effort per Model

The reasoning effort each riff targets, beside the vendor's default.
Model	Vendor Default	Anvil Target	Change
Anthropic / Claude
Fable 5.1	high	high	unchanged
Opus 5.5	medium	high	raised
Sonnet 5	high	xhigh	raised
Haiku 4.5	unavailable
OpenAI / GPT
GPT-6 Astra	low	low	unchanged
GPT-6 Sol	medium	medium	unchanged
GPT-6 Luna	medium	medium	unchanged
Google / Gemini
Gemini 3.1 Pro	high	high	unchanged
Gemini 3.8 Flash	medium	medium	unchanged

Cost

Each step up the ladder adds more capability to the anvil. Two ladders climb the same seven tiers, one focused on Anthropic and the other on OpenAI. They are alternatives, not stages. Pick the ladder focused on the model you reach for most, since the money buys depth in one vendor rather than savings.

Anthropic Focused

Cost by tier and vendor, with Anthropic in focus. Each vendor row merges the tiers a plan covers into one span; a colored left edge marks the tier where a plan upgrades. Each cell leads with the monthly and shows the yearly beneath; the totals row gives an effective monthly and the yearly.
Vendor	Starter	Apprentice	Journeyman	Professional	Elite	Ultimate	Mythic
Anthropic	Free	Claude Pro≈$17/mo$200/yr	Claude Max 5x$100/mo$1,200/yr		Claude Max 20x$200/mo$2,400/yr
OpenAI	Free			ChatGPT Plus$20/mo$240/yr		ChatGPT Pro 5x$100/mo$1,200/yr	ChatGPT Pro 20x$200/mo$2,400/yr
Total	$0/mo$0/yr	≈$17/mo$200/yr	$100/mo$1,200/yr	$120/mo$1,440/yr	$220/mo$2,640/yr	$300/mo$3,600/yr	$400/mo$4,800/yr

OpenAI Focused

The same seven tiers with OpenAI in focus instead. Each vendor row merges the tiers a plan covers into one span; a colored left edge marks the tier where a plan upgrades. Each cell leads with the monthly and shows the yearly beneath; the totals row gives an effective monthly and the yearly.
Vendor	Starter	Apprentice	Journeyman	Professional	Elite	Ultimate	Mythic
Anthropic	Free			Claude Pro≈$17/mo$200/yr		Claude Max 5x$100/mo$1,200/yr	Claude Max 20x$200/mo$2,400/yr
OpenAI	Free	ChatGPT Plus$20/mo$240/yr	ChatGPT Pro 5x$100/mo$1,200/yr		ChatGPT Pro 20x$200/mo$2,400/yr
Total	$0/mo$0/yr	$20/mo$240/yr	$100/mo$1,200/yr	≈$117/mo$1,400/yr	≈$217/mo$2,600/yr	$300/mo$3,600/yr	$400/mo$4,800/yr

*Anthropic Claude Pro bills at $20 per month or $200 per year. This anvil example assumes the annual rate, which saves $40.

Add-ons (optional at any tier, not counted in the totals above)

You can reach for a tool without building around it. Two ladders, any number of add-ons. Gemini rides free on both of them, which is why Google sits here instead of climbing a third. JetBrains sits here too, since the IDEs are a choice and not every anvil runs them.

Optional add-ons. These attach to any tier and are not included in any total above. The monthly and yearly columns give each add-on's own cost.
Vendor	Plan	Monthly	Yearly
Google	AI Plus	$5	$50
	AI Pro	$20	$200
	AI Ultra	$100	$1,200
JetBrains	All Products Pack, year 1	$25	$299
	All Products Pack, year 2	$20	$239
	All Products Pack, year 3+	$15	$179
	AI Ultimate	$25	$300

*Google AI Plus costs $4.99 per month, AI Pro $19.99, and AI Ultra $99.99, rounded here to $5, $20, and $100 for simplicity. AI Plus and AI Pro also have an annual rate, $49.99 and $199.99, rounded here to $50 and $200. AI Ultra has no annual rate, so its yearly figure is twelve monthly payments.

*JetBrains All Products Pack is billed yearly, at $299 the first year, $239 the second, then $179 onwards. Its monthly figures are the yearly price divided by twelve, rounded to the nearest dollar.

*JetBrains AI Ultimate is billed yearly at $300.

Urda's Anvil

Urda runs the Anvil Professional tier of the Anthropic Focused ladder, plus the Google AI Pro and JetBrains All Products Pack add-ons. The Source column shows which of the two each plan comes from.

The plan Urda runs today. One row per vendor. The Source column reads Anvil Professional for a plan from the Professional tier of the Anthropic Focused ladder. It reads Add-on for a chosen add-on. The last row gives the combined total.
Vendor	Plan	Source	Monthly	Yearly
Anthropic	Claude Max 5x	Anvil Professional	$100	$1,200
OpenAI	ChatGPT Plus	Anvil Professional	$20	$240
Google	AI Pro	Add-on	$20	$200
JetBrains	All Products Pack	Add-on	≈$15	$179
Total			≈$152	$1,819

The riff bill of rights

What is a riff? A short shell command, named after a musical riff, a phrase you play again and again. A riff bakes in your model of choice and any additional arguments you want. You can have as many as you like; think of them as shortcuts you reach for often.

Each model is a subcommand of one riff command, such as riff opus.
Launches from your home directory or / are prevented and redirected into a sandbox (~/sandbox, created on first use).
Your original directory is restored when you are done.
The CLI runs in the foreground, and its exit code should return to the calling shell.
Tab completes the model name.
Extra arguments pass straight through to the CLI.

An example riff setup in bash 4+

# riff <model> [args...]: one launcher, one model per subcommand
riff() {
  # the shared engine every model calls: run the CLI (blocking), then
  # restore your working directory when the CLI exits, via a trap
  _riff_shell() {
    local bin="${1}" origin="${PWD}" sandbox="${AI_SHELL_SANDBOX:-${HOME}/sandbox}"; shift
    # never turn an agent loose in your home dir (ssh keys, dotfiles, creds) or at /; sandbox it
    # defaults to ~/sandbox, created on first use; override with AI_SHELL_SANDBOX
    if [[ "${PWD}" == "${HOME}" || "${PWD}" == "/" ]]; then
      mkdir -p "${sandbox}" || return
      cd "${sandbox}" || return
    fi

    # ~~~~~ make it yours here: customizations, tab title, color, whatever ~~~~~

    trap 'trap - RETURN; cd "${origin}"' RETURN  # back to where you started when the CLI exits
    "${bin}" "${@}"                              # keep last so a Ctrl-C still runs the cleanup
  }

  # each model is just a thin declaration: a client, a model, and any flags you want
  # defining a _riff_cmd_* function is all it takes to register it
  _riff_cmd_fable()  { _riff_shell claude --model fable  --effort high  "${@}"; }
  _riff_cmd_opus()   { _riff_shell claude --model opus   --effort high  "${@}"; }
  _riff_cmd_sonnet() { _riff_shell claude --model sonnet --effort xhigh "${@}"; }
  _riff_cmd_astra()  { _riff_shell codex  --model gpt-6-astra --config "model_reasoning_effort='low'"    "${@}"; }
  _riff_cmd_sol()    { _riff_shell codex  --model gpt-6-sol   --config "model_reasoning_effort='medium'" "${@}"; }
  _riff_cmd_luna()   { _riff_shell codex  --model gpt-6-luna  --config "model_reasoning_effort='medium'" "${@}"; }

  # Tab completion: bash sets COMP_LINE only when it calls riff as a completer
  if [[ -n "${COMP_LINE:-}" ]]; then
    COMPREPLY=()
    [[ "${COMP_CWORD}" -eq 1 ]] || return 0  # complete the model name only
    mapfile -t COMPREPLY < <(compgen -W "$(compgen -A function _riff_cmd_ | sed 's/^_riff_cmd_//')" -- "${COMP_WORDS[COMP_CWORD]}")
    return 0
  fi

  # dispatch: riff opus -> _riff_cmd_opus, with any extra args passed along
  local cmd="${1:-}"
  shift
  if declare -F "_riff_cmd_${cmd}" >/dev/null; then
    "_riff_cmd_${cmd}" "${@}"
  else
    printf 'usage: riff <model> [args...] (press Tab to list models)\n' >&2
    return 2
  fi
}
complete -F riff riff