Comprehensive Analysis of Transparency and Accessibility of ChatGPT, DeepSeek, And other SoTA Large Language Models

1. Introduction

Natural Language Processing (NLP) and Large Language Models (LLMs), including multimodal LLMs such as GPT-4o, DeepSeek-V2, and Gemini 1.5, have witnessed transformative advancements and significant growth in recent years, as illustrated by the surging global interest from both research and industry, as depicted in Figure 1a

These technologies have become integral to systems and solutions across a diverse array of sectors, including healthcare [2], finance [3], education [4], and entertainment[5]. Their remarkable capabilities in language understanding and generation have not only revolutionized these industries but have also spurred a new wave of innovation and application development [6,7]. Amidst this rapid expansion, the term “open-source” frequently surfaces within discussions about LLMs [8]. However, this descriptor is often misapplied or misunderstood. In many instances, developers may release only the model weights, that is, the trained parameters, without sharing the comprehensive suite of model assets such as model card, training data, code, sustainability factors (e.g., CO₂ emissions), or detailed development processes. This gap is also widely discussed in the literature [9] and in numerous tech blogs, including [10], to name a few.

Although proprietary LLMs like OpenAI GPT-series (4/4o) [11] exhibit strong performance, their closed-source nature limits access to API-based interactions. In contrast, open-weight models like Meta LLama-series [12] provide downloadable model weights under non-proprietary licenses, enabling specialized deployments and cost-effective fine-tuning. For instance, Princeton’s Llemma leverages Code Llama for advanced mathematical modeling [13], showcases the flexibility and cost benefits of open-weight models.

The distinction between "open" and "closed" LLMs is evident in their adoption trends. Closed models like GPT-3 followed a linear growth pattern (gray bars, Figure 1d), while open LLMs surged after Meta’s Llama release, driving exponential adoption (green and orange bars, Figure 1d). Figure 1e further illustrates how open source models increasingly attract scientific focus compared to the same with proprietary models such as GPT-4.

Despite this growing interest, the term “open-source” has frequently been used interchangeably with “open weights”, leading to confusion in discussions about model accessibility. Many models labeled as open-source provide access only to their trained weights while withholding essential components such as training data, fine-tuning methodologies, and full implementation details. This distinction is critical, as true open-source models enable not just inference but also full transparency and reproducibility in AI research. A recent case highlighting the confusion between open-source and open-weight models is DeepSeek-R1 [14]. Initially surpassing ChatGPT in search interest (Figure 1b), its popularity rapidly declined (Figure 1c), reflecting unmet expectations. While DeepSeek-R1 provides weights and partial code under the MIT license 1, it lacks full open-source transparency, including access to training data and methodologies. This partial openness, common to models like ChatGPT and Google’s Gemini, allows broader usage compared to fully closed models, but restricts deeper architectural modifications, evaluation of biases, and further enhancement of the training processes and datasets.

This ambiguity in AI terminologies necessitates clearer distinctions between open-source and open-weight models. True open-source AI requires full transparency, including training data and development processes, fostering reproducibility and ethical AI advancements. Defining and broadly adopting clear standards would enhance transparency, set realistic expectations, and promote responsible AI development.

1.1. Aim and Objectives

The goal of this study is to critically examines transparency practices of such "open-weight" LLMs, using DeepSeek-R1 and ChatGPT4o as primary examples, to map the distinctions between open-weight and fully open-source models. By doing so, we aim to:

• Elucidate the terminological ambiguities surrounding "open-source" within the AI domain, specifically distinguishing between truly open-source models and those termed "open-weight" which offer limited transparency.
• Investigate the implications of partial transparency on the reproducibility, community engagement, and ethical dimensions of AI development, emphasizing how these factors influence the practical deployment and trustworthiness of LLMs.
• Propose clearer guidelines and standards to differentiate truly open-source methodologies and models from strategies that merely provide access to pre-trained model weights.

With this study, we seek to contribute to an informed advancement of responsible AI, where both technological innovation and collaborative transparency are harmonized. The following sections describe the current landscape of LLMs, the tensions between proprietary and open-weight models, and the broader impacts of these approaches on the AI research community.

2. Methodology

This study systematically examines the concepts of openness and transparency in the development and dissemination of LLMs. A multi-stage approach is used in this study,beginning with a thorough examination of foundational concepts and progressing through detailed analyses of licensing types and transparency definitions as they relate to AI systems.

2.1. Research Design

This study adopts a multi-stage research design to evaluate the openness and transparency of SoTA LLMs. As illustrated in Figure 2, the approach integrates established open-source criteria, foundational linguistic definitions of “transparency”, and an extensive review of scholarly AI literature. A concise mind map (Figure 3) further delineates the core analytical branches, structured into three research questions (RQs) guiding the study. Below, each methodological component is described in detail.

2.2. Criteria for Openness and Transparency

Open-Source LLMs: An open-source LLM provides unrestricted access to its entire codebase, including the model architecture, training data, and the training processes [9]. Beyond the code and weights, a truly open-source model also discloses key factors such as performance benchmarks, bias mitigation strategies, computational efficiency, and sustainability metrics (e.g., Carbon dioxide emissions, energy consumption). For example, Meta’s LLamA aligns with the open-source paradigm by offering detailed insights into its design and implementation.

The primary goal with open-source models is to ensurecomplete transparency and flexibility. This openness enables comprehensive understanding, recreation, and reproducibility , even though some usage restrictions may still apply. Such transparency allows the research community to scrutinize, improve, and tailor models for diverse applications. Developing and maintaining such models, however, demands substantial effort and resources, making the open-source approach both a technical and logistical challenge. For example, early models like GPT-1 and GPT-2 were released as open-source projects, providing access to their training data, code and model weights. With subsequent versions like GPT-3, OpenAI shifted to a closed-source approach, restricting access to the model architecture, code, and weights. This trend continued with GPT-4, which also remains proprietary.

Open-Weight LLMs: Open-weight LLMs make their pre-trained model weights [15], the parameters learned during the pre-training process, publicly available, while the underlying code, training data, or training methodologies may remain proprietary. Open-weight models, while more accessible and easier to deploy than closed-source models, do not provide the same level of insight into the model’s inner workings as fully open-source models would. Meta’s LLama series is a prime example of an open-weight LLM. Researchers can download the pre-trained weights to fine-tune and deploy the model for various applications. However, while LLama weights are available, the full training pipeline, including the code and data, remains proprietary. This enables a balance between accessibility and intellectual property protection.

2.2.1. Open Source and Licensing Types

OSI stands for the Open Source Initiative [16]. It is a non-profit organization dedicated to promoting and protecting open source software. OSI is best known for its Open Source Definition (OSD), which outlines the criteria that a software license must meet to be considered "open source." These criteria include free redistribution, source code availability, the ability to create derivative works, and non-discrimination, among others. Essentially, OSI serves as a guardian of open source principles, ensuring that software labeled as open source truly adheres to standards that promote collaboration, transparency, and freedom in software development.

The primary attributes of the OSI’s official definition of open-source AI are illustrated in Figure 4. OSI emphasizes that for an AI system to be truly open source, there must be unrestricted access to its entire structure. This means that key components—such as the model weights, source code, and training data—must be accessible under OSI-approved terms. uch access allows any user to use, modify, share, and fully understand the AI system without needing special permissions.

Transparency refers to the clarity and understandability of the underlying mechanisms that drive AI systems. It is achieved when training data and code are available, enabling stakeholders to replicate and scrutinize the AI’s decision-making processes [17,18,19]. This openness ensures that AI operations are not only visible but also comprehensible and accountable, thereby enhancing trust and fostering collaboration in AI development and application.

Open source software licenses further define the usage, modification, and distribution rights for software [20]. They are critical for both protecting creators and enabling users to innovate and adapt software to their needs [21]. For example, the MIT License, highly permissive, allows almost unrestricted use provided the original copyright is included.Similarly, the Apache License 2.0 2 permits broad use—including modifications and distributions—with the additional safeguard of patent rights protection Although Creative Commons licenses 3 are primarily designed for creative content, variants such as CC-BY-4.0 can also govern software use by allowing commercial use provided that proper credit is given to the creator. Choosing the right license involves careful consideration of the intended use, attribution requirements, and legal protections, ensuring that software developers can support their objectives while fostering broader collaboration and innovation within the community. Table 1 provides an overview of popular licenses in AI practices, highlighting the varying degrees of permissiveness—from the flexible MIT License 4 to the stricter copyleft provisions of the GNU GPL 3.0 5.

2.2.2. Open Source and Transparency

Following the OSI guidelines, dictionary definitions further support the concept of open source and transparency. According to Oxford 6 , open source software is described as “Used to describe software for which the original source code is made available to anyone.” Cambridge further explains that open source software or information can be “obtained legally and for free from the internet, and can be used, shared or changed without paying or asking for special permission.” Merriam-Webster defines it as “Having the source code freely available for possible modification and redistribution.” For transparency, Oxford states it as “The quality of something, such as glass, that allows you to see through it.” Cambridge calls it “The characteristic of being easy to see through.” Merriam-Webster describes transparency as “The quality or state of being transparent so that bodies lying beyond are seen clearly.” These definitions set a foundational understanding to evaluate the transparency practices in AI systems, as shown in Table 2, which presents a literature review and definitions derived from 10 popular literature defining transparency in AI systems.

2.3. Synthesis of Literature

2.3.1. Search Strategy

The study first identified the requirements outlined by the OSI 7 as the baseline for evaluating AI models. These criteria covers various facets of openness, including licensing provisions, access to source code, free redistribution rights, and the ability to modify or derive new work/models from the original codebase. Building on the OSI standards, the concept of “transparency” was clarified through an examination of widely used dictionaries (Oxford, Cambridge, and Merriam-Webster) [44]. Key steps included:

Databases and Sources: The selection of databases was aligned with the goal of capturing a breadth of interdisciplinary research that intersects with artificial intelligence. Academic repositories such as ACM Digital Library, IEEE Xplore, Elsevier, Nature, Scopus, ScienceDirect, SpringerLink, Wiley Online Library, MathSciNet and renowned pre-print servers like arXiv were chosen for their extensive coverage of both technical and ethical dimensions pertinent to AI. These platforms are renowned for their consolidation of high-impact and specialized journals, which provide critical insights into both emerging and established research areas within technology and applied sciences.

Our literature search was further reinforced by prioritizing papers that are highly cited within the academic community. Citation counts, often seen as a proxy for the influence and relevance of a study, were utilized as a key metric in selecting sources. Papers with exceptionally high citation counts (e.g., > 3000 citations), were specifically targeted. This criterion was instrumental because highly cited papers typically reflect pivotal developments in the field and are often the genesis of new research trajectories or shifts in scientific paradigms. The search terms used were “Transparency in AI”, “Transparency in LLMs”, “Explainable AI”, “Reproducible AI”, “Open Source AI”, “Open Source Model”, “Open Source Software”, “Fairness in AI”, “Ethical AI”, “Responsible AI”, “Bias in AI”, “Sustainable AI”, “Green AI”, “AI Ethics”, “AI Accountability”, “Interpretable AI”, “AI Robustness”, “AI Reliability”, and “AI Compliance”.

Timeframe The literature selected for this study spans publications from 2017 onward—a timeframe strategically chosen to align with the introduction of Transformers. In 2017, Vaswani et al. published Attention is All You Need [45], marking the beginning of a new era in AI by introducing a model architecture based entirely on attention mechanisms. Following this, the launch of GPT-2, T5, BART, and several other language model architectures further advanced the field, shaping the development of modern LLMs. We systematically assessed published research to identify models that exemplify various degrees of openness, including open-source and open-weight practices

In the process of synthesizing these findings, we evaluated a total of 112 LLMs, a sample that represents the diverse and rapidly evolving landscape of language models from 2019 to 2025. These models were analyzed based on a wide array of architectural specifications—such as the number of layers, hidden unit sizes, attention head counts, and overall parameter scales—as well as openness metrics including licensing type and the public availability of training resources. The integrated results, illustrated in Figure 5, provide a visual representation of the temporal distribution and evolution of these models. The figure shows that although the foundational literature for LLMs was established with the advent of Transformers in 2017, the major model breakthroughs and integrated transparency and accessibility features have predominantly materialized from 2019 onward and more post-ChatGPT era (Nov. 2022).

Inclusion Criteria A thorough literature review was conducted to locate transparency within broader discourses in AI development and ethics. This review captured highly cited articles and technical reports, emphasizing themes such as explainable AI, reproducibility, interpretability, and responsible AI governance [46]. By synthesizing these studies, our study addressed both technical (e.g., code-level transparency) and ethical (e.g., data biases) dimensions of openness.

2.4. Evaluation Framework and Application

Findings from the previous stages were synthesized into five key dimensions representing critical facets of open-source and open-weight classifications:

• Licensing, Usage, and Redistribution Rights
• Code Accessibility and Modification Rights
• Training Data Transparency
• Community and Support
• MMLU Score and Carbon Emissions
• Ethical Considerations and Reproducibility

Each of these dimensions was assessed to determine whether a given model adhered to OSI-like openness or employed more restrictive practices similar to “open-weight” approaches (i.e., sharing only the model parameters). SoTA LLMs were systematically evaluated against these five dimensions as 1) Licensing, usage, and redistribution rights , 2) Training Code and Training Data, 3) Community Support, 4) Open source, and 5) Open Weights. Any evidence of collaborative contributions or transparent reporting of potential biases and vulnerabilities was also documented.

2.5. Research Questions

The methodology section of this study was structured around a detailed mind map, as depicted in Figure 3. This visual representation, employed to assess the transparency and openness of SoTA multimodal LLMs, organized the analytical framework into three main branches, each corresponding to a specific research question (RQ) as follows:

• What drives the classification of LLMs as open weights rather than open source, and what impact do these factors have on their efficiency and scalability in practical applications?
• How do current training approaches influence transparency and reproducibility, potentially prompting developers to favor open-weight models?
• How does the limited disclosure of training data and methodologies impact both the performance and practical usability of these models, and what future implications arise for developers and end-users?

This methodology integrates well-established open-source standards, linguistically and ethically grounded definitions of transparency, and a structured evaluation framework. The outcome is an assessment of whether leading MLLMs adhere to open-source principles or merely present limited transparency through open-weight practices. The subsequent sections detail the findings that emerged from applying this framework, highlighting significant discrepancies and implications for researchers, developers, and broader AI stakeholders.

3. Results

3.1. Overall Findings on Openness and Transparency

Drawing on OSI guidelines, dictionary-based definitions of transparency, and scholarly literature, this narrative review reveals that many models marketed or perceived as “open” primarily provide open weights (i.e., publicly available trained parameters) rather than full open-source access (i.e., source code, training data, and detailed methodologies). Table 3 outlines these distinctions across leading multimodal LLMs.

The analysis of the comprehensive table (Table 3), which evaluates 112 LLMs released between 2019 and 2025 interms of release year, training data and key features. Early models, such as GPT-2 [47] and BERT [48], primarily focused on foundational capabilities including improved text generation, masked language modeling, and next-sentence prediction. These models relied on relatively simple training data and featured basic natural language processing tasks. However, subsequent developments have led to a remarkable progression in both complexity and functionality. Recent models—such as DeepSeek-R1 [14] and advanced iterations of ChatGPT, introduce enhanced multimodal capabilities, advanced reasoning through mixture-of-experts (MoE) architectures, and efficient scaling strategies. The table demonstrates that models released after 2020 increasingly leverage diverse and massive training datasets, from extensive web corpora to hybrid synthetic-organic data—which significantly boost performance. Moreover, these models exhibit notable improvements in precision, processing speed, and bias mitigation. Although many SoTA models disclose only pre-trained weights, thereby limiting reproducibility, an emerging trend toward greater transparency regarding training methodologies is evident. This evolution reflects an industry-wide shift towards balancing commercial interests with greater accountability and openness in AI research.

Further comparative analysis indicates that the evolution of LLMs is marked by continuous refinement of critical features essential for practical applications. Models such as T5-XXL [55] have significantly expanded both the scale and diversity of training data, transitioning from datasets with millions of tokens to those with trillions. This dramatic increase in training volume has enabled improvements in computational efficiency, reproducibility, and bias mitigation. Additionally, evolving training methodologies—from basic text-to-text transfer to sophisticated hybrid approaches—have resulted in models that are increasingly adept at handling complex, real-world tasks. Advances in ethical and operational transparency, as evidenced by improved MMLU scores and the integration of sustainability metrics (e.g., carbon emissions tracking), underscore a dual focus on technical performance and responsible governance. The emergence of open-weight models, such as those from DeepSeek and ChatGPT, illustrates a deliberate strategy to balance accessibility with proprietary innovation. These findings in the Table 3 suggest that future LLMs will continue to build on these innovations, paving the way for more transparent, efficient, and ethically responsible AI systems [105].

Furthermore, in appendix section, Table 5 provides a comprehensive overview of these 111 LLMs investigated in this study, detailing both architectural specifications and openness metrics. A clear pattern emerges regarding licensing: prominent models such as the GPT family (e.g., GPT-2 [47], ChatGPT-3.5, ChatGPT-4) largely adopt proprietary licenses, restricting access to their training data, code, and methodologies. In contrast, models like BERT [48] and certain DeepSeek variants (e.g., DeepSeek-R1 [14]) are disseminated under open-source licenses such as MIT or Apache 2.0, which facilitate greater transparency through public availability of weights and, in some cases, additional resources. The DeepSeek family, for example, demonstrates a strategic move toward open-weight transparency while still withholding full training pipelines. Similar trends are observed in the T5 series [55] and LLaMA 2 [12], where a mix of open and proprietary strategies reflects divergent priorities—commercial viability versus reproducibility. This heterogeneous licensing landscape, as corroborated by studies e.g., [14,48,49,53,55,56], underlines the challenges in balancing innovation, transparency, and community engagement in modern LLM development.

Detailed specifications of Large Language Models (2019–2025), including the model name, release year, training data characteristics, and key features.

Despite variances in licensing terms, from permissive licenses (e.g., MIT, Apache 2.0) to more restrictive or proprietary frameworks, training data and code remain largely undisclosed in most of the models reviewed. Community engagement and support frequently generally appeared robust (via forums, documentation, or user guides), but comprehensive transparency of datasets, training pipelines, and model internals such as hyperparameters and attention mechanisms remains limited. These findings align with broader trends in AI development, where commercial or strategic interests often restrict full access to the underlying training infrastructure [132,133].

Further analysis of Table 5 (Refer to appendix section) reveals significant trends in performance and sustainability metrics. Notably, recent models in the ChatGPT family achieve high MMLU scores, ChatGPT-4, for instance, reports an MMLU score of 86.4%, while also indicating substantial carbon emissions (e.g., 552 tCO₂eq for several variants and 1,035 tCO₂eq for GPT-4o [49]). In contrast, earlier models such as GPT-2 lack these performance benchmarks, reflecting evolving evaluation standards. The DeepSeek family shows a promising balance: DeepSeek-R1 records a robust MMLU score (90.8%) and comparatively lower carbon emissions (44 tCO₂eq), suggesting improved energy efficiency and refined training methodologies. Similar sustainability trends are evident in the T5 series [55] and LLaMA 2 [12], which have progressively incorporated larger, more diverse datasets alongside performance improvements. Studies e.g., [14,53,104,105,112,134] indicate that while performance enhancements are significant, the associated environmental costs necessitate a shift toward more energy-efficient architectures and transparent reporting practices.

Table 5 also details the architectural specifications that underpin model performance. The GPT family, including variants like ChatGPT-3.5 and GPT-4, generally features 96 layers, 12,288 hidden units, and parameter counts scaling up to 1.8T, indicating a massive computational footprint [49]. In contrast, the DeepSeek family employs a different architecture—DeepSeek-R1, for instance, is built with 64 layers and 8192 hidden units, achieving high performance (MMLU score of 90.8%) with relatively fewer parameters (671B). The T5 series [55] and LLaMA 2 [12] further illustrate a trend toward optimizing architectural design for scalability, efficiency, and energy conservation. These models reveal a shift from sheer scale towards balanced configurations that emphasize reproducibility and ethical considerations. Several works e.g., [12,48,53,55,56,105] support the observation that while larger models deliver superior performance, they also present challenges in terms of energy consumption and transparency. Overall, the architectural trends underscore the importance of evolving design principles that can reconcile performance, efficiency, and openness in next-generation LLMs.

Furthermore, Table 5 (Refer to appendix section) presents an extended analysis of 111 LLMs from 2019 to 2025, emphasizing architectural specifications and openness metrics. Early models such as GPT-2 [47] and BERT [48] laid the groundwork with moderate layer counts, hidden sizes, and attention head configurations. As the field evolved, later models—particularly within the ChatGPT and DeepSeek families [14,53], exhibited significant increases in layers, hidden units, and overall parameter scales, reflecting a trend toward more complex architectures designed for enhanced performance and multimodal capabilities. The table categorizes the openness of training data (fully open, partially open, or proprietary) and evaluates accessibility to model weights, code, and training datasets, thereby delineating a clear divergence between models that offer full reproducibility and those that only provide open weights. MMLU scores and reported carbon emissions further indicate that while state-of-the-art models achieve higher performance, they also incur greater environmental costs—a factor increasingly scrutinized in recent literature [12,55,105]. Overall, the extended analysis highlights an industry-wide progression from simpler architectures with limited transparency to highly engineered systems that balance commercial interests with technical rigor and ethical considerations.

3.2. Model-Specific Evaluations

ChatGPT

GPT-4 [134] and ChatGPT [11] are proprietary models with limited architectural transparency: their training datasets, fine-tuning protocols, and structural details (e.g., layer configurations, attention mechanisms) remain undisclosed. While GPT-4’s technical report outlines high-level capabilities[135], it omits reproducibility-critical specifics such as pre-training corpus composition, hyperparameters, and energy consumption metrics, reflecting a priority on commercial secrecy, which limits its scientific openness. Similarly, ChatGPT’s API-based access restricts users to input-output interactions without exposing model internals [136], thus creating a "black box" system that lacks transparency and does not allow third-party modifications.

ChatGPT adopt a functional accessibility paradigm, where API endpoints enable task execution (e.g., text generation, reasoning) but do not allow direct weight inspection, retraining, or redistribution [137,138]. This approach, therefore, creates a dependency on proprietary infrastructure, which can limit long-term reproducibility and bias mitigation in downstream applications. While the term "open-weights" is occasionally used to describe these systems due to their API availability, this is misleading because true open-weight standards—such as parameter accessibility (e.g., Llama 2) or training code disclosure (e.g., BLOOM [139]), are absent, underscoring the competing priorities between commercial control and open scientific collaboration in modern AI ecosystems. The ChatGPT’s version’s:

• GPT-2: [47] adopts an open-weights model under MIT License, providing full access to its 1.5B parameters and architectural details (48 layers, 1600 hidden size). However, the WebText training dataset (8M web pages) lacks comprehensive documentation of sources and filtering protocols. While permitting commercial use and modification, the absence of detailed pre-processing methodologies limits reproducibility of its zero-shot learning capabilities.
• Legacy ChatGPT-3.5:Legacy ChatGPT-3.5 uses proprietary weights with undisclosed architectural details (96 layers, 12288 hidden size). The pre-2021 text/code training data lacks domain distribution metrics and copyright compliance audits. API-only access restricts model introspection or bias mitigation, despite claims of basic translation/text task capabilities [50].
• Default ChatGPT-3.5: Default ChatGPT-3.5 [50] shares Legacy’s proprietary architecture but omits fine-tuning protocols for its "faster, less precise" variant. Training data temporal cutoff (pre-2021) creates recency gaps unaddressed in technical documentation. Restricted API outputs prevent reproducibility of the 69.5% MMLU benchmark results.
• GPT-3.5 Turbo: GPT-3.5 Turbo [50] employs encrypted weights with undisclosed accuracy optimization techniques. The 16K context window expansion lacks computational efficiency metrics or energy consumption disclosures. Proprietary licensing blocks third-party latency benchmarking despite "optimized accuracy" claims.
• GPT-4o: GPT-4o [49] uses multimodal proprietary weights (1.8T parameters) with undisclosed cross-modal fusion logic. Training data (pre-2024 text/image/audio/video) lacks ethical sourcing validations for sensitive content. "System 2 thinking" capabilities lack peer-reviewed validation pipelines.
• GPT-4o mini: GPT-4o mini [49] offers cost-reduced proprietary access (1.2T parameters) with undisclosed pruning methodologies. The pre-2024 training corpus excludes synthetic data ratios and human feedback alignment details. Energy efficiency claims (60% cost reduction) lack independent verification.

DeepSeek

The DeepSeek-R1 model, a 671-billion-parameter mixture-of-experts (MoE) system built on the DeepSeek-V3 architecture, adopts an open-weights framework under the MIT License, permitting unrestricted access to its neural network parameters for commercial and research use [14]. MoE is an ensemble machine learning technique where multiple specialist models (referred to as "experts") are trained to handle different parts of the input space, and a gating model decides which expert to consult for a given input [140,141]. This method allows for more scalable and efficient training as well as inference processes, especially in complex models like DeepSeek-R1, by dynamically allocating computational resources to the most relevant experts for specific tasks or data points.

While the DeepSeek-R1 model’s weights and high-level architectural details—including its MoE design with 37 billion activated parameters per inference and reinforcement learning-augmented reasoning pipelines—are publicly disclosed, critical transparency gaps persist. The pre-training dataset composition, comprising a hybrid of synthetic and organic data, remains proprietary, obscuring potential biases and ethical sourcing practices. Similarly, the reinforcement learning from human feedback (RLHF) pipeline lacks detailed documentation of preference model architectures, safety alignment protocols, and fine-tuning hyperparameters, limiting independent reproducibility. These omissions reflect a strategic prioritization of computational efficiency (leveraging 10,000 NVIDIA GPUs for cost-optimized training) over full methodological transparency, positioning the model as open-weights rather than fully open-source.

The DeepSeek models:

• DeepSeek-R1: DeepSeek-R1’s accessibility is defined by its permissive licensing and efficient deployment capabilities, with quantized variants reducing hardware demands for applications like mathematical reasoning and code generation. However, its reliance on undisclosed training data and proprietary infrastructure optimizations creates dependencies on specialized computational resources, restricting independent assessment for safety or performance validation. The model’s MoE architecture, which reduces energy consumption by 58% compared to dense equivalents [14], challenges conventional scaling paradigms, as evidenced by its disruptive impact on GPU market dynamics [51,52,53,54]. This open-weights approach balances innovation dissemination with commercial secrecy, highlighting unresolved tensions between industry competitiveness and scientific reproducibility in large-language-model development. Full open-source classification would necessitate disclosure of training datasets, fine-tuning codebases, and RLHF implementation details currently withheld.
• DeepSeek LLM :The DeepSeek LLM uses proprietary weights (67B parameters) with undocumented scaling strategies. Books+Wiki data (up to 2023) lacks multilingual token distributions and fact-checking protocols. Custom licensing restricts commercial deployments despite "efficient training" claims [51].
• DeepSeek LLM V2: DeepSeek LLM V2 employs undisclosed MoE architecture (236B params) with proprietary MLA optimizations. The 128K context window lacks attention sparsity patterns and memory footprint metrics. Training efficiency claims ("lowered costs") omit hardware configurations and carbon emission data [52].
• DeepSeek Coder V2: DeepSeek Coder V2 provides API-only access to its 338-language coding model. Training data excludes vulnerability scanning protocols and license compliance audits. Undisclosed reinforcement learning pipelines hinder safety evaluations of generated code [53].
• DeepSeek V3: DeepSeek V3 uses proprietary FP8 training for 671B MoE architecture. The 128K context implementation lacks quantization error analysis and hardware-specific optimizations. Benchmark scores (75.7% MMLU) lack reproducibility scripts or evaluation framework details. [54]

Miscellaneous Proprietary Models

Meta’s Llama The Llemma language model [13], developed for mathematical reasoning, provides open weights through its publicly accessible 7B and 34B parameter variants, released under a permissive license alongside the Proof-Pile-2 dataset and training code. These weights enable users to deploy, fine-tune, and study the model’s mathematical capabilities, such as chain-of-thought reasoning, Python tool integration, and formal theorem proving. For example, Llemma 34B achieves 25.0% accuracy on the MATH benchmark, outperforming comparable open models like Code Llama (12.2%) and even proprietary models like Minerva (14.1% for 8B). The weights are hosted on Hugging Face, with detailed evaluation scripts and replication code provided, allowing researchers to validate performance metrics like GSM8k (51.5% for Llemma 34B) and SAT (71.9%).

However, Llemma is also categorized as open-weights rather than fully open-source due to incomplete transparency in its development pipeline [13]. While the Proof-Pile-2 dataset is released 8, it excludes subsets like Lean theorem-proving data and lacks detailed documentation on data-cleaning methodologies. The training code provided is modular but omits critical infrastructure details, such as hyperparameter optimization workflows and cluster-specific configurations (e.g., Tensor parallelism settings for 256 A100 GPUs). This partial disclosure limits reproducibility and prevents independent evaluation of potential biases or training inefficiencies, aligning with broader critiques of open-weight models’ inability to fulfill open-source AI’s “four freedoms” (use, study, modify, share).

Like Meta’s Llama 3—which shares weights but restricts training data and methodology—Llemma’s openness prioritizes usability over full transparency. Both models exemplify the open-weight paradigm: they release parameters for inference and fine-tuning but withhold various key elements (e.g., Llama 3’s 15T-token dataset; Llemma’s cluster-optimized training scripts). For Llemma, this approach balances mathematical innovation with competitive safeguards, as its Proof-Pile-2 dataset represents a significant research asset. However, the MIT License governing Llemma imposes fewer restrictions than Llama 3’s proprietary terms, enabling commercial use and redistribution without attribution. The distinction lies in the degree of openness: Llemma provides more components (dataset, code) than Llama 3 but still falls short of open-source standards by omitting infrastructure-level details. This reflects a strategic compromise—enhancing accessibility for mathematical research while retaining control over computationally intensive training processes. Such tradeoffs underscore the AI community’s ongoing debate about whether partial transparency suffices for ethical AI development or if full open-source disclosure remains essential for accountability.

Google Gemini Google’s Gemini model family, comprising Ultra (1.56T parameters), Pro (137B), and Nano (3.2B/17.5B) variants, operates under an open-weights paradigm as well, where pretrained model parameters are accessible via APIs but remain proprietary and non-modifiable [142]. The architecture integrates multimodal fusion mechanisms, including cross-modal attention layers and sparsely activated mixture-of-experts (MoE) blocks, trained on a corpus of 12.5 trillion text tokens, 3.2 billion images, and 1.1 billion video-audio pairs. While technical documentation outlines innovations such as dynamic token routing for modality-specific computations and TPUv5-optimized distributed training, critical reproducibility details such as the MoE router logic, TPU compiler configurations, and multimodal alignment loss functions are not shared. Furthermore, the training dataset composition that includes spanning web documents (50%), code repositories (18%), and proprietary media (32%) lacks granular metadata, obscuring data provenance and ethical sourcing practices. This partial transparency enables limited third-party deployment (e.g., Gemini Nano on Pixel devices) but restricts independent assessment of biases or safety protocols, as weights are encrypted and inference-only.

Gemini is classified as open-weights rather than open-source due to the constraints in transparency and licensing. Its proprietary Google license prohibits weight modification, redistribution, and commercial use cases competing with Google services, diverging from open-source standards like Apache 2.0 that permit unrestricted adaptation. The model’s technical report omits hyperparameters critical for replication, such as Gemini Ultra’s learning rate schedule (0.00000625), Pro’s 4.8-bit quantization thresholds, and Nano’s knowledge distillation ratios from larger variants. Additionally, the reinforcement learning from human feedback (RLHF) pipeline—including reward model architectures and safety filtering protocols, is described only abstractly, preventing independent validation of alignment strategies. While Gemini’s API-accessible weights support downstream applications (e.g., Android’s on-device AI), the absence of training code (e.g., JAX/FLAX implementations), dataset indices, and infrastructure blueprints encourages dependency on Google’s proprietary ecosystem. This lack of transparency safeguards Google’s business secrecy including multimodal data pipelines, similar to those of others discussed above, illustrating the inherent tradeoff in corporate AI between accessibility and competitive secrecy. For these Google models, full open-source status would necessitate disclosing training methodologies, infrastructure configurations, and dataset curation frameworks, steps incompatible with Google’s commercial AI roadmap.

Mistral AI Mistral AI’s models, including Mistral 7B and Mixtral 8x7B, can also be classified as open-weights due to their release of model parameters and architectural blueprints under the Apache 2.0 license, which permits commercial use, modification, and redistribution [56]. These models employ advanced architectures such as grouped-query attention (GQA) and sliding window attention (SWA) to optimize inference efficiency, with Mistral 7B trained on 2.4 trillion tokens of multilingual data. However, critical components necessary for full reproducibility—including the composition of the training dataset, hyperparameter configurations (e.g., learning rate schedules, batch sizes), and reinforcement learning from human feedback (RLHF) pipelines—remain undisclosed. This selective transparency extends to licensing: advanced models like Codestral-22B are governed by the Mistral Non-Production License (MNPL), which restricts commercial deployment without explicit agreements, creating a tiered accessibility framework. While Mistral provides inference code and quantized weight variants (e.g., GGUF, AWQ), the absence of training infrastructure details (e.g., TPU/GPU cluster configurations) and proprietary fine-tuning datasets limits independent replication of their results.

Mistral AI’s models diverge from open-source standards through three systemic constraints: (1) data opacity, as the training corpus—spanning web texts, code repositories, and multilingual sources—lacks detailed documentation, preventing analysis of potential bias or ethical sourcing; (2) methodological gaps, where architectural innovations like SWA (window size: 4,096 tokens) are disclosed, but RLHF reward models and distributed training protocols remain proprietary; and (3) restrictive licensing, including the prohibition of commercial use by MNPL, which does not follow open-source principles where modification rights would be granted to users/developers. This hybrid approach, as mentioned before, tries to balance regional and companies’s interests in protecting their commercial competitiveness while enabling, at least marginally, community-driven adaptations (e.g., fine-tuning for code generation). Full open-source compliance would necessitate releasing training data, infrastructure blueprints, and unconstrained licenses—compromises incompatible with Mistral’s market strategy, which prioritizes controlled innovation over unrestricted transparency.

Microsoft Phi Microsoft’s Phi family, including Phi-3 (3.8B parameters) and Phi-4 (14B parameters), adopts an open-weights paradigm under the MIT License, granting access to model weights, architectural specifications (e.g., Phi-3’s 3,072-dimensional embeddings and Phi-4’s pivotal token search for STEM tasks), and inference code optimized for edge deployment [87,143]. These models leverage sliding window attention (SWA) and grouped-query attention (GQA) to reduce computational overhead, with Phi-3 achieving sub-2-second latency on mobile devices via 4-bit quantization. While the MIT License permits commercial use and modification—enabling applications like on-device code generation—critical reproducibility elements are withheld. The training datasets, comprising 4.8 trillion tokens for Phi-4 (40% synthetic data from multi-agent simulations) and 2.1 trillion tokens for Phi-3, lack detailed documentation of sources, copyright compliance measures, or bias mitigation protocols. Additionally, proprietary components like reinforcement RLHF pipelines, hyperparameter schedules (e.g., Phi-4’s learning rate = 0.00012), and Azure-specific distributed training configurations remain undisclosed, limiting independent validation of safety or reported performances (e.g., Phi-4’s 80.6% MATH benchmark accuracy).

The Phi models’ classification as open-weights rather than open-source stems from three limitations: (1) Data opacity, where synthetic data generation workflows (e.g., instruction inversion, self-revision loops) lack open-sourced prompts or validation metrics; (2) Methodological gaps, as RLHF reward models, safety alignment protocols, and hardware-specific optimizations (e.g., Qualcomm NPU drivers for Phi-3) remain proprietary; and (3) Licensing dependencies, shown by Phi-3’s reliance on closed-source ONNX Runtime for mobile deployment. Microsoft’s selective transparency reflects industry trends, as in other models and companies discussed earlier, in balancing community engagement (via permissive licensing) with competitive control over high-value assets like synthetic data pipelines. Full open-source compliance would require disclosing training code (e.g., SynapseML frameworks), dataset indices, and infrastructure blueprints, which might be incompatible steps for Microsoft to stay at the highly competitive position, particularly in edge AI markets.

Dolly 2.0 Dolly 2.0 stands out in the landscape of LLMs by being fully open-sourced, a rarity in a field where most models are typically released with "open weights" only (https://huggingface.co/databricks/dolly-v2-12b). Unlike its predecessors and many contemporaries, Dolly 2.0 extends openness beyond just the model weights to include its training code and the specific dataset used for its instruction tuning. This comprehensive approach to transparency is facilitated by Databricks’ use of a permissive CC-BY-SA license for the model and dataset, and an Apache 2.0 license for the code. These licenses allow for both commercial use and community adaptation, encouraging innovation and customization without the typical restrictions imposed by proprietary models or models with limited openness discussed earlier. Full openness of Dolly 2.0 addresses a critical gap in the AI community, where the utility of LLMs has often been hampered by limited access to the underlying tools that could allow users to understand, replicate, and build upon pre-existing work. By open-sourcing the entire ecosystem of Dolly 2.0, which includes weights, code, and training data, Databricks sets a new precedent for transparency and adaptability in AI development. This approach not only democratizes access to cutting-edge technology but also fosters an environment of collaborative improvement and widespread application, spanning academic, private, and public sectors. This strategic move differentiates Dolly 2.0 from other models that restrict access to their training methodologies and data, thus enabling broader and more equitable advancements in AI technology.

Grok Grok-1, developed by xAI, represents a step towards open engagement in the AI field but does not achieve full open-source status. Released under the Apache 2.0 license in March 2024, Grok-1’s weights and architecture are openly accessible, permitting both commercial and non-commercial use 9 https://x.ai/blog/grok-2 This allows users to utilize and modify the model’s weights freely, enhancing transparency to a degree. However, the release scope is limited; it includes only the raw model checkpoint from the pre-training concluded in October 2023 and excludes critical components such as the full training data and methodologies, as well as the fine-tuned versions employed in the Grok AI assistant. This selective openness reflects a common practice in the industry followed by most of the models review in this article as discused above where companies balance transparency with their interest to protect competitive edge in AI capabilities. While the open weights of Grok-1 promote a level of user adaptation and transparency, they do not provide complete visibility into the model’s development process. Users gain access to the model’s capabilities and can experiment with its basic framework, but the absence of comprehensive training details and the weights for their refined, application-ready versions of the model means that the full extent of its development remains closed.

In contrast, Grok 3, the latest iteration from xAI, represents a significant leap in AI capabilities but remains far from open-source status. It was developed using a massive computing infrastructure, including a Colossus supercomputer with approximately 200,000 GPUs, and was trained with ten times more computing power than its predecessor, Grok 2. rok 3 has demonstrated superior performance in benchmarks, outperforming models like OpenAI’s GPT-4o and Google’s Gemini 10. Despite its advanced capabilities, nothing has been disclosed about making Grok 3 open-source or providing access to its weights or detailed training methodologies. This reflects the ongoing trend in the AI industry where companies prioritize protecting their competitive advantages over full transparency.

BERT Family BERT models [48] offer open weights under Apache 2.0 with disclosed architectural specifications (12-24 layers, 768-1024 hidden sizes). The Books+Wiki training data (up to 2019) lacks temporal metadata and copyright compliance details. Though accessible for modification, the proprietary nature of Google’s pretraining infrastructure (TPU configurations, hyperparameters) limits full reproducibility.

T5 Series T5 models [55] provide open weights under Apache 2.0 with text-to-text architecture transparency (6-24 encoder/decoder layers). The C4 training dataset description omits granular composition details and ethical sourcing validations. While offering commercial adaptability, the undisclosed distributed training protocols (e.g., Mesh-TensorFlow configurations) restrict independent scaling attempts.

Mistral 7B Mistral 7B [56] releases weights under Apache 2.0 with architectural innovations like SWA (sliding window attention) documented. The 2.4T token training corpus lacks source diversity analysis and bias mitigation reports. Though permitting commercial deployment, the proprietary RLHF pipelines and cluster-specific optimizations hinder safety validation.

LLaMA 2 70B LLaMA 2 70B [12] provides weights under custom license with GQA (grouped-query attention) specifications. The 2T token training data composition remains proprietary, obscuring multilingual representation balances. Commercial use restrictions and withheld distributed training code (256 GPUs) limit independent performance verification.

Gemma Gemma [81] operates under proprietary license with encrypted weights and API-only access. The 6T token training dataset lacks domain distribution details (e.g., code vs web text ratios). TPUv4-optimized architectures remain undisclosed, preventing energy efficiency assessments despite claimed environmental benefits.

BLOOM BLOOM [108] offers open weights under RAIL License with disclosed 176B parameter architecture. The ROOTS corpus (1.6T tokens) documentation omits cultural bias audits and source language proportions. Non-commercial restrictions and absent RLHF codebases limit enterprise adaptability despite multilingual capabilities.

OPT OPT [107] provides non-commercial weights with GPT-3-like architecture transparency (96 layers, 12288 hidden size). The web-crawled training data lacks deduplication methodology and toxicity filtering details. Restricted modification rights and omitted distributed training blueprints (256 GPUs) hinder academic reproducibility efforts.

Gopher Gopher [104] maintains proprietary weights with undisclosed 280B parameter MoE configurations. The MassiveText dataset (2.5T tokens) composition remains confidential, preventing copyright compliance verification. API-based access restricts model introspection and bias mitigation, despite published scaling law analyses.

Chinchilla Chinchilla [105] uses proprietary weights with compute-optimal 70B parameter design. The 1.4T token training corpus lacks temporal stratification and domain diversity reports. Though influential in scaling theory, the withheld infrastructure details (JAX/TPU implementations) block energy efficiency replication studies.

PaLM PaLM [106] employs proprietary weights with Pathways system details omitted from technical reports. The multilingual training data (50+ languages) lacks per-language token counts and quality control metrics. Restricted access to 540B parameter model variants limits independent evaluation of claimed reasoning improvements.

Jurassic-1 Jurassic-1 [109] operates via encrypted API with undisclosed 178B parameter architecture. The web-text training data composition and preprocessing filters remain trade secrets. Commercial users face output stochasticity controls that prevent deterministic reproducibility of results.

Codex Codex [110] uses proprietary weights with specialized 12B parameter code architecture. The GitHub-sourced training data lacks license compliance verification and vulnerability filtering protocols. Restricted to Azure API access, it prevents security audits of generated code despite wide developer adoption.

Switch Transformer Switch Transformer [123] provides open weights under Apache 2.0 with disclosed 1.6T parameter MoE design. The web-text training corpus omits geographical source distributions and demographic bias assessments. Though permitting architectural modifications, the absent TPU cluster configurations hinder efficient scaling replication.

WuDao 2.0 WuDao 2.0 [124] maintains proprietary 1.75T parameter weights with undisclosed Chinese/English data mixing ratios. The training infrastructure (2048 GPUs) details and energy consumption metrics remain state secrets. Domestic access restrictions and absent safety filters limit global research collaboration potential.

LaMDA LaMDA [125] uses proprietary 137B parameter weights with dialog-specific architecture details withheld. The conversation training data lacks participant consent verification and persona diversity metrics. API guardrails prevent adversarial testing of safety protocols despite published harm reduction claims.

Megatron-LM Megatron-LM [95] uses a custom license with proprietary weights and no architectural transparency (72 layers, 3072 hidden size). Training data (Common Crawl, Wikipedia, Books) lacks deduplication metrics and ethical sourcing documentation. Though optimized for NVIDIA GPUs, the undisclosed parallelism strategies and TPU compiler configurations hinder reproducibility of its 8.3B parameter model.

Turing-NLG Turing-NLG [96] operates under proprietary licensing with encrypted 17B parameter weights. The diverse web-text training corpus omits content moderation protocols and demographic bias audits. Restricted API access prevents model introspection, despite its integration into Microsoft products for text generation.

CTRL CTRL [97] provides open weights under Apache 2.0 with disclosed 1.6B parameter architecture. Control codes for text generation lack documentation of validation methodologies and real-world deployment safeguards. The web-text training data excludes toxicity filtering reports, limiting safe commercial adaptation.

XLNet XLNet [98] offers open weights under Apache 2.0 with permutation-based training mechanics documented. The BooksCorpus/Wikipedia/Giga5 dataset mix lacks temporal stratification (pre-2019 cutoff) and copyright compliance verification. Though outperforms BERT on benchmarks, the undisclosed TPU cluster configurations hinder training replication.

RoBERTa RoBERTa [99] uses MIT-licensed weights with improved pretraining techniques over BERT. The CC-News/OpenWebText training data omits geographic source distributions and political bias assessments. While enabling commercial modification, the withheld dynamic masking algorithms limit reproducibility of claimed performance gains.

ELECTRA ELECTRA [100] adopts Apache 2.0 licensing with disclosed discriminative pretraining architecture. BooksCorpus/Wikipedia data lacks accessibility compliance audits for visually impaired users. The 335M parameter model’s efficiency claims are unverifiable due to proprietary Google TPU optimizations.

ALBERT ALBERT [101] provides open weights under Apache 2.0 with parameter reduction techniques detailed. Training data (BooksCorpus/Wikipedia) excludes non-English content percentages and age appropriateness metadata. Cross-layer parameter sharing innovations lack energy consumption metrics for sustainability analysis.

DistilBERT DistilBERT [102] offers Apache 2.0-licensed weights with knowledge distillation methodology documented. The BooksCorpus/Wikipedia dataset omits student-teacher training dynamics and bias propagation audits. Mobile deployment optimizations remain proprietary, hindering edge computing reproducibility.

BigBird BigBird [103] uses Apache 2.0 licensing with sparse attention mechanisms for 4096-token contexts. The PG-19/BooksCorpus training data lacks readability scoring and cultural representation metrics. Though enabling long-sequence processing, the undisclosed block-sparsity patterns limit hardware-specific optimizations. CriticGPT CriticGPT [57] employs undisclosed architecture fine-tuned on human feedback data. Critique generation mechanisms lack adversarial testing protocols and hallucination rate metrics. Proprietary licensing blocks academic access to its harm reduction pipelines.

Olympus Olympus (2000B params) uses fully proprietary training on 40T tokens with no architectural disclosures. The lack of technical reports or dataset composition data prevents independent safety audits. Commercial exclusivity clauses restrict even high-level capability documentation.

HLAT HLAT [58] operates as a 7B parameter black-box model for task-specific applications. Undisclosed training data and optimization objectives hinder reproducibility of "high-performance" claims. No public APIs or research licenses available for evaluation.

Multimodal-CoT Multimodal-CoT [59] uses undisclosed architecture for chain-of-thought reasoning. Training datasets lack modality alignment validation and cross-domain generalization tests. Proprietary access limits academic verification of multimodal benchmark results.

AlexaTM 20B AlexaTM 20B [60] provides encrypted weights for multilingual task-specific applications. Training data composition and cross-lingual transfer methodologies remain Amazon trade secrets. On-device deployment optimizations lack energy consumption metrics.

Chameleon Chameleon [61] employs 34B proprietary weights trained on 9.2T tokens. Multimodal capabilities lack disentanglement metrics between text/image processing pathways. Benchmark scores exclude adversarial robustness testing frameworks.

LIMA LIMA [63] uses 65B proprietary weights with undisclosed "high-performance" fine-tuning. Training data excludes task difficulty stratification and domain shift mitigation reports. No reproducibility kits for claimed efficiency improvements.

BlenderBot 3x BlenderBot 3x [64] operates via API with 150B parameters and 300B token training. Conversational safety guards lack transparency reports on bias propagation rates. Restricted access prevents independent testing of "improved reasoning" claims.

Atlas Atlas [65] uses 11B proprietary weights trained on 40B tokens. Task-specific optimizations omit few-shot adaptation protocols and cross-dataset generalization tests. No architectural blueprints for its retrieval-augmented design.

InCoder InCoder [66] provides API access to 6.7B parameter code generation. GitHub-trained model lacks license compliance checks and vulnerability repair mechanisms. Output stochasticity controls hinder deterministic reproducibility.

4M-21 4M-21 [67] employs 3B proprietary weights with undisclosed "high-performance" architecture. Training data composition and task-specific tuning protocols remain confidential. No third-party benchmarking allowed under licensing terms.

Apple On-Device Apple On-Device model [68] uses 3.04B encrypted weights (1.5T tokens). Edge deployment optimizations lack quantization error analysis and privacy preservation metrics. CoreML integration details remain proprietary.

MM1 MM1 [69] trains 30B proprietary weights on 2.08T multimodal tokens. Cross-modal attention mechanisms lack interpretability frameworks and bias propagation audits. No public access to its "high-performance" image-text alignment.

ReALM-3B ReALM-3B [70] employs 3B proprietary architecture for task-specific applications. The 134B token training corpus lacks domain diversity reports and novelty detection metrics. Energy efficiency claims omit per-inference carbon calculations.

Ferret-UI Ferret-UI [71] uses 13B proprietary weights trained on 2T UI-specific tokens. Interface understanding capabilities lack accessibility compliance testing for disabled users. No open benchmarks for screen reader compatibility.

MGIE MGIE [72] operates via API with 7B proprietary image-editing weights. Training data (2T tokens) lacks artist attribution protocols and copyright infringement safeguards. Output moderation filters remain undocumented.

Ferret Ferret [73] employs 13B proprietary multimodal weights (2T tokens). Cross-domain reasoning lacks verifiable fact-checking pipelines and hallucination suppression metrics. Commercial licenses prohibit adversarial testing.

Nemotron-4 340B Nemotron-4 340B [74] uses proprietary MoE architecture trained on 9T tokens. Multilingual capabilities lack low-resource language quality metrics and dialect coverage reports. Enterprise-only access restricts fairness evaluations.

VIMA VIMA [75] trains 0.2B proprietary weights for multimodal robotics. Sensorimotor integration lacks real-world deployment safety protocols and failure mode analyses. No simulation-to-reality transfer benchmarks published.

Retro 48B Retro 48B [76] employs proprietary retrieval-augmented architecture (1.2T tokens). Knowledge integration lacks source credibility scoring and misinformation filtering. API restrictions block external knowledge base audits.

Raven Raven [77] uses 11B proprietary weights trained on 40B tokens. Task-specific optimizations omit cross-domain generalization tests and adversarial robustness metrics. No reproducibility packages for claimed efficiency gains.

Gemini 1.5 Gemini 1.5 [78] extends proprietary multimodal training to 30T tokens. Architectural innovations like cross-modal routing lack computational complexity disclosures. Enterprise API access prohibits independent latency/accuracy tradeoff analysis.

Med-Gemini-L 1.0 Med-Gemini-L 1.0 [79] trains 1.5T proprietary weights on medical data (30T tokens). HIPAA compliance claims lack third-party audits and patient privacy preservation proofs. Restricted to Google Cloud healthcare API.

Hawk Hawk [80] uses 7B proprietary weights (300B tokens) with undisclosed efficiency optimizations. Training data lacks diversity audits and toxicity propagation metrics. No open benchmarks against equivalent open-source models.

Griffin Griffin [80] scales Hawk to 14B parameters with identical proprietary constraints. Architectural innovations in attention mechanisms lack computational footprint disclosures. Energy efficiency claims omit per-inference Joule measurements.

Gemini 1.5 Pro Gemini 1.5 Pro [78] offers encrypted enterprise access to 1.5T multimodal parameters. Training dataset curation (30T tokens) excludes content moderation workflows and bias mitigation reports. No SDK for local deployment or fairness testing.

PaLi-3 PaLi-3 [82] employs 6B proprietary weights for multimodal tasks. Image-text alignment lacks accessibility features for visually impaired users. Benchmark scores exclude real-world deployment variance analyses.

RT-X RT-X [83] trains 55B robotics-specific weights with undisclosed simulation frameworks. Sensorimotor integration lacks failure mode documentation and safety shutdown protocols. No open-source robot control interfaces.

Med-PaLM M Med-PaLM M [84] uses 540B proprietary weights (780B medical tokens). Diagnostic accuracy claims lack FDA validation and multicenter trial reproducibility. Restricted to Google Research collaborations.

MAI-1 MAI-1 [85] employs 500B proprietary weights trained on 10T tokens. Architectural details and distributed training infrastructure remain confidential. No third-party access for benchmarking against open models.

YOCO YOCO [86] uses 3B proprietary weights (1.6T tokens) with undisclosed efficiency optimizations. Training data lacks novelty detection metrics and duplicate content filters. Latency claims omit hardware-specific acceleration details.

phi-3-medium phi-3-medium [87] provides API access to 14B proprietary STEM weights. The 4.8T token dataset lacks synthetic data validation and error propagation audits. No local deployment options for academic verification.

phi-3-mini phi-3-mini [87] scales down to 3.8B proprietary parameters (3.3T tokens). Quantization optimizations lack bit-error rate analyses and precision degradation metrics. Mobile deployment locks users into Microsoft ONNX runtime.

WizardLM-2-8x22B WizardLM-2-8x22B [88] employs 141B proprietary weights with undocumented "high-performance" tuning. Training data composition and instruction-following protocols remain confidential. No reproducibility kits for claimed reasoning improvements.

WaveCoder-Pro-6.7B WaveCoder-Pro-6.7B [89] uses proprietary 6.7B weights (20B code tokens). Vulnerability repair capabilities lack CVE database alignment and exploit prevention metrics. Restricted to Azure DevOps integrations.

WaveCoder-Ultra-6.7B WaveCoder-Ultra-6.7B [89] shares Pro’s architecture with undisclosed "ultra" optimizations. Code refinement pipelines lack technical debt reduction metrics and API deprecation safeguards. No standalone IDE plugin availability.

WaveCoder-SC-15B WaveCoder-SC-15B [89] scales to 15B proprietary parameters for legacy code modernization. Training data lacks license compatibility checks and architecture migration validations. Enterprise licenses prohibit codebase analysis.

OCRA 2 OCRA 2 [90] employs 7B/13B proprietary weights for task-specific applications. Undisclosed few-shot adaptation protocols and cross-domain generalization tests. No public benchmarks against instruction-tuned open models.

Florence-2 Florence-2 [91] trains proprietary weights on 5.4B visual annotations. Multimodal fusion lacks accessibility features for non-visual interaction modes. Commercial licenses restrict art/medical use cases.

Qwen Qwen [92] uses 72B proprietary weights (3T tokens) with undisclosed Chinese/English balancing. Training data excludes geopolitical bias audits and censorship alignment reports. Limited to Alibaba Cloud API access.

SeaLLM-13b SeaLLM-13b [93] employs 13B proprietary weights (2T multilingual tokens). Southeast Asian language coverage lacks dialect diversity metrics and low-resource support proofs. No community-driven fine-tuning options.

T0 T0 [111] extends T5 with Apache 2.0 weights for zero-shot tasks. The NLP task mixture lacks difficulty calibration and cultural bias assessments. Undisclosed prompt engineering strategies hinder reproducibility.

UL2 UL2 [112] uses Apache 2.0 licensing (20B params) with unified pretraining objectives. Web-text data lacks temporal stratification and misinformation filtering. Denoising mechanisms omit computational overhead disclosures.

GLaM GLaM [113] employs 1.2T proprietary MoE weights with sparse activation. Training data diversity lacks demographic representation metrics and content moderation reports. No public access to its few-shot capabilities.

MT-NLG MT-NLG [96] scales to 530B proprietary parameters with undisclosed tensor parallelism. Training corpus (diverse web text) excludes factuality scoring and hallucination suppression details. Restricted to Azure AI supercomputers.

GShard GShard [126] uses 600B proprietary MoE weights with custom TPU optimizations. Sparse expert routing lacks load balancing documentation and failure recovery protocols. No open benchmarks against dense transformers.

T5-XXL T5-XXL [55] provides Apache 2.0 weights (11B params) for text-to-text tasks. C4 dataset omissions include adult content filters and geographic source diversity. Scaling laws lack energy efficiency comparisons.

ERNIE 3.0 ERNIE 3.0 [114] employs proprietary weights with knowledge-enhanced 10B parameter architecture. Chinese/English training data mixing ratios and entity-linking validation protocols remain undisclosed. Baidu’s API restrictions prevent independent evaluation of multilingual claim robustness.

GPT-NeoX GPT-NeoX [115] provides Apache 2.0-licensed weights with 20B parameter architecture transparency. The Pile dataset’s 825GB composition lacks ethical sourcing guarantees for biomedical/legal content. Distributed training code omissions hinder scaling beyond 8 GPUs despite open design claims.

CodeGen CodeGen [116] uses Apache 2.0 licensing with disclosed 16B parameter code-generation architecture. GitHub-sourced training data excludes vulnerability detection metrics and license compliance audits. Though permitting commercial use, the absent code-repair feedback loops limit secure deployment verification.

FLAN-T5 FLAN-T5 [117] offers Apache 2.0-licensed weights with instruction fine-tuning protocols. The NLP task mixtures lack difficulty stratification and non-English task proportions. Undisclosed few-shot prompting templates hinder reproducibility of claimed generalization improvements.

mT5 mT5 [118] adopts Apache 2.0 licensing with multilingual 13B parameter transparency. The mC4 dataset’s 101-language coverage omits low-resource language quality controls and speaker demographics. Energy consumption disparities across languages remain unmeasured despite sustainability claims.

Reformer Reformer [119] provides Apache 2.0-licensed weights with efficient attention for 64K contexts. Web-text training data lacks NSFW filtering documentation and geographic source diversity. Though enabling long-text processing, the proprietary locality-sensitive hashing implementations limit hardware portability.

Longformer Longformer [120] uses Apache 2.0 licensing with 4096-token attention window specifications. BooksCorpus/Wikipedia training excludes readability adaptations for dyslexic users. Sliding window optimizations remain tied to undisclosed NVIDIA cuDNN kernels, hindering AMD GPU deployments.

DeBERTa DeBERTa [121] offers MIT-licensed weights with disentangled attention mechanics. The BooksCorpus/Wikipedia data lacks gender neutrality scoring and stereotype propagation audits. Though outperforms BERT, the undisclosed dynamic mask ratios prevent fair benchmark comparisons.

T-NLG T-NLG [122] operates under proprietary licensing with undisclosed 17B parameter architecture. Web-text training excludes fact-checking pipelines and misinformation propagation risks. Microsoft’s restricted API prevents adversarial testing of hallucination rates in enterprise deployments.

ProphetNet ProphetNet [127] uses MIT licensing with future token prediction architecture. The BooksCorpus/Wikipedia dataset omits temporal coherence checks and event chronology validation. Though improving sequence modeling, the undisclosed teacher-forcing schedules limit controlled text generation.

DialoGPT DialoGPT [128] provides MIT-licensed weights with 345M parameter conversational architecture. Reddit dialogue data lacks user consent verification and toxicity recurrence metrics. Absent persona consistency guards hinder safe deployment in mental health applications.

BART BART [129] adopts MIT licensing with denoising autoencoder design. BooksCorpus/Wikipedia training excludes accessibility adaptations for screen readers and braille interfaces. Though effective for summarization, the proprietary noise injection algorithms limit reproducibility.

PEGASUS PEGASUS [130] uses Apache 2.0 licensing with gap-sentence generation objectives. The C4 dataset’s summarization suitability lacks expert validation and source credibility scoring. Undisclosed hierarchical attention patterns hinder low-resource language adaptations.

UniLM UniLM [131] offers MIT-licensed weights with unified NLU/NLG pretraining. BooksCorpus/Wikipedia data excludes task difficulty balancing across masked/seq2seq objectives. Though versatile, the undisclosed gradient conflict resolutions limit multi-task reproducibility.

3.3. Synthesis of Findings

Overall, the results of this review highlights a clear pattern that most SoTA multimodal LLMs do not fulfill the holistic, widely accepted criteria of open-source AI. Instead, most of those models follow a partial openness strategy, specifically achieving an open-weight transparency level where the model weights are shared with or without a few subsidiary information, but withholding the full suite of resources including training data, code and processes that OSI-aligned open-source status would demand. This selective transparency helps balance community engagement and commercial interests, albeit at the expense of reproducibility, deeper examination, and broader collaborative innovation.

In the broader context of AI ethics and governance, these practices often lack desired accountability and reproducibility, may raise questions about their reliability and scalability. While open weights can facilitate certain forms of customization and development, the limited visibility into training data and code can perpetuate biases, obstruct robust error analysis, and limit the community’s ability to fully interpret or replicate results.

4. Discussion

4.1. Trends and Implications in AI Development

4.1.1. Geopolitical and Technological Trends

The release of DeepSeek-R1 has underscored the rapid advancement of China in the field of generative AI, marking a significant shift in the global AI landscape. This development challenges the previously held U.S. dominance in AI technologies, particularly in LLMs, as shown by numerous exemples such as ChatGPT, Llama, and underscores the increasing capabilities of Chinese AI models such as Qwen and Kimi. The comparative performance of DeepSeek-R1 and its American counterparts, particularly in areas like video generation, illustrates not only the closing gap between the two geopolitical giants but also highlights different strategic approaches to AI development. While U.S. models have traditionally leaned on extensive computational resources and proprietary data, DeepSeek-R1’s innovation in efficiency, likely necessitated by U.S. chip export controls, demonstrate a viable alternative path that emphasizes algorithmic efficiency and hardware optimization. This approach has significant implications for the global AI arms race, potentially altering the dynamics of technological and economic powers.

Economic Impact and Market Trends

The commoditization of foundation models, as seen with the pricing strategy of DeepSeek-R1, is dramatically reducing the costs associated with LLM usage. This trend is reshaping the economic landscape of AI by making advanced technologies more accessible to a broader range of developers, businesses, and general public. For instance, while OpenAI’s usage costs for models like ChatGPT remain relatively high, DeepSeek’s aggressive pricing strategy undercuts these costs significantly, thereby democratizing access to powerful AI tools. This economic accessibility is likely to spur innovation and enable smaller players to compete more effectively in the AI space, challenging larger firms’ dominance and potentially leading to a surge in AI-driven applications and services.

Implications for Open Weights and Open Source AI Models

The strategic release of DeepSeek-R1 as an open-weights model under a permissive MIT license contrasts sharply with the more restrictive approaches of some U.S.-based companies, which often limit full access to their models’ training data and code. This distinction highlights a growing divergence in the AI development community between fully open-source models like BLOOM and GPT-J, and open-weights models like LLaMA from Meta, which offer some level of accessibility but do not fully embrace open-source principles. The open-weights approach, while facilitating greater collaboration and transparency than completely proprietary models, still falls short of the true open-source ideal that fosters maximum community participation and innovation. The ongoing debate between these approaches will likely intensify as more stakeholders from diverse sectors engage with AI technologies, pushing for standards and practices that align with broader goals of transparency, reproducibility, and ethical responsibility in AI development.

4.2. Discussion on Research Questions

We discuss the findings of our search for each question in this section, presenting the current scenarios and future paths as illustrated in Figure 6.

RQ1: What drives the classification of LLMs as open weights rather than open source, and what impact do these factors have on efficiency and scalability in practical applications?

The classification of LLMs as open weights rather than open source is primarily driven by the selective disclosure of components in the model development process [144,145]. Open-weight models, such as DeepSeek-R1, LLaMA, and Mistral AI, provide access to pre-trained weights and sometimes the model architecture but withhold critical details such as the training data, preprocessing steps, and full training methodologies. This partial transparency is often motivated by competitive advantages, intellectual property protection, and the desire to maintain control over proprietary innovations. For instance, companies like OpenAI and DeepSeek AI release weights under permissive licenses (e.g., MIT or Apache 2.0) to encourage widespread use and fine-tuning while safeguarding their proprietary training processes and datasets. This approach allows them to balance openness with commercial interests, ensuring that their models remain accessible without fully exposing their competitive edge. The impact of this classification on efficiency and scalability in practical applications is multifaceted.

On the one hand, open-weight models enable rapid deployment and customization, as developers can fine-tune pretrained weights for specific tasks without the need for extensive computational resources, training datasets and/or expertise in model training. This flexibility has democratized access to SoTA AI capabilities, allowing smaller organizations and researchers to leverage advanced models like DeepSeek-R1 and LLaMA. On the other hand, the lack of full transparency (aligned with established criteria of open source software) limits the ability to optimize these models for new domains or identify inefficiencies in their architecture. For example, without access to the original training data, developers may struggle to address biases or errors in the model’s outputs, potentially compromising its performance in real-world applications. Additionally, the inability to reproduce the training process hinders scalability, as users cannot fully understand or replicate the conditions under which the model was developed.

The trade-off between accessibility and transparency also raises ethical and operational concerns. While open-weight models provide a pragmatic solution for deploying AI at scale, their partial disclosure complicates efforts to enhance fairness, accountability, and long-term scalability of these models. For instance, the lack of transparency in training data and methodologies can perpetuate biases or errors in the model’s outputs, which may go unnoticed without rigorous investigation. This opacity also limits the ability of users to reproduce results or validate the model’s performance across different contexts, raising concerns about reliability and trustworthiness. As a result, while open-weight LLMs offer significant advantages in terms of accessibility and flexibility, their classification as such poses challenges for ensuring efficiency, scalability, and ethical use in practical applications. Increased openness is waranted to further excellerate the advancement and broader applicability of SoTA LLMs.

RQ2: How do current training methodologies affect the transparency and reproducibility of these models, leading potentially to their classification as open weights? Current training methodologies for LLMs significantly influence their transparency and reproducibility (Refer to Figure 6), contributing to their classification as open weights. One of the primary factors is the lack of access to complete training code and configuration details. While open-weight models like DeepSeek-R1 and LLaMA provide pretrained weights and sometimes the model architecture, they often omit critical information about hyperparameters, optimization techniques, training schedules, and training data used. This omission makes it difficult for researchers and developers to replicate the reported results or understand the nuances of the model’s performance. For example, without access to the full training pipeline, users may struggle to identify the specific conditions under which the model was trained, limiting their ability to reproduce or validate its results. Another key issue is the limited disclosure of data processing procedures and pretraining datasets. Even when the general composition of the training data is revealed, specific details about preprocessing steps, data augmentation techniques, and quality control measures are often withheld. This lack of transparency prevents users from fully reproducing benchmark evaluations or assessing the model’s behavior in different contexts. For instance, without knowing how the training data was curated or cleaned, it becomes challenging to identify potential sources of bias or error in the model’s outputs. This opacity not only hinders reproducibility but also raises ethical concerns, as users may unknowingly deploy models with hidden flaws or biases.

The trend toward releasing only final weights and architecture details reflects a broader shift in the AI community, where the emphasis on rapid innovation often comes at the expense of transparency. Many recent LLMs fall into a spectrum of openness, where they are neither fully open-source nor entirely closed. This middle ground allows developers to share their work with the broader community while retaining control over proprietary aspects of the model. However, it also creates a trade-off between accessibility and accountability. As a result, the classification of these models as open weights is both a reflection of current training practices and a response to the growing complexity of LLM development, where full transparency is often seen as impractical or undesirable.

RQ3: How does the limited disclosure of training data and methodologies affect both the performance and practical usability of these models, and what future implications arise for developers and end users? The limited disclosure of training data and methodologies in open-weight LLMs has profound implications for their performance and practical applications. By withholding details about the training process, developers create a barrier to understanding how these models achieve their results. This lack of transparency makes it difficult to assess the model’s strengths and limitations, particularly in high-stakes applications where reliability and fairness are critical. For example, without access to the original training data, users cannot evaluate whether the model has been exposed to diverse and representative datasets, which is essential for ensuring equitable outcomes. Similarly, the absence of detailed methodologies hinders efforts to identify and mitigate biases, as users lack the information needed to trace the origins of problematic behaviors. The designation of these models as open weights also has significant implications for their operationalization.

On the one hand, the availability of pre-trained weights allows developers to quickly deploy advanced AI capabilities without investing in costly training processes. This accessibility has democratized AI development, enabling smaller organizations and individual researchers to leverage SoTA models. On the other hand, the lack of transparency surrounding training data and methodologies complicates efforts to fine-tune and adapt these models for specific use cases. For instance, without visibility into the original pre-training data, developers may inadvertently introduce data leakage or overfitting in downstream tasks, undermining the model’s performance.

4.3. Sustainability and Ethical Responsibility in AI Development

The sustainability of these LLMs and their environmental impact is becoming an increasingly critical component of ethical AI development. The transparency in reporting CO₂ emissions during the training of these models is not just a matter of environmental concern but also reflects the broader ethical stance of the organizations developing these technologies. For example, GPT-3 is estimated to emit around 500 metric tons of CO₂ [146]. That is roughly the same amount of carbon that would take over 23,000 mature trees an entire year to absorb. As AI systems scale, ethical accountability in energy consumption and carbon impact must be prioritized. Table 6 presents a comparative analysis of carbon emissions from various LLMs, highlighting the environmental burden of scaling AI systems.

4.4. Synthesis and Future Directions

Looking to the future as depicted in Figure 6 and, as LLMs increasingly permeate critical systems in all sectors and industries, the limited disclosure of their training data and methodologies necessitates enhanced frameworks for transparency and accountability. The development of parameter-normalized and task-agnostic evaluation frameworks could enable more equitable comparisons between open and closed-source models, assisting stakeholders in making informed decisions about their applicability to specific tasks or issues. Additionally, stringent data governance and compliance measures are crucial to ensure that LLMs adhere to ethical and legal standards during training and deployment. Addressing these challenges will require a collaborative, unified effort from the global AI community, including researchers, developers, and policymakers. By collectively establishing and following best practices for transparency, reproducibility, and responsible AI development, the field can advance toward a future that upholds both innovation and ethical integrity.

5. Conclusions

This case investigation underscores the critical distinction between open weights and open source in the context of SoTA LLMs like DeepSeek-R1, ChatGPT, LLaMa, Grok and Phi-series. Although these models grant access to pre-trained weights under relatively permissive licenses, the lack of full discloser of training data, methodologies, and comprehensive development processes makes them fall short of truely open source models, and are categorized as open weights. This approach, primarily driven by competitive advantages and proprietary interests, significantly affects their applicability, scalability, and reproducibility across various practical settings. This approach could be argued as a good balance to protect some commercial interest of the companies and organizations who invest huge resources in developing these models, and to encourage continued private investment for further advancement of the technology. However, the constrained transparency restricts the ability of developers and researchers to perform thorough evaluations, effectively mitigate biases, and adapt these models to specific domains, which introduces substantial ethical and operational dilemmas. It is noted that sometimes these models with open access to pre-trained weights have been referred to as open source models, which is inaccurate or misleading. Looking ahead, it is imperative for the AI community to develop and adopt frameworks that promote greater transparency (including truly open source releases), reproducibility, and accountability. Enhancing these aspects in open-weight models is crucial to ensure they meet ethical standards and effectively serve user needs. Addressing these challenges will be the key to achieving an equilibrium between fostering innovation and upholding responsibility, ultimately enhancing trust and facilitating more collaborative advancements in AI development.