AI on TorchTree

Notion CEO's Jazz Mode: Five Deep Shifts in AI-Era Organizational Management

Tue, 25 Aug 2026 12:58:43 +0800

In a recent conversation with Sequoia partner Brian Halligan (former HubSpot CEO), Notion CEO Ivan Zhao introduced a new concept: Jazz Mode. He argues that after Manager Mode and Founder Mode, organizations in the AI era should operate like a jazz band: everyone has room to improvise, yet the whole still comes together in collaboration.

This article doesn’t intend to recap everything Ivan said. Instead, it tries to extract a few structural changes that are easy to overlook from his remarks, and what those changes mean for teams building products with AI.

From Building Bridges to Brewing Beer: Why AI Rewrites the Underlying Logic of Product Development

Ivan used a metaphor to distinguish traditional software development from AI product development: traditional software is like building a bridge — designers draw the blueprint and engineers build to it; AI products are more like brewing beer — you can only experiment, observe, and adjust, without precisely controlling the final result.

The value of this metaphor isn’t rhetorical; it exposes a structural problem that has been underestimated in AI product development: traditional software development is requirement-driven; AI product development is technology-driven.

In the traditional model, product managers define requirements, designers produce solutions, and engineers implement them. The whole process starts from customer needs, with technology as the means of execution. But AI products are different. The boundaries of model capability determine what a product can do, and those boundaries change every week. If you plan your product roadmap strictly according to customer requirements, three months later what you’ve built may already be obsolete.

Ivan said their internal development model has shifted from “customer-driven” to “technology-driven experimentation.” The traditional boundaries between PM, designer, and engineer have been thoroughly blurred — even product designers are among the team members who consume the most LLM tokens.

This isn’t just Notion’s practice. As LLM capabilities iterate quickly, more and more AI product teams face the same dilemma: you can’t fully plan your product at the start of the year, because three months later the model’s capabilities have already changed. An AI product roadmap is, in essence, a collection of assumptions that keep being overturned.

For teams building AI products, this means two things. First, you need to accept that “plans can’t keep up with change” isn’t a management problem but a consequence of the product form. Second, you need to let the people with the best judgment on your team (not just engineers) work directly with the model, because instinctive judgment about model capability is becoming a more valuable product asset than a requirements document.

Hierarchy Won’t Disappear, But Its Function Is Being Redefined

Ivan was explicit in the conversation that he doesn’t believe in hierarchical-free organizations. His reasoning is simple: hierarchy is human nature — even chimpanzee societies have natural hierarchies, and you can’t eliminate it by forcibly flattening the org.

But he also pointed out that language models are becoming the new infrastructure of organizations. Information transfer, state synchronization, and decision coordination — work that once required many middle managers — can now be partly handled by AI. Future organizations will be flatter, but hierarchy won’t disappear.

Hidden beneath this is a deeper change: the rationale for hierarchy is shifting from “information transfer” to “allocation of judgment.”

In traditional organizations, one core function of hierarchy is information filtering and passing. A CEO can’t know every detail, so you need VPs; VPs need Directors; Directors need Managers. Each layer compresses information and reports upward. But AI tools (including Notion’s own products) are making information transfer more efficient, even automated. When information transfer is no longer the bottleneck, hierarchy only retains two values: decision judgment and resource allocation.

This means the job of future middle managers will fundamentally change. They will no longer be transfer stations for information, but carriers of judgment in specific domains. The value of a middle manager will no longer depend on how many people they manage, but on how broadly they can make high-quality decisions.

For organizational designers, this is a very practical question: if your middle managers mostly do meetings, reporting, and passing information, their roles are being eroded by AI; if your middle managers are the judgment centers of a domain, their value is actually rising.

The Talent Formula Has Changed: Capability or Taste — Which Is Scarcer?

Ivan proposed a talent formula he currently endorses most: Talent = Capability × Taste × Agency.

In the past, Capability was the most important variable. An engineer’s technical skill determined their output. But in the AI era, capability is being rapidly commoditized. Tools like Claude Code, Cursor, and Copilot are making “writing code that runs” increasingly easy.

When capability becomes cheap, Taste and Agency become scarce resources. Taste is what you think is good; Agency is whether you proactively push things forward.

This isn’t empty philosophy. Notion has adjusted its hiring strategy along these lines: it no longer focuses mainly on work history, big-company background, or resume length, but on curiosity, optimism, energy, and proactivity. Their first-round interviews no longer review resumes; they simply ask candidates to “build something,” looking at the work before the background.

Even more noteworthy is their “barbell model” engineering organization: at one end, very young engineers responsible for fast trial-and-error and efficient execution; at the other, a tiny number of super-senior architects responsible for judgment, Taste, and architecture. One senior architect guides 2–3 junior engineers, and with the help of AI Agents, each junior engineer can produce as efficiently as managing a mini-team.

The underlying logic of this model is: AI amplifies individual execution, but not judgment. A tasteful senior engineer, plus AI tools and a few junior executors, can produce what a small team used to. But if the Taste is wrong, no amount of execution is doing anything but accelerating in the wrong direction.

For team managers, this means you need to reassess who in your team is the “Taste center,” and ensure those people’s judgment directly shapes product direction rather than being diluted by layers of reporting.

Founders Are an Organization’s Decalcifying Agent: Why Notion Took In 60 Founders

Notion has 50–60 former startup founders internally — an unusual number. Ivan said founders are an organization’s “decalcifying agent.”

His logic is clear: a 1,000-person company will naturally tend toward bureaucracy; that’s a physical law. But if a steady stream of founders keeps mixing in, they continuously launch new projects, challenge old processes, propose new ideas, and push organizational change — effectively injecting new vitality into the organization.

This observation reveals a problem often neglected in organizational theory: bureaucratization isn’t a management failure, but a natural result of organizational scale. Any sufficiently large organization will produce processes, norms, and hierarchy. These things ensure efficiency early on, but once they accumulate past a certain point, they become obstacles to innovation.

The value of founders is that they naturally distrust process. They’re used to “doing first, then talking,” used to breaking existing frames and rethinking problems. Scattered across a large organization, they act like so many “anti-entropy nodes,” constantly resisting the force that drives organizations toward rigidity.

But there’s a prerequisite: the organization must give these people enough autonomy. If founders are assimilated by existing processes after joining a large company, the “decalcifying agent” fails. Ivan said Notion’s approach is to keep these people highly autonomous, consistent with the spirit of Jazz Mode.

Enterprise Sales Is the Last Fortress AI Can’t Take

One detail in the conversation is easy to overlook: Ivan said they had previously made mistakes in the sales area — they tried to reinvent sales and failed. Later they found that many enterprise customers simply want to talk to a real person.

This observation forms an interesting contrast with the current narrative of many AI companies. Over the past two years, a lot of AI startups have tried to replace the sales process with AI, from automated outbound calling to intelligent customer service to AI SDRs. But Ivan’s experience suggests that, at least in the enterprise market, trust relationships between people remain the key to closing deals.

The logic behind this: enterprise procurement decisions are costly, and the consequences of error are severe. In such scenarios, customers need more than just information and efficiency; they need “someone who can be found when something goes wrong.” AI can handle information, but it’s hard for it to provide that kind of psychological security.

For AI entrepreneurs, this points to a pragmatic direction: AI’s best position in the enterprise market may not be replacing sales, but empowering it. Let salespeople use AI tools to prepare materials, analyze customers, and follow up leads more efficiently, but the final customer relationship is still maintained by humans.

Planning Cycles Are Shrinking Dramatically

Ivan said something very direct: financial planning can be done quarterly, but product planning may need to change weekly, because model capabilities change too fast.

That’s not an exaggeration. Over the past two years, the capability curve of LLMs has been nearly exponential. Tasks considered impossible when GPT-4 was released in early 2023 had been matched or surpassed by multiple models by the end of 2024. If your product planning is built on the assumption of “GPT-4-level capability,” that assumption needs updating every few months.

Ivan also stressed that a CEO must experience AI firsthand — not just watch videos, talks, or summaries. He used two phrases: Feel the AI, Feel the AGI. Only by using it yourself and building with it can you know which opportunities really exist.

The practical meaning of this advice: product decisions in the AI era increasingly rely on intuitive judgment of model capability, and that intuition can only come from hands-on use. You can’t gain an accurate sense of model capability by reading secondhand information, just as you can’t learn to swim by reading a swimming tutorial.

A Company Eventually Grows Into the Image of Its Founder

At the end of the conversation, Ivan touched on a view: many CEOs like to imitate others — Jobs, Musk, or Brian Armstrong — but a company is ultimately a projection of its founder. If you’re a craftsman, the company becomes a craftsman culture; if you’re a salesperson, it becomes a sales culture; if you’re a jazz musician, the company also eventually becomes a jazz band.

He was very candid about the quasi-religious/“cultish adoration” perception of the Notion community, even saying he “liked” it. He believes a company is, in a sense, a religion, projecting a worldview and value system onto the real world through commerce and products.

The deeper meaning of this view: organizational culture isn’t designed; it’s an amplification of the founder’s personality. You can draw a perfect org chart, but what ultimately determines organizational behavior is what the founder believes, values, and how they make decisions.

Jazz Mode suits Notion not just because it’s a good management concept, but because it matches Ivan’s own personality. He doesn’t like pure delegation, pure process, or pure management, so he needs an organization that allows improvisation. If a founder is a natural controller by nature, Jazz Mode will most likely fail in their company.

For entrepreneurs, this may be the question most worth thinking about: does the organizational model you’re trying to build match your own personality? If it doesn’t, even the best concept is nothing but a castle in the air.

Original link: Notion CEO on the New Paradigm for AI-Era Organizational Management: Jazz Mode

OpenCode Go vs Command Code GOAT: Which $10 Coding AI Subscription Is Better Value?

Mon, 17 Aug 2026 14:00:03 +0800

OpenCode and Command Code are both terminal-based coding agents — open-source alternatives to Claude Code. You chat with an AI in your command line and it writes code, fixes bugs, and refactors projects for you. Both let you switch between underlying models from different vendors and don’t lock you into a single provider.

OpenCode’s community is much larger, with 198K GitHub stars (measured via the GitHub API) and over 7.5 million monthly active developers. Command Code’s community is smaller — 3.7K GitHub stars (measured via the GitHub API) — but it invests more in harness engineering (the layer that optimizes tool calling for AI agents), such as a built-in Read tool that automatically filters out irrelevant file content to reduce context waste.

Both have launched low-cost subscription plans aimed at individual developers. This article compares two plans that both cost $10/month: OpenCode Go and Command Code GOAT.

Pricing and Credit Limits

Both plans use the same pricing model: you pay $10 a month and receive a credit allowance denominated in US dollars, which is consumed at each model’s actual API price. Cheaper models burn credits slowly; expensive models burn them fast.

Dimension	OpenCode Go	Command Code GOAT
Monthly fee	$10 ($5 first month)	$10
Monthly credit	$60	$70
Credit multiplier	6x	7x
5-hour limit	$12	$14
Weekly limit	$30	$35
Top-ups	Yes (Zen balance)	Yes (never expires)

The “credit multiplier” is how much model usage your $10 actually buys. OpenCode Go gives $60 (6x), while Command Code GOAT gives $70 (7x) — 17% more.

Model Library Comparison

OpenCode Go offers 19 models; Command Code GOAT offers 36+.

Shared core models include: DeepSeek V4 Pro/Flash, Kimi K3/K2.7 Code/K2.6, GLM-5.3/5.2/5.1, MiMo-V2.5/V2.5-Pro, MiniMax M3/M2.7, Qwen 3.8 Max/3.7 Max/3.7 Plus/3.6 Plus, GPT 5.6 Luna, Grok 4.5, Tencent Hy3.

These shared models are priced identically on both platforms. For example, DeepSeek V4 Pro is off-peak $0.66 input/$1.98 output per million tokens on both, and MiMo V2.5 is $0.14 input/$0.28 output per million tokens on both.

Models exclusive to Command Code GOAT include: Gemini 3.7 Flash (limited-time 50% discount), Grok 4.6, Muse Spark 1.2, Laguna S 2.1 (free, limited capacity), Inkling, Step 3.7/3.5 Flash, Qwen 3.7 Flash, and more MiniMax variants.

Exclusive Discounts

The general model pricing is the same on both platforms, but Command Code GOAT has a series of permanent or time-limited discounts:

MiMo V2.5 Pro: permanent 99% discount. It has a dedicated $30 monthly quota on GOAT, equivalent to roughly $150 of usage at the discounted rate. On OpenCode Go, this model consumes credits at standard pricing with no extra benefit.

MiMo V2.5: permanent 98% discount. Output drops from about $4.00 to $0.28 per million tokens, and input from about $0.80 to $0.14. Using this model on GOAT, a $10 subscription is equivalent to roughly $100 of standard-priced usage.

MiniMax M3: permanent 50% discount. Your credit effectively doubles.

Laguna S 2.1: completely free. This is Poolside’s open-source coding model — all tokens (input, output, cached reads) cost $0, with limited capacity on a first-come, first-served basis.

Gemini 3.7 Flash: 50% off until December 31, 2026.

OpenCode Go has no exclusive discounts; all models consume credits at standard pricing.

This means that if you frequently use MiMo or MiniMax models, Command Code GOAT’s effective capacity far exceeds the nominal $70. For heavy users of these models, GOAT’s value advantage goes well beyond 17% — the real gap can be several times.

API Access

Both platforms offer API access, but the implementations differ.

OpenCode Go’s API endpoint is https://opencode.ai/zen/go/v1/chat/completions (OpenAI-compatible format). You can call it directly with an API key, or configure it as a custom provider in other coding agents.

Command Code GOAT similarly offers API endpoints compatible with both OpenAI Chat Completions and Anthropic Messages, with a single API key used for both the CLI and external calls.

Both platforms’ APIs can plug into other toolchains. For developers who only write code in the terminal, this difference barely matters. If your workflow involves multiple tools sharing one model subscription, both work — the difference comes down to endpoint format and integration convenience.

How to Choose

Already in the Command Code ecosystem: Upgrading to GOAT is the natural choice — more credit and exclusive discounts right away.

Value model diversity: GOAT’s 36+ models nearly double OpenCode Go’s 19, and the extras include popular options like Gemini 3.7 Flash and Grok 4.6.

Frequently use the MiMo line: GOAT’s permanent discounts are the decisive advantage. MiMo V2.5 Pro at 99% off and MiMo V2.5 at 98% off mean the same money goes several times further.

Just need a standalone CLI coding tool: OpenCode Go is plenty. 19 models cover mainstream needs, and $60 of monthly credit is enough for moderate usage.

The real choice depends on which models you use most. Both platforms promise not to train on your code, both accept credit cards, and extra purchased credits never expire on either.

Pricing information comes from the official OpenCode and Command Code pricing pages (August 2026); actual prices may change — refer to official announcements for the latest.

Sources

Advanced Pi Agent Configuration: AGENTS.md, Model Switching, and Thinking Levels in Practice

Wed, 22 Jul 2026 12:14:08 +0800

In the article Pi Coding Agent in Practice: From Installation to Everyday Use, I covered Pi’s installation, first-time configuration, and its core extension packages. That content lets beginners get up and running quickly, but Pi’s real flexibility lives in its configuration files.

Pi’s core is just 418 lines of TypeScript, and by default it only gives the model four tools (read, write, edit, bash). All of its advanced behavior — which model to use, how large a context, how deep to think — is controlled through external configuration files. Understanding how these files relate to each other and how they’re prioritized is the key step in taking Pi from “usable” to “actually good.”

How many layers does Pi’s configuration have, and what does each one manage?

Pi’s configuration system uses a layered, additive design. Once you understand what each layer is responsible for and its order of precedence, you won’t run into “I changed it but nothing happened.”

Global configuration lives in ~/.pi/agent/, affecting all projects. Project configuration lives in a project’s .pi/settings.json, affecting only the current project. Nested objects in the project config are merged with the global config rather than replacing it entirely.

Beyond the two layers of settings.json, Pi also uses four specialized configuration files, each with a different purpose:

Config file	Location	Purpose	Load timing
AGENTS.md	Project root or ~/.pi/agent/	Project context and coding instructions, injected into the system prompt	Auto-loaded at startup
APPEND_SYSTEM.md	~/.pi/agent/	Global behavior rules, appended to the end of the system prompt	Loaded at startup
settings.json	Global or .pi/	Model selection, UI theme, compaction strategy, retries, and other runtime parameters	Loaded at startup
models.json	~/.pi/agent/	Custom models and Providers (Ollama, vLLM, etc.)	Reloaded each time you open /model
auth.json	~/.pi/agent/	API keys and OAuth credentials (permission 0600)	Read on demand

Below I’ll break down best practices for each configuration file in turn.

How to write an AGENTS.md that actually works

AGENTS.md is the primary entry point for Pi to understand a project’s context. When Pi starts, it looks in several locations and merges their contents into the system prompt: it loads ~/.pi/agent/AGENTS.md first (global instructions), then walks up through parent directories, and finally loads the AGENTS.md in the current directory.

In other words, the global AGENTS.md defines your typical tech stack and general conventions as a developer, while the project AGENTS.md defines that specific project’s constraints and workflow.

What to put in the global AGENTS.md

The global ~/.pi/agent/AGENTS.md is a good place to record the tech-stack preferences you use day to day. The global AGENTS.md that DeepakNess shares on his blog is a great reference example:

This content comes from DeepakNess’s article, Setting Up and Using the Pi Coding Agent. It doesn’t try to be overly specific — instead it gives broad tech-stack hints while asking Pi to defer to the project-level AGENTS.md first.

How to organize a project AGENTS.md

The project-level AGENTS.md needs to be more precise. Here’s a template tailored for a TypeScript project, based on the recommendations in the official Pi documentation:

If you manage multiple projects, it’s worth keeping a template for each project type. Copy it over each time you start a new project and adjust the tech-stack fields as needed.

Remember to reload after changes

Every time you modify AGENTS.md, you need to run /reload or restart Pi for the change to take effect. This operation isn’t triggered often, but it’s easy to forget. It’s best to test immediately after writing a new rule to confirm Pi’s behavior changed as expected.

What does APPEND_SYSTEM.md control?

~/.pi/agent/APPEND_SYSTEM.md is appended to the end of the system prompt, and it takes precedence over AGENTS.md. This means its instructions override what came before.

It’s a good fit for defining behavioral guidelines that apply across projects, especially constraints about how the agent works and how it interacts with the user. Drawing on official recommendations and community practice, a typical APPEND_SYSTEM.md looks like this:

These rules ensure Pi maintains a consistent way of working across projects, without having to restate everything at the start of every conversation.

settings.json: common options explained

settings.json has two layers: global (~/.pi/agent/settings.json) and project (.pi/settings.json). Nested objects in the project layer merge with the global layer. Drawing on the official Pi Settings documentation, here are the settings most worth knowing:

Models and thinking levels

defaultProvider and defaultModel control the model Pi uses by default at startup. defaultThinkingLevel sets the thinking depth, with options including off, minimal, low, medium, high, xhigh, and max.

enabledModels is a high-impact setting. It defines the list of models cycled through by Ctrl+P, and supports wildcards. If you leave it unset, Ctrl+P iterates over every available model for that provider, which hurts the experience significantly.

thinkingBudgets lets you customize the token budget for each thinking level. The numbers above follow the defaults given in the official Pi documentation. Whether to adjust them depends on your model and task: the higher the budget, the deeper the thinking, and the more tokens consumed.

Context compaction

Compaction is Pi’s core mechanism for handling long contexts. When the session approaches the context limit, Pi automatically summarizes older messages to free up space for subsequent conversation.

reserveTokens: the number of tokens reserved for the LLM’s response (default 16384). The smaller this value, the sooner compaction happens.
keepRecentTokens: the number of recent tokens kept without being summarized (default 20000). Kept messages stay intact, ensuring the most recent discussion isn’t lost.

If you regularly handle long sessions, you can raise keepRecentTokens. Note, though, that this reduces compaction efficiency and may hit the model’s context-window ceiling sooner.

Retry strategy

The retry configuration is split into two layers: agent-level retries (handled by Pi itself) and provider-level retries (handled by the API SDK). The official documentation recommends keeping retry.provider.maxRetries at 0, because provider-level retries can burn quota before you even see a rate-limit error.

baseDelayMs controls the initial delay of exponential backoff: 2s → 4s → 8s. For tasks that need to run stably over a long time (for example, batch data crawling), you can reasonably increase this value.

Project trust mode

When Pi first starts in a project, it asks whether to trust that project’s .pi/ directory. This mechanism exists to prevent malicious project plugins from auto-loading.

Available values include ask (ask every time, the default), always (auto-trust), and never (never trust). In CI or automation scenarios, you can use the -a / --approve flag to skip the prompt.

Adding custom models with models.json

If your model isn’t among Pi’s built-in 20-plus Providers, you can add it via ~/.pi/agent/models.json. This file supports Ollama, LM Studio, vLLM, OpenRouter, Cloudflare AI Gateway, and any OpenAI-compatible API endpoint.

Referencing the full configuration notes in the official Pi Models documentation, here are the three most common scenarios:

Scenario 1: a local model via Ollama

apiKey being set to "ollama" is just a placeholder. Ollama doesn’t validate the API key, but Pi needs an auth value to show the model in /model. The two switches under compat target Ollama’s characteristics: it doesn’t support the developer role or the reasoning_effort parameter.

The name field gives a human-readable label. Pi uses this value both in the model selector and when matching the --model mode.

Scenario 2: OpenRouter routing configuration

OpenRouter lets you set routing preferences among multiple API providers. The configuration below follows the OpenRouter example in the official Pi documentation:

The openRouterRouting object is passed through verbatim to the provider field of the OpenRouter API. order specifies provider priority, and data_collection: "deny" declines to use your data for training.

Scenario 3: proxying the Anthropic API

If you use a third-party proxy for the Anthropic Messages API, you can configure it like this:

In models.json, apiKey and headers support three value-resolution modes: a direct literal, $ENV_VAR environment-variable interpolation, or !command command execution. Bitdoze notes in the Pi Coding Agent Setup Guide that Pi supports Ollama, LM Studio, vLLM, and any OpenAI-compatible endpoint. This extensibility is a major advantage over comparable tools.

Managing API credentials with auth.json

~/.pi/agent/auth.json stores the API keys and OAuth tokens for all providers. Its permission is set to 0600, allowing only the current user to read and write it.

auth.json supports three ways of resolving keys:

Literal: use the API key string directly
Environment-variable interpolation: "$MY_KEY" or "${KEY_PREFIX}_${KEY_SUFFIX}"
Shell command: "!security find-generic-password -ws 'anthropic'"

The official documentation notes that auth.json takes precedence over environment variables. This means if you’ve set both a DEEPSEEK_API_KEY environment variable and a deepseek entry in auth.json, the latter overrides the former.

One practical tip is to use a shell command to read the credential from the system keychain, avoiding writing your API key in plaintext to any file:

Model-switching strategy: which model to use when

One of Pi’s core strengths is model-agnosticism. You can pick a different model for different tasks, and switching is instantaneous.

How to switch

Action	Shortcut / command	Notes
Open the model selector	Ctrl+L or /model	Quickly switch models
Cycle through models	Ctrl+P	Rotate through the enabledModels list
Adjust thinking level	Shift+Tab	Toggle thinking depth
Interrupt the current action	Escape	Cancel the running task
Send a steering message	Enter	Interrupt the agent’s current workflow and respond immediately
Send a follow-up message	Alt+Enter	Append a message after the agent finishes its work
Quit	Ctrl+C (press twice)	Exit Pi
Reference a file	@	Fuzzy-search files
Run a command	!	Send a command’s output to the model
Silent command	!!	Run a command without adding it to context

The shortcut table partly draws on the Pi Agent Chinese guide and DeepakNess’s setup article.

A recommended layered strategy

Experience from multiple community users converges on the same pattern: use models in layers, matching capability to task complexity. The following is drawn from DeepakNess and Bitdoze’s articles:

Task type	Recommended model	Thinking level	Reasoning
Quick edits, file operations, batch scripts	DeepSeek V4 Flash / MiniMax M2.7	low or off	Extremely cheap, plenty for fast tasks
Everyday coding, small-to-medium refactors	DeepSeek V4 Pro / Qwen 3.6 Plus	medium	Balances quality and cost
Deep analysis, architecture design, complex debugging	DeepSeek V4 Pro / Claude Sonnet 4	high or xhigh	Needs a deeper reasoning chain
Visual tasks (screenshot understanding, UI analysis)	Kimi K3 / Claude	depends on the model	Proxied via pi-vision-proxy when the main model has no vision

DeepakNess provides a concrete data point in his article: crawling 285,000 URLs with DeepSeek V4 Flash took about 1.5 hours with a total cost of $1. That illustrates the cost-effectiveness of low thinking level plus a cheap model on batch tasks.

enabledModels wildcards

To make Ctrl+P switching more efficient, it’s worth setting an enabledModels list in settings.json:

Wildcards match all qualifying models. If you only need two or three specific models, you can also write exact IDs:

How Thinking Level affects output quality

Pi’s thinking level is a layered parameter that controls how deeply the model reasons before answering. Based on the official Settings docs at pi.dev and the thinkingLevelMap explanation in models.md, different levels correspond to different behavioral characteristics:

Level	Use case	Token budget (default)
off	Simple Q&A, tasks that need no reasoning	no reasoning tokens
minimal	Very simple judgments, such as “yes/no” classification	1024
low	Light reasoning, e.g. formatting, simple conversions	4096
medium	Routine coding tasks	10240
high	Complex refactors, debugging	32768
xhigh	Deep analysis, architecture design	65536
max	Extremely complex multi-step reasoning	provider cap

The differences between levels aren’t linear. The biggest quality gain is from low to medium; from high to xhigh, the marginal returns diminish. In practice, 80% of everyday tasks get satisfactory results at the medium level.

For models that support thinkingLevelMap, you can finely control in models.json which provider-side parameter each level maps to. For example, a given model might only need the high and max levels, with the middle levels skipped:

This mechanism comes from the thinkingLevelMap explanation in the Pi Models documentation. When a model doesn’t support certain levels, Pi automatically jumps to the adjacent supported level.

Context management: compaction, session trees, and manual control

Long sessions are the norm for coding agents. Pi provides three layers of context-management mechanisms.

Automatic compaction

Compaction runs in the background. When the context approaches the model’s window limit, Pi automatically summarizes older messages. compaction.reserveTokens controls when compaction triggers: it fires when the remaining tokens drop below this value. compaction.keepRecentTokens ensures the most recent messages aren’t summarized.

If you want finer control, you can trigger /compact manually and Pi will immediately compact the current session.

Session-tree management

The /tree command displays the session history as a tree structure. Each branch represents a conversation path. Pi supports:

/resume: pick up a previous session and continue working
/new: start a new session
/fork: branch from the current session to begin a new line of conversation

This design lets you try different solution paths without losing context.

A complete configuration template

Combining all of the above, here’s a complete configuration you can put into daily use.

Global settings.json

Global APPEND_SYSTEM.md

Project .pi/settings.json (overriding the global compaction strategy)

This override makes short-session projects that need frequent compaction trigger it earlier, avoiding wasted context window.

Summary

Pi’s configuration system revolves around one core principle: layer on layer, precise control. Global configuration defines general behavior, project configuration overrides specific needs, AGENTS.md conveys project context, and APPEND_SYSTEM.md constrains the agent’s behavioral patterns.

Once you understand what each layer is responsible for and its priority, Pi’s “minimal core + external configuration” design philosophy stops being a “too few features” weakness and becomes a “you control everything” strength. When facing different tasks each day, you only need to switch models with Ctrl+P and adjust thinking depth with Shift+Tab to move quickly between different working modes.

If your configuration already covers the main files mentioned in this article, the next step is to focus on the extension system: use pi install to add packages such as pi-web-access (web search), pi-codex-goal (task tracking), and pi-vision-proxy (vision proxy), gradually building a Pi environment fully suited to your own workflow.

Sources:

Malus.sh: How AI Clean-Room Clones Threaten the Open Source Sustainability Loop

Tue, 05 May 2026 07:16:47 +0800

What is Malus.sh

Malus.sh (pronounced like “malice”) is an AI-powered tool that claims to recreate functional equivalents of any open source software from scratch using “Clean Room” engineering methods, while stripping away all license obligations of the original project. Its most eye-catching slogan: “No attribution. No copyleft. No problems.”

What makes the project unique is that it is both a satirical work and a genuinely operating commercial product. Founder Mike Nolan works as a researcher on the political economy of open source at the United Nations. In an interview with 404 Media, he explicitly stated that if it were only satire, open source practitioners would dismiss it with “that can’t happen to me.” Making the tool actually usable forces the community to confront the structural cracks that already exist in the open source economic model.

Malus.sh is registered as an LLC, accepts payments via Stripe, and has real paying customers. Its “liberation service” is currently unavailable, but the industry discussion it ignited keeps spreading.

Technical mechanism: AI-accelerated clean-room engineering

Historical precedent of the traditional clean-room method

The legal foundation of clean-room engineering dates back to the 1982 IBM BIOS case. At the time, IBM monopolized the personal computer market, and competitors wanted compatibility without infringing copyright. The solution was:

Team A analyzes IBM’s original BIOS code and writes a functional specification
Firewall isolation: strict separation between Team A and Team B
Team B sees only the specification and reimplements the code from scratch
Legal outcome: functionally compatible but independently written code, ruled by the court to be non-infringing

This case was dramatized in the first season of the HBO series Halt and Catch Fire, becoming a key milestone in the history of software copyright law.

Malus’s AI version of the process

Malus fully automates the traditional clean-room method:

The concrete steps include:

Upload manifest: supports formats like package.json, requirements.txt, and Cargo.toml
Isolated analysis: four AI units separately read the README, analyze the API, study type definitions, and review documentation—“never seeing a single line of original source code”
Independent rebuild: behind an isolation firewall, a separate set of AIs reimplements the code from the specification
License liberation: the output code ships with the MalusCorp-0 License—zero attribution, zero copyleft, zero obligations

A leap in speed

AI’s biggest change to clean-room engineering is time compression. Malus claims:

Project	Traditional time	Malus time
IBM BIOS clone (1984)	4+ months	an entire engineering team
left-pad (11 lines of code; its 2016 deletion crashed builds worldwide)	hours of manual rewrite	10 seconds
SPACEWAR! (the first video game)	weeks	5 seconds

Developer Dan Blanchard used Anthropic’s Claude Code in early 2026 to do a similar “from scratch” MIT-licensed rewrite of the popular Python library chardet. His verdict: “What used to take a team months or even years to rewrite, AI can now do in days. This trend is irreversible.”

Business model and pricing

Malus.sh uses a usage-based pricing model:

Item	Details
Billing method	Per-KB, based on uncompressed package size
Per-package limit	10 MB
Per-run limit	50 packages
Payment methods	USD, EUR, BTC, stock options
Output license	MalusCorp-0 License
Legal protection	Claims indemnification via “an offshore subsidiary that doesn’t recognize software copyright”

The “customer testimonials” on the site are clearly satirical—e.g., “guilt doesn’t show up on quarterly reports.” But the pricing structure and payment functionality are real.

The founder’s core argument

Mike Nolan laid out Malus’s position systematically in his March 2026 blog post, “Thank You for Your Service.”

Three structural problems with open source

Cases where open source has already failed

Year	Event	Type
2016	left-pad deleted, thousands of builds crashed worldwide	Maintainer sabotage
2021	Log4Shell (CVE-2021-44228)	Critical CVE
2022	colors.js and faker.js injected with infinite loops	Maintainer protest
2022	node-ipc contained a file-deletion payload targeting Russian/Belarusian IPs	Geopolitical sabotage
2025	Shai Hulud 2.0 npm worm	Supply chain attack

On Log4Shell, Nolan wrote: “Engineers patched it over their Christmas holidays, while the people who actually maintain Log4j are mostly unpaid volunteers who received panicked emails from around the world. This isn’t the failure of any individual—it’s the natural consequence of building critical global infrastructure on code that nobody is formally responsible for maintaining.”

Enterprise compliance cost comparison

Expense item	Annual cost
SCA tools	$1.2M
OSPO team	$850K
Legal review	$700K
Incident response	$980K
CLA management	$270K
Total traditional open source compliance	$4M
Malus full liberation package	$50K/year

Nolan claims savings of 98.75%.

Response to “exploitation” accusations

Acknowledgment of the “tragedy of the commons”

Legal and ethical controversy

Arguments supporting clean-room validity

Copyright law protects expression, not ideas. The 1879 case Baker v. Selden established this principle. Phoenix Technologies successfully cloned the IBM BIOS using the clean-room method in 1984 and received court recognition. If AI-generated code differs completely from the original at the level of expression and is only functionally equivalent, then in theory it does not infringe copyright.

Core arguments questioning the authenticity of the clean room

Training data exposure: AI models have already been exposed to the original open source code during training. If the LLM’s weights contain patterns from the original code, can its output truly be considered “independent creation”?
Copyright ownership of AI output: The US Copyright Office has made clear that purely AI-generated works are not copyrightable. If Malus’s output has no human author, users can’t claim copyright protection for it either.
Inducement to infringe: marketing explicitly aimed at “circumventing copyright” may constitute inducement liability.

A highly-upvoted Slashdot comment noted: “Good luck getting a judge to agree that an AI performed a ‘clean-room’ implementation—when that very AI was trained on the code it’s ‘reinventing.’”

Another commenter added: “The Chinese Wall legal strategy requires Team A to produce the specification and Team B to produce the implementation. If these people can’t show the specification, they’re done. Arguing that a specification must exist somewhere in the abstract Platonic space of an LLM’s black-box network won’t convince a courtroom.”

Why this threatens the open source sustainability loop

The sustainability of the open source ecosystem relies on an implicit social contract:

Contributors publish code and receive reputation, collaboration opportunities, and indirect commercial value
Users comply with license obligations (attribution, copyleft, feeding improvements back)
Companies use open source to cut development costs while giving back to the ecosystem through compliance spending

The capability Malus.sh demonstrates breaks this loop on three levels:

First, the enforceability of license obligations is hollowed out. When anyone can obtain a functionally equivalent but legally independent version at near-zero cost, MIT’s attribution requirement, GPL’s copyleft constraints, and Apache’s notice-preservation clauses all lose their practical teeth.

Second, contribution incentives are eroded. If developers know their work can be copied by AI with obligations stripped away, why choose open source at all? The reward of reputation presupposes that attribution is respected—and Malus’s core selling point is precisely “zero attribution.”

Third, the motivation for corporate compliance spending disappears. Traditionally, companies invest in OSPOs, SCA tools, and legal review both as a compliance need and as an indirect way to support the open source ecosystem. When Malus cuts compliance costs from $4M to $50K, that “savings” doesn’t flow to open source projects—it simply disappears.

The “commons decay” scenario Nolan himself acknowledges in his blog describes exactly this gradual unraveling of the loop: not a sudden collapse, but a slow erosion of willingness to contribute, ultimately draining the open source commons dry.

An irreversible trend

Malus.sh itself may be an elaborately designed satire, but the capability it demonstrates is already being used seriously. Dan Blanchard’s rewrite of chardet with Claude Code shows that this technique needs no dedicated Malus platform—anyone with a mainstream AI coding tool can achieve a similar result.

Blanchard’s verdict reflects a broad consensus in the industry: “What used to take a team months or years to rewrite, AI can now do in days. I don’t think there’s any way to put the genie back in the bottle.”

The market impact of this trend is already visible. In early 2026, software stocks like Oracle were sold off over concerns that “AI can be used to rapidly replicate software functionality.”

References

Z.ai Tightens GLM Coding Plan Usage Policy: Non-Coding Uses Trigger Throttling and Bans

Tue, 21 Apr 2026 01:26:07 +0800

Event Overview

Recently, AI platform Z.ai updated the usage policy for its GLM Coding Plan subscription, strictly restricting the plan to coding scenarios. According to user communities and official announcements, non-coding uses (such as running AI Agents, role-playing, translating websites, and general chat) now trigger the platform’s risk-control mechanisms; repeated violations may lead to permanent account bans, and subscription fees are non-refundable.

This change has sparked widespread discussion in overseas AI user communities, and some industry practitioners read it as a signal that AI subscription business models are shifting from “subsidizing to win users” to “precisely acquiring training data.”

Policy Details: What the Official Statement Says

According to a screenshot of Z.ai’s official announcement shared by Reddit user JustSomeGuy3465, the new GLM Coding Plan policy includes the following core terms:

Usage restriction: The GLM Coding Plan is designed specifically for Coding Scenarios. If the system detects the subscription being used for requests unrelated to programming, the platform may restrict the relevant subscription benefits.
Risk-control measures: After violating the Usage Rules and triggering risk control, an account may face high-intensity throttling, account suspension, or permanent ban.
Violation red line: Violating the Usage Rules three or more times will result in a permanent ban, and subscription fees are non-refundable.

The user also noted that the 1302 and 1303 rate-limit errors many users have recently encountered are related to this policy update.

User Feedback: What’s Happening in the Community

In the Reddit post mentioned above, the poster explicitly warned: “If you are thinking about buying or renewing a Z AI coding plan subscription for anything other than coding: Don’t do it.”

Comments and related discussions show that some users have already reported their accounts being banned after using them for non-coding scenarios (such as running Agents via OpenClaw or engaging in role-play conversations), without receiving clear warnings in advance.

Notably, the plan previously attracted quite a few non-coding users because of its relatively low price. After the sudden policy change, these users became the most directly affected group.

Industry Commentary: Observations From the OpenClaw Founder

OpenClaw founder Peter Steinberger (@steipete) commented on the matter on X:

Steinberger’s view places this policy change in a larger industry context: some AI platforms’ low-priced subscriptions don’t make money from the subscription fee itself; their purpose is to obtain high-quality code data generated by users in real workflows.

Third-Party Analysis: Re-Examining the Subsidy Logic

Chinese tech commentator AYi (@AYi_AInotes), while sharing Steinberger’s view, expanded the analysis of this phenomenon:

The difference in data value: The commentator argues that real private code produced by users in daily work is far higher in quality than public code on platforms like GitHub, giving it greater data value for training next-generation code models.
The cost-structure conflict: Activities like running Agents, chatting, and role-playing consume a lot of GPU compute while producing no data returns useful for training the platform’s models. From the platform’s perspective, this usage pattern constitutes a “net cost.”
Industry trend judgment: The entire AI industry may be shifting from a phase of “acquiring user scale through subsidies” to a phase of “filtering high-value users through precise pricing.”

It should be noted that the above analysis is personal observation and inference, and has not been officially confirmed by Z.ai or the relevant platforms.

Observations and Summary

Based on available information, the facts of Z.ai’s policy adjustment are clear: the scope of the GLM Coding Plan has been significantly narrowed, and non-coding uses now face explicit risks. For users who have subscribed or plan to subscribe to this plan, the first step is to confirm whether their actual use cases match the platform’s definition.

As for the “data in exchange for subsidies” hypothesis proposed by Steinberger and the Chinese commentator, it offers one lens for explaining low-priced subscription strategies, but generalizing it as a universal rule for the whole industry requires more evidence. Different platforms have different cost structures, business models, and competitive strategies; a single case is not enough to capture the full picture.

For ordinary users, the more practical takeaway is: before subscribing to any AI service, read the updated terms of its usage policy carefully, to avoid having your account or service restricted due to policy changes.

Guide to Buying China's Mainstream AI Coding Plans: A Hands-on Speed and Price Comparison of 9 Platforms

Thu, 16 Apr 2026 09:46:38 +0800

Since the second half of 2025, Chinese LLM vendors have been rolling out Coding Plan subscriptions aimed at developers, replacing the traditional per-token billing with a fixed monthly fee and significantly lowering the barrier to AI-assisted programming. However, the platforms differ widely in pricing, quotas, response speed, and model support—and some even have hidden clauses like different metering units and strict limits, leaving many developers struggling to choose.

This article combines a hands-on Xiaohongshu test note, an in-depth cross-review from Cnblogs (博客园), and each platform’s official documentation to sort through 9 Chinese Coding Plans from the two core dimensions of price and speed, hoping to inform your purchasing decision.

1. Coding Plan billing models and pitfalls to avoid

Before comparing specific plans, it’s necessary to clarify the different metering units these vendors use, as this is the easiest place to trip up:

API request count: Alibaba Cloud Bailian (百炼), Volcengine Ark (火山方舟), and Infinity (无问芯穹) use this. One user prompt can trigger 5–30 model calls in the backend, and each call counts as 1 API request (per Tencent Cloud’s official docs).
Prompt count: Zhipu GLM and MiniMax use this. 1 Prompt is roughly equivalent to 1,200–1,600 API requests.
Token metering: Kimi switched to this mode on January 28 of this year, billing by input/output tokens, and cache hit rate directly affects actual usable quota.

Because the metering units differ, comparing raw numbers is meaningless. For example, Bailian Lite’s “1,200 API requests every 5 hours” and Zhipu Lite’s “80 Prompts every 5 hours” may amount to similar real-world usage intensity.

2. Price and quota comparison

2.1 The big four platforms

According to the screenshots in the Xiaohongshu note and the Cnblogs compilation, the pricing strategies of Alibaba Cloud Bailian, Volcengine Ark, Tencent Cloud, and JD JoyCoder are highly convergent:

Platform	Lite Plan	Pro Plan	Core quota (Lite)	Supported models
Alibaba Cloud Bailian	¥40 (first month ¥7.9)	¥200	1,200/5h, 9,000/week, 18,000/month	Qwen3.5-Plus, Qwen3-Coder-Next, GLM-4.7, Kimi-K2.5
Volcengine Ark	¥40 (first month ¥8.91)	¥200	Same as Bailian	Doubao-Seed-Code, DeepSeek-V3.2, GLM-4.7, Kimi-K2.5
Tencent Cloud	¥40 (first month ¥7.9)	¥200	Same as Bailian	Hunyuan series, MiniMax-M2.5, Kimi-K2.5, GLM-5
JD JoyCoder	¥40	¥200	Same as Bailian	DeepSeek-V3.2, Kimi-K2.5, MiniMax-M2.7, GLM-5

2.2 Emerging AI vendors

Compared to the big four, emerging vendors’ pricing is more scattered:

Platform	Entry price	Core quota	Billing	Highlights
Infinity	¥19.9/month	1,000/5h, 6,000/week	API requests	Lowest monthly fee, multi-model aggregation
MiniMax	¥29 (first month ¥9.9)	40 Prompt/5h, no weekly cap	Prompt	Lowest entry price, no weekly limit
Kimi	¥49 (Andante)	Per token (3x for a limited time)	Token	Native multimodal, 256K long context
Zhipu GLM	¥49 (after the 2-month price increase)	80 Prompt/5h, 400/week	Prompt	Pure in-house models, 20+ tool integrations
StepFun	Not tested	—	—	No hands-on data yet

From a value-for-money standpoint:

Budget-conscious users: Infinity (¥19.9) and MiniMax (¥29) have lower entry barriers.
New users trying the waters: Alibaba Cloud Bailian’s first-month ¥7.9 is currently the lowest known trial price.

3. Hands-on speed tests: TTFT and TPS

The following speed data comes from a Xiaohongshu hands-on test note, tested under the conditions of “daytime @ 10K tokens,” measuring time to first token (TTFT) and TPS generation speed respectively. This data directly reflects the “responsiveness” of coding and code-generation efficiency.

3.1 Time to first token (TTFT)

Platform	Fastest model	TTFT	Slowest model	TTFT
Zhipu GLM	glm-5-turbo	1.43s	glm-5	7.82s
Tencent	hunyuan-2.0-thinking	2.51s	kimi-k2.5	12.38s
MiniMax	m2.1	2.44s	m2.5	5.54s
Alibaba	glm-4.7	2.76s	qwen3-coder-next	11.58s
Infinity	deepseek-v3.2-thinking	3.26s	kimi-k2.5	7.76s
Volcengine	doubao-seed-2.0-pro	3.29s	glm-4.7	21.52s
JD	deepseek-v3.2	~5s	kimi-k2.5	~19s
Kimi	kimi-for-coding	5.71s	—	—

Observations: Zhipu GLM’s glm-5-turbo is the fastest of all at 1.43s TTFT; the time-to-first-token for some models on Volcengine and JD is notably higher, hitting 21.52s and 19s respectively, possibly related to platform scheduling policies or model deployment methods.

3.2 TPS generation speed

Platform	Fastest model	TPS	Slowest model	TPS
Zhipu GLM	glm-4.5-air	103	glm-5	23
Volcengine	doubao-seed-2.0-pro	76	kimi-k2.5	23
Tencent	hunyuan-2.0-thinking	76	glm-5	30
Alibaba	qwen3-coder-next	67	glm-4.7	41
Infinity	minimax-m2.5	51	kimi-k2.5	25
MiniMax	m2.5	48	m2.1	45
JD	deepseek-v3.2	35	glm-5	25
Kimi	kimi-for-coding	35	—	—

Observations: Zhipu’s glm-4.5-air reaches 103 TPS, significantly ahead of other platforms; Volcengine and Tencent’s Hunyuan/Doubao models also hit 76 TPS. JD and Kimi are relatively slow at around 35 TPS.

In addition, MiniMax officially claims its M2.5 model can reach 100+ TPS, which differs from the 48 TPS measured on the MiniMax platform in the Xiaohongshu note, indicating that the same model may perform differently when deployed on different platforms.

4. Platform reviews and buying recommendations

Combining price, quota, and speed data, here are recommendations for different usage scenarios:

New users / those wanting to try it cheap

First choice: Alibaba Cloud Bailian Lite (first month ¥7.9). Rich model selection, backed by Alibaba Cloud infrastructure, with solid stability. Downsides: only the primary account is supported, and the config documentation isn’t beginner-friendly.

Budget-conscious, light use (monthly budget ≤ ¥30)

First choice: Infinity Lite (¥19.9/month). Quota close to Bailian’s at half the price, ideal for light developers who code 2–3 times a week.
Second choice: MiniMax Starter (¥29/month). No weekly cap; quota only refreshes every 5 hours, good for continuous use.

Daily development, moderate use (monthly budget ¥40–50)

First choice: Alibaba Cloud Bailian Lite (regular ¥40) or Volcengine Ark Lite (regular ¥40). Both have transparent quotas and many model choices.
Not recommended: Zhipu GLM (¥49 after the price increase, worse value) and Kimi (¥49, few tool integrations and quota heavily affected by cache).

Heavy development, full-stack, or multi-model switching

First choice: Alibaba Cloud Bailian Pro or Volcengine Ark Pro (¥200/month). Around 5x the quota of Lite, with free switching between multiple models. Volcengine also supports Auto smart scheduling.
If you prefer GLM’s in-house models, consider Zhipu GLM, but note its weekly limit and peak-time quota multipliers (3x during peak, 2x off-peak).

Pursuing ultimate response speed

If time-to-first-token and generation speed are your top priorities, Zhipu GLM’s glm-5-turbo (1.43s TTFT) and glm-4.5-air (103 TPS) perform best.

5. Summary

The Chinese Coding Plan market is iterating rapidly, with price wars and model wars running in parallel. When choosing, don’t fixate on surface prices; instead, focus on three core questions:

What is the metering unit? API requests, Prompt counts, or tokens? Different units can’t be compared directly.
How does the quota mechanism work? Refreshed every 5 hours, capped weekly, or capped monthly? This determines whether you can sustain high-intensity use.
Is the speed responsive? TTFT and TPS directly affect the coding experience, and the same model can perform wildly differently across platforms.

A final reminder: plan policies change frequently across vendors (e.g., Zhipu’s price increase, Kimi switching to token billing, Alibaba Cloud discontinuing its Lite tier), so be sure to confirm the latest details on each platform’s official website before subscribing.

Data sources

Claude Rolls Out Identity Verification: Impact on Users in Unsupported Regions and How to Respond

Wed, 15 Apr 2026 15:22:53 +0800

Anthropic recently rolled out an identity verification mechanism on the Claude platform. Based on the official help center documentation and the list of supported countries and regions, this article summarizes the core points of the mechanism, with a focus on assessing the actual impact on users in unsupported regions (e.g., mainland China) and viable strategies.

1. Core points of the identity verification mechanism

1.1 Purpose

According to the official statement, identity verification aims to:

Prevent technical abuse
Enforce platform usage policies
Fulfill legal and security compliance obligations

When users access certain features, a verification prompt may appear — this is part of routine platform integrity checks.

1.2 Verification methods and required materials

The verification service is powered by Persona Identities. Users need to prepare:

A valid government-issued photo ID (passport, driver’s license/state ID, or national ID)
A device with a camera: a live selfie may be required
The verification process typically takes no more than five minutes

Document types that are NOT accepted include: photocopies/screenshots/scans, digital IDs (such as electronic driver’s licenses), student/employee/bank cards, and temporary paper IDs.

1.3 Data privacy statement

The official documentation highlights the following privacy protections:

Anthropic is the data controller of verification data; Persona only processes data as instructed
ID documents and selfies are not stored directly by Anthropic but kept on the Persona platform
Data is used only for identity confirmation and legal/security obligations, not for model training, and is not shared with third parties for marketing or advertising
Both transmission and storage are encrypted

1.4 Why accounts can still be banned after verification

The official documentation explicitly lists four situations that can lead to account suspension:

Repeated violations of usage policies
Creating an account from an unsupported location
Violating the Terms of Service
Use by individuals under 18

This point is especially critical for users in unsupported regions: even if identity verification passes, if the system determines the account originates from an unsupported region, there is still a risk of a ban.

2. Real impact on Chinese users

2.1 Mainland China is not on the official supported list

According to Anthropic’s Supported Countries and Regions page, mainland China does not appear in the supported list for Claude.ai or the commercial API. The list includes Taiwan, but not mainland China, Hong Kong, or Macau.

2.2 Core impact assessment

Impact dimension	Details
Ban risk shifts from implicit to explicit	Previously, the platform mainly relied on IP, payment methods, and login behavior for risk control; now identity verification is directly tied to regional policy. Even after passing verification with a genuine Chinese passport, users may still be banned for “originating from an unsupported region.”
Account acquisition threshold rises significantly	For users relying on shared accounts or SMS-activation platforms, completing a “physical ID + live selfie” verification process is nearly impossible.
Cross-border data concerns	Chinese users must submit ID documents and biometric data to Persona, a US third-party service provider, raising privacy and cross-border data compliance concerns.
Low success rate for appeals	If the ban reason is “originating from an unsupported region,” this is an explicit policy red line for Anthropic rather than a system error, so the likelihood of a successful appeal is low.

2.3 Behaviors more likely to trigger verification

Although the official trigger conditions are not fully disclosed, based on standard platform risk-control logic, the following behaviors are more likely to trigger identity verification:

High-frequency API calls or anomalous usage patterns
Upgrading to Claude Pro / purchasing large API credits
Frequently switching IP addresses or login devices
Accounts being reported or generating policy-violating content
Using unconventional payment methods such as virtual credit cards or gift cards

3. Response strategies

3.1 For existing accounts: reduce the chance of being triggered

If you still hold a usable account, the following measures can help extend its useful life:

Keep a low profile: try to avoid triggering high-risk-control features
Stabilize your network environment: minimize IP hopping and maintain consistent access patterns
Comply with usage policies: avoid generating prohibited content to reduce the chance of being reported

It should be clear that these measures can only lower the probability of being triggered; they cannot eliminate the structural risk of being in an “unsupported region.”

3.2 Long-term alternatives

Given the low compliance ceiling for personal accounts, it’s advisable to migrate to more stable, sustainable channels:

Option	Details
Enterprise cloud platforms	Access the Claude API through enterprise-grade platforms such as Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Foundry. These channels target enterprise users, are more compliant, and are not directly subject to the regional verification restrictions of personal accounts.
Official partners	Watch whether Anthropic provides services in mainland China through authorized partners.
Local alternative models	For daily work and development, migrate to models that operate compliantly in mainland China, such as DeepSeek, Qwen, ERNIE Bot, and Zhipu AI (GLM).

3.3 If you’ve already been banned

The official appeal form lets users submit a review request. However, if the ban reason is “originating from an unsupported region,” the chance of a successful appeal is very low. It’s better to prioritize backing up and migrating your data and session records.

3.4 Risks of creating a new account

Under the current policy, the long-term viability of a new mainland China user registering a personal Claude account and passing identity verification is highly uncertain. If there’s a genuine need, it’s recommended to apply through enterprise-grade cloud services or a physical office environment in a supported region in a compliant way, rather than relying on SMS-activation codes or virtual payment methods.

4. Summary

Claude’s identity verification mechanism elevates “regional restrictions” from a background risk-control rule to a front-facing compliance hurdle. This means:

Technical and payment-based workarounds (VPNs, virtual numbers, shared accounts) largely fail in the face of identity verification
Even after passing verification, “unsupported region” remains a red line that can directly trigger a ban
For long-term, stable business needs, migrating to enterprise cloud channels or local alternative models is the more sustainable strategy

This change also reflects the trend of leading AI platforms tightening compliance boundaries during global expansion. For users in unsupported regions, accepting this structural constraint and planning alternatives in advance is more rational than continuously investing in circumvention.

Nous Research Subscription Models: Prepaid vs Pay-as-you-go, Which Is Better Value?

Tue, 14 Apr 2026 03:57:09 +0800

Recently, Nous Research’s API service, Portal, has gradually drawn the attention of developers. This article systematically maps out its pricing system based on official documentation and public information, clarifies core concepts such as “credits,” “tokens,” and “rate limits,” and compares the use cases for the two consumption modes.

1. Core Concepts: The Exchange Relationship Between Credits and Tokens

In Nous Portal’s billing system, 1 Credit = $1 USD. This means:

The “$10.00 monthly credits” in a subscription plan is equivalent to $10 of API usage credit.
Model pricing (e.g., Hermes-4-70B at $0.13/1M input tokens) is priced directly in USD.
The actual amount of tokens a credit converts to depends on the unit price of the chosen model.

Conversion example (using Basic plan’s $10 credits):

Model	Input price/1M	Input tokens purchased with $10
DeepHermes 3 (Mistral 24B)	$0.02	500 million tokens
Hermes-4-70B	$0.13	~76.9 million tokens
Hermes-4-405B	$1.00	10 million tokens
Claude Opus 4.6	$5.00	2 million tokens

Source: Nous Portal Models page

As shown, when using high-performance models (such as Claude Opus 4.6), the amount of tokens your credits buy can differ by dozens of times.

2. The Two Consumption Modes Explained

According to the official API documentation, Nous Portal offers two independent consumption modes:

Mode A: Subscription (prepaid)

Plan	Monthly fee	Credits received	Rate Limits
Free	$0	Trial credits (small amount)	50 RPM, 100K TPM
Basic	$10	$10.00	400 RPM, 2M TPM
Plus	$20	$20.00	400 RPM, 4M TPM
Scale	$50	$50.00	600 RPM, 6M TPM
Max	$100	$100.00	800 RPM, 8M TPM

Source: Nous Portal API Docs

Analysis of characteristics:

A fixed monthly charge that grants equal-value credits.
Access to rate limits higher than the “default paid user” tier.
Credits may reset at the end of the month (confirm the exact policy on the billing page).

Mode B: Pay-as-you-go (direct top-up)

No subscription required; add API credits directly to your account (any amount).
Rate Limits: 200 RPM, 800,000 TPM (corresponding to the “Default paid users” level in the docs).
Use until depleted, top up at any time.
Credits may not expire (per the WorldSim Terms of Service: “Purchased credits will not expire unless the application(s) is retired”).

Source: WorldSim Terms of Service

3. Key Differences vs OpenRouter

Feature	Nous Portal	OpenRouter
Consumption mode	① Subscription prepaid ($10-100/month); ② Direct credit top-up (any amount)	Pure pay-as-you-go (no monthly barrier)
Rate Limits	Determined by subscription tier: Free(50) → Basic(400) → Max(800) RPM	Dynamically adjusted by usage
Credits mechanism	Prepaid credits, may reset monthly	Credits never expire
Anonymous payment	Not supported	Supports x402 protocol (Solana USDC)
Model coverage	400+ models, incl. OpenAI/Anthropic/open-source	200+ models, aggregates multiple providers

Source: Nous Portal API Docs, OpenRouter official site

Key difference: Nous Portal’s subscription model essentially trades “monthly fees for higher rate limits + equal-value credits”; OpenRouter is pure per-usage billing with no subscription barrier.

4. Billing Formula and Cost Estimation

API call cost formula:

Model price reference (from the official Models page):

Model	Input/1M	Output/1M
DeepHermes 3 Mistral 24B	$0.02	$0.10
Hermes-4-70B	$0.13	$0.40
Hermes-4-405B	$1.00	$3.00
GPT-5.4	$2.50	$15.00
Claude Opus 4.6	$5.00	$25.00

Source: Nous Portal Models page

Real example: if you use Hermes-4-70B to process one conversation (2K input tokens, 1K output tokens):

Cost = (2000/1M × $0.13) + (1000/1M × $0.40) = $0.00026 + $0.0004 = ~$0.00066
$10 in credits can support about 15,000 such conversations.

5. Selection Advice and Potential Caveats

Recommended options for different scenarios

User type	Recommended approach	Reason
Trial/light use	Free tier → top up a small amount of credits	No monthly commitment
Developer/moderate traffic	Basic Subscription ($10)	400 RPM is enough for daily use; $10 credits are roughly consumed
High-traffic production	Scale/Max Subscription	600-800 RPM avoids 429 throttling
Agent developers	Plus ($20)	Balance between rate limit and credit amount
Uncertain usage	Direct credit top-up	Avoid wasting subscription credits that reset monthly

Potential issues to note

Credit reset risk: subscription monthly credits may reset at the end of the month (confirm the exact policy by logging into the portal billing page).
Rate limit difference: the top-up mode offers only 200 RPM; high-concurrency scenarios can easily trigger throttling.
Huge model price gaps: Claude Opus 4.6 costs 38× more than Hermes-4-70B; choosing the wrong model can drain credits quickly.
Refund policy: per the Terms of Service, “All Fees are non-refundable.”

Source: Nous Portal Terms of Service

6. Summary

Nous Research Portal’s pricing system is designed to serve both “stable subscription users” and “flexible on-demand users”:

Subscription mode suits production environments that need a stable, high-concurrency rate limit.
Top-up mode suits scenarios with fluctuating usage where users want to avoid being bound by a monthly fee.

Developers should choose the most suitable billing method based on their token consumption, concurrency needs, and cost budget. For users who are uncertain, it’s recommended to first try the Free tier or a small top-up, then decide whether to upgrade the subscription based on actual usage.

This article is compiled from Nous Research’s official documentation and public materials; specific policies are subject to the latest official announcements.