Claude Code + GPT-5.6 Sol: Why One Developer Was Suspended—and What Anthropic Actually Said

Introduction

A small experiment in mixing AI coding tools turned into one of the more revealing developer-platform disputes of August 2026.

The recipe looked simple:

Claude Code CLI
→ local proxy
→ GPT-5.6 Sol

Instead of replacing Claude Code itself, the setup kept its terminal interface, tools, permissions, agent workflow, and session behavior while routing model inference to OpenAI’s GPT-5.6 Sol.

OpenAI Codex lead Thibault “Tibo” Sottiaux had publicly shared a quick version of the setup in July.

His message was playful: if the configuration got blocked, he said he would owe users a Codex reset.

A month later, developer Alex Getman said he followed the setup almost exactly and was suspended by Anthropic shortly afterward for “suspicious signals.”

That immediately raised a practical question:

Does Anthropic prohibit using Claude Code as an agent harness with a non-Claude model?

Claude Code lead Boris Cherny answered publicly.

He said Anthropic does not ban users simply for using harnesses with other models and said the suspension was almost certainly caused by a different account classifier.

That sounds like a clean resolution.

It is not quite that simple.

Anthropic’s current documentation also says that although Claude Code can connect to compatible LLM gateways, Anthropic does not support routing Claude Code to non-Claude models through those gateways.

Those statements are not contradictory.

They mean:

Using another model in the harness
≠ an automatic ban reason

but

Using another model in the harness
≠ an Anthropic-supported configuration

That distinction is the most important lesson from the incident.

Tibo’s Five-Minute Claude Code + GPT Setup

The story began with developers comparing coding models inside different agent harnesses.

A model is only one part of an AI coding product.

The harness also determines:

• Which tools the model can call.
• How files are read and edited.
• How permissions work.
• How subagents are spawned.
• How context is managed.
• How terminal commands are executed.
• How long-running sessions are compacted.
• How failures are retried.

That means the same underlying model can feel different when placed inside another agent environment.

Sottiaux publicly encouraged experimentation with GPT-5.6 Sol inside the Claude Code harness.

His high-level recipe had three steps:

1. Install CLIProxyAPI.
2. Connect the desired provider.
3. Define a claudex alias and launch Claude Code with the alternate model configuration.

The alias shown in his July post was:

alias claudex='CLAUDE_CODE_SUBAGENT_MODEL=gpt-5.6-sol \
CLAUDE_CODE_ALWAYS_ENABLE_EFFORT=1 \
CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY=3 \
ENABLE_TOOL_SEARCH=false \
claude --model gpt-5.6-sol'

Sottiaux ended the post with a joke that became important later:

If the setup got blocked, he owed users a reset.

The command itself does not magically translate OpenAI traffic into Anthropic traffic.

The other piece is the proxy.

What CLIProxyAPI Does

CLIProxyAPI is an open-source proxy server that exposes several API-compatible interfaces and can connect command-line AI tools to multiple model providers.

Its project describes support for:

• OpenAI-compatible APIs.
• Anthropic-compatible APIs.
• Gemini-compatible APIs.
• Codex access.
• Claude Code.
• Grok.
• Multiple accounts.
• Streaming.
• Tool calls.
• Compatible upstream providers.

In this particular workflow, the proxy sits between Claude Code and the provider account.

A simplified architecture looks like:

claudex
   ↓
Claude Code CLI
   ↓
localhost proxy
   ↓
protocol translation / routing
   ↓
OpenAI provider account
   ↓
GPT-5.6 Sol

Getman’s later public implementation describes the path more explicitly:

claudex  ──►  Claude Code CLI  ──►  127.0.0.1:8317  ──►  provider account
                 unmodified            CLIProxyAPI          GPT / other model

claude   ──►  Claude Code CLI  ──►  api.anthropic.com

The normal claude command can remain untouched while the alternate command uses a local route.

This is why the experiment attracted attention.

It does not require patching the Claude Code executable itself.

The Claude Code CLI Remains the Harness

The setup separates two layers that are often treated as one product.

Harness Layer

Claude Code still provides the user-facing execution environment:

• Terminal interface.
• File tools.
• Permissions.
• Skills.
• Agent behavior.
• Session management.
• MCP integrations.
• Subagents.

Model Layer

GPT-5.6 Sol performs the underlying inference after the proxy translates or routes the request.

Conceptually:

Claude Code
= orchestration and tools

GPT-5.6 Sol
= model inference

That modularity is becoming more important as developers compare not just models, but model + harness combinations.

It is also where support boundaries become less obvious.

Claude Code Officially Supports LLM Gateways—but With a Major Caveat

Anthropic’s current Claude Code documentation has an entire section for LLM gateways.

It says organizations can route Claude Code through a gateway they already operate.

Documented use cases include:

• Centralized authentication.
• Usage tracking.
• Rate limits.
• Budget controls.
• Provider routing.
• Enterprise policy enforcement.

Claude Code can be configured with variables such as:

ANTHROPIC_BASE_URL

and provider-specific base URL settings.

Current Claude Code documentation also supports custom model identifiers and gateway aliases.

However, Anthropic states an important boundary:

It does not support routing Claude Code to non-Claude models through any gateway.

In practical terms, there are three different concepts:

Concept	Status
Claude Code through an approved/compatible gateway to Claude	Documented Anthropic use case
A third-party gateway that exposes a compatible API	Can technically work; Anthropic does not endorse or audit the gateway
Claude Code routed through a gateway to a non-Claude model	Technically possible in some setups, but explicitly not supported by Anthropic

“Not supported” does not necessarily mean “prohibited.”

It means Anthropic does not promise compatibility, troubleshooting, correctness, or continued operation for that configuration.

That distinction became central after Getman’s suspension.

The Developer Who Followed the Recipe Was Suspended

On August 9, Alex Getman posted that he had reproduced Sottiaux’s setup almost exactly.

He said the configuration used:

• The official Claude Code CLI.
• No patching of Claude Code itself.
• A localhost-only proxy.
• GPT-5.6 Sol as the routed model.
• A provider account he already paid for.

Shortly after testing it, he said Anthropic suspended his account.

According to Getman, the stated reason was:

suspicious signals

He submitted an appeal and publicly asked both Anthropic and OpenAI whether the configuration itself was prohibited.

That was an important question because there were several possible explanations.

Possibility 1: The Model Routing Was Prohibited

Anthropic could have considered using Claude Code with another model a policy violation.

Possibility 2: The Proxy Looked Like Account Abuse

The traffic pattern might have resembled automation, credential misuse, or another suspicious account signature.

Possibility 3: The Suspension Was Unrelated

Another account signal could have triggered the classifier at approximately the same time.

Possibility 4: A Classifier Produced a False Positive

The system may simply have misclassified otherwise legitimate activity.

Cherny’s public response strongly favored the fourth explanation.

Boris Cherny: “We Don’t Ban People for Using Harnesses With Other Models”

Claude Code lead Boris Cherny responded directly.

His statement was concise:

• Anthropic does not ban people for using harnesses with other models.
• The suspension was almost certainly caused by another account classifier.
• The team was looking into it.

This is the clearest public statement associated with the incident.

It answers the narrow policy question raised by Getman:

Simply using a coding harness with another model is not, according to Cherny, itself a reason Anthropic bans an account.

But this statement should be read together with Anthropic’s documentation.

The official documentation still says Anthropic does not support non-Claude routing.

Those two statements describe different layers.

“Not a Ban Reason” Is Not the Same as “Officially Supported”

Developers often collapse platform status into two categories:

allowed
or
forbidden

Real product support is more nuanced.

A configuration can be:

1. Officially supported.
2. Technically possible but unsupported.
3. Discouraged.
4. Prohibited by policy.
5. Blocked technically.

The Claude Code + non-Claude gateway pattern currently sits closest to:

technically possible
+
not a ban reason according to the Claude Code lead
+
not supported by Anthropic documentation

That means users should not assume Anthropic support will debug problems such as:

• Tool-schema incompatibility.
• Streaming differences.
• Context-window mismatches.
• Unsupported beta headers.
• Tool-search failures.
• Prompt-format translation.
• Subagent behavior.
• Changes after Claude Code upgrades.

The proxy owner—not Anthropic—effectively becomes responsible for keeping the translation layer working.

Why Tool Search Was Disabled in the Shared Alias

One detail in Sottiaux’s alias is:

ENABLE_TOOL_SEARCH=false

Current Anthropic documentation helps explain why this can matter.

Claude Code’s MCP tool search uses model and protocol features that a custom ANTHROPIC_BASE_URL or compatibility proxy may not forward correctly.

Anthropic’s current MCP documentation notes that tool search behavior can differ when:

• A custom ANTHROPIC_BASE_URL is used.
• ENABLE_TOOL_SEARCH=false is set.
• The model does not support the required tool-reference behavior.
• A gateway does not forward the relevant beta features.

This is a good example of why a proxy can preserve most of the Claude Code harness while still changing edge-case behavior.

The interface may look identical.

The protocol path is not identical.

Current Claude Code Supports Custom Model Options

Claude Code’s current model configuration documentation also includes a mechanism for custom model options and custom gateway model IDs.

That is useful for organizations whose gateway maps internal names to model deployments.

For example, a gateway might expose an internal identifier rather than a standard Anthropic model ID.

Claude Code can accept configured custom values without validating them as a standard Claude name.

Again, that does not imply Anthropic supports every upstream model behind such an ID.

It means Claude Code can function in environments where the gateway controls model naming.

Why a Localhost Proxy Can Still Trigger Account Signals

Getman emphasized that his proxy listened only on:

127.0.0.1

That means the proxy itself was not exposed as a public internet service.

However, “localhost-only” does not mean no external services are involved.

The workflow still contains outbound connections:

local Claude Code
→ local proxy
→ external model provider

Account-security systems can observe many signals unrelated to whether the proxy port is public.

Potential signals in any online service can include:

• Authentication changes.
• Request patterns.
• Device changes.
• Session behavior.
• Usage spikes.
• Network origin.
• Automated behavior.
• Account-integrity indicators.

Anthropic did not publish the exact classifier that triggered Getman’s account.

Cherny only said it was almost certainly a different account classifier.

So it would be incorrect to claim that localhost proxying itself is known to trigger suspensions.

What “Suspicious Signals” Does—and Does Not—Tell Us

A generic suspension reason is frustrating because it provides little diagnostic information.

It does not tell a user whether the system detected:

• Usage-policy concerns.
• Account compromise.
• Identity mismatch.
• Automated abuse.
• Payment issues.
• Location anomalies.
• False-positive account behavior.

Anthropic’s support documentation says accounts may be suspended for reasons including repeated Usage Policy violations, unsupported-location account creation, or Terms of Service violations.

When a user believes the suspension is incorrect, Anthropic provides an appeal path through the restricted-account experience.

That formal appeal process remains the correct route even when a public employee is helping investigate a specific incident.

How to Appeal an Anthropic Account Suspension

Anthropic’s current help center says users who believe their account was wrongly suspended or terminated should:

1. Go to claude.ai.
2. Sign in with the suspended account.
3. Open the appeal form shown on the restricted-account screen.
4. Submit the requested account information and explanation.
5. Wait for the Safeguards team to review the case.

The company notes that response times can be longer during periods of high volume.

If an organization rather than the individual account is on hold, Anthropic says the restricted screen can provide a separate Request a review option.

For an appeal related to an unusual local proxy setup, useful evidence can include:

• Exact date and time of the suspension.
• Claude Code version.
• Whether the CLI was modified.
• Proxy name and version.
• Listening address.
• Model provider.
• Relevant configuration.
• Logs that do not expose secrets.
• A link to a public reproduction if available.

Never publish API keys, OAuth tokens, cookies, or account credentials while trying to prove what happened.

Getman Published His Implementation

After the suspension, Getman published a repository documenting the setup:

alexgetmancom/claude-proxy

The repository describes its goal as running Claude Code with a different model behind it through a localhost-only CLIProxyAPI server.

It preserves the ordinary claude command and allows a separate command such as:

claudex

for the alternate route.

The README includes examples such as:

claudex
claudex --continue
claudex --effort low -p "explain this file"

It currently describes support for macOS or Linux with zsh, with Windows use through WSL.

The project is community-maintained, not an Anthropic or OpenAI product.

Claude Desktop Is a Different Case

Getman’s repository also documents an important limitation:

CLI only

The proxy approach described there is intended for the Claude Code command-line workflow.

It says the Claude Desktop app pins its own model and API endpoint when launching its integrated Claude Code experience, so the same project-level routing path does not behave identically.

This is another reminder that “Claude Code” can appear in more than one surface.

A setup that works in a terminal should not automatically be assumed to work in desktop-integrated workflows.

Tibo’s Response: Harness Freedom Matters

Once Cherny responded, Sottiaux returned to the thread.

He said he was glad the issue was being sorted out and argued that freedom of harness is important.

His position was that users should be able to decide which model works best for them.

The exchange is revealing because the two platform leads were not actually far apart on the narrow point.

Cherny:

We do not ban users for using harnesses with other models.

Sottiaux:

Users should be able to choose the best model for a harness.

The remaining gap is product support.

Anthropic’s documentation does not promise to support arbitrary non-Claude backends inside Claude Code.

Tibo Then Reset Paid ChatGPT Work and Codex Usage Limits

Sottiaux had previously joked that he owed users a reset if the setup got blocked.

After the incident, he followed through publicly.

He posted that he had reset usage limits for paid users of:

• ChatGPT Work.
• Codex.

The reset was a one-time community gesture associated with the incident.

It should not be interpreted as:

• A permanent plan entitlement.
• A contractual SLA.
• A guarantee of future resets.
• A reimbursement from Anthropic.
• Evidence that OpenAI can modify Anthropic accounts.

OpenAI controls its own usage limits.

Anthropic controls Claude accounts.

Sottiaux himself noted that he could not directly fix an Anthropic suspension because he does not work there.

Sam Altman Joined the Conversation

OpenAI CEO Sam Altman later commented publicly on Sottiaux’s role in the episode.

The exchange turned what began as one developer’s suspension into a broader discussion about model and harness portability.

The underlying technical issue is likely to outlast the social-media moment.

Developers increasingly want to combine:

Model A
+
Harness B
+
Tools C
+
Provider D

rather than accepting one vertically integrated stack.

Why Model and Harness Are Becoming Separate Competitive Layers

Coding agents are becoming modular.

A modern coding workflow can be divided into several layers.

Model

The reasoning and generation engine.

Examples include GPT-5.6 Sol or a Claude model.

Harness

The environment that turns a model into an agent.

Examples include Claude Code and Codex.

Tools

File editing, shell execution, browser access, MCP, search, and other capabilities.

Gateway

Authentication, routing, logging, model mapping, and protocol translation.

Provider

The service that actually runs inference.

This separation creates new comparisons.

A developer might ask:

• Which model writes the best code?
• Which harness has the best permission model?
• Which tool system is fastest?
• Which provider is cheapest?
• Which gateway gives the best observability?
• Which combination is most reliable?

The answer may no longer be one brand.

Same Model, Different Harness, Different Result

The original motivation for the Claude Code + GPT experiment was the observation that a model can perform differently depending on the harness around it.

That is plausible for several reasons.

A harness controls:

• System instructions.
• Context construction.
• Tool descriptions.
• Search behavior.
• Subagent delegation.
• Retry logic.
• Compaction.
• Approval flow.
• File-editing methods.

So the effective system is:

Model quality
×
Harness quality
×
Tool quality
×
Context quality

A benchmark that compares only model names may therefore miss a large part of real developer experience.

The Support Boundary Matters More as Agents Become Modular

Modularity gives developers freedom.

It also spreads responsibility across more components.

If Claude Code is connected to a non-Claude model through a community proxy and the tool call fails, who owns the bug?

Possible causes include:

• Claude Code changed its request format.
• The proxy mistranslated a field.
• The upstream model does not support the tool schema.
• The gateway dropped a header.
• The model has a different context limit.
• Streaming behavior differs.
• A beta feature is missing.

Anthropic can reasonably say:

Claude Code itself works as documented with supported Claude paths.

while the proxy maintainer says:

The translator needs an update.

That is the trade-off of composable infrastructure.

A Safer Way to Experiment With Alternate Models

If you want to test a non-Claude model in a Claude Code-style gateway setup, treat it as an experiment rather than a supported production path.

Step 1: Read the Current Claude Code Gateway Documentation

Check:

• Gateway requirements.
• Supported API formats.
• Base URL configuration.
• Tool and streaming behavior.
• Model configuration.
• Current support caveats.

Documentation changes more slowly than social posts, but faster than old tutorials.

Step 2: Use a Separate Shell Command

Keep the normal Claude path intact.

For example:

claude
→ official Claude route

claudex
→ experimental local proxy route

This makes rollback easier.

Step 3: Keep the Proxy Local Unless You Intentionally Operate a Gateway

A local development proxy can bind to:

127.0.0.1

rather than all interfaces.

Do not expose a development proxy publicly without authentication and security review.

Step 4: Do Not Patch the Claude Code Binary

Using documented environment variables and an external gateway keeps changes easier to inspect and remove.

Step 5: Use Your Own Authorized Provider Credentials

Do not share account sessions, steal tokens, or use credentials you are not authorized to use.

Step 6: Start With a Disposable Test Project

Do not begin with:

• Production secrets.
• Customer repositories.
• Deployment credentials.
• Irreplaceable local state.

First verify that file editing, tool calls, streaming, and context handling behave as expected.

Step 7: Disable or Test Features the Proxy Cannot Translate

Tool search is one example.

Other gateway-specific features may also need adjustment.

Step 8: Log the Model You Actually Used

A proxy can make the front end and model name diverge.

For reproducibility, log:

Harness
Gateway
Upstream provider
Actual model
Reasoning setting
Proxy version
Claude Code version

Step 9: Monitor Account Health

If a service displays:

• Warnings.
• Suspicious-login messages.
• Safeguard notices.
• Authentication failures.

stop and investigate rather than repeatedly retrying.

Step 10: Be Ready to Remove the Experiment

A Claude Code update or provider change can break an unofficial compatibility path.

Keep the setup reversible.

Current Anthropic Documentation Is the Better Production Baseline

For organizations that need a supported Claude Code deployment, Anthropic documents several official paths.

These include:

• Anthropic API.
• Amazon Bedrock.
• Google Cloud’s Agent Platform.
• Microsoft Foundry.
• Enterprise LLM gateways that ultimately route supported Claude traffic.

These paths have clearer support expectations than translating requests to an unrelated model provider.

If the business requirement is simply “centralize Claude access behind our own gateway,” use the supported gateway architecture.

If the requirement is “use Claude Code’s harness with a different vendor’s model,” understand that you are crossing into an unsupported integration even though Cherny says that alone is not a ban reason.

What to Do If You Already Use a Claude Code Proxy

You do not need to panic because of one public suspension.

The public evidence does not establish a general Anthropic policy of banning proxy users.

But it is worth auditing the setup.

Check:

1. Are you using the official Claude Code CLI?
2. Is the proxy trustworthy and actively maintained?
3. Where are credentials stored?
4. Does the proxy log prompts or secrets?
5. Does it expose a network port beyond localhost?
6. Which provider actually receives the code?
7. Does the setup violate your employer’s security policy?
8. Which Claude Code features are silently disabled?
9. Can you reproduce the environment?
10. Can you remove it cleanly?

The third-party proxy itself may present more security risk than the model-routing policy question.

Third-Party Proxy Security Deserves Attention

A proxy may see extremely sensitive information:

• Source code.
• Prompts.
• Tool definitions.
• File paths.
• Environment details.
• API credentials.
• Agent outputs.

Before using one, inspect:

• Source code.
• License.
• Release history.
• Maintainers.
• Network behavior.
• Secret handling.
• Logging defaults.
• Update mechanism.

Do not assume that a popular repository is equivalent to a security review.

Anthropic explicitly says it does not endorse, maintain, or audit third-party gateways.

Why This Incident Is Bigger Than Claude Code

The event highlights a broader change in AI developer tools.

The first generation of AI coding assistants was vertically integrated:

Vendor model
+
vendor UI
+
vendor tools

The emerging developer preference is more modular:

favorite model
+
favorite harness
+
favorite tools
+
favorite provider

That creates pressure for clearer standards around:

• Model portability.
• Gateway compatibility.
• Tool schemas.
• Context metadata.
• Usage policies.
• Identity and billing.
• Telemetry.

The rise of LLM gateways and open protocols makes this modular future more realistic.

The support and policy boundaries have not caught up everywhere.

What the Incident Does Not Prove

The suspension generated many strong claims online.

Several go beyond the evidence.

It Does Not Prove Anthropic Bans Users for GPT in Claude Code

Cherny explicitly said Anthropic does not ban users merely for using harnesses with other models.

It Does Not Prove the Proxy Was Definitely the Suspension Trigger

The timing is suggestive, but Anthropic did not publish the exact classifier or full account investigation.

It Does Not Mean Anthropic Supports GPT Inside Claude Code

Its documentation explicitly says non-Claude routing through gateways is unsupported.

It Does Not Mean the Alias Is Future-Proof

Claude Code variables and internal behavior can change.

It Does Not Mean OpenAI Supports Every Proxy Pattern

Sottiaux shared this particular experiment, but a public social post is not a universal compatibility guarantee for every third-party proxy, provider, or account configuration.

It Does Not Mean a Reset Is Guaranteed if You Get Suspended

The reset was a community gesture affecting OpenAI usage limits, not a standing policy.

The Practical Policy Matrix

The situation can be summarized like this:

Question	Best-supported answer as of August 13, 2026
Can Claude Code connect through an LLM gateway?	Yes, Anthropic documents gateway support
Can compatible gateways technically expose custom model IDs?	Yes
Does Anthropic officially support non-Claude models behind Claude Code?	No
Does Anthropic ban users simply for using other models in a harness?	Boris Cherny says no
Was Alex Getman suspended?	Yes, according to his public report
Did Anthropic say the proxy was the policy violation?	No
What did Cherny say caused it?	Almost certainly another account classifier
Is CLIProxyAPI an Anthropic product?	No
Is the proxy path guaranteed to keep working?	No
Is there an official appeal path for mistaken suspensions?	Yes

That is much more useful than treating the event as a simple “Claude bans GPT users” story.

常见问题

Can I use GPT-5.6 Sol inside Claude Code?

A third-party compatibility gateway can technically route the Claude Code CLI to another provider, and public community setups demonstrate this with GPT-5.6 Sol. Anthropic’s documentation, however, says it does not support routing Claude Code to non-Claude models, so this should be treated as an unsupported experimental configuration.

Will Anthropic ban me for using another model in the Claude Code harness?

Claude Code lead Boris Cherny publicly said Anthropic does not ban people simply for using harnesses with other models. That does not guarantee that an account can never be suspended for other security, policy, account-integrity, or classifier reasons.

Why was Alex Getman’s Anthropic account suspended?

Getman said the account was suspended for “suspicious signals” shortly after he tested a localhost proxy setup. Cherny said the cause was almost certainly a different account classifier and that Anthropic was looking into it; Anthropic did not publish a detailed classifier report.

Is CLIProxyAPI officially supported by Anthropic or OpenAI?

No. CLIProxyAPI is an independent open-source project. Anthropic explicitly says it does not endorse, maintain, or audit third-party gateways, and OpenAI does not make CLIProxyAPI part of its official Codex product documentation.

Does Claude Code officially support LLM gateways?

Yes. Anthropic documents LLM gateway configurations for authentication, routing, budgeting, usage tracking, and enterprise deployment. Its documentation simultaneously states that routing Claude Code to non-Claude models is not supported.

What is ANTHROPIC_BASE_URL used for?

Claude Code can use a custom base URL to send requests through a configured gateway rather than directly to the default endpoint. Gateway behavior can affect tool search, model detection, context handling, and other features, so operators should follow current Claude Code gateway documentation.

How do I appeal a mistaken Claude suspension?

Anthropic says to sign in to claude.ai with the suspended account and use the appeal form shown on the restricted-account screen. The Safeguards team can review the case; include useful technical context but never expose API keys, OAuth tokens, or other secrets.

Did Tibo Sottiaux really reset Codex limits after the incident?

Yes. Sottiaux publicly said he reset usage limits for paid ChatGPT Work and Codex users after the exchange. That was a specific community action, not a permanent entitlement or promise of future resets.

相关工具

• Claude Code: Anthropic’s official command-line agent for software development workflows.
• CLIProxyAPI: An independent open-source proxy that exposes compatible interfaces for multiple AI model providers.
• Alex Getman’s claude-proxy: The public localhost-only setup published after the suspension incident.
• Codex: OpenAI’s official software-engineering agent and development environment.
• LiteLLM: An independent LLM gateway and compatibility layer commonly used to normalize multiple model-provider APIs.
• Model Context Protocol: An open protocol used by agent applications such as Claude Code to connect to tools and external systems.

Related Links

• Tibo Sottiaux’s Original Claude Code + GPT Post: The July 12 public post showing the three-step proxy and alias approach.
• Alex Getman’s Suspension Report: The developer’s public account of the suspension and request for policy clarification.
• Boris Cherny’s Response: The Claude Code lead’s statement that Anthropic does not ban people for using harnesses with other models.
• Anthropic: Other LLM Gateways: Official Claude Code documentation explaining gateways and the unsupported status of non-Claude routing.
• Anthropic: Claude Code Model Configuration: Current documentation for model IDs, custom gateway models, context settings, and related environment variables.
• Anthropic: Safeguards Warnings and Appeals: Official appeal instructions for users who believe an account suspension was incorrect.
• OpenAI Forum: Codex Is for Everyone: Official OpenAI Forum page identifying Thibault Sottiaux as the leader of Codex.
• OpenAI GPT-5.6: Official information on the GPT-5.6 family, including GPT-5.6 Sol.

Summary

A developer was suspended shortly after routing GPT-5.6 Sol through an unmodified Claude Code CLI with a localhost proxy, but the strongest public clarification does not support the claim that Anthropic bans users simply for putting another model behind the Claude Code harness. Boris Cherny said the suspension was almost certainly triggered by another account classifier.

At the same time, Anthropic’s own documentation is clear that non-Claude model routing is unsupported. Claude Code officially supports gateways, but Anthropic does not promise support, compatibility, or troubleshooting when those gateways connect the harness to a non-Claude backend.

That makes the incident a useful case study in the difference between policy and product support. Something can be technically possible and not itself prohibited while still falling outside the vendor’s supported configuration.

The safest conclusion is: harness freedom may be allowed, but once you route Claude Code to another model through a third-party proxy, you own much more of the compatibility, security, and operational risk yourself.