Sovereign AI is the Next Stack. Here's What We Built.

Most teams building "AI products" today are gluing wrappers around someone else's API and calling it a moat.

We at RiNET took a different bet: build the whole stack ourselves, end to end, in Europe, and own every layer that matters.

It works. Here's how.

(Spoiler: no GPT. No Anthropic. No "we'll just integrate with OpenAI." Three Hetzner servers in Germany, an obscene amount of PostgreSQL, and a quiet conviction that the AI era will belong to the people who actually know what's underneath them.)

The Sovereign Stack

RiNET runs on what we call The Sovereign Stack — an autonomous AI operating system we built from first principles, in production, today.

Cognition layer (GPU server, DE). Open-weight LLMs: Qwen, Llama variants. LoRA fine-tunes trained on our own domain corpora. Embedding models on disk. A reranker pool. An agent orchestrator that routes between them based on intent, budget, and quality. Every inference runs on metal we own. Cost: deterministic. Latency: predictable. Vendor lock: zero.

Memory layer (data server, DE). PostgreSQL as the source of truth — forty-something schemas, hundreds of tables, real institutional knowledge under transactional integrity. Qdrant for vectors. Neo4j for the graph. Redis for cache. Meilisearch for full-text. MinIO for objects. WAL streaming, PITR, offsite replication. Code is rebuildable. Memory is not. Plan accordingly.

Surface layer (front server, DE). APIs, frontends, agent dashboards. A JARVIS-style command palette to drive the system. Iron Man wishes.

Autonomic layer (everywhere). A fleet of background agents in tmux swarms. Self-monitoring. Self-healing. Self-evolving. Daily LoRA fine-tunes on accumulated interaction data. Watchdogs that detect drift and restart services. A learner that closes the loop: question, answer, ground truth, updated knowledge. AI that builds AI — not as a marketing slogan, but as actual systemd units running tonight.

This isn't a thought experiment. It's in production. It serves real queries. It is what RiNET is.

Why we built it

Sovereignty. If your AI runs on someone else's GPU, behind someone else's API, with someone else's terms of service, you don't have an AI strategy. You have a vendor strategy. Pricing changes. Policies change. Politics change. The companies that will own the next decade are the ones whose intelligence belongs to them. Everyone else is a feature.

Cost. The per-token economics of frontier APIs are seductive until you instrument them. We've watched teams burn five-figure monthly bills on GPT-4 calls for workflows that run on llama-3.1-8b-instant for free, with no perceptible quality drop. The hyperscalers aren't pre-selling 2030 GPU capacity by accident. They know.

The interesting problems live downstream of the model. How do you keep an AI system honest about what it knows versus what it's guessing? How do you build memory that doesn't decay? How do you let an agent take real-world actions without it confidently making things up? How do you compose seven specialized agents into one coherent workflow that doesn't crash? These are the questions that decide which AI products survive past the demo. None of them get solved at the model layer. They get solved at the system layer — which is exactly the layer most teams have outsourced.

What we've learned

Postgres is an AI operating system. Every team building production AI on a bespoke vector DB eventually rediscovers transactions, joins, RBAC, schema migrations, replication, and someone who can read EXPLAIN. Then they bolt those onto their vector DB. Then they realize they've reimplemented Postgres, badly. Skip the detour.

Pattern-matching orchestrators are how you lose. Your first query router will be a five-hundred-line regex tree. By month six it will be five thousand lines and nobody will know what it does. The correct architecture: resolve the entity, classify the intent, query the structured source, then let an LLM phrase the answer. We learned this the slow way. You don't have to.

Self-healing is table stakes. Self-evolving is the bet. Most respectable engineers think the system should not improve itself yet. We think the people who'll find out first are the ones running it in production while everyone else writes blog posts about whether to run it in production.

The hard part is institutional memory, not intelligence. Models are cheap. Embeddings are cheap. What takes years and cannot be cloned is the curated, audited, lineage-tracked corpus of facts your AI is grounded on. Lose the GPU, you buy another. Lose the memory, you start over.

Europe is where this gets built. Lower noise. Smarter engineers per square kilometer than anyone suspects. Closer to the sovereignty questions the continent will spend the decade answering. Better data-protection instincts. And the espresso is better.

What's next on this blog

Architecture deep-dives. Lessons that cost us weekends. Anonymized notes from client work — no names, ever; generalize or don't write it. The occasional industry rant when something deserves one.

We don't have a content calendar. We have a backlog of opinions.

Work with RiNET

We partner with a small number of organizations per year — typically when the problem is hard, the stakes are real, and the team understands why owning the stack matters. AI infrastructure. Autonomous agent systems. Data sovereignty architecture. The occasional rescue mission.

European focus. Built by people who remember when the web was small.

The contact form on this site lands in our inbox. Real reply, usually within forty-eight hours.