Anthropic Marshmallow & Melon Deep Dive: Cotton Candy and Melon — What Claude's New Model Codename Reveals About Product Line Restructuring
Anthropic Marshmallow & Melon Deep Dive: Cotton Candy and Melon — What Claude’s New Model Codename Reveals About Product Line Restructuring
I. Introduction: A Leak That Signals More Than Just New Models
August 24, 2026 — an otherwise ordinary Monday, until the AI developer community erupted over a single post on X. Developer @kimmonismus discovered two previously unseen model codenames in Anthropic’s API: claude-marshmallow-eap and claude-melon-eap. The news spread like wildfire through Discord, X, and developer communities worldwide, with tech media outlets including 36Kr, Jiqizhixin, and凤凰网科技 (Phoenix Tech) picking up the story within hours.
This is not the first time Anthropic has “accidentally” leaked model codenames through its API. In early July, claude-honeycomb-eap briefly appeared in Cursor’s model picker before being pulled — and when Opus 5 launched on July 24, it confirmed that Honeycomb was indeed its internal codename. The “eap” suffix in this latest leak follows the same pattern: Early Access Program, meaning both models have entered a restricted testing phase.
But this time, the story runs deeper than a simple “new model spotted” headline. The appearance of Marshmallow and Melon comes at a moment when Anthropic is grappling with multiple strategic pressures: its flagship Fable 5 is seeing stagnant enterprise adoption, Opus 5 is outperforming its own premium sibling on cost-effectiveness, and open-source models have surged from 11% token share in April to 62% in August. This codename leak is, in essence, a prematurely exposed signal of a major product line restructuring.
This article will analyze the technical, commercial, and strategic implications of these two mysterious codenames across eight dimensions.
II. The Revelation: How the Codename Leak Unfolded
2.1 The Discovery
On August 24, 2026, AI news tracker @kimmonismus posted screenshots on X showing two new model IDs in Anthropic’s API system:
claude-marshmallow-eap
claude-melon-eap
Shortly after, security researcher @chetaslua further confirmed that claude-marshmallow-ht-eap had been active since August 21. The “ht” suffix likely indicates “holdout test” or “hand-tuned,” suggesting the model was undergoing red-team security evaluation.
2.2 What “EAP” Means
EAP (Early Access Program) is Anthropic’s standard pre-release testing protocol. Before a new model’s public launch, Anthropic distributes it under EAP to a limited group of security researchers and test developers for performance evaluation and safety audits. The Honeycomb EAP precedent provides a clear timeline:
| Event | Date | Interval |
|---|---|---|
| Honeycomb EAP leak | July 9 | — |
| Opus 5 official release | July 24 | 15 days |
| Marshmallow/Melon EAP leak | August 24 | — |
| Estimated official release | Early September | ~10-15 days |
Following the Honeycomb cadence, Marshmallow and Melon’s formal release could arrive as early as the first week of September.
2.3 Early Community Interpretation
Early tester feedback has provided several key data points:
- Marshmallow outperforms Melon overall
- Marshmallow’s conversational naturalness reportedly exceeds Opus 5
- Neither model reaches Fable 5’s capability level
- Both models show strong performance on 3D reinforcement learning tasks (e.g., building placement), using substantial thinking tokens
These findings point to a clear conclusion: Marshmallow and Melon are iterative updates at the Opus/Sonnet tier, not a new frontier-class breakthrough.
III. Marshmallow vs Melon: Capability Comparison and Positioning
3.1 Performance Stratification
The community has proposed several hypotheses for the models’ positioning:
Mainstream Hypothesis (A):
- Marshmallow → Claude Opus 5.1 (Opus-tier iteration)
- Melon → Claude Sonnet 5.1 (Sonnet-tier iteration)
Mainstream Hypothesis (B):
- Marshmallow → Claude Opus 5.1
- Melon → Next-generation Haiku (lightweight iteration)
Minority View:
- Both belong to an entirely new development branch, not directly mapping to existing product lines
Based on early tester feedback, Hypothesis A has the highest credibility. Marshmallow’s conversational quality exceeding Opus 5 is consistent with an Opus-tier upgrade, while Melon’s slightly lower performance fits a Sonnet or Haiku positioning.
3.2 Capability Heatmap Comparison
┌─────────────────────────────────────────────────────────────────────┐
│ Claude Model Capability Comparison │
├──────────────┬──────────┬──────────────┬──────────┬──────────────────┤
│ Dimension │ Opus 5 │ Marshmallow │ Melon │ Fable 5 │
├──────────────┼──────────┼──────────────┼──────────┼──────────────────┤
│ Conversation │ ████████ │ █████████ │ ███████ │ ███████████ │
│ Naturalness │ 80% │ 85% │ 72% │ 92% │
├──────────────┼──────────┼──────────────┼──────────┼──────────────────┤
│ Code Gen │ █████████│ █████████ │ ████████ │ ███████████ │
│ │ 88% │ 90% │ 82% │ 93% │
├──────────────┼──────────┼──────────────┼──────────┼──────────────────┤
│ Reasoning │ ████████ │ █████████ │ ███████ │ ████████████ │
│ │ 82% │ 86% │ 75% │ 95% │
├──────────────┼──────────┼──────────────┼──────────┼──────────────────┤
│ 3D RL │ ███████ │ █████████ │ ███████ │ ██████████ │
│ │ 70% │ 88% │ 76% │ 90% │
├──────────────┼──────────┼──────────────┼──────────┼──────────────────┤
│ Tool Use │ █████████│ █████████ │ ████████ │ ███████████ │
│ │ 85% │ 87% │ 80% │ 91% │
├──────────────┼──────────┼──────────────┼──────────┼──────────────────┤
│ Cost Eff. │ █████████│ █████████ │ █████████│ ██████ │
│ │ 90% │ 92% │ 95% │ 60% │
└──────────────┴──────────┴──────────────┴──────────┴──────────────────┘
Note: The above data is based on qualitative community tester feedback and technical speculation, not official Anthropic data.
3.3 The Significance of 3D Reinforcement Learning
Early testers specifically noted that Marshmallow excels at 3D reinforcement learning tasks, with particularly good results in building placement. This detail is significant: the combination of 3D spatial reasoning and reinforcement learning is far more complex than pure text reasoning, requiring simultaneous visual understanding, spatial planning, physical rule comprehension, and long-horizon planning. If Marshmallow has indeed achieved significant gains in this area, it suggests Anthropic has made progress on:
- Deepened multimodal reasoning: Improved joint visual-spatial-language reasoning
- Optimized thinking token allocation: Automatic allocation of more compute to tasks requiring deep reasoning
- Improved RL training paradigms: Potentially new RL training strategies or reward model designs
IV. The Evolution of Naming Conventions: From Literature to Food — A Semiotic Analysis
4.1 Naming Timeline
Anthropic’s model naming has evolved through three phases, each reflecting different strategic intentions:
Phase 1: Literary Genres (March 2024 - June 2026)
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Haiku │ │ Sonnet │ │ Opus │ │ Fable │ │ Mythos │
│ (poem) │ │ (sonnet) │ │ (musical)│ │ (story) │ │ (myth) │
└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
Lightweight Mid-Range Premium Frontier Restricted
Phase 2: Animals (February 2026 - July 2026)
┌──────────────┐
│ Fennec │
│ (fox) │
│ Sonnet 4.6 │
│ Internal │
└──────────────┘
Phase 3: Food (July 2026 - Present)
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Honeycomb │ │ Marshmallow │ │ Melon │
│ → Opus 5 │ │ → Opus 5.1? │ │ → Sonnet 5.1│
│ Confirmed │ │ Speculated │ │ / Haiku? │
└──────────────┘ └──────────────┘ └──────────────┘
4.2 Strategic Implications of the Naming Shift
The shift from literary genres to animals to food is far from a random internal whim. It likely reflects strategic changes on three levels:
Level 1: Independent Development Branches
Literary genre names correspond to officially released product lines — the “brand identity” for the market and users. Food codenames, by contrast, suggest these models belong to an independent, parallel internal development branch. This mirrors Google’s shift from “Bard” to “Gemini” — a signal of generational product line transition.
Level 2: Testing Phase Isolation
Using food codenames for EAP models rather than formal product names is itself a form of “psychological isolation” — even if the codename leaks, it won’t directly impact the formal brand. If testing fails, “Marshmallow” and “Melon” can be quietly abandoned without affecting the brand value of “Haiku” and “Sonnet.”
Level 3: Architecture Implications
Sources suggest that the food naming convention may correspond to entirely new training architectures or paradigms. If Marshmallow and Melon are indeed based on a different technical path from Opus 5 (e.g., deeper Transformer layers, novel attention mechanisms, or larger MoE configurations), adopting a completely new naming system becomes logical.
4.3 Code Example: Naming Convention Parser
"""
Anthropic Claude Model Naming Parser
Parses and classifies Claude model codenames
"""
from dataclasses import dataclass
from typing import Optional
import re
@dataclass
class ClaudeModelInfo:
"""Claude model information"""
codename: str
tier: str
gen_version: str
is_eap: bool
naming_family: str # literature, animal, food
class ClaudeNamingParser:
"""Claude naming parser"""
LITERATURE_TIERS = {'haiku', 'sonnet', 'opus', 'fable', 'mythos'}
ANIMAL_NAMES = {'fennec'}
FOOD_NAMES = {'honeycomb', 'marshmallow', 'melon'}
EAP_TO_PRODUCT = {
'honeycomb': 'opus-5',
'marshmallow': 'opus-5.1', # speculated
'melon': 'sonnet-5.1', # speculated
}
@classmethod
def parse(cls, model_id: str) -> Optional[ClaudeModelInfo]:
"""Parse a model ID"""
eap_match = re.match(r'claude-(\w+)-eap', model_id)
prod_match = re.match(r'claude-(\w+)-(\d+(?:\.\d+)?)', model_id)
if eap_match:
codename = eap_match.group(1).lower()
is_eap = True
if codename in cls.LITERATURE_TIERS:
naming_family = 'literature'
tier = codename.capitalize()
gen_version = 'eap'
elif codename in cls.ANIMAL_NAMES:
naming_family = 'animal'
tier = 'Unknown'
gen_version = 'eap'
elif codename in cls.FOOD_NAMES:
naming_family = 'food'
tier = 'Unknown (EAP)'
gen_version = 'eap'
else:
naming_family = 'unknown'
tier = 'Unknown'
gen_version = 'eap'
return ClaudeModelInfo(
codename=codename,
tier=tier,
gen_version=gen_version,
is_eap=is_eap,
naming_family=naming_family
)
return None
# Test parsing
test_ids = [
'claude-marshmallow-eap',
'claude-melon-eap',
'claude-honeycomb-eap',
'claude-fennec-eap',
'claude-opus-5',
'claude-sonnet-5',
]
parser = ClaudeNamingParser()
for model_id in test_ids:
info = parser.parse(model_id)
if info:
print(f"{'='*60}")
print(f"Model ID: {model_id}")
print(f" Codename: {info.codename}")
print(f" Tier: {info.tier}")
print(f" Version: {info.gen_version}")
print(f" EAP: {info.is_eap}")
print(f" Naming Family: {info.naming_family}")
V. Deep Dive: The Fable 5 Dilemma
5.1 What the Ramp Data Reveals
If the Marshmallow and Melon leak is the “symptom,” then Fable 5’s struggle is the “root cause.” Payment data from Ramp, covering approximately 70,000 enterprises, reveals a signal Anthropic cannot ignore:
Two months after Fable 5’s launch, enterprise spending accounts for only ~11% of Anthropic’s model expenditure, with growth plateauing — far below the market penetration expected of a flagship model.
┌─────────────────────────────────────────────────────────────────────┐
│ Anthropic Model Enterprise Spending Share (August 2026) │
│ │
│ Fable 5 ████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 11.4% │
│ │
│ Opus 5 ██████████████████████████████████████░░░░░░░░ 30.2% │
│ │
│ Sonnet 5 ████████████████████████████████████████████████ 38.5% │
│ │
│ Haiku 4.5████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 15.3% │
│ │
│ Others █████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ 4.6% │
│ │
└─────────────────────────────────────────────────────────────────────┘
*Source: Ramp enterprise payment data, ~70,000 companies, August 2026*
Even more striking: Opus 5, which launched in late July, has already surpassed Fable 5 in enterprise spending. This is nearly unprecedented in AI industry history — a new flagship being commercially defeated by its own "second-tier" sibling.
### 5.2 CursorBench 3.2 Cost Efficiency Comparison
CursorBench 3.2 results explain from a technical perspective why Fable 5 is "praised but not purchased":
| Metric | Opus 5 | Fable 5 | Gap |
|--------|--------|---------|-----|
| CursorBench 3.2 Score | 70.0% | 70.5% | **Only 0.5 pp** |
| Cost per Task | $8.23 | $17.32 | **Fable costs 110% more** |
| Cost Efficiency (Score/$) | 8.51 | 4.07 | **Opus 109% more efficient** |
When Opus 5 achieves nearly identical CursorBench scores at half the price, rational enterprise CTOs have no reason to choose Fable 5.
### 5.3 Competitor Diversion
OpenAI's GPT-5.6 Sol, priced at $5/$30 per million tokens (input/output), captured 25% of token volume and 23% of spending share in Ramp's data during the same period. Fable 5's total revenue contribution was only 75% of Sol's.
More devastating is the impact from the open-source ecosystem. DeepSeek V4 Pro is priced at just $0.87 per million tokens, and Grok 4.6 at $6 — these "good enough" models are eating into the flagship reasoning market at one-tenth the price.
---
## VI. Opus 5's Cost-Effectiveness Dominance: Technical Metrics and Business Logic
### 6.1 Comprehensive Benchmark Comparison
Opus 5 launched on July 24, 2026, at the same price as Opus 4.8 ($5/$25 per million tokens input/output), but with comprehensively superior performance. Here's the key benchmark comparison:
```python
"""
Fable 5 vs Opus 5 Benchmark Comparison Analysis
"""
import pandas as pd
import numpy as np
# Benchmark data
benchmarks = {
'Benchmark': [
'SWE-bench Verified',
'SWE-bench Pro',
'Frontier-Bench v0.1',
'GDPval-AA v2 (Elo)',
'ARC-AGI-3',
'OSWorld 2.0',
'CursorBench 3.2'
],
'Opus 5': [96.0, 79.2, 43.3, 1861, 30.2, 38.5, 70.0],
'Fable 5': [95.0, 80.3, 33.7, 1747, 'N/A', 35.0, 70.5],
'Opus 5 Cost($/task)': ['N/A', 'N/A', 'N/A', 2.03, 'N/A', 'N/A', 8.23],
'Fable 5 Cost($/task)': ['N/A', 'N/A', 'N/A', 2.75, 'N/A', 'N/A', 17.32],
}
df = pd.DataFrame(benchmarks)
print("=" * 80)
print("Opus 5 vs Fable 5 Benchmark Comparison")
print("=" * 80)
print(df.to_string(index=False))
print("=" * 80)
# Count benchmark wins
opus_wins = 0
fable_wins = 0
ties = 0
for i in range(len(benchmarks['Benchmark'])):
o = benchmarks['Opus 5'][i]
f = benchmarks['Fable 5'][i]
if isinstance(o, (int, float)) and isinstance(f, (int, float)):
if o > f:
opus_wins += 1
elif f > o:
fable_wins += 1
else:
ties += 1
print(f"\nOpus 5 leads: {opus_wins} benchmarks")
print(f"Fable 5 leads: {fable_wins} benchmarks")
print(f"Ties: {ties} benchmarks")
print(f"\nConclusion: Opus 5 leads or ties in {opus_wins}/{opus_wins + fable_wins + ties} benchmarks")
print(f" at half the price of Fable 5")
# Cost efficiency analysis
print("\n" + "=" * 80)
print("Cost Efficiency Analysis (per-task cost)")
print("=" * 80)
print(f"CursorBench 3.2:")
print(f" Opus 5: $8.23/task → Score 70.0% → Efficiency: {70.0/8.23:.2f} pts/$")
print(f" Fable 5: $17.32/task → Score 70.5% → Efficiency: {70.5/17.32:.2f} pts/$")
print(f" Opus 5 efficiency gain: {(70.0/8.23)/(70.5/17.32) - 1:.1%}")
print(f"\nGDPval-AA v2:")
print(f" Opus 5: $2.03/task → Elo 1861")
print(f" Fable 5: $2.75/task → Elo 1747")
print(f" Opus 5 costs {(2.75-2.03)/2.75:.0%} less, Elo {(1861-1747)/1747:.1%} higher")
6.2 The Deep Logic of Pricing Strategy
Opus 5’s pricing of $5/$25 (input/output per million tokens), exactly half of Fable 5’s $10/$50, is not simply “price competition.” It’s based on three core judgments:
Price elasticity has been validated: Sonnet 5’s launch pricing of $2/$10 drove far higher-than-expected token volume growth. Enterprise customers are highly price-sensitive — lower prices directly drive volume.
Flagship positioning needs redefinition: Fable 5’s positioning is “peak model for long-horizon, complex tasks,” but in practice, the vast majority of enterprise tasks (code generation, document analysis, customer service, etc.) don’t need Fable-level capability. Opus 5’s “daily flagship” positioning is more precisely targeted.
Defending against open-source disruption: Open-source models’ token share surge from 11% to 62% relies precisely on a “good enough and extremely cheap” positioning. Opus 5’s pricing strategy is essentially fighting open-source’s price war with closed-source resources.
6.3 API Model Selection Strategy
"""
Claude Model Selection Strategy: Task-Driven Cost Optimization
"""
from enum import Enum
from dataclasses import dataclass
from typing import Dict, List, Optional
class TaskType(Enum):
CODE_GENERATION = "code_generation"
CODE_REVIEW = "code_review"
DOCUMENT_ANALYSIS = "document_analysis"
CUSTOMER_SERVICE = "customer_service"
COMPLEX_REASONING = "complex_reasoning"
CREATIVE_WRITING = "creative_writing"
DATA_EXTRACTION = "data_extraction"
LONG_RUNNING_AGENT = "long_running_agent"
@dataclass
class ModelConfig:
name: str
input_price: float
output_price: float
max_context: int
strength: int
best_for: List[TaskType]
AVAILABLE_MODELS = {
'claude-opus-5': ModelConfig(
name='Claude Opus 5',
input_price=5.0, output_price=25.0,
max_context=1_000_000, strength=9,
best_for=[TaskType.CODE_GENERATION, TaskType.CODE_REVIEW,
TaskType.COMPLEX_REASONING, TaskType.DOCUMENT_ANALYSIS]
),
'claude-fable-5': ModelConfig(
name='Claude Fable 5',
input_price=10.0, output_price=50.0,
max_context=1_000_000, strength=10,
best_for=[TaskType.LONG_RUNNING_AGENT, TaskType.COMPLEX_REASONING]
),
'claude-sonnet-5': ModelConfig(
name='Claude Sonnet 5',
input_price=2.0, output_price=10.0,
max_context=1_000_000, strength=7,
best_for=[TaskType.CODE_REVIEW, TaskType.DOCUMENT_ANALYSIS,
TaskType.CREATIVE_WRITING, TaskType.DATA_EXTRACTION]
),
'claude-haiku-4.5': ModelConfig(
name='Claude Haiku 4.5',
input_price=1.0, output_price=5.0,
max_context=200_000, strength=5,
best_for=[TaskType.CUSTOMER_SERVICE, TaskType.DATA_EXTRACTION,
TaskType.CREATIVE_WRITING]
),
}
def estimate_cost(model: ModelConfig, input_tokens: int,
output_tokens: int) -> float:
input_cost = (input_tokens / 1_000_000) * model.input_price
output_cost = (output_tokens / 1_000_000) * model.output_price
return input_cost + output_cost
def recommend_model(task: TaskType, complexity: int = 5,
daily_volume: int = 1000) -> Dict:
candidates = []
for name, config in AVAILABLE_MODELS.items():
if task in config.best_for and config.strength >= complexity:
if task in [TaskType.CUSTOMER_SERVICE, TaskType.DATA_EXTRACTION]:
est_input, est_output = 2000, 500
elif task in [TaskType.CODE_GENERATION, TaskType.CODE_REVIEW]:
est_input, est_output = 8000, 2000
elif task == TaskType.COMPLEX_REASONING:
est_input, est_output = 15000, 4000
elif task == TaskType.LONG_RUNNING_AGENT:
est_input, est_output = 50000, 10000
else:
est_input, est_output = 4000, 1000
per_call_cost = estimate_cost(config, est_input, est_output)
daily_cost = per_call_cost * daily_volume
monthly_cost = daily_cost * 22
candidates.append({
'model': name,
'strength': config.strength,
'per_call_cost': round(per_call_cost, 4),
'daily_cost': round(daily_cost, 2),
'monthly_cost': round(monthly_cost, 2),
})
candidates.sort(key=lambda x: x['per_call_cost'])
return {
'task': task.value,
'complexity': complexity,
'daily_volume': daily_volume,
'recommendations': candidates,
'best_value': candidates[0] if candidates else None,
'best_capability': candidates[-1] if candidates else None,
}
# Example scenarios
scenarios = [
(TaskType.CODE_GENERATION, 6, 500),
(TaskType.CUSTOMER_SERVICE, 3, 10000),
(TaskType.COMPLEX_REASONING, 8, 100),
(TaskType.LONG_RUNNING_AGENT, 9, 50),
]
for task, complexity, volume in scenarios:
print(f"\n{'='*60}")
print(f"Scenario: {task.value} | Complexity: {complexity} | Daily Volume: {volume}")
print(f"{'='*60}")
result = recommend_model(task, complexity, volume)
print(f"Recommendations:")
for i, rec in enumerate(result['recommendations'], 1):
print(f" {i}. {rec['model']:25s} "
f"Per call: ${rec['per_call_cost']:.4f} | "
f"Monthly: ${rec['monthly_cost']:.2f}")
print(f"Best value: {result['best_value']['model']}")
print(f"Best capability: {result['best_capability']['model']}")
VII. The Open-Source Onslaught: The 62% Inflection Point
7.1 The Vercel Data Panorama
If Fable 5’s stagnation is the “symptom,” then the open-source model surge is the “root cause.” On August 22, 2026, Vercel CEO Guillermo Rauch released data that stunned the entire industry:
Open-source models’ token share on Vercel AI Gateway surged from 11% in April to 62% in August, surpassing closed-source models for the first time in history.
┌─────────────────────────────────────────────────────────────────────┐
│ Vercel AI Gateway: Open-Source vs Closed-Source Token Share │
│ │
│ Share │
│ 100% │ │
│ │ Closed 89% │
│ 80% │ ████████████████████████████████████████ │
│ │ ████████████████████████████████████████ Closed 38% │
│ 60% │ ████████████████████████████████████████ ████████████████ │
│ │ ████████████████████████████████████████ ████████████████ │
│ 40% │ ████████████████████████████████████████ ████████████████ │
│ │ ████████████████ │
│ 20% │ Open 28% ████████████████ │
│ │ Open 11% ██████████████████████ ████████████████ │
│ 0% │ ███████████████████ ██████████████████████ ████████████████ │
│ └──────────┬──────────┬──────────┬──────────┬──────────┬────── │
│ Apr Jun Jul Aug │
│ │
│ ┌─────┐ Closed-Source ┌─────┐ Open-Source │
│ └─────┘ └─────┘ │
└─────────────────────────────────────────────────────────────────────┘
*Source: Vercel AI Gateway, April-August 2026; reported by 36Kr and Jiqizhixin*
### 7.2 The Revenue-Token Divergence
Even more noteworthy is the massive divergence between token share and revenue share:
| Metric | Open-Source | Anthropic | OpenAI | Other Closed |
|--------|-------------|-----------|--------|--------------|
| Token Share | 62% | ~15% | ~12% | ~11% |
| Spending Share | ~4% | 61-65% | ~23% | ~8% |
| Cost Efficiency | Extremely Low | Very High | Medium-High | Medium |
Open-source models generate only ~4% of API spending while handling 62% of tokens, meaning open-source average token prices are approximately 1/15th of closed-source models. Anthropic, with ~15% of tokens, captures 61-65% of spending — its average token price is roughly 40x that of open-source models.
This "volume-value divergence" reveals the core tension in the AI inference market: **premium intelligence still commands a premium, but the premium window is rapidly closing.**
### 7.3 Open-Source's "Terrifying" Speed
In its August 24 in-depth report titled "Open-Source Models Have Killed the Game in Two Months," 36Kr cited SemiAnalysis's analysis showing that the time required for open-source models to catch up to closed-source frontiers is shrinking dramatically.
┌─────────────────────────────────────────────────────────────────────┐ │ Closed-Source Lead → Open-Source Catch-Up Time Evolution │ │ │ │ Scaling Era (2023-2024) │ │ GPT-3.5 → Llama 2 │ │ ├───────────────────────────────┤ │ │ Initial Gap: 35.8 pts Catch-up: ~12 months │ │ │ │ Reasoning Era (2024-2025) │ │ o1 → DeepSeek R1-0528 │ │ ├────────────────────┤ │ │ Initial Gap: 12.1 pts Catch-up: ~8.5 months │ │ │ │ Agentic Era (2025-2026) │ │ Opus 4.5 → Kimi K2.6 │ │ ├───────────────┤ │ │ Initial Gap: ~8 pts Catch-up: ~4.8 months │ │ │ │ Current (2026) │ │ Fable 5 → GLM-5.3/DeepSeek V4 Pro │ │ ├────────────┤ │ │ Initial Gap: ~5 pts Catch-up: ~3-4 months (estimated) │ └─────────────────────────────────────────────────────────────────────┘ Source: SemiAnalysis, compiled by 36Kr
### 7.4 NVIDIA's Game-Changing Move
If the open-source surge is "natural evolution," then NVIDIA's entry is "active acceleration." On the same day — August 24 — sources revealed that NVIDIA would pay Poolside $6 billion in technology licensing fees, invest an additional $1 billion in equity, and absorb over 100 engineers into its Nemotron team.
This move is profoundly symbolic: NVIDIA — the most critical hardware supplier to both OpenAI and Anthropic — is actively backing open-source models, even at the cost of confronting its own largest customers.
Jensen Huang's logic is clear: he doesn't care which model scores highest on benchmarks. He wants to drive down the inference cost of foundation models to the floor. When open-source models become cheap and ubiquitous, global applications will consume tokens at a furious pace, and all profits will ultimately flow back to NVIDIA's hardware base.
---
## VIII. Product Line Restructuring: From "Every Model Has a Position" to "Every Price Point Has a Model"
### 8.1 Current Product Line Panorama
Synthesizing all the above analysis, here is the complete picture of Anthropic's current product line:
┌─────────────────────────────────────────────────────────────────────┐ │ Anthropic Claude Product Line Panorama (Aug 2026) │ ├─────────────────────────────────────────────────────────────────────┤ │ │ │ Price Tier │ │ ▲ $50/output MTok │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ Claude Fable 5 / Mythos 5 │ Frontier Peak │ │ │ │ $10/$50 · 1M ctx · 128K out │ (Restricted) │ │ │ └──────────────────────────────────────┘ │ │ │ ↓ Near-equivalent performance at half price │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ Claude Opus 5 │ Daily Flagship │ │ │ │ $5/$25 · 1M ctx · 128K out │ ← Current主力 │ │ │ └──────────────────────────────────────┘ │ │ │ ↓ Upcoming iteration │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ Marshmallow (Speculated Opus 5.1) │ Mid-High Iteration │ │ │ │ EAP testing · Conversational > Opus5│ (Expected Sep) │ │ │ └──────────────────────────────────────┘ │ │ │ ↓ Mid-range workhorse │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ Claude Sonnet 5 │ Daily Workhorse │ │ │ │ $2/$10 (intro) · 1M ctx │ (High value) │ │ │ └──────────────────────────────────────┘ │ │ │ ↓ ??? │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ Melon (Speculated Sonnet 5.1/Haiku) │ Mid/Light TBD │ │ │ │ EAP testing · Below Marshmallow │ (Position TBD) │ │ │ └──────────────────────────────────────┘ │ │ │ ↓ Lightweight │ │ │ ┌──────────────────────────────────────┐ │ │ │ │ Claude Haiku 4.5 │ Low-Cost Workhorse │ │ │ │ $1/$5 · 200K ctx │ (High throughput) │ │ │ └──────────────────────────────────────┘ │ │ └─────┼───────────┼───────────┼───────────┼───────────► │ │ Capability Value Speed Ecosystem │ │ │ └─────────────────────────────────────────────────────────────────────┘
### 8.2 Three Dimensions of Strategic Restructuring
**Dimension 1: Maximizing Price Bandwidth**
From Fable 5's $10/$50 to Haiku 4.5's $1/$5, Anthropic's product line covers a 10x price bandwidth. The addition of Marshmallow and Melon will further fill the mid-high and mid-range gaps within this bandwidth.
**Dimension 2: From "Best Model" to "Right Model"**
Anthropic is shifting from a linear approach of "each new model tries to surpass the previous one" to a matrix approach of "each price point has an optimal model." This mirrors OpenAI's GPT-5.6 series (Sol/Terra/Luna) differentiation strategy.
**Dimension 3: Accelerated Release Cadence**
2026 Anthropic Model Release Timeline ┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┐ │ Jan │ Feb │ Mar │ Apr │ May │ Jun │ Jul │ Aug │ Sep │ │ │ │ │ │ │ │ │ │ │ │ │ Opus │ Opus │ Opus │ Opus │Fable5│ Opus5│ Marsh│ │ │ │ 4.6 │ 4.7 │ 4.8 │ │Sonnet5│ │mallow│ │ │ │Sonnet│ │ │ │ │ │ Melon│ │ │ │ 4.6 │ │ │ │ │ │ (EAP)│ │ │ │ │ │ │ │ │ │ │ │ └──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┘ Average ~2-3 weeks between major updates
### 8.3 Code Example: Product Line Strategy Simulator
```python
"""
Anthropic Product Line Strategy Simulator
Simulates market response under different pricing strategies
"""
import numpy as np
from typing import Dict, List
class ProductLineSimulator:
"""Product line strategy simulator"""
def __init__(self):
self.price_elasticity = {
'premium': -0.8,
'mid': -1.5,
'budget': -2.2,
}
self.open_source_pressure = 0.62
def simulate_market_share(self, models: Dict[str, Dict]) -> Dict:
"""Simulate market share under given pricing strategy"""
total_utility = 0
model_utilities = {}
for name, config in models.items():
cap_utility = config['capability'] * 1.5
avg_price = (config['input_price'] + config['output_price']) / 2
tier = config['tier']
elasticity = self.price_elasticity.get(tier, -1.0)
price_utility = avg_price * (1 + elasticity)
if tier == 'premium':
os_penalty = self.open_source_pressure * 0.3
elif tier == 'mid':
os_penalty = self.open_source_pressure * 0.6
else:
os_penalty = self.open_source_pressure * 0.8
utility = cap_utility - price_utility - os_penalty
model_utilities[name] = max(utility, 0.1)
total_utility += model_utilities[name]
return {name: model_utilities[name] / total_utility
for name in models}
def optimize_pricing(self, base_models: Dict[str, Dict]) -> Dict:
"""Optimize pricing strategy"""
optimized = {}
for name, model in base_models.items():
tier = model['tier']
base_avg = (model['input_price'] + model['output_price']) / 2
best_price = base_avg
best_share = 0
for price_mult in np.arange(0.5, 2.0, 0.1):
test_input = model['input_price'] * price_mult
test_output = model['output_price'] * price_mult
test_models = {
name: {
'capability': model['capability'],
'input_price': test_input,
'output_price': test_output,
'tier': tier,
},
'gpt_5.6_sol': {
'capability': 8.5,
'input_price': 5.0,
'output_price': 30.0,
'tier': 'premium',
},
'deepseek_v4_pro': {
'capability': 7.5,
'input_price': 0.87,
'output_price': 4.35,
'tier': 'budget',
}
}
share = self.simulate_market_share(test_models)
if share[name] > best_share:
best_share = share[name]
best_price = (test_input, test_output)
optimized[name] = {
'optimal_input_price': round(best_price[0], 2),
'optimal_output_price': round(best_price[1], 2),
'expected_share': round(best_share * 100, 1),
}
return optimized
# Run simulation
simulator = ProductLineSimulator()
current_lineup = {
'Fable 5': {'capability': 9.8, 'input_price': 10.0,
'output_price': 50.0, 'tier': 'premium'},
'Opus 5': {'capability': 9.2, 'input_price': 5.0,
'output_price': 25.0, 'tier': 'premium'},
'Sonnet 5': {'capability': 8.0, 'input_price': 2.0,
'output_price': 10.0, 'tier': 'mid'},
'Haiku 4.5': {'capability': 6.5, 'input_price': 1.0,
'output_price': 5.0, 'tier': 'budget'},
}
print("Current Product Line Market Share Simulation:")
print("=" * 60)
current_share = simulator.simulate_market_share(current_lineup)
for model, share in sorted(current_share.items(),
key=lambda x: x[1], reverse=True):
print(f" {model:15s}: {share*100:.1f}%")
print("\n\nOptimized Pricing Recommendations:")
print("=" * 60)
optimized = simulator.optimize_pricing(current_lineup)
for model, result in optimized.items():
print(f" {model:15s}: Optimal Input ${result['optimal_input_price']:.2f} "
f"Optimal Output ${result['optimal_output_price']:.2f} "
f"Expected Share {result['expected_share']:.1f}%")
IX. Technical Implementation and API Integration
9.1 Calling Marshmallow and Melon via API
While Marshmallow and Melon haven’t officially launched, based on EAP conventions, developers can attempt to call them as follows:
Note: The following code is for demonstration only. Actual calls require Anthropic EAP authorization.
"""
Claude EAP Model API Call Example
"""
import os
import json
import time
from typing import Optional, Dict, Any
import anthropic
class ClaudeEAPClient:
"""Claude EAP model client"""
def __init__(self, api_key: Optional[str] = None):
self.api_key = api_key or os.environ.get('ANTHROPIC_API_KEY')
if not self.api_key:
raise ValueError("ANTHROPIC_API_KEY is required")
self.client = anthropic.Anthropic(api_key=self.api_key)
def call_marshmallow(self, prompt: str, system: str = "",
max_tokens: int = 4096,
temperature: float = 0.7) -> Dict[str, Any]:
"""Call Marshmallow EAP model"""
try:
response = self.client.messages.create(
model="claude-marshmallow-eap",
system=system,
max_tokens=max_tokens,
temperature=temperature,
messages=[{"role": "user", "content": prompt}]
)
return {
"success": True,
"content": response.content[0].text,
"model": response.model,
"usage": {
"input_tokens": response.usage.input_tokens,
"output_tokens": response.usage.output_tokens,
},
"latency_ms": None,
}
except Exception as e:
return {"success": False, "error": str(e)}
def call_melon(self, prompt: str, system: str = "",
max_tokens: int = 4096,
temperature: float = 0.7) -> Dict[str, Any]:
"""Call Melon EAP model"""
try:
response = self.client.messages.create(
model="claude-melon-eap",
system=system,
max_tokens=max_tokens,
temperature=temperature,
messages=[{"role": "user", "content": prompt}]
)
return {
"success": True,
"content": response.content[0].text,
"model": response.model,
"usage": {
"input_tokens": response.usage.input_tokens,
"output_tokens": response.usage.output_tokens,
},
"latency_ms": None,
}
except Exception as e:
return {"success": False, "error": str(e)}
def benchmark_models(self, test_prompts: list) -> Dict:
"""Benchmark multiple models"""
results = {
'marshmallow': {'total_time': 0, 'total_input': 0,
'total_output': 0, 'responses': []},
'melon': {'total_time': 0, 'total_input': 0,
'total_output': 0, 'responses': []},
'opus_5': {'total_time': 0, 'total_input': 0,
'total_output': 0, 'responses': []},
}
for prompt in test_prompts:
for model_key in ['marshmallow', 'melon', 'opus_5']:
method = getattr(self, f'call_{model_key}'
if model_key != 'opus_5' else 'call_opus_5')
start = time.time()
resp = method(prompt)
elapsed = time.time() - start
if resp['success']:
results[model_key]['total_time'] += elapsed
results[model_key]['total_input'] += resp['usage']['input_tokens']
results[model_key]['total_output'] += resp['usage']['output_tokens']
results[model_key]['responses'].append({
'prompt': prompt[:50],
'time': elapsed,
'tokens': resp['usage']['output_tokens'],
})
for key in results:
r = results[key]
n = len(r['responses'])
r['avg_latency'] = round(r['total_time'] / n, 2) if n > 0 else None
r['avg_output_tokens'] = round(r['total_output'] / n, 1) if n > 0 else None
return results
# Usage example
if __name__ == "__main__":
test_prompts = [
"Implement quicksort in Python and analyze its time and space complexity.",
"Explain how the self-attention mechanism works in Transformer architecture.",
"Write a function to compute the nth Fibonacci number using dynamic programming.",
]
print("=" * 70)
print("Claude EAP Model Benchmarking Framework")
print("=" * 70)
print(f"Test prompts: {len(test_prompts)}")
print(f"Models to test: marshmallow-eap, melon-eap, opus-5")
print(f"\n{'='*70}")
print("Note: Actual execution requires valid Anthropic API Key and EAP access")
print("The above code will be usable after official release")
9.2 Smart Model Router Implementation
"""
Smart Model Router - Automatically selects optimal model based on task characteristics
"""
from typing import Dict, List, Optional
from dataclasses import dataclass
import json
import hashlib
@dataclass
class TaskProfile:
task_type: str
input_length: int
required_reasoning_depth: int
latency_sensitive: bool
cost_sensitive: bool
requires_tool_use: bool
requires_long_context: bool
@dataclass
class ModelPerformance:
model_id: str
success_rate: float
avg_latency: float
avg_cost: float
sample_count: int
class SmartModelRouter:
"""Smart model router"""
def __init__(self):
self.performance_history: Dict[str, List[ModelPerformance]] = {}
self.routing_rules: Dict[str, str] = self._default_rules()
def _default_rules(self) -> Dict[str, str]:
return {
'code_generation_simple': 'claude-sonnet-5',
'code_generation_complex': 'claude-opus-5',
'code_review': 'claude-opus-5',
'document_summary': 'claude-sonnet-5',
'customer_service': 'claude-haiku-4.5',
'data_extraction': 'claude-sonnet-5',
'complex_reasoning': 'claude-opus-5',
'creative_writing': 'claude-sonnet-5',
'long_running_agent': 'claude-fable-5',
}
def profile_task(self, task: Dict) -> TaskProfile:
"""Profile a task"""
input_text = task.get('prompt', '') + task.get('system', '')
reasoning_keywords = ['proof', 'analysis', 'reasoning', 'optimize',
'compare', 'evaluate', 'synthesize']
depth = sum(1 for kw in reasoning_keywords if kw in input_text.lower())
depth = min(max(depth, 1), 10)
return TaskProfile(
task_type=task.get('type', 'general'),
input_length=len(input_text),
required_reasoning_depth=depth,
latency_sensitive=task.get('latency_sensitive', False),
cost_sensitive=task.get('cost_sensitive', True),
requires_tool_use=task.get('tool_use', False),
requires_long_context=task.get('long_context', False),
)
def route(self, task: Dict) -> str:
"""Routing decision"""
profile = self.profile_task(task)
if profile.requires_long_context and profile.input_length > 100000:
return 'claude-opus-5'
if profile.latency_sensitive:
if profile.required_reasoning_depth <= 5:
return 'claude-haiku-4.5'
return 'claude-sonnet-5'
if profile.required_reasoning_depth >= 8:
if profile.cost_sensitive:
return 'claude-opus-5'
return 'claude-fable-5'
if profile.requires_tool_use:
return 'claude-opus-5'
task_key = f"{profile.task_type}_{'complex' if profile.required_reasoning_depth > 5 else 'simple'}"
return self.routing_rules.get(task_key, 'claude-sonnet-5')
# Demo
router = SmartModelRouter()
test_tasks = [
{"type": "code_generation", "prompt": "Implement a binary search tree",
"latency_sensitive": False, "cost_sensitive": True,
"tool_use": False, "long_context": False},
{"type": "customer_service", "prompt": "Customer asks about refund process",
"latency_sensitive": True, "cost_sensitive": True,
"tool_use": False, "long_context": False},
{"type": "complex_reasoning", "prompt": "Analyze this mathematical proof for flaws",
"latency_sensitive": False, "cost_sensitive": False,
"tool_use": True, "long_context": True},
{"type": "data_extraction", "prompt": "Extract key info from 100-page PDF",
"latency_sensitive": False, "cost_sensitive": True,
"tool_use": False, "long_context": True},
]
print("=" * 70)
print("Smart Model Routing Decision Demo")
print("=" * 70)
for task in test_tasks:
model = router.route(task)
profile = router.profile_task(task)
print(f"\nTask: {task['type']}")
print(f" Reasoning depth: {profile.required_reasoning_depth}/10")
print(f" Latency sensitive: {profile.latency_sensitive}")
print(f" Cost sensitive: {profile.cost_sensitive}")
print(f" → Recommended model: {model}")
X. Industry Impact and Outlook
10.1 Impact on the Developer Ecosystem
The release of Marshmallow and Melon will profoundly affect the developer community’s choices:
- Further model selection granularity: From “which model to choose” to “which model at which price point,” the decision space expands
- Cost optimization as a core skill: Model routing, intelligent caching, and task prioritization become standard MLOps competencies
- EAP access becomes scarce: Early tester feedback directly influences product direction; EAP participation becomes a “technical privilege”
10.2 Impact on the Competitive Landscape
┌─────────────────────────────────────────────────────────────────────┐
│ H2 2026 AI Model Competitive Landscape Forecast │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ Frontier Layer │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Anthropic │ │ OpenAI │ │ Google │ │
│ │ Fable/Mythos│ │ GPT-5.6 Sol │ │ Gemini 3.1 │ │
│ │ $10/$50 │ │ $5/$30 │ │ $2/$12 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ Flagship Layer │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Opus 5 │ │ GPT-5.6 │ │ Gemini 3.1 │ │
│ │ Marshmallow→│ │ Terra │ │ Pro │ │
│ │ $5/$25 │ │ $2.5/$15 │ │ $2/$12 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ Mid-Range Layer │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Sonnet 5 │ │ GPT-5.6 │ │ Gemini 3.1 │ │
│ │ Melon→ │ │ Luna │ │ Flash │ │
│ │ $2/$10 │ │ $1/$6 │ │ $0.5/$2 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ Open-Source Layer │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ DeepSeek │ │ GLM-5.3 │ │ Qwen 3.8 │ ← 62% Token│
│ │ V4 Pro │ │ │ │ Nemotron │ Share │
│ │ ~$0.87 │ │ ~$1.0 │ │ ~$0.5 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
10.3 Three Key Questions
Q1: Will Marshmallow and Melon officially launch?
Almost certainly yes. Honeycomb went from leak to official Opus 5 launch in 15 days. The Marshmallow and Melon leak is more complete, richer in information, and arrives at a critical moment when Fable 5 is underperforming. Anthropic urgently needs new product lines to stabilize market confidence.
Q2: What will the pricing be?
Following Opus 5’s pricing strategy, Marshmallow (Opus 5.1) will likely maintain $5/$25 or slightly increase. Melon, if positioned as Sonnet 5.1, would maintain $2/$10 (introductory pricing), or if positioned as a next-generation Haiku, could be priced around $1.5/$7.5.
Q3: Will open-source models continue to erode closed-source share?
Yes, but the erosion rate may slow. Vercel data shows that while open-source models command 62% of token share, they account for only 4% of spending. This means truly high-value workflows still concentrate on closed-source models. However, SemiAnalysis notes that as open-source models rapidly catch up in Agentic capabilities, this landscape could fundamentally shift by late 2026 to early 2027.
XI. Conclusion: The Metaphor of Marshmallow and Melon
Let’s return to the two codenames: Marshmallow and Melon.
A marshmallow’s texture — soft, fluffy, easily molded — perfectly mirrors the core demand of product line restructuring: “flexible adaptation.” Anthropic is no longer trying to cover all scenarios with a single model. Instead, like marshmallow, it’s “filling” appropriate models into different price brackets, letting every developer find their preferred “texture.”
Melon, meanwhile, suggests the metaphor of “being cut open.” Anthropic is slicing its previously “one-size-fits-all” flagship model system into a finely segmented product matrix with more tiers, more price points, and more capability gradients. This is both a defensive strategy against the open-source onslaught and an active adaptation to enterprise customers’ rational “good enough” choices.
The exposure of Marshmallow and Melon is, on the surface, another API code leak tech news story. But at its core, it marks a strategic inflection point for Anthropic: a transition from “model-centric” to “customer-centric” product strategy. In an era of diminishing marginal returns on intelligence, an AI company’s core competitive advantage is no longer “building the strongest model” but “ensuring every customer can find the right model at the right price.”
This transformation — sparked by a marshmallow and a melon — is redefining the business logic of the AI industry.
References:
- Jiqizhixin (机器之心), “Just In: Two New Claude Models Exposed”, August 24, 2026
- Phoenix Tech (凤凰网科技), “Just In: Two New Claude Models Exposed”, August 24, 2026
- 36Kr / Jiqizhixin, “Open-Source Models Have Killed the Game in Two Months”, August 24, 2026
- gentic.news, “Claude ‘Marshmallow’ and ‘Melon’ Spotted, Release Imminent”, August 25, 2026
- The Win Central, “Anthropic Opus 5.1 & Sonnet 5.1 Leaks: Marshmallow and Melon Could Be Next”, August 24, 2026
- Financial Times / Ramp, Enterprise Payment Data Analysis (cited via Sina Finance/36Kr), August 2026
- DataCamp, “Claude Opus 5 vs Claude Fable 5”, July 29, 2026
- Anthropic Transparency Hub, Model Transparency Reports, August 2026
- Vercel CEO Guillermo Rauch, AI Gateway Data Announcement, August 22, 2026
- SemiAnalysis Industry Report (cited via 36Kr)