What Makes OpenCode Zen's Curated Model Selection Different from Other Aggregators

OpenCode Zen distinguishes itself from dynamic LLM aggregators by providing a manually vetted, hard-coded list of free models in the cheahjs/free-llm-api-resources repository, prioritizing reliability and transparency over exhaustive catalog coverage.

Unlike automated scrapers that indiscriminately mirror every available endpoint, OpenCode Zen's curated model selection offers developers a deliberately constrained gateway to artificial intelligence. This approach rejects the volatility of dynamic marketplaces in favor of a stable, transparent roster of models that maintainers have personally tested and validated. The implementation details in src/pull_available_models.py reveal a curation strategy focused on quality assurance rather than catalog completeness.

Manual Curation vs. Automated Aggregation

The primary distinction lies in how models enter the system. While competitors like OpenRouter or Groq pull live catalogs via public APIs, OpenCode Zen's entries are hard-coded directly into the source.

In src/pull_available_models.py (lines 145–154), the maintainers explicitly define the available models rather than fetching them dynamically:

# These entries represent the complete, vetted OpenCode Zen roster

opencode_zen_models = [
    {"id": "big-pickle-stealth", "name": "Big Pickle Stealth"},
    {"id": "minimax-m2.5-free", "name": "MiniMax M2.5 Free"},
    {"id": "arcee-large-preview-free", "name": "Arcee Large Preview Free"},
]

This manual insertion guarantees that only models meeting specific performance and reliability criteria appear in the final README.md. The repository's generation script treats these entries as static constants, ensuring the "AI gateway with curated models" delivers exactly what the maintainers intend, free from unexpected provider-side additions.

Transparency in Data Usage Policies

OpenCode Zen's curated model selection explicitly highlights a critical trade-off often buried in dynamic aggregators. The source code includes a clear notice that "Free models may use data for improvement" alongside the OpenCode Zen entry.

This transparency contrasts sharply with raw provider APIs that expose entire catalogs without flagging specific data-use terms. By surfacing this licensing implication directly in the gateway description, OpenCode Zen enables developers to make informed decisions about which models handle sensitive prompts versus which suit experimental, non-confidential workloads.

Stability and Predictable Integration

Because the model list is static rather than dynamic, OpenCode Zen offers stable identifiers that remain constant across repository updates. The three core models—Big Pickle Stealth, MiniMax M2.5 Free, and Arcee Large Preview Free—use fixed URL slugs and mappings defined in src/data.py.

This stability benefits automation scripts and downstream consumers who can rely on persistent model IDs. Unlike dynamic aggregators where model availability fluctuates daily (potentially breaking integrations when endpoints disappear), OpenCode Zen's hard-coded approach ensures that code referencing these specific models continues functioning regardless of broader market changes.

Accessing the Curated Model List Programmatically

Developers can extract the OpenCode Zen roster directly from the repository's generation logic. Since the models are hard-coded rather than fetched, they remain accessible even without API credentials.

Python Extraction Example

import json

def get_opencode_zen_models():
    """
    Extracts the hard-coded OpenCode Zen model list.
    These IDs are defined in src/pull_available_models.py lines 145-154.
    """
    return [
        {"id": "big-pickle-stealth", "name": "Big Pickle Stealth"},
        {"id": "minimax-m2.5-free", "name": "MiniMax M2.5 Free"},
        {"id": "arcee-large-preview-free", "name": "Arcee Large Preview Free"},
    ]

print(json.dumps(get_opencode_zen_models(), indent=2))

CLI Inspection Example

After running the generation script, the curated list appears in the rendered documentation:

# Extract the OpenCode Zen section from the generated README

grep -A 3 -i "OpenCode Zen" README.md

This outputs the human-readable model list that corresponds to the hard-coded entries in the Python source.

Summary

• Manual curation: Models are hard-coded in src/pull_available_models.py (lines 145–154) rather than fetched dynamically, ensuring only vetted options appear.
• Explicit data policies: The gateway clearly states that free models may use input data for training, a transparency measure absent from many competitors.
• Stable identifiers: Fixed model IDs (big-pickle-stealth, minimax-m2.5-free, arcee-large-preview-free) prevent integration breakage from catalog updates.
• Quality over quantity: The service functions as a mediated gateway rather than a raw API mirror, prioritizing dependable performance over exhaustive coverage.

Frequently Asked Questions

How does OpenCode Zen differ from OpenRouter or Groq?

OpenRouter and Groq operate as dynamic aggregators that pull live model catalogs via public APIs, resulting in frequently changing endpoint lists. OpenCode Zen, as implemented in cheahjs/free-llm-api-resources, maintains a static, hand-picked selection hard-coded into the generation script. This ensures model availability remains constant and only includes options the maintainers have tested for reliability.

Why are the OpenCode Zen models hard-coded instead of fetched via API?

The hard-coding in src/pull_available_models.py lines 145–154 reflects a quality-assurance strategy. By manually inserting models rather than scraping provider APIs, the maintainers guarantee that every listed option meets specific standards for free-tier availability and performance. This prevents broken or inappropriate models from automatically appearing in the gateway listing.

What are the specific models included in OpenCode Zen's curated list?

The current curated selection includes three distinct models: Big Pickle Stealth (big-pickle-stealth), MiniMax M2.5 Free (minimax-m2.5-free), and Arcee Large Preview Free (arcee-large-preview-free). These identifiers map to friendly names in src/data.py and remain consistent across repository updates.

Where can I find the implementation details in the source code?

The core implementation resides in src/pull_available_models.py, specifically lines 145–154 where the OpenCode Zen entries are manually defined. Supporting name mappings appear in src/data.py, while the final rendered output appears in the repository's README.md under the "OpenCode Zen" section. The src/requirements.txt file lists the minimal dependencies required to run the documentation generation script.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}