European Open Source AI Index: Measuring True AI Openness
4 min read

European Open Source AI Index: Measuring True AI Openness

782 words

Lately I’m seeing more and more AI models calling themselves “open source”. Llama, Mistral, Falcon… they all claim to be “open”. But are they really? How open are they actually?

I recently discovered the European Open Source AI Index (OSAI), a European initiative doing excellent work systematically evaluating how open generative AI models really are.

What is the OSAI Index?

The OSAI Index is a community-driven public resource hosted at Radboud University (Netherlands). Its mission is simple but important: to evaluate the real openness of generative AI models (text, images, code, video, and audio) beyond the marketing.

What’s interesting is that it’s not a subjective opinion. They have a 14-parameter evaluation system that measures different aspects of a model’s openness.

The 14 Evaluation Parameters

What I like most about OSAI is that their evaluation is very detailed. It’s not just a simple “yes/no”. They analyze:

  1. Base Model Data - Are training datasources documented and available?
  2. End User Model Data - Same for the model the user interacts with?
  3. Base Model Weights - Are the weights freely available?
  4. End User Model Weights - And for the user model?
  5. Training Code - Is all pipeline code available?
  6. Code Documentation - Is it well documented?
  7. Hardware Architecture - What hardware was used for training?
  8. Preprint - Are there technical preprints available?
  9. Paper - Any peer-reviewed scientific publications?
  10. Modelcard - Standardized model documentation?
  11. Datasheet - Datasheet following Gebru et al. standard?
  12. Package - Packaged for easy installation (PyPI, etc.)?
  13. API and Meta Prompts - Unrestricted API available?
  14. Licenses - OSI-approved licenses for EVERYTHING (data, code, weights)?

The “Openwashing” Problem

This is where the OSAI Index really shines. They identify what they call “openwashing”: when a model is marketed as “open source” but doesn’t meet real open source standards.

A very recent example: Lumo, Proton’s AI assistant. OSAI analyzed it and classified it as “the least open ‘open’ model we’ve ever evaluated”.

So it was sold as open but was actually almost as closed as any traditional proprietary solution.

Why This Matters for Us as Developers

I think this is important for several reasons:

Technical Transparency

When you choose a model for a project, you need to know:

  • Can I inspect how it works?
  • Can I audit training data?
  • Can I modify and redistribute it?
  • What legal restrictions do I have?

Independence

If the model isn’t truly open:

  • You depend on the provider for changes
  • You can’t audit behavior
  • You can’t self-host
  • You’re tied to their terms of service

Regulatory Compliance

With the EU AI Act and other regulations, you need models you can audit. Real open source gives you control; “openwashing” gives you false security.

The Ranking: Truly Open Models

According to the OSAI Index, the most open models currently include:

  • OLMo (Ai2) - Very highly rated for openness
  • BLOOMZ (BigScience Workshop)
  • Pythia (EleutherAI)
  • OpenLLaMA
  • SmolLM (HuggingFace)

And curiously, very popular models like Llama (Meta) or Mistral don’t fare as well when evaluating all 14 parameters. Yes, they release the weights, but many things are missing: training code, data, complete documentation…

My Personal Opinion

I’ve been following the open source world for years, and I believe transparency matters especially in AI.

With traditional software, if it’s not open source, you can at least read the spec, understand the API, use it. With AI, the model is an opaque block: you don’t know what it learned, nor how, nor what biases it has.

If a model claims to be “open source” but:

  • Doesn’t share training data
  • Doesn’t document the hardware used
  • Doesn’t allow real redistribution
  • Uses licenses with hidden restrictions

…then it’s not open source. It’s “openwashing”.

How to Use the OSAI Index

My recommendation is simple: before choosing a model for a serious project, check the OSAI Index.

The process:

  1. Go to osai-index.eu
  2. Filter by type (text, image, code…)
  3. Compare models you’re interested in
  4. Review the 14 parameters
  5. Make an informed decision

For example, if you’re evaluating between three language models:

  • Check if they have proper modelcards
  • Verify if licenses are OSI-approved
  • Look for peer-reviewed papers
  • Check if you can audit the training

Conclusion

The European Open Source AI Index is a necessary and timely tool.

In a world where everyone claims to be “open”, you need an objective evaluation. OSAI’s 14 parameters give you exactly that: a way to distinguish marketing from reality.

For us developers and system architects, this means we can make more informed decisions about which models to use, how to deploy them, and what risks we’re taking.

And that, at the end of the day, is what matters: real transparency, not marketing slogans.


Resources:

Comments

Latest Posts

2 min

349 words

A few days ago I came across an article that literally left me with my mouth open. It’s about TinyEMU-Go: a RISC-V emulator written entirely in Go, ported from C using Claude. And the best part: you can run a complete Linux with a single command.

The Command Line That Gave Me Envy

go run github.com/jtolio/tinyemu-go/temubox/example@2c8151233c2d

And boom, you have a complete Linux running. No special permissions, no containers, no weird dependencies. A pure static Go binary.

5 min

1020 words

I have been using Claude Code daily for months, and there is one configuration that has completely changed how it works with my code. It is not a new plugin, a more powerful model, or a magic prompt. It is something that has existed since 2016 and that most developers use without knowing it every time they open VS Code: the Language Server Protocol (LSP).

Karan Bansal published an excellent article explaining in detail how to enable LSP in Claude Code and why it matters. After trying it, I can confirm the difference is real and significant.

3 min

591 words

Greg Brockman, President and Co-Founder of OpenAI, recently published a thread that perfectly describes the moment we’re living in software development. According to him, we’re witnessing a genuine renaissance in software development, driven by AI tools that have improved exponentially since December.

The qualitative leap

The most striking part of Brockman’s thread is how they describe the internal change at OpenAI: engineers who previously used Codex for unit tests now see the tool writing practically all code and handling a large portion of operations and debugging. This isn’t an incremental improvement, it’s a paradigm shift.

7 min

1438 words

A few days ago I discovered Agent Lightning, a Microsoft project that I believe marks a before and after in how we think about AI agent orchestration. It’s not just another library; it’s a serious attempt to standardize how we build multi-agent systems.

What is Agent Lightning?

Agent Lightning is a Microsoft framework for orchestrating AI agents. It enables composition, integration, and deployment of multi-agent systems in a modular and scalable way. The premise is simple but powerful: agents should be components that can be combined, connected, and reused.

9 min

1747 words

If you’re using tools like Claude Code, GitHub Copilot Workspace, or similar, you’ve probably noticed there’s technical jargon that goes beyond simply “chatting with AI”. I’m talking about terms like rules, commands, skills, MCP, and hooks.

These concepts are the architecture that makes AI agents truly useful for software development. They’re not just fancy marketing words — each one serves a specific function in how the agent works.

Let’s break them down one by one in a clear way.

3 min

609 words

Recently, Addy Osmani published an article that gave me much to think about: “Self-Improving Coding Agents”. The idea is simple but powerful: agents that not only execute tasks, but improve their own performance over time.

This isn’t science fiction. It’s happening now, in 2026. And it has profound implications for the future of software development and, by extension, for all professions.

What is a Self-Improving Agent?

A self-improving agent is an AI system with the capacity to: