Author’s note: Using Iceman — an unclaimed free stealth model on OpenCode — as an example, this piece breaks down three layers of information: official statements, catalog parameters, and unverified clues. It lays out a 5-item checklist to run through before integration and explains how to merge multiple IDs when reading usage leaderboards.
Free, unlimited requests, a massive context window — and nobody knows who made it. This kind of free stealth model has become common in coding tools lately, and many developers’ first instinct is “let me plug it into the project and see.” Using Iceman on OpenCode as a case study, this article answers one specific question: what do you need to confirm before sending your code or business data to a free model of unknown origin?
This isn’t an article telling you not to use it. Free stealth models are perfectly fine for prototype validation and public code experiments. The key is sorting out which information you can actually base decisions on, which is just rumor, and what the training and retention terms really mean for your data.
Key takeaways: By the end, you’ll have a reusable checklist for stealth models, covering four dimensions: data training, zero data retention, free period, and source attribution. You’ll also learn to spot leaderboard misreads like “fake growth caused by swapping IDs.”
Free Stealth Model Iceman: Key Takeaways
As of 2026-11-04 18:31 UTC, no AI lab has claimed Iceman. According to OpenCode usage data, it has burned through roughly 3.37 trillion tokens across two ids since October 23. The table below sorts what we know about it into three tiers of credibility — and that’s the foundation for everything that follows.
| Information tier | Details | Safe to rely on? |
|---|---|---|
| Official platform statement | OpenCode merged PR 58792: free for a limited time, no request limits, prompts used for training, non-zero data retention | ✅ Yes — this is a matter of the terms themselves |
| Catalog parameters | models.dev catalog: 262,144 context, up to 131,072 output tokens, supports reasoning and tool calling, text in / text out | ✅ Yes — for technical evaluation |
| Unverified leads | Third-party trackers claim it self-identifies as Microsoft MAI, with token counts matching MAI Thinking 1 | ❌ No — treat it as rumor only |
What the Official Terms for the Stealth Model Iceman Actually Say
On October 24, OpenCode added Iceman to its $10-a-month Go plan, corresponding to pull request 58792 in the repo, merged at 20:24 UTC. The model name is Iceman Contributor Free, and the terms state “free for a limited time, no request limits.” The same change flags two other things at once: prompts sent to it are used for training, and the data retention policy is not zero data retention.
Those last two lines are what developers should care about most. More than the context window and output length, they directly determine what kind of data you can send. The PR also adds this id to OpenCode’s stealth model list, which is why the lab column on the usage page shows Unknown. In other words, the platform itself is telling you plainly: source unknown.
What Contributor Really Means in the Stealth Model’s Name
Plenty of people read the Contributor in iceman-contributor as the name of some lab or contributor. It actually refers to a barter model at OpenCode: training data in exchange for free access. Meta’s Muse Spark 1.3 and 1.2 also have Contributor versions, which shows this is a generic platform-level label, not a clue about where the model came from.
So when you see the word Contributor, the right reading is “this channel’s data goes into training” — not “this is a contributed version from some lab.” That’s the first item on the verification checklist further down.
How Free Stealth Models’ Training Terms Affect Your Code and Private Data
“Prompts may be used for training” sounds abstract, but in a real project it comes down to something very concrete: every piece of context you send out can end up as a training sample for someone else’s model. In coding tools, that context is often more than just the question you typed — it also includes file contents that get pulled in automatically, error logs, config files, and even environment variables.
Non-zero data retention means request contents sit on the server for a while. How long, where exactly, and who handles them — none of that can be confirmed when the model’s origin is unknown. For enterprise projects, this usually runs straight into confidentiality clauses in your contracts or data compliance requirements. The table below lays out the actual risk by data type.
| Data type | Typical source | Risk under training + non-zero retention | Recommendation |
|---|---|---|---|
| Open-source or public code | Public repos, sample projects | Low — the content is already public | Fine to use |
| Private company business code | Internal repos, core algorithms | High — may leak implementation details and architecture | Don’t send |
| Keys and config | .env, config files, CI scripts |
Extremely high — credentials may be retained and trained on | Must be excluded |
| User private data | Logs, database samples, support tickets | Extremely high — involves personal-information compliance | Never send |
| Synthetic or de-identified data | Test fixtures, mock data | Low to medium, depending on de-identification quality | Usable after de-identification |
One thing worth flagging here is the “implicit context” problem with coding tools. Many agents automatically read workspace files, so you think you only asked how to write one function, when in reality the entire directory structure and neighboring files may have been packed into the request. When you’re using a channel that trains on your data, the safest approach is to work in a separate workspace containing only public or synthetic data.
How to vet a free stealth model: a 5-item pre-integration checklist
This checklist isn’t specific to Iceman. It applies to any free model with an unclaimed source. The first four items come from terms and attribution; the fifth comes from how you read the data. I’d recommend turning it into a fixed review process inside your team.
| # | Check | Where to confirm | Iceman current status |
|---|---|---|---|
| 1 | Are prompts used for training? | Platform terms, model configuration change log | Yes, used for training |
| 2 | Is there zero data retention? | Platform terms, privacy statement | No, not zero data retention |
| 3 | How long is the free period? | Platform announcements, plan details | Only says “limited time”; duration unknown |
| 4 | Is source attribution confirmed? | Official lab statement | Not confirmed; lab shows Unknown |
| 5 | Are usage numbers split by id? | All relevant ids on usage leaderboards | Yes, split into iceman and iceman-contributor |
Stealth model source attribution: why a clue isn’t confirmation
On Iceman’s origin, tracking site stealthmodels.com reports that X account @aitrackerbot found Iceman introducing itself as Microsoft’s MAI, and that its prompt token counting method matches MAI Thinking 1 exactly. But the site’s own testing found it matches MAI Thinking 1 and also matches OpenAI’s GPT-6 family. That means token counts can’t distinguish among these models.
A model “saying who it is” is equally unreliable. Models repeat identity information from their training data, and system prompts can deliberately set it. As of now, Microsoft hasn’t made any statement. So the right way to frame this information is “a clue”—not something to put in your technical selection document as fact.
Historical precedents for stealth model claims
Looking at past OpenCode stealth models, claims usually happen at launch or within a few weeks. ox-alpha was claimed by Z.ai as GLM-5.3 Flash, cat-jam was claimed by Reflection AI as Beam, and Space Bunny was claimed by MiniMax as M3.1 Flash 26 days after it first appeared. As of November 4, Iceman has been live for 11 days and still has no claimant.
The value of precedents is that they set expectations, not predictions. They tell you a claim might take weeks, and during that time the model’s size, origin, and free duration are all unknown—so your plan can’t depend on those unknowns.
Getting started with the free stealth model: read the usage leaderboard by merging ids
Iceman’s run on the OpenCode weekly leaderboard is a textbook case of misreading a ranking. Look at a single id, and you’d conclude “explosive growth.” Put two ids together, and the conclusion flips.
| id | Weekly rank | Tokens this week | Week-over-week change |
|---|---|---|---|
| iceman-contributor | #12 | 670B | +768% |
| iceman | #16 | 567B | -72% |
| Total | — | ~1.24T | ~-42% (last week ~2.13T) |
That +768% isn’t growth — it’s the same model’s traffic moving from one id to another. Combined, the two ids ran about 1.24 trillion tokens over the past 7 days, down roughly 42% from about 2.13 trillion the week before. Daily usage peaked at about 653 billion tokens on October 28, then ranged between 162 billion and 251 billion per day from October 29 through November 3.
Minimal Example: Merging IDs to Compute the Real Week-over-Week Change
The Python snippet below shows the merge logic, using the public numbers from the section above. Last week’s value for each id is back-calculated from this week’s figure and the week-over-week change, so it’s an approximation.
# Multiple ids for the same model, this week's tokens (in billions) and week-over-week change
ids = {
"iceman-contributor": {"this_week": 670, "change": 7.68}, # +768%
"iceman": {"this_week": 567, "change": -0.72}, # -72%
}
this_total = sum(v["this_week"] for v in ids.values())
# Back out last week's value from the week-over-week change: last = this / (1 + change)
last_total = sum(v["this_week"] / (1 + v["change"]) for v in ids.values())
print(f"本周合计：{this_total}B")
print(f"上周合计（反推）：{last_total:.0f}B")
print(f"合并后环比：{(this_total / last_total - 1):.1%}")
Running it gives roughly 1,237B for this week and something in the 2,100B range for last week, for a combined week-over-week change of about -41% to -42% — which lines up with the aggregate figures in the report. The back-calculation carries rounding error, so for real analysis you should read each id’s original weekly data directly.
View the full implementation: a model policy gate before integration
The code below turns the checklist into a simple “policy gate.” It doesn’t call any specific platform’s API — it just decides, based on the metadata you fill in after manual verification, whether a given kind of data can be sent to a given model. You can put it in front of your own request routing layer.
from dataclasses import dataclass
from typing import Optional
@dataclass
class ModelPolicy:
model_id: str
used_for_training: bool # Check item 1
zero_data_retention: bool # Check item 2
free_until: Optional[str] # Check item 3; None means the deadline is unknown
lab_confirmed: bool # Check item 4
related_ids: tuple = () # Check item 5, used for merged statistics
# Data sensitivity levels: 0 public, 1 de-identified/synthetic, 2 private code, 3 secrets or PII
SENSITIVITY = {"public": 0, "synthetic": 1, "private_code": 2, "secret_or_pii": 3}
def max_allowed_level(p: ModelPolicy) -> int:
"""Return the highest sensitivity level allowed by the model's terms"""
if p.used_for_training or not p.zero_data_retention:
return 1 # Training or non-zero retention: public and synthetic data only
if not p.lab_confirmed:
return 1 # Unclaimed source: likewise limited to low-sensitivity data
return 2 # Only once terms and ownership are confirmed do we consider private code
def can_send(p: ModelPolicy, data_kind: str) -> bool:
level = SENSITIVITY[data_kind]
if level >= 3:
return False # Secrets and PII never go to external free channels
return level <= max_allowed_level(p)
def production_ready(p: ModelPolicy) -> list:
"""Return the list of issues blocking production integration; an empty list means it can move to evaluation"""
issues = []
if p.used_for_training:
issues.append("提示词用于训练")
if not p.zero_data_retention:
issues.append("非零数据保留")
if p.free_until is None:
issues.append("免费期限未知，存在突然收费或下线风险")
if not p.lab_confirmed:
issues.append("来源未认领，无法评估模型规模与长期可用性")
return issues
iceman = ModelPolicy(
model_id="iceman-contributor",
used_for_training=True,
zero_data_retention=False,
free_until=None,
lab_confirmed=False,
related_ids=("iceman", "iceman-contributor"),
)
for kind in SENSITIVITY:
print(f"{kind:15s} -> {'允许' if can_send(iceman, kind) else '拒绝'}")
print("生产接入阻碍：", production_ready(iceman))
Practical tip: Treat the metadata above as shared team configuration, and update it whenever platform terms or a model’s claim status changes. That way, when a new colleague onboards any free model, they can reuse the same set of criteria instead of going with their gut.
Frequently Asked Questions (FAQ)
Q1: What is a free stealth model?
A stealth model is one that goes live on a platform under a codename, with the lab behind it not yet disclosed. The platform’s usage page typically shows its origin as Unknown. Iceman is one of the entries on OpenCode’s stealth model list and, as of 2026-11-04, hasn’t been claimed.
Q2: What’s the difference between Iceman and iceman-contributor?
Based on public data, they’re two IDs the OpenCode usage leaderboard uses to track the same model. On the weekly chart, one spikes while the other crashes — in reality, traffic is just shifting between the two IDs. The word “contributor” refers to the platform’s exchange model of “training data in return for free access,” not the name of a lab.
Q3: How long will Iceman’s free period last?
There’s no public answer right now. OpenCode’s changelog only says “free for a limited time, no request limits” — no end date. The model’s size, its developer, and how long it’ll stay free are all unknown at this point, so don’t build production plans that depend on its free status.
Q4: What scenarios are free stealth models best suited for?
Assuming the terms clearly state “used for training, non-zero retention,” the more suitable scenarios include:
– **Open-source project experiments**: Working with code that’s already public, like writing examples or tests for an open-source library.
– **Capability benchmarking**: Using synthetic prompts to test its reasoning and tool-calling performance, and to see how it behaves with a large context.
– **Personal learning prototypes**: Building demos with no real data to check whether an interaction flow is workable.
Q5: How do I roll out this stealth model checklist across a team?
Three steps: first, write the five checks into your model onboarding doc; then enforce them at the routing layer by data sensitivity level, like the policy gate described above; finally, give coding tools a separate workspace so the agent doesn’t automatically pull in private files. When the terms change, just update the metadata.
Q6: If a model says it’s a product of some company, can I believe it?
Not at face value. A model’s self-description can come from its training corpus or system prompt, and token counting can be identical across several models. Take Iceman: third-party tests found its counts also match MAI Thinking 1 and the GPT-6 series, so you can’t tell them apart that way. Attribution should be based only on an official claim from the lab.
Q7: What happens to data I sent before a stealth model gets claimed?
A claim only changes the information about who’s behind the model; it doesn’t change the terms that applied when you sent the data. If the terms at the time said the data was used for training with non-zero retention, then how that data is handled is already settled. That’s why the checks have to happen before you send anything, not after a claim comes in.
Free Stealth Model Key Takeaways
- Read the terms before the parameters: Training use and data retention decide what you can send; context length only decides how much you can send.
- Contributor is an exchange model: It means trading training data for free access — not a statement about where the model comes from.
- Clues aren’t confirmation: A model’s self-claimed identity and token counts prove nothing about ownership.
- Treat the free window as unknown: “Limited time” has no end date, so don’t build your plan around it.
- Read leaderboards with merged IDs: Iceman’s +768% works out to roughly -42% once the IDs are combined.
- Isolate all sensitive data: Keys, private data, and proprietary core code never go to training-grade channels.
Summary
Whether you can plug a free stealth model into your project depends on what data you’ll be sending, not on whether it’s free. Take Iceman: what you can actually rely on are the platform terms and catalog parameters — used for training, non-zero data retention, free for a limited time, 262,144 context, support for reasoning and tool calling. What you can’t rely on are the various clues about the developer; until there’s an official claim, they’re just rumors.
The reusable methodology boils down to three points:
- Layer your information: Keep platform statements, catalog parameters, and unverified clues separate, and make decisions using only the first two.
- Use channels by data tier: Training-grade channels only handle public or synthetic data; proprietary code and private data go through separate channels.
- Read leaderboards with merged accounting: Multiple IDs for the same model must be summed before you calculate growth rates, so fake growth from ID swapping doesn’t mislead you.
No matter who eventually claims Iceman, this verification method will keep working for the next stealth model that shows up.
📚 References
- ArtificialWatch – Iceman Usage and Attribution Analysis: the core source of facts for this article
- Link:
artificialwatch.com/wire/iceman-opencode-stealth-model-3-trillion-tokens-unclaimed -
Note: Compiles Iceman’s dual-ID usage, terms changes, and attribution clues, published on 2026-11-04
-
OpenCode Data Usage Page: usage data for iceman and iceman-contributor
- Link:
opencode.ai/data -
Note: You can directly view each ID’s weekly leaderboard ranking and token usage
-
models.dev Model Catalog: Iceman’s technical specifications
- Link:
models.dev -
Note: Provides catalog information such as context window, max output, reasoning, and tool calling
-
stealthmodels.com Stealth Model Tracking: the source of reports on attribution clues
- Link:
stealthmodels.com - Note: Records tests of Iceman’s self-claimed identity and token counts, for reference only as a lead
Author: APIYI Tech Team
Note: The facts in this article are current as of 2026-11-04. Iceman’s claim status and free-period terms may change at any time; please refer to the platform’s latest terms.
