Abstract
Open-source artificial intelligence represents one of the most important technological developments in modern computing. It changes how artificial intelligence is researched, developed, distributed, audited, modified, commercialised, and secured. Unlike a conventional proprietary AI system, whose source code, model parameters, training processes, or infrastructure may remain under the control of a single organisation, open AI ecosystems can distribute important components to researchers, developers, companies, universities, governments, and individuals.
However, open-source AI is not simply “an AI model whose code is available.” Its anatomy is considerably more complex. A modern AI system consists of multiple layers: data, datasets, algorithms, source code, model architecture, parameters, weights, training infrastructure, optimisation methods, evaluation systems, inference software, applications, documentation, and licensing. Each layer can have a different degree of openness.
This thesis examines the scientific and technological anatomy of open-source AI, with particular attention to MIT licensing, model weights, datasets, software dependencies, security, intellectual property, reproducibility, commercialisation, governance, and responsible AI development. It also establishes a framework for distinguishing genuinely open AI systems from systems that are merely open-weight, source-available, research-only, or otherwise restricted.
1. Introduction: The Emergence of Open AI
Artificial intelligence has evolved from academic experimentation into a global technological infrastructure.
The development of modern AI has involved:
- mathematics;
- statistics;
- computer science;
- neuroscience-inspired computing;
- semiconductor technology;
- cloud computing;
- distributed systems;
- enormous datasets;
- machine-learning algorithms;
- specialised processors;
- neural-network architectures; and
- increasingly sophisticated software ecosystems.
Historically, much AI research was conducted within universities and publicly funded laboratories. Later, commercial organisations increasingly developed proprietary models and computing infrastructure.
The open-source movement introduced another development model: collaborative technological construction.
Instead of a single organisation controlling every component, open development allows different participants to contribute:
researchers → algorithms → programmers → datasets → models → tools → applications → communities.
This creates an ecosystem in which knowledge can propagate rapidly.
2. Defining Open-Source AI
The expression open-source AI needs careful scientific definition.
Traditional open-source software generally refers to software whose licensing permits users to access, study, modify, and redistribute the source code under specified conditions.
AI introduces additional layers that do not exist in ordinary software.
An AI system may contain:
- source code;
- model architecture;
- training data;
- trained parameters;
- model weights;
- evaluation datasets;
- training procedures;
- inference code;
- documentation;
- hardware requirements;
- deployment infrastructure.
Consequently, an AI system can be open in one dimension and closed in another.
3. The Open AI Spectrum
A useful scientific framework is to consider openness as a spectrum.
| Category | Code | Weights | Data | Modification | Commercial use |
|---|---|---|---|---|---|
| Fully open system | Open | Open | Potentially open | Generally permitted by license | Depending on license |
| Open-weight model | Sometimes open | Open | Usually unavailable | License dependent | License dependent |
| Source-available model | Open/available | Variable | Usually closed | Restricted | Often restricted |
| Research model | Available | Available | Usually restricted | Limited | Often restricted |
| Proprietary model | Closed | Closed | Closed | Controlled by owner | Contractual |
This distinction is fundamental.
Open weights do not automatically mean open source.
Similarly:
open source code does not automatically mean reproducible AI.
4. The Anatomy of an AI System
A modern AI system can be represented as a technological stack:
AI APPLICATION
│
▼
USER INTERFACE
│
▼
AI AGENT / APPLICATION
│
▼
INFERENCE ENGINE
│
▼
MODEL WEIGHTS
│
▼
MODEL ARCHITECTURE
│
▼
TRAINING ALGORITHMS
│
▼
DATASETS
│
▼
COMPUTING HARDWARE
│
▼
ENERGY + DATA CENTRES
This stack demonstrates that an AI model is not an isolated piece of software.
It is a computational ecosystem.
5. Layer One: Data
Data is the raw material from which machine-learning systems learn patterns.
Depending on the application, training data may include:
- text;
- images;
- audio;
- video;
- scientific measurements;
- financial information;
- sensor data;
- programming code;
- mathematical problems;
- biological information;
- geographic information.
The quality of the data strongly influences the quality of the resulting model.
A simplified relationship is:
Data → Learning → Parameters → Model Behaviour
Poor-quality data can introduce:
- errors;
- duplication;
- bias;
- misinformation;
- unwanted correlations;
- security vulnerabilities.
6. Layer Two: Datasets
Raw information becomes a dataset after being collected, organised, filtered, labelled, transformed, or otherwise prepared for machine learning.
Dataset engineering can involve:
- collection;
- cleaning;
- deduplication;
- classification;
- filtering;
- tokenisation;
- annotation;
- quality assessment;
- formatting;
- version control.
The dataset therefore becomes an important intellectual and technological asset.
One of the major challenges for open AI is that the model may be openly distributed while the complete training dataset cannot legally or practically be distributed.
7. Layer Three: Algorithms
Algorithms define how a machine-learning system learns.
Modern AI relies heavily on mathematical optimisation.
A simplified training process can be represented as:
[
\theta_{t+1}=\theta_t-\eta\nabla_\theta L(\theta)
]
where:
- (\theta) represents model parameters;
- (\eta) represents the learning rate;
- (L) represents the loss function;
- (\nabla_\theta L) represents the gradient.
Repeated optimisation modifies the parameters so that the model progressively improves its ability to represent patterns in its training data.
8. Layer Four: Model Architecture
Architecture determines how computational components are organised.
Modern large language models frequently use Transformer-based architectures.
A simplified Transformer pipeline is:
Input
↓
Tokenisation
↓
Embedding
↓
Attention
↓
Feed-Forward Networks
↓
Repeated Transformer Layers
↓
Output Representation
↓
Prediction
The architecture defines how information is transformed through the network.
Important architectural concepts include:
- attention;
- self-attention;
- embeddings;
- positional information;
- feed-forward layers;
- normalisation;
- residual connections;
- output heads.
9. Layer Five: Parameters and Weights
A trained AI model contains numerical parameters.
These parameters encode learned statistical relationships.
A simplified neural network can be represented as:
[
y=f(Wx+b)
]
where:
- (x) is the input;
- (W) represents learned weights;
- (b) represents biases;
- (f) represents an activation or transformation;
- (y) represents the resulting output.
For large AI models, the number of parameters can reach billions or more.
The weights are therefore one of the most valuable components of a modern AI model.
10. Open Weights
When a model’s trained weights are publicly distributed, developers may be able to download and run the model locally.
This creates important advantages:
- local inference;
- research;
- independent evaluation;
- customisation;
- fine-tuning;
- reduced dependence on an API provider;
- deployment in private environments.
However, open weights alone do not necessarily provide:
- the original training dataset;
- complete training code;
- exact training infrastructure;
- complete reproducibility;
- unrestricted commercial rights.
Therefore, open weights should be treated as one layer of openness, not the definition of openness itself.
11. Layer Six: Training Infrastructure
Training large AI models requires substantial computational infrastructure.
A simplified training environment contains:
DATA
│
▼
DATA PIPELINES
│
▼
CPU / GPU / AI ACCELERATORS
│
▼
HIGH-SPEED NETWORK
│
▼
DISTRIBUTED TRAINING
│
▼
MODEL CHECKPOINTS
│
▼
EVALUATION
Large-scale training may involve:
- GPUs;
- AI accelerators;
- high-bandwidth memory;
- storage systems;
- networking;
- cooling;
- electricity;
- distributed computing software.
Thus, open AI remains connected to the physical semiconductor and data-centre industries.
12. Layer Seven: Inference
Training and inference are different computational processes.
Training
The model learns parameters.
Inference
The trained model generates an output from new input.
Simplified:
[
Input \rightarrow Model \rightarrow Prediction
]
Inference can occur:
- in a cloud data centre;
- on a workstation;
- on a server;
- on an edge device;
- on a mobile device;
- potentially on specialised embedded hardware.
Open-weight models have made local inference increasingly important.
13. MIT Licensing
The MIT License is a permissive software licence widely associated with open-source software.
Its general characteristics include permission to:
- use the software;
- copy it;
- modify it;
- merge it with other software;
- publish it;
- distribute it;
- sublicense it;
- use it commercially.
The licence also contains important conditions, including preservation of the copyright and licence notice.
The MIT licence includes a broad disclaimer of warranty and limitation of liability.
However, a critical distinction must be made:
An MIT licence applied to software code does not automatically make the model weights, training data, or other AI components MIT-licensed.
Each component must be examined separately.
14. The MIT Licence and AI Models
Consider a hypothetical AI project:
Project
│
├── Source code → MIT
├── Training dataset → CC BY-NC
├── Model weights → Custom licence
├── Documentation → Apache-2.0
└── Dependencies → Various licences
Calling the entire system “MIT licensed” would therefore be misleading.
A serious analysis must identify the licence attached to each component.
15. Licensing Anatomy
The licensing structure of an AI project can be represented as:
[
AI\ License =
Code + Data + Weights + Documentation + Dependencies
]
Each component may have different legal conditions.
Important licence questions include:
- Can the model be modified?
- Can it be redistributed?
- Can it be used commercially?
- Must attribution be retained?
- Are derivatives permitted?
- Are there usage restrictions?
- Are model outputs subject to special terms?
- Are third-party components included?
16. Copyright and AI
AI introduces difficult questions concerning intellectual property.
Several separate issues must be distinguished:
A. Copyright in software
The source code may be copyrighted.
B. Copyright in training material
Training datasets may contain copyrighted material.
C. Copyright in model parameters
The legal status of trained parameters can vary depending on jurisdiction and circumstances.
D. Copyright in outputs
The legal status of generated outputs can depend on the jurisdiction, human contribution, applicable law, and other circumstances.
Therefore, technical openness does not eliminate intellectual-property questions.
17. Open-Source AI Security
Security is one of the most important dimensions of open AI.
Open distribution provides benefits for security research because researchers can inspect and test systems.
However, public availability can also increase the number of people capable of examining or modifying a model.
Important security categories include:
- data poisoning;
- model poisoning;
- malicious code;
- compromised dependencies;
- supply-chain attacks;
- model extraction;
- adversarial inputs;
- prompt injection;
- credential leakage;
- insecure deployment;
- malicious model modifications.
18. AI Supply-Chain Security
An AI model is increasingly similar to a software supply chain.
Dataset
↓
Preprocessing
↓
Training Code
↓
Libraries
↓
Framework
↓
Model
↓
Weights
↓
Inference Engine
↓
Application
↓
User
A vulnerability introduced at any stage can propagate downstream.
This means AI security cannot focus exclusively on the model itself.
19. Dataset Poisoning
Dataset poisoning occurs when malicious or inappropriate information is deliberately introduced into training data with the intention of influencing model behaviour.
Conceptually:
[
Clean\ Dataset + Malicious\ Data
\rightarrow
Altered\ Training\ Outcome
]
Strong dataset governance therefore requires:
- provenance;
- validation;
- version control;
- integrity checking;
- anomaly detection;
- access control;
- reproducible pipelines.
20. Model Integrity
Model weights should be treated as valuable software artefacts.
Important security mechanisms include:
- cryptographic hashes;
- digital signatures;
- trusted repositories;
- version control;
- provenance records;
- controlled distribution;
- reproducible builds where feasible.
A user should be able to determine:
Where did this model come from, which version is it, and has it been modified?
21. Dependency Security
Open AI systems frequently depend on large software ecosystems.
Examples include:
- operating systems;
- programming languages;
- machine-learning frameworks;
- numerical libraries;
- GPU drivers;
- container systems;
- inference engines;
- authentication systems;
- databases.
A vulnerable dependency can compromise an otherwise secure AI application.
This creates an important principle:
The security of an AI system is constrained by the security of its surrounding software supply chain.
22. Reproducibility
Scientific AI research depends heavily on reproducibility.
A highly reproducible model should ideally provide information about:
- architecture;
- training methodology;
- datasets;
- preprocessing;
- hyperparameters;
- optimisation;
- evaluation;
- hardware;
- software versions.
A useful conceptual model is:
[
Reproducibility =
Data + Code + Architecture + Parameters + Environment
]
The more components that are hidden, the harder independent reproduction becomes.
23. Evaluation of Open AI Models
Open AI models require systematic evaluation.
Evaluation can measure:
Capability
- reasoning;
- language understanding;
- coding;
- mathematics;
- scientific tasks.
Reliability
- factual accuracy;
- consistency;
- robustness.
Safety
- harmful-content resistance;
- prompt-injection resistance;
- privacy behaviour.
Efficiency
- latency;
- memory usage;
- energy consumption;
- computational cost.
24. Open AI and Scientific Research
Open models can accelerate scientific progress by allowing researchers to:
- inspect architectures;
- reproduce experiments;
- fine-tune models;
- conduct independent evaluations;
- develop new applications;
- compare methodologies.
This is particularly valuable in universities and research institutions where independent verification is central to scientific practice.
25. Open AI and Education
Open AI can become a major educational technology.
Students can learn:
- machine learning;
- mathematics;
- programming;
- neural networks;
- data engineering;
- AI security;
- model deployment.
Instead of merely interacting with an AI system through an interface, learners can potentially study the underlying technology.
26. Open AI and Developing Economies
Open AI has particular significance for countries that may not have the financial resources to build frontier proprietary AI infrastructure.
Open models can reduce certain barriers to:
- experimentation;
- education;
- local-language AI;
- research;
- entrepreneurship;
- public-sector applications;
- small-business software.
However, openness does not eliminate infrastructure requirements.
Countries still require:
- computing capacity;
- electricity;
- telecommunications;
- skilled researchers;
- data;
- cybersecurity;
- financing.
27. Economic Anatomy of Open AI
Open AI creates a different economic model from traditional proprietary software.
Instead of monetising only access to a closed product, companies can build businesses around:
- hosting;
- cloud inference;
- fine-tuning;
- consulting;
- enterprise integration;
- specialised applications;
- support;
- cybersecurity;
- data services;
- hardware;
- developer platforms.
Thus:
[
Open\ Model \neq Free\ Business
]
A model may be freely available while substantial commercial opportunities exist around it.
28. Open Source vs. Proprietary AI
| Dimension | Open AI | Proprietary AI |
|---|---|---|
| Source availability | Often greater | Usually restricted |
| Model weights | May be available | Usually closed |
| Modification | Often possible | Controlled |
| Independent auditing | Potentially greater | More limited |
| Infrastructure | Can be self-hosted | Usually provider-controlled |
| Commercial model | Diverse | Provider-centred |
| Transparency | Potentially higher | Often lower |
| Security | Inspectable but modifiable | Centralised control |
Neither model is automatically superior in every circumstance.
The correct choice depends on the application’s requirements.
29. The Security–Openness Relationship
There is an important technological tension:
[
More\ Openness
\rightarrow
More\ Transparency
]
but potentially:
[
More\ Openness
\rightarrow
More\ Access\ to\ Technology
]
Therefore, responsible open AI requires security engineering rather than simply restricting access.
A mature ecosystem should combine:
openness + auditing + provenance + responsible licensing + security + evaluation.
30. Governance
Open AI requires governance at several levels:
Technical governance
- model evaluation;
- security;
- versioning;
- access controls.
Organisational governance
- responsibility;
- documentation;
- incident response;
- quality management.
Legal governance
- licences;
- copyright;
- privacy;
- liability;
- regulatory compliance.
Social governance
- fairness;
- accessibility;
- transparency;
- accountability.
31. The Open AI Development Lifecycle
A complete lifecycle can be represented as:
Research
↓
Data Collection
↓
Data Preparation
↓
Architecture Design
↓
Training
↓
Evaluation
↓
Security Testing
↓
Licensing
↓
Release
↓
Community Development
↓
Monitoring
↓
Version Updates
↓
Retirement
Open AI is therefore not simply a model release event.
It is a continuous technological lifecycle.
32. A Scientific Framework for Measuring Openness
A useful future framework could assign openness across several dimensions:
[
O = f(C,D,W,T,A,L,S)
]
where:
- (C) = code openness;
- (D) = data openness;
- (W) = weights openness;
- (T) = training transparency;
- (A) = architecture transparency;
- (L) = licensing freedom;
- (S) = security/provenance transparency.
This does not produce a universal legal definition, but it provides a useful analytical framework.
33. What Makes an AI System Truly Open?
A highly open AI ecosystem would ideally provide:
- accessible source code;
- transparent architecture;
- accessible model weights;
- detailed documentation;
- clear licensing;
- dataset information;
- training methodology;
- evaluation results;
- provenance;
- reproducible tooling;
- security information.
The closer a system comes to exposing these layers, the more meaningful the term open AI becomes.
34. The Future of Open-Source AI
The future is likely to involve increasingly distributed AI ecosystems.
AI development may move from:
centralised model providers
toward:
global networks of models, developers, researchers, hardware providers, applications, and communities.
Future open AI development may involve:
- smaller specialised models;
- multimodal systems;
- local AI;
- edge AI;
- AI agents;
- scientific models;
- robotics;
- sovereign AI infrastructure;
- multilingual systems;
- domain-specific models.
35. The Open AI Ecosystem of the Future
A mature open AI ecosystem can be visualised as:
HUMAN KNOWLEDGE
│
▼
DATA
│
▼
DATASETS
│
▼
ALGORITHMS
│
▼
AI ARCHITECTURE
│
▼
MODEL WEIGHTS
│
┌─────────────┴─────────────┐
▼ ▼
LOCAL AI CLOUD AI
│ │
└─────────────┬─────────────┘
▼
AI AGENTS
│
▼
APPLICATIONS
│
▼
SOCIETY
This illustrates the ultimate importance of open AI: it is not merely a software distribution philosophy. It is becoming an alternative architecture for organising technological knowledge and computational capability.
36. Conclusion
The anatomy of open-source AI extends far beyond the source code of a neural network.
It encompasses an entire technological chain:
data → datasets → algorithms → architecture → parameters → weights → training infrastructure → inference → applications → licensing → security → governance.
The MIT License is an important part of this ecosystem because its permissive nature can facilitate software reuse, modification, distribution, and commercial development. Nevertheless, the presence of an MIT licence on one component does not automatically mean that every component of an AI system is open or MIT licensed.
The most important conceptual distinction is therefore:
Open-source AI should be analysed as a layered ecosystem rather than a single software object.
Its greatest scientific value comes from transparency and reproducibility. Its greatest economic value comes from enabling innovation on top of shared technological foundations. Its greatest social value comes from broadening access to advanced computational capabilities. Its greatest challenge is ensuring that openness is accompanied by security, responsible governance, intellectual-property clarity, scientific integrity, and appropriate risk management.
Ultimately, the evolution of open-source AI represents a transition from AI as a closed technological product toward AI as a shared technological ecosystem—one in which researchers, developers, businesses, educational institutions, governments, and communities can participate in building the next generation of computational intelligence.







Be First to Comment