Projects

Can open-source AI handle demanding business work without your data ever leaving Germany? Two examples from my recent work answer that question. They are not a complete list of my projects but illustrate how I work. In both, the data was far too sensitive for a public AI service. In both, open-weight models running in Germany fully met the client’s requirements, and the systems were built in four months. Here is how. Further down: my own open-source lab project, a chess engine stronger than any human player.

AI-assisted document creation

Client: a European transformation consultancy
Duration: 4 months (Phase 1), developed by me using AI coding agents

The challenge

For every engagement the consultancy prepares extensive, structured documents for its clients. Each one combines approved standard text, project-specific requirements, and experience from earlier projects, and producing them by hand takes experienced consultants a lot of time. The inputs are confidential: they contain client information and the firm’s own know-how. Data residency in Germany or the EU was a requirement, and the data must not be used to train anyone else’s models.

The solution

A web application in which consultants upload the project inputs and a network of AI agents drafts the document section by section:

  • Deterministic where possible, AI where it adds value: approved standard text is copied verbatim; the language model only adapts the sections where the project requires it. The results are predictable and easy to review.
  • Knowledge base: a hybrid search (semantic and keyword) over earlier projects and guidance documents supplies examples and answers questions.
  • Human in control: consultants refine the draft with targeted edits in a chat, see what is still missing, and publish the result as a Word document.
  • Adjustable by domain experts: the rules the agents follow can be edited in the application, without changing code.
flowchart TD
    subgraph provider["German cloud provider"]
        direction TB
        app["Web application<br/>for consultants"] --> agents["AI agent networks<br/>drafting, editing, Q&A"]
        agents --> kb[("Knowledge base")]
        agents --> text[("Approved<br/>standard text")]
        agents --> model["Open-weight<br/>model"]
    end

Deployment

  • Containers throughout: the web application, the agent server, the knowledge base, and the tool servers run as Docker containers. The same stack runs in development and production; only the model backend differs.
  • Automated CI/CD with GitHub Actions: a release builds all images in CI, tags them with the exact code version, and pushes them to a private container registry at the same German provider. The server only pulls finished images and never fetches anything from public registries.
  • Safe releases: production releases are started deliberately with one click, and a release only counts as successful once every service reports healthy.
  • Rootless Docker: the container runtime runs without root privileges, under a dedicated deploy user with no administrator rights. Even a leaked deploy key would not give anyone control of the server.

Data sovereignty and security

  • Open-weight models, German hosting: development runs gpt-oss on a local GPU; production uses the same model family on the IONOS AI Model Hub in Germany. Switching between them is a configuration change.
  • Open to any provider: because the system uses the standard OpenAI-compatible API, it can just as well run on a hyperscaler such as Azure, AWS, or Google Cloud, again with a single configuration setting.
  • Hardened setup: designed for secure operation, with a single server, one TLS-encrypted entry point, role-based access, separate keys for every purpose, and nightly off-site backups.
  • Confidential data stays out of the code: client documents live in a separate data area. Development and automated tests use synthetic documents only.
  • Security in the pipeline: secret scanning runs on every push and keeps confidential files out of the repository, and an extensive regression test suite guards the behavior of agents, tools, and the web application.

Result

Open-weight models hosted in Germany fully meet the client’s requirements for demanding, structured business documents. The key is a design that plays to their strengths: code handles what is mechanical, and the model contributes judgment. Because I developed it using AI coding agents, the first working drafts appeared within two weeks and the application was in production after three. The remaining months went into extending it step by step.

Technology: Python, FastAPI, Neuro SAN (multi-agent framework), Qdrant, gpt-oss, Ollama, IONOS AI Model Hub, Docker, GitHub Actions

Analyzing call center conversations

Client: a business process outsourcing (BPO) provider operating large call centers across Germany
Duration: 4 months, as part of a team from the client and a partner company

The challenge

Call centers handle a huge number of customer interactions every day: emails, chats, and phone calls. Quality managers can only review a small sample by hand, so recurring problems, unhappy customers, and coaching opportunities go unnoticed. The conversations are full of personal data such as names, phone numbers, addresses, and contract details. Sending them to a public AI service was not an option.

The solution

A pipeline of small, independent services that runs entirely on a dedicated server in Germany:

  • Preparation: emails, chat logs, and voice transcripts are converted into a structured timeline of who said what and when.
  • Anonymization: personal data is detected and replaced before the analysis, with recognizers adapted to German phone numbers and addresses. The language model never sees who the customer is.
  • Analysis: an open-weight language model categorizes each conversation, summarizes it, assesses customer sentiment, checks whether the issue was resolved, and suggests improvements for the agent, in German and English.
  • Orchestration: the services are available as tools via the Model Context Protocol (MCP). An orchestrator lets a language model decide which steps a request needs, and analysts can use the tools directly from a chat interface.
flowchart TD
    subgraph server["GPU server in a German data center"]
        direction TB
        prep["Preparation<br/>emails, chats, voice transcripts"] --> anon["Anonymization<br/>personal data removed"]
        anon --> analysis["Analysis<br/>open-weight model"]
    end

Deployment

  • One container per service: preparation, anonymization, analysis, and orchestration each run in their own Docker container and are started together with Docker Compose.
  • Automated CI/CD with GitHub Actions: every push to the development branch builds the affected service’s image for Intel/AMD and ARM, pushes it to a private container registry, and redeploys it on the GPU server automatically.
  • Independent updates: each service can be updated and redeployed on its own, and a separate workflow redeploys the whole pipeline on demand.

Data sovereignty

  • Open-weight models only: the analysis runs on gpt-oss, served by Ollama on a single dedicated GPU server in a German data center. Mistral and Qwen models were evaluated as alternatives; switching is a configuration change.
  • Open to any provider: thanks to standard APIs, the pipeline can also use models from a hyperscaler such as Azure, AWS, or Google Cloud, by changing a single configuration setting.
  • Privacy by design: personal data is removed before the analysis, so the language model only ever works with anonymized text.
  • No external AI services: conversation data is never sent to a third-party AI provider.
  • Open source throughout: from the language model to the chat interface (Open WebUI). The anonymization uses the open-source version of Microsoft Presidio, self-hosted on the same server rather than as a cloud service.

Result

A medium-sized open-weight model on one rented GPU server fully meets the client’s requirements for categorization, summaries, sentiment analysis, and resolution checks of German customer interactions, at fixed infrastructure costs and without any compromise on data protection. The first prototype ran within days, the pipeline ran in the cloud after about seven weeks, and the complete agent-based architecture followed within the four months.

Technology: Python, FastAPI, MCP, Ollama, gpt-oss, Presidio, Open WebUI, Docker, GitHub Actions

Lab: an open-source chess engine

Project: Endspiel, my own open-source chess engine, written in Rust
Code: github.com/thilo11/endspiel

Endspiel is where I try out new AI tools before I rely on them in client work: new models, coding agents and their harnesses such as Claude Code, Codex, Grok, and OpenCode, and workflows all the way up to automated loops that run experiments overnight. A chess engine makes an ideal testbed. The problem is hard, and every change can be measured objectively by playing thousands of games.

The result

Endspiel 2.0 is rated 3508 Elo on the CCRL Blitz list, a rating list for chess engines. That is far beyond any human player. It runs on desktops, laptops, a Raspberry Pi 5, and Android phones, and you can play against it on Lichess as endspiel-pi.

Everything is built from scratch: move generation, a modern search, a neural network evaluation trained on billions of positions, endgame tablebase support, and releases for six platforms. Before AI coding agents, an engine of this strength was the work of a team over several years. I built it on my own, using AI agents as tools, in a few months as a side project.

How it works

  • I develop, agents are my tools: I decide what to try, specify the changes, and review every result; coding agents carry out the implementation.
  • Measurement instead of opinion: every change must prove itself in a statistical match of thousands of games before it is merged. An agent can argue that its change is an improvement, but it cannot argue with the score.
  • Automated loops: scheduled pipelines generate training games overnight, train new networks, and test each candidate automatically against a reference engine.
flowchart TD
    idea["Idea"] --> impl["Coding agent<br/>implements the change"]
    impl --> test["Automated test<br/>thousands of games"]
    test -->|"stronger"| merge["Merged"]
    test -->|"not stronger"| discard["Discarded"]

What I take into client projects

  • AI agents deliver the most where results can be checked automatically by tests, benchmarks, and quality gates.
  • New models and tools appear every month. Trying them on a demanding real problem shows quickly what holds up and what is hype.
  • The human role shifts from writing code to setting goals, designing experiments, and judging results, and it remains essential.

Your project

Do you have a similar challenge? Write to .

Table of Contents