Balancing the Anvil

This page lists the models on the anvil, the CLI that launches each, the effort each targets, and what the plans cost. 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. riff is a bash function. riff <model> starts that model's CLI in the current directory with the model and effort flags preset.

Model Coverage

Effort per Model

Cost

A tier is a combined monthly spend across one Claude plan and one ChatGPT plan. Two ladders climb the same seven tiers, one focused on Anthropic and the other on OpenAI. They are alternatives, not stages. A higher tier buys more usage of the same tools. What a free tier includes changes often, so check the vendor's plan page before you count on it. Pick the ladder focused on the model you reach for most, since the money buys depth in one vendor rather than savings. If you have no preference yet, either ladder's Apprentice tier is a fine place to start.

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.

See plan notes.

Urda's Anvil

Urda runs the Anvil Professional tier of the Anthropic Focused ladder, plus the JetBrains All Products Pack add-on. Google sits on the Free tier. The Source column shows where each plan comes from.

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.

# riff opus, riff sonnet: one vendor, one effort, nothing else
riff() { claude --model "${1}" --effort high "${@:2}"; }

# 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 high  "${@}"; }
  _riff_cmd_astra()  { _riff_shell codex  --model gpt-6-astra --config "model_reasoning_effort='low'"    "${@}"; }
  _riff_cmd_sol()    { _riff_shell codex  --model gpt-6.1-sol --config "model_reasoning_effort='low'"    "${@}"; }
  _riff_cmd_terra()  { _riff_shell codex  --model gpt-6.1-terra --config "model_reasoning_effort='low'"  "${@}"; }
  _riff_cmd_luna()   { _riff_shell codex  --model gpt-6-luna  --config "model_reasoning_effort='medium'" "${@}"; }
  _riff_cmd_lite()   { _riff_shell junie  --model junie-lite "${@}"; }

  # 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

References

Plan Notes

Pricing Sources