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

Effort per Model

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.

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 Google AI Pro and JetBrains All Products Pack add-ons. The Source column shows which of the two 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 <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_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

References

Plan Notes

Pricing Sources