OpenAI's New Model Disrupts Price-Performance: One-Tenth the Price, Top-Tier Performance

The AI world is buzzing again. According to a tip from a Bilibili creator, OpenAI has released a new model touted as "super cost-effective," offering performance close to top-tier models at roughly one-tenth the price of Ostra. Although the source doesn't provide specific pricing figures or benchmark scores, the magnitude comparison of "one-tenth the price" alone is telling—if true, it means inference costs have been pushed into an entirely new range.

Price Killer or Marketing Hype?

The phrase "top-tier performance at one-tenth the price" should be familiar to anyone who follows the AI space. Similar claims surface with every new release. But what's noteworthy this time is that the tipster focuses on "cost-effectiveness" rather than "the strongest."

This actually reflects an industry trend: the capability gap among top players is narrowing, and the marginal returns from simply stacking parameters and climbing leaderboards are diminishing. Whoever can drive down inference costs will capture a larger developer market. The creator's exact words in the video were "this money burns faster than it's spent"—a joke, but one that precisely highlights the biggest pain point in commercializing large models today: token consumption costs.

As for the claim that "the kill line has arrived," it reads more like a content creator's headline rhetoric. From the source material, there are no specific performance comparison tables or third-party evaluation data to support the "kill" judgment. A rational view: cost-effectiveness is indeed a signal worth watching, but words like "crushing" and "disruptive" need to wait for independent benchmarks before drawing conclusions.

Inference Cost and Token Consumption

The inference cost of large models is primarily determined by the number of tokens. A token is the basic unit of text a model processes, roughly equivalent to 0.75 English words or half a Chinese character. Each conversation generates token consumption for both input and output, and API calls are typically priced per million tokens. Inference costs far exceed training costs because every user request requires a full forward pass. Therefore, the key to reducing inference costs lies in optimizing model architecture (e.g., MoE sparse activation), using more efficient hardware, or compressing model size through quantization. The so-called "one-tenth the price" essentially means the unit price per million tokens has been pushed to one-tenth that of competitors—significant for high-frequency use cases like code completion and batch document processing.

JPT6 Tops the Leaderboards—Where Are Its Limits?

The creator mentions that JPT6 "directly topped various evaluation leaderboards across the board," and offers two vivid examples: generating a League of Legends in three sentences, and hand-coding a CrossFire with a few lines of text.

These demos are essentially showcases of code generation capability. Having a model generate a game prototype from natural language descriptions tests its understanding of complex logic and consistency over long contexts. From the "three sentences" description, the model indeed performs well in instruction following and structured code output. But a word of caution: generating a playable game prototype and generating a commercially viable game are orders of magnitude apart in engineering effort. The value of the demo is to show that the model's "floor capability" has risen—not that it can actually replace game developers.

Another detail mentioned is "running for half an hour consumes only one banana." This is a vivid cost description; the specific token consumption isn't specified in the source, but the signal is clear: inference efficiency has been significantly optimized.

Code Generation and Long-Context Consistency

Code generation tasks require the model to not only understand natural language instructions but also maintain syntactic correctness, logical coherence, and consistency with existing code style during generation. When a model outputs a game prototype based on descriptions like "generate a League of Legends in three sentences," it must simultaneously handle game rules, character attributes, interaction logic, and multiple other modules—testing its ability to maintain consistency over long contexts, i.e., not "forgetting" previously defined variables or functions when generating lengthy code. Current mainstream models mitigate this by expanding context windows (e.g., 128K tokens) and optimizing attention mechanisms, but generating commercially viable software still requires substantial engineering refinement. The demo showcases the model's "floor" rather than its "ceiling."

JPT6 Luna: A Lightweight Choice for Everyday Users

The latter half of the video switches to JPT6 Luna, where the creator asks it to "draw a Tihu"—and it does. This scenario is quite representative: ordinary users' first need for a model is often not coding or complex reasoning, but "can it help me quickly get a small thing done."

Luna is positioned as a "more cost-effective" option, complementing the flagship JPT6. This product tiering strategy is increasingly common in the industry: flagship models flex their muscles and raise the ceiling, while lightweight models drive volume and cover everyday use cases. For developers, this means flexible model selection based on task complexity, rather than routing every request through the most expensive channel.

However, the source doesn't elaborate on Luna's specific parameters, context window, or multimodal capability boundaries—only a drawing demo. So what can be confirmed now is just one thing: it works, and it should be considerably more affordable than the flagship.

Product Tiering and Model Selection

The tiering strategy of flagship and lightweight models is similar to "on-demand selection" in cloud computing. Flagship models have large parameter counts and high inference costs, suited for complex reasoning and code generation; lightweight models use distillation, pruning, or smaller parameter sizes to maintain basic capabilities while significantly reducing unit price, suited for everyday Q&A, simple drawing, and document summarization. For developers, this tiering means dynamically routing requests based on task complexity—simple tasks through the lightweight channel, complex tasks through the flagship channel—balancing experience and cost. A common industry practice is to offer multiple model sizes (e.g., small, medium, large) and allow users to switch via API parameters.

How to Choose Between JPT and Claude? The Answer Depends on the Scenario

The creator directly poses a question in the video: which is better, JPT or Claude? There's no standard answer, but we can break it down.

If your tasks are primarily code generation and you're pursuing extreme cost efficiency, the information presented suggests the JPT series is indeed competitive this round. If your tasks involve long document analysis, nuanced writing style control, or complex reasoning chains, the Claude series has consistently held a stable reputation in the developer community. The real selection advice is: take your three most typical tasks and run them through both models, comparing output quality and token bills. That's more reliable than any leaderboard.

As for the creator's remark "the poor play with cars, the rich play with watches, and Lingfu Extra says hello"—that's just entertainment. Translated, it roughly means: different budgets, different approaches; whatever fits your workflow is best.

How Should Ordinary Users Respond?

If you just want to try these models, the barrier isn't high. The creator mentions "I've already smoothed things over for my bros," hinting that access methods are in the video comments or description. For ordinary users who don't want to tinker, my advice is simple: first figure out what problem you want to solve, then choose a model.

No matter how powerful a model is, it's meaningless if it can't solve your specific problem. No matter how cost-effective, if you only ask three questions a day, you won't save much. What's truly worth watching are capability improvements that can be embedded in your daily workflow—code completion, document summarization, rapid prototype validation. These scenarios are most cost-sensitive and best demonstrate the real value of "one-tenth the price."

One-line Summary

OpenAI's new model emphasizes cost-effectiveness at one-tenth the price; JPT6 tops leaderboards but needs independent verification.

Paragraph Summary

The article revolves around tips about OpenAI's new model, with the core message being its price at roughly one-tenth of Ostra, targeting the high-value, volume-driven market. JPT6 tops multiple evaluation leaderboards, and its code generation capability is demonstrated through examples like "generating a game prototype in three sentences," though the author cautions that demos don't equal commercial replacement. JPT6 Luna serves as a lightweight option covering everyday scenarios, forming a flagship-plus-lightweight product tier. The selection advice versus Claude is to run A/B tests with actual tasks rather than relying on leaderboards. Finally, it notes that ordinary users should focus on capability improvements that integrate into workflows, such as code completion and document summarization—cost-sensitive scenarios.