Can We Build AI Without OpenAI? A LEGIBUS Case Study

A field report on building a sovereign legal AI without dependency on OpenAI, through the LEGIBUS project.

A recurring question

Since the explosion of large language models, one question keeps coming up in the projects I lead:

Can we build artificial intelligence without OpenAI?

Behind this question lies another one:

Can we build high-performance AI systems without depending on an external API?

With the LEGIBUS project, this is precisely the question we had to address from day one.

The natural reflex: use OpenAI

In most AI projects today, the path is very standard:

  • pick a model via an API;
  • integrate quickly;
  • get immediate results;
  • feel like it’s simple.

Solutions like OpenAI do allow you to get started very fast.

For many use cases, it’s even the best option at first.

But as soon as you talk about sensitive data, sovereignty, or regulatory constraints, the nature of the question completely changes.

LEGIBUS: a sensitive use case by nature

In LEGIBUS, we are building an AI assistant for French legal professionals.

This implies several strong constraints:

  • client data confidentiality;
  • sovereignty requirement;
  • traceability of responses;
  • control of the infrastructure;
  • GDPR compliance.

In this context, sending legal data to an external API is not a neutral option.

It is not just a technical question.

It is a question of responsibility.

Building without OpenAI: what it really means

Building AI without OpenAI does not mean “not using an LLM.”

It rather means:

  • not depending on a single vendor;
  • mastering the models used;
  • controlling the hosting;
  • keeping control of the data;
  • accepting greater complexity.

Concretely, this often implies an architecture based on:

  • open-source models;
  • local or private deployment;
  • RAG pipelines;
  • controlled infrastructure.

Alternative technical building blocks

In the case of LEGIBUS, we explored and integrated several open-source and self-hosted building blocks:

  • open-source models (depending on use cases);
  • document retrieval systems (RAG);
  • vectorization and embeddings;
  • internal knowledge bases;
  • orchestration via internal APIs;
  • containerized infrastructure.

The goal is not to “reinvent OpenAI.”

The goal is to rebuild a complete chain, mastered end-to-end.

The real cost of sovereignty

Moving away from dependency on an API like OpenAI has a real cost.

This cost is not only financial.

It is mainly organizational and technical:

  • infrastructure management;
  • model updates;
  • performance optimization;
  • monitoring and observability;
  • deployment complexity;
  • ongoing maintenance.

The common illusion is to think that “open source = free.”

In reality, the cost is simply shifted.

What you gain in return

In exchange, several advantages become decisive in certain contexts:

  • total control of the data;
  • independence from a vendor;
  • ability to adapt the models;
  • control over latency and hosting;
  • alignment with strong regulatory constraints.

In projects like LEGIBUS, these elements are not optional.

They are structural.

OpenAI is not the enemy

It would be wrong to frame this as OpenAI versus sovereign solutions.

In reality:

  • OpenAI is often unbeatable for prototyping;
  • closed models are often very performant;
  • the API ecosystem is mature and fast to integrate.

So the real question is not “for or against OpenAI.”

The real question is:

At what point does dependency become a problem?

Hybrid architecture: the most realistic answer

In most serious projects, the answer is not binary.

We tend to move toward hybrid architectures:

  • some processing via external APIs;
  • others locally;
  • segmentation of sensitive data;
  • model choice based on criticality level.

It is often in this compromise that the most pragmatic solution lies.

Conclusion

Building artificial intelligence without OpenAI is possible.

But it is not a simple technical choice.

It is a choice of architecture, governance, and responsibility.

With LEGIBUS, we chose control and sovereignty, at the cost of higher complexity, but with total control over the data and uses.

And in the end, the real question may not be:

“Can we do AI without OpenAI?”

But rather:

“In which cases do we accept not controlling what our artificial intelligence actually does?”

← Back to blog