# Claude Opus 5.5 Disabled in Claude Code? Why Homebrew Says You’re Up to Date and How to Fix It

Seeing Opus 5.5 disabled in Claude Code? Learn why Homebrew can lag behind 2.1.280 and how to upgrade safely on macOS.

Canonical URL: https://aiidelist.com/blog/claude-opus-5-5-disabled-update-2-1-280

Language: en

Published: 2026-09-23

Updated: 2026-09-23

## Key Takeaways

- **Claude Opus 5.5 requires Claude Code 2.1.280 or newer.** Anthropic added `claude-opus-5-5` in Claude Code 2.1.280 and made it the default Opus model.
- If Claude Code shows `Opus 5.5 (disabled) — Update to 2.1.280+ to use Opus 5.5`, the first thing to check is the local CLI version with `claude --version`.
- **Homebrew can report that Claude Code is fully up to date even when it is behind Anthropic's newest upstream release.** As of September 23, 2026, Homebrew's `claude-code` cask is 2.1.267 and `claude-code@latest` is 2.1.278, both below the 2.1.280 requirement.
- Anthropic's npm package has already reached 2.1.280, so switching from the lagging Homebrew cask to the official npm package is a practical fix when immediate Opus 5.5 access is needed.
- If the version is already 2.1.280+ but Opus 5.5 is still unavailable, check for multiple `claude` binaries, shell path caching, organization model restrictions, or a gateway/provider that has not exposed the model yet.

## Why Does Claude Code Say Opus 5.5 Is Disabled?

The message is primarily a **client-version compatibility warning**.

Claude Code 2.1.280 added the model entry `claude-opus-5-5`. Anthropic's changelog also identifies Opus 5.5 as the new default Opus model and lists a 1M-token context window, API pricing of $4 per million input tokens and $20 per million output tokens, plus $0.20 per million cache-read tokens.

That means an older Claude Code build can know that a newer model exists while still refusing to activate it because the local client does not contain the required model support.

A typical symptom looks like this:

```text
Opus 5.5 (disabled)
Update to 2.1.280+ to use Opus 5.5
```

The important part is `2.1.280+`. This is not the same as a generic subscription error. The local executable must first satisfy the minimum client version.

Check it with:

```bash
claude --version
```

If the result is:

```text
2.1.267 (Claude Code)
```

then the disabled state is expected.

## Why `brew upgrade claude-code` Can Say Nothing Needs Updating

This is the confusing part.

A package manager only knows about the newest version available **inside its own repository or channel**. It does not necessarily track the newest upstream release in real time.

As of September 23, 2026, Homebrew reports:

- `claude-code`: **2.1.267**
- `claude-code@latest`: **2.1.278**

Meanwhile, Anthropic has published Claude Code **2.1.280**, which is the release that adds Opus 5.5.

So this output is internally consistent:

```text
Warning: Not upgrading claude-code, the latest version is already installed
```

Homebrew is effectively saying:

**The newest version currently available through this Homebrew cask is already installed.**

It is not saying:

**No newer Claude Code release exists upstream.**

This distinction matters whenever a newly launched model requires a same-day or near-same-day CLI update.

## The Fastest Fix on macOS

First confirm the installed version and the binary being executed:

```bash
claude --version
which -a claude
type -a claude
```

If the active version is below 2.1.280 and it came from Homebrew, one clean approach is to remove the lagging cask and install Anthropic's official npm package.

```bash
brew uninstall --cask claude-code
npm install -g @anthropic-ai/claude-code@latest
hash -r
claude --version
```

Anthropic's setup documentation supports global npm installation and specifically warns against using `sudo npm install -g`, because doing so can create permission and security problems. The documentation also recommends `claude doctor` for installation diagnostics.

After installation, the version should be at least:

```text
2.1.280 (Claude Code)
```

Then launch Claude Code again:

```bash
claude
```

Inside the session, open the model selector:

```text
/model
```

Claude Code's command documentation confirms that `/model` is the interactive model-selection command.

## Verify npm Before Changing Anything

Developers who want to avoid changing installation methods blindly can first inspect the npm version:

```bash
npm view @anthropic-ai/claude-code version
```

At the time of writing, the package has reached 2.1.280.

Then compare it with the local binary:

```bash
claude --version
```

If npm reports 2.1.280 or newer but Claude Code reports 2.1.267, the problem is no longer model availability. It is an installation or path issue.

## Check for Multiple Claude Code Installations

This is one of the most common reasons an upgrade appears to succeed while `claude --version` remains unchanged.

Run:

```bash
which -a claude
type -a claude
```

On macOS, several paths may appear, for example:

```text
/opt/homebrew/bin/claude
/Users/yourname/.nvm/versions/node/vXX.X.X/bin/claude
/Users/yourname/.local/bin/claude
```

That means more than one Claude Code executable is installed.

Typical sources include:

- Homebrew
- npm installed through the system Node.js
- npm installed through `nvm`
- Anthropic's native/local installer
- an older binary left in `~/.local/bin`

The shell executes the first matching binary in `PATH`. Updating one copy does not automatically update the others.

Use this sequence to identify the active one:

```bash
command -v claude
which -a claude
claude --version
```

If an old Homebrew binary appears before a newer npm binary, either remove the old installation or correct the `PATH` order.

## Clear the Shell Command Cache

Zsh and Bash can cache command locations.

After changing installations, run:

```bash
hash -r
```

For Zsh, reopening the terminal is also an easy way to eliminate stale command resolution.

Then verify again:

```bash
which -a claude
claude --version
```

This small step prevents a surprisingly common false negative where the new package is installed correctly but the current shell still resolves an older command path.

## Use `claude doctor` to Diagnose the Installation

Anthropic provides an installation diagnostic command:

```bash
claude doctor
```

The official setup documentation recommends it for checking the installation type and troubleshooting update problems.

This is particularly useful when Claude Code has been installed through more than one method over time.

A clean troubleshooting order is:

1. Check `claude --version`.
2. Check `which -a claude`.
3. Run `claude doctor`.
4. Upgrade or replace the outdated installation.
5. Clear the shell command cache.
6. Verify the version again.
7. Reopen `/model`.

## What About `claude update`?

Claude Code supports:

```bash
claude update
```

Anthropic documents this as the manual update command.

It is worth trying first because it is simple and preserves the current setup.

However, package-manager installations can still depend on the package source having the new version available. Claude Code also exposes package-manager-specific update behavior for Homebrew and WinGet installations.

If Homebrew's available cask is still below 2.1.280, repeatedly running `brew upgrade claude-code` will not create a version that Homebrew has not published yet.

That is why changing to the current official npm package can be the fastest workaround during a release-window mismatch.

## Should You Use `claude-code@latest` Instead?

Normally, this is a reasonable option:

```bash
brew uninstall --cask claude-code
brew install --cask claude-code@latest
```

But at the time of writing, Homebrew lists `claude-code@latest` as **2.1.278**, while Opus 5.5 requires **2.1.280+**.

So moving from Homebrew's 2.1.267 stable cask to its 2.1.278 latest cask may make the CLI newer, but it still does not satisfy the Opus 5.5 requirement.

This is a time-sensitive detail. Homebrew may catch up shortly after publication, so always recheck the current package version before switching installation methods.

## Why the Model Can Appear in `/model` Before You Can Use It

A disabled model entry can seem contradictory: if Claude Code is too old, why does it know Opus 5.5 exists?

Modern developer tools often combine local capabilities with server-delivered metadata. A client can therefore display information about a newly available model while still gating activation behind a minimum local version.

The practical model is:

```text
Claude service exposes a new model
        ↓
Claude Code displays the model entry
        ↓
Local client version is checked
        ↓
Client is older than 2.1.280
        ↓
Opus 5.5 remains disabled
```

The 2.1.280 changelog confirms that `claude-opus-5-5` itself was added in that release, which explains why the minimum-version gate matters.

## What Changed in Claude Code 2.1.280?

The most relevant change is straightforward:

**Claude Opus 5.5 was added to Claude Code as `claude-opus-5-5`.**

Anthropic also made it the default Opus model. The same changelog records a 1M context window and the model's token pricing.

For developers, the larger context window can matter when Claude Code needs to reason across:

- large monorepos
- long debugging sessions
- multi-file architectural refactors
- extensive logs and test output
- large specifications or migration plans

A larger context window does not mean every session should consume one million tokens. It means the client can preserve substantially more relevant working context before compaction becomes necessary.

## Updated to 2.1.280+ but Opus 5.5 Is Still Disabled?

Version compatibility is necessary, but it may not be the only requirement.

Check these possibilities.

**1. The wrong binary is still running**

```bash
which -a claude
claude --version
```

If multiple versions appear, resolve the path conflict.

**2. The terminal cached the old command**

```bash
hash -r
claude --version
```

**3. Claude Code needs to be restarted**

Close the current session and launch a new one after upgrading.

**4. The model selector is using managed configuration**

Claude Code supports organization-level model controls, custom model mappings, gateways, and an `availableModels` allowlist. Gateway-discovered models can also be filtered by that allowlist.

If the CLI version is correct but the model is absent or unavailable in a managed environment, check the organization's Claude Code configuration rather than reinstalling repeatedly.

**5. A third-party provider or gateway is involved**

Claude Code can route through custom Anthropic-compatible gateways and cloud-provider configurations. A local Claude Code update cannot force an external provider or internal gateway to expose a model it does not yet support.

For direct Anthropic users, this layer is usually simpler. For enterprise environments, model rollout can involve both the Claude Code client and the configured provider.

## The Permission Wildcard Warning Is a Separate Issue

Another message can appear when starting Claude Code:

```text
Permission allow rule (.claude/settings.local.json) ... has a wildcard before the rest of the command ...
```

This warning is **not what disables Opus 5.5**.

Claude Code reads project-local configuration from `.claude/settings.local.json`, including permission rules. Anthropic documents `settings.local.json` as a project-only local override file, and `/permissions` can be used to review permission rules interactively.

The warning means an allow rule is broad enough that extra command options could potentially match without another permission prompt.

Review the rule with:

```text
/permissions
```

or inspect:

```text
.claude/settings.local.json
```

The safe fix is to narrow or remove the over-broad allow rule rather than suppress the warning.

This matters even more when Claude Code is started with:

```bash
claude --dangerously-skip-permissions
```

Anthropic's CLI documentation describes `--dangerously-skip-permissions` as bypassing permission prompts and explicitly says to use it with caution.

Updating to Opus 5.5 does not require this flag.

## Recommended Clean Upgrade Workflow

For a Mac currently running Claude Code 2.1.267 from Homebrew, this is a concise migration path:

```bash
claude --version
which -a claude
brew uninstall --cask claude-code
npm install -g @anthropic-ai/claude-code@latest
hash -r
which -a claude
claude --version
claude doctor
```

Then start a fresh session:

```bash
claude
```

And select the model:

```text
/model
```

The target is simple: **the executable actually being launched must report Claude Code 2.1.280 or newer.**

Avoid assuming that an installer succeeded merely because it returned without an error. Always verify the executable path and version afterward.

## Common Mistakes

- **Running `brew upgrade claude-code` repeatedly.** If Homebrew has not published 2.1.280 yet, nothing changes.
- **Installing npm 2.1.280 without removing or checking the Homebrew binary.** The older binary may still come first in `PATH`.
- **Using `sudo npm install -g`.** Anthropic's setup documentation advises against it.
- **Assuming the permission-rule warning caused the model issue.** It is a separate configuration warning.
- **Skipping `claude --version` after upgrading.** This makes it easy to miss a stale executable.
- **Assuming 2.1.280 guarantees access in every enterprise setup.** Managed model allowlists and external gateways can independently affect model availability.

## Quick Diagnostic Checklist

Run:

```bash
claude --version
which -a claude
npm view @anthropic-ai/claude-code version
claude doctor
```

Then interpret the results:

- **Claude Code < 2.1.280:** upgrade the client.
- **npm >= 2.1.280 but local Claude < 2.1.280:** likely an installation or `PATH` conflict.
- **Local Claude >= 2.1.280 but model still unavailable:** restart Claude Code and check `/model`, managed model policy, gateway configuration, and account/provider availability.
- **Homebrew says latest but local version is 2.1.267:** Homebrew's cask is current for its channel but behind upstream.
- **A permission wildcard warning appears:** fix the permission rule separately; it is not the Opus 5.5 version gate.

## Conclusion

The `Opus 5.5 (disabled) — Update to 2.1.280+ to use Opus 5.5` message is usually straightforward: **the installed Claude Code binary is too old for the new model**.

The confusing case is macOS users who installed Claude Code through Homebrew. On September 23, 2026, Homebrew's stable `claude-code` cask is still 2.1.267 and its `claude-code@latest` cask is 2.1.278, while Anthropic has already published 2.1.280 with Opus 5.5 support.

For immediate access, verify the current binary, move to an installation source that provides 2.1.280+, clear the shell command cache, and confirm the active executable with `claude --version`.

The final check is not whether an installer says it succeeded. The final check is whether the Claude Code binary that actually runs is **2.1.280 or newer** and Opus 5.5 is selectable from `/model`.