Product Observation 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

Pi Coding Agent: A Terminal AI Coding Agent Built on 418 Lines of Code

Wed, 29 Apr 2026 02:07:14 +0800

Pi (full name pi-coding-agent) is an open-source terminal AI coding agent (a CLI coding harness). It has accumulated more than 17,500 stars on GitHub, with peak npm weekly downloads of 1.3 million. It was developed by Mario Zechner (author of the well-known game framework libGDX, GitHub @badlogic), and recently ranked first on OpenRouter’s trending list.

Core philosophy: minimalism and extensibility

Pi was born out of Zechner’s dissatisfaction with existing coding agents. As he wrote on his blog: “Claude Code has turned into a spaceship — I don’t use 80% of its features. The system prompt and tools change with every release, breaking my workflow.”

Pi’s philosophy can be summed up as: “If I don’t need it, I don’t build it.”

Compared with similar tools, Pi chooses extreme minimalism on multiple dimensions:

Dimension	Mainstream tools like Claude Code	Pi
Core agent loop	Thousands of lines of code	418 lines of TypeScript
System prompt + tool definitions	Thousands of tokens	< 1,000 tokens
Default tools	A dozen or more	4 (read, write, edit, bash)
Built-in features	Big and comprehensive	Minimal, filled out with extensions

Zechner’s core assumption: all frontier models have been heavily trained with RL, so they already understand what a coding agent is. Therefore the harness doesn’t need to over-instruct the model — the lighter the better.

Four-layer architecture

Pi uses a strictly bottom-up layered design, with each layer having zero dependency on the layers above it:

pi-ai: cross-provider context migration

pi-ai is the low-level unified LLM API, supporting 15+ providers and 300+ models. It normalizes four protocols — OpenAI Completions, OpenAI Responses, Anthropic Messages, and Google Generative AI — into a unified event-stream format.

Its killer feature is cross-provider context migration: in a single session you can think with Claude first, then switch to GPT-4o to verify, with the context carried over seamlessly. Claude’s thinking traces are automatically converted into `` tags for OpenAI models to read.

pi-agent-core: the 418-line dual loop

This is Pi’s core, using a two-layer separation of AgentMessage (application layer) and LLM Message (model layer):

No maximum step limit: the loop keeps running until the agent itself declares completion
Runtime hot-swapping: setModel(), setTools(), setSystemPrompt() take effect at any time
Steering mechanism: users can send “steering messages” while the agent is executing tools; the agent responds as soon as it finishes the current tool, skipping the remaining queued tool calls
Three-tier event system: full streaming event subscription at the agent / turn / message / tool level

pi-coding-agent: the terminal application layer

Provides four operating modes:

Mode	Use case
Interactive	Full TUI interaction experience
Print (-p)	Generate a shell script and print it
JSON (–mode json)	Structured event stream, good for pipelining
RPC (–mode rpc)	JSON protocol over stdin/stdout, embeddable in other applications
SDK	Embed directly into Node.js applications

Extensibility: Pi’s real killer feature

Pi turns “features built into other tools” into “extensions you build or install yourself” — this is its most fundamental difference from tools like Claude Code.

Extensions: TypeScript modules with access to tools, commands, shortcuts, events, and the full TUI
Skills: on-demand capability packages (instructions + tools)
Prompt Templates: reusable Markdown prompts expanded quickly with /name
Pi Packages: extension packages distributed via npm or git

The official repo offers 50+ extension examples, including subagents, plan mode, permission gating, path protection, SSH execution, sandboxing, and MCP integration.

Context-engineering mechanisms

Pi provides multiple mechanisms for precise context control:

Mechanism	Use case
AGENTS.md	Project-level instructions, placed in ~/.pi/agent/ or the project directory
SYSTEM.md	Replace or append to the default system prompt
Compaction	Automatically summarizes near the context limit; customizable
Dynamic Context	Inject messages, filter history, RAG, and long-term memory via extensions

Community positioning and the Harness Effect

According to a six-harness comparison released by Pawel Jozefiak in April 2026, Pi’s positioning is that of a moldable, minimal harness.

The review proposed an important “Harness Effect”: the same model can differ by 5–40 percentage points across different harnesses. For example, Claude Opus scores 77% in Claude Code but reaches 93% in Cursor. Pi’s value is that it provides a highly tunable, fully transparent foundation, letting users optimize this effect for themselves.

Tool	Positioning	Characteristics
Claude Code	Agent Orchestrator	Strongest contextual coherence; suited to complex multi-file tasks and unattended overnight runs
Codex CLI	Coding Tool	Executes cleanly but lacks contextual coherence
Aider	Coding Tool	High editing precision, but doesn’t aim to be an autonomous agent
OpenCode	Middle ground	Built by the SST team; feature-complete
Pi	Moldable minimal harness	Lightweight, transparent, deeply customizable

What can you use it for

Everyday coding agent: a replacement for Claude Code / Codex CLI, handling code generation, refactoring, and debugging in the terminal
Custom workflows: build your own “plan mode”, “permission gating”, and “subagent orchestration” via extensions
Embedding in other applications: use Pi as an engine inside your own tools via the SDK or RPC mode (OpenClaw takes this approach)
Multi-model collaboration: switch between different models within a single task, leveraging each one’s strengths
Overnight autonomous runs: combine the steering and follow-up mechanisms for long-running autonomous tasks
Team standardization: share coding conventions and workflows across a team through AGENTS.md, Skills, and Pi Packages

Quick start

Pi’s install and launch flow is extremely simple.

Installation

Launch it after entering your project directory:

Adding a model (authentication)

Pi supports two authentication methods:

Method 1: subscription login

Run this inside Pi’s interactive interface:

Then choose a provider. Built-in support includes Claude Pro/Max, ChatGPT Plus/Pro (Codex), GitHub Copilot, and Google Gemini CLI.

Method 2: API key

Set the environment variable before launching:

You can also choose an API-key provider via /login, storing the key in ~/.pi/agent/auth.json.

Task conversations

After launching, just type what you need:

Four tools are provided by default: read (read files), write (write files), edit (edit files), and bash (run commands). Read-only tools like grep, find, and ls can be enabled via options.

Common operations:

Reference a file: type @ for fuzzy search, or specify directly on the command line: pi @README.md "Summarize this"
Run a command: !npm run lint (send output into the model’s context), !!command (run without sending into context)
Switch models: /model or Ctrl+L
Continue sessions: pi -c (most recent session), pi -r (browse history), /resume, /new, /tree (session management)
Non-interactive mode: pi -p "Summarize this codebase" (single-shot output)

Project instructions

Create an AGENTS.md in the project root, which Pi loads automatically at startup:

Run /reload after modifying it for changes to take effect.

Summary

Pi is not “yet another Claude Code replacement.” It is a radical minimalist experiment, proving that a well-designed lightweight harness can match or even surpass complex frameworks.

It’s best suited to developers dissatisfied with the “black-box behavior” of existing agents, and to advanced users who want full control over the system prompt, tools, and context flow. If all you want is an “out-of-the-box, feature-complete” experience, Claude Code may remain the first choice; but if you want to understand and control every line of behavior in your agent, Pi is one of the most transparent options available today.

Sources

Success Is Not a Door but a Wall: Naval's Takedown of the Overnight-Success Myth

Wed, 15 Apr 2026 07:38:37 +0800

Introduction: the story selectively ignored

The success narrative the media loves to tell is always the same: a person, a product, a book—suddenly capturing everyone’s attention overnight. An app goes viral, a bestseller hits the top, a founder rings the bell. The headline always carries the same word—overnight success.

But Naval Ravikant, in this article published on Naval’s Archive, points out that this headline always leaves out the seven years that came before.

The tweet itself is only a few words, but the newsletter expands it into a full cognitive-recalibration essay. Here’s a breakdown and interpretation of its core argument.

1. “The Invisible Years”: the foundation beneath all visible success

The article introduces an easily overlooked concept: The Invisible Years.

Jeff Bezos sold books in a garage for years, J.K. Rowling’s manuscript was rejected twelve times, and Naval himself spent years building companies, writing, and thinking in public—these years, preceding any viral tweet, are what constitute the real foundation.

This line in the original text pinpoints the exact moment most people quit:

Interpretation: The value of this passage is that it redefines “giving up” as a time-perception bias—not a lack of ability, but a misjudgment of the feedback cycle. Struggle doesn’t go viral, process doesn’t trend; the only thing that gets shared is the outcome. This filtering mechanism of the information environment systematically inflates the illusion of “quick success.”

2. Why this myth is genuinely destructive

The article doesn’t stop at the cliché that “success takes hard work”; it goes further: believing in “overnight success” not only misleads you, it actively harms you.

If you believe success happens suddenly, then every day it doesn’t happen becomes evidence that “this isn’t going to happen.” You measure yourself against a timeline that doesn’t exist, comparing someone else’s chapter thirty to your chapter three.

Naval uses a set of very concrete, bodily words to describe the process:

Grind and sweat: the monotonous repetition day after day, with nothing romanticized about it
Toil and bleed: the real cost, the sacrifice, the effort that will never be known
Face the abyss: looking at everything you’ve built, genuinely unsure whether any of it will ever amount to anything

Interpretation: This is the sharpest insight. Many people can endure hardship, even sacrifice, but what they cannot endure is uncertainty itself. The abyss isn’t failure; it’s continuing in the complete absence of any cosmic feedback. This is a discipline that runs against human nature—the human brain is designed to rely on feedback to correct behavior, yet genuine long-termism demands that you hold course inside a feedback vacuum.

3. “Overnight success” isn’t entirely fiction—it’s just misdefined

The article concedes that the “overnight” part of overnight success does exist:

But that moment isn’t success itself. It’s the visibility of success. The real success happens in slow, unglamorous, unwatched rooms, accumulating day by day.

Interpretation: This is one of the clearest concretizations of the concept of “compounding.” Compound interest is a mathematical model in economics, but on a personal level it’s a psychological test—you have to keep investing before the curve breaks above the horizontal axis. The tipping point is a mathematical certainty, but before it arrives, it looks like a miracle that will never come.

4. Success is a lagging indicator

Strip away the poetic shell, and the article leaves you with a mathematical truth:

Everything you see today—money, reputation, influence—is the delayed result of decisions made years ago. The person you admire wasn’t successful the moment you noticed him; he succeeded on the day he chose to continue when “giving up made more sense.”

Interpretation: This fundamentally reframes the coordinate system of effort. If success is a lagging indicator, then your task isn’t to chase results, but to build the inputs. Day after day of inputs—no applause, no feedback, no dopamine reward. Naval has said elsewhere that life’s most important skill is the ability to delay gratification; this tweet is the lived experience of that idea.

5. The abyss is a filter

The article closes with a powerful metaphor:

The abyss filters out most people not because it selects for intelligence, talent, or capital, but because it selects for only one thing: the willingness to keep going when there is no rational reason to continue.

The phrase “overnight success” itself becomes a punchline—it’s the universe’s way of erasing all the evidence that came before. And those who have truly been through it will never say the word without a smile, because they remember every sleepless night that preceded it.

Interpretation: This “wall” metaphor is colder and more honest than any success-coaching chicken soup. A door implies a key, a shortcut, a moment of unlocking; a wall implies no technique, only pushing. When others on the other side of the wall call you “lucky,” it’s only because they haven’t seen the every single day you spent pushing against it.

Conclusion: to those living in the invisible years

The most valuable thing about this article isn’t telling us to “work hard,” but providing a normal narrative framework for “having not yet seen results.” In an era when social media only shows outcomes, realizing that “the stage without feedback is itself part of the process” is a rare cognitive immunity.

If you’re going through your own invisible years, Naval’s line can serve as an anchor:

Original source: The Myth You Were Sold About Success — Naval’s Archive

This article is a summary of and personal commentary on the Naval’s Archive newsletter piece; all quoted passages are attributed to their sources.

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.