
Alexander is a writer, traveler, and serial digital entrepreneur. He’s the founder of the Tushi, the Gen X personal growth newsletter Further, and offers small business advice at Unemployable.

Twitter

Linkedin

Facebook

Director and Chief Evangelist

Alexander Hipp


Anil is a content-obsessed marketer who loves driving organic traffic for outstanding companies. He is also the creator of Hack the Content, co-host of The Runner, and owner of several digital commerce sites.

Managing Partner

Anil Vugels


Monika is a writer, musician, and content strategist with a passion for language. When she isn’t helping clients, you can find her writing songs, hiking in a northern forest, or furiously journaling.

Director of Operations

Ann Monika

Mastodon

Github

Programmer / Founder / Student

Tim Schupp


Hello everybody.

Some of you might know [this video here from two something years ago](https://www.youtube.com/watch?v=OqT_kIhz8Dc), where I presented the concept for 'open-chat' and said: *"So I'm only developing on this project in my free time and cannot make any promises on the development speed, but I'm very motivated to help bringing out stuff that lets us run models locally."*

Well, it was quite silent since then - except for maybe some heard that I shut down the original [beta.msgmate.io](https://msgmate.io) due to time constraints - now today I'm finally back with a *serious update*.

In my free time I've fully re-written [open-chat](https://github.com/msgmate-io/open-chat-go) in Go lang, especially to prepare for portability, cross-device compatibility and scalability.

So now open-chat is everything that I need, that you as a product "AI" user / developer may need, that a company rolling out "AI" products to their employees needs - and anything I ever wanted in an actual "AI" orchestration tool, while being fully sovereign, private and self-hostable. Fully self-controlled "AI" orchestration for you.

Open-chat bundles all the functions and strives to be able to do anything any other fancy LLM provider online chat interface or local Codex app or Claude app can do - *while being different*: open-chat is local-first, open-chat is multi-user first, open-chat is control and sandbox integration by itself, open-chat has built-in governance, built-in automation and is an orchestration tool at once. This sort of tool never existed in my opinion - so I created it.

And I want to offer it to everybody. Of course such a tool and such an application is highly complex, but bit by bit I think I'll be able to make this accessible to anyone. Open-chat is fully extensible, it may compile in custom integrations, and you can of course also develop your own private integrations.

I've designed open-chat in such a way that it fulfills any criteria that any OSS tool has missed for me. I've tested a lot of them - ask my friends, I was switching "AI" and automation tools every 3 days. They all somewhat work and of course have their use case and niche, but there were always some things that my software architecture / DevOps / platform engineering mind was missing. So I kind of re-thought the concept and created what I think is the right solution here.

In my opinion such a tool has to be a platform, an "AI" orchestration tool and an "AI" runtime - but it may never contain any external services or binaries. It shall only interface with any other tool, application, app or service.

The tool itself MUST BE PORTABLE, IT MUST BE COMPOSABLE, IT MUST BE SELF-HOSTABLE, and it must not ever write any custom client code - the clients must always be derived and generated from the back-end API specification. Yeah, I know, strict rules - but these come with a lot of power: if the tool orchestrates, ports and builds itself, it may *evolve itself*. And we can already see that with open-chat actually now developing itself in its own code base, using open-chat.

That's just a taste of the possibilities. For example, see how easy it is to set up an [MCP](https://modelcontextprotocol.io) connection to a Google Workspace with three clicks - and suddenly your local LLM at home can search, edit and work on your Google files fully privately (well, Google has the data, of course). I've tested this, it definitely works - I've hosted and deployed open-source models on [my private cluster](https://blog.t1m.me/blog/building-own-private-kuberntes-ai-cluster) and tested open-chat with it. And if you want to read my comment on the state of open-source "AI", [read this blog article](https://blog.t1m.me/blog/commoditization-of-ai-local-ai-and-the-future-of-europe). All of this works without any US big tech, OpenAI or Anthropic shenanigans - just with the mini PC in your own basement.

You can connect any MCP - for example throw in [Playwright](https://playwright.dev) and start controlling your browser sandboxes with any model. This ain't limited to anything, really.

Open-chat is already taking over development. Open-chat has voice input, open-chat can do image processing - and any imaginable thing that can be done out there with some open-source model can be integrated with open-chat.

Open-chat itself orchestrates its own sandboxes with Docker or Kubernetes (or any other backend we add in the future). It allows for full access control definition for any multi-user account, fine-grained tool confirmations, executions and scopings, and it has a full async runtime with its own workers that is horizontally scalable - the distribution is directly built in. It's designed to be extensible and efficient from the ground up, and it's still a tiny binary.

For now it will be really hard to grasp what it is, but as I release more and more demos and benchmarks and announce the first company integrations (already some in the making here), things will become more clear.

For now the most important thing is that you get an idea and I get the message out there: I think having good sovereign "AI" infrastructure in Europe will be an important game changer for us - and that is what I want to contribute to.

For now open-chat's core is released under AGPL, and there are several closed-source optional integrations at the moment. Depending on requests and reception of this release, I'm planning to open-source more and more of them.

Open-chat itself is also cross-platform from the ground up. An Android app is already in the making - and contrary to any other LLM tool, the app will actually include the full server, so once local LLMs become feasible you'll be able to take all your workflows directly onto your phone. iOS is also in the making, so no worries there.

I seriously believe such a tool has massive potential, especially because it solves several access-right management and orchestration issues that I didn't really see solved anywhere else - or at least not in non-proprietary software.

And I'm very confident that the negative impact of LLMs on code quality, or for coding in general, is very controllable by introducing error-correcting tests, having good CIs, having benchmarks, having human oversight, having self-healing deployments, and so on. I'm actively rolling out these parts in my workflows already, and I'll also be publishing more and more benchmarks, tests and results.

At some point open-chat / [msgmate](https://msgmate.io) will also release its own benchmarking. I'm already testing all the open-source LLMs on all the pre-existing workflows that work, so I can verify whether any future model - or any smaller model - will also work. My aim is to provide a state-of-the-art overview of open-source LLM capabilities, and to analyze them by energy consumption, intelligence, token usage, memory usage and speed - and hopefully show how fast and when we can use open-source LLMs in which use case.

Many things said here - many things I will have to show over the next months and years. Still, my time to work on open-chat is quite limited, but depending on the interest and reception of the first release I'll make sure that development efforts can also be scaled.

I'm also very curious about possible collaborations or contracts on integrations, pilots, or from people that just want to use the tool. I'll happily offer development and integration services alongside possible talks about custom development of integrations or custom licensing for companies.

Contact me for an initial talk: tim@timschupp.de

Anyways, let's see where this goes - [check out open-chat today](https://github.com/msgmate-io/open-chat-go). Thanks for listening.

Cheers Tim


Open-chat is a portable, composable, self-hostable platform for sovereign, private and self-controlled 'AI' — now released under AGPL.

Announcing Open-Chat: A Sovereign, Local-First 'AI' Platform


> **Note on terms:** I use KI (German) and AI interchangeably at the start; from here on I keep 'AI' in quotes. Everything below is my personal opinion and could well be wrong.

Shenanigans from OpenAI and Anthropic are ever present - *in my opinion more desperation, than anything else*.
But in my opinion *the commoditization of 'AI' has started* - and it will be fast from here.

### Always an early adopter

When it comes to technology I was *always an early adopter*, [I've even kinda predicted the relevance of harnesses when I started open-chat 3 years ago](https://www.youtube.com/watch?v=OqT_kIhz8Dc).
I've used LLMs from the start, few people knew that I was even checking out GPT-2 before the public release of GPT-3.

Since I was young I've been very interested and intrigued by ML systems or generally the thought to create something 'intelligent' that could become lively even possibly.
In my mind this is something that humans would naturally try to create - *this is not a rating - I'm not saying this is a good thing*.

I've been experimenting with 'AI' programming for a while, I've tried all hyped tools, I've even played with ['aider'](https://aider.chat/) before agentic coding really became a thing.
*The twist here isn't the 'AI' models -> It is their general agentic capability + some coding knowledge*.

At the moment though I believe *'AI' is a net negative for humanity so-far* - the cat is out of the bag argument is hard to get rid of.
But I think there is a *better way to use this technology*. This better way are 'local models'.

### A better way: local models

It gives, and takes little:

- Full privacy achievable through local hardware
- DSGVO compatible European hosters popping up everywhere
- Post-alignment and fine-tuning allows custom use-case models (in the past only through provider APIs possible)
- Sovereignty from the US
- Small model training and distillation flourishes

And many more advantages, esp that possibly we have these models simply running on our own devices and we can control how they think and act.

### The threshold is finally passed

I think the threshold is finally passed.
[After running Qwen3.8](https://blog.t1m.me/blog/vllm-litellm-on-amd-strix-halo) I've now moved to using qwen3.8-next-flash (new post on this soon) this runs directly on my cluster.
My results after literally switching 100% to OSS LLMs in coding for over 2 weeks now - *I'm never going back* - are that HELL YES THEY ARE GOOD ENOUGH FOR SURE!

### The pricing and value proposition

And then if you just take a look at the pricing differences then, *you realize fast* -
if the business case from US tech companies relies *on us using their compute in their datacenters* -
somebody has to make sure there is enough value to actually use them there.
*I strongly believe this value proposition isn't working out at the moment*.

### A less dystopian path for Europe

To me all of this gives some 'hope' at least that Europe will be fine, and that *there might still be a 'less dystopian path' for the global 'AI' rollout*.
But we will see :) Anyways *things could also be made or broken with the mid-term elections in the USA*.

Anyways, I'll be using only OSS models in all my private workflows from now on!
I'll report further; but you can already see open-chat is taking over development currently, with a fully automated agent starting to make more and more changes and commits in [open-chat-go](https://github.com/msgmate-io/open-chat-go).

More on open-chat soon too — it is becoming a *seriously helpful tool*.

Cheers Tim

<p class="post-image-grid-caption">Some insights on open-chat working in its own code-base.</p>

<div class="post-image-grid">
  <img width="2114" height="908" alt="Open-chat user automation overview" src="/static/assets/commoditization_post/open-chat-coding-user-automation-overview.png" />
  <img width="1555" height="1015" alt="Open-chat coding agent running on OSS LLMs" src="/static/assets/commoditization_post/open-chat-coding-agent-oss-llms.png" />
  <img width="1483" height="982" alt="Open-chat coding contributions" src="/static/assets/commoditization_post/open-chat-coding-contributions.png" />
  <img width="1531" height="1268" alt="Open-chat benchmark summary overview" src="/static/assets/commoditization_post/open-chat-benchmark-summary-overview.png" />
</div>


Why I think the commoditization of 'AI' has started, how local and open-source models change the equation, and what that could mean for Europe.

The Commoditization of AI, Local AI and the Future of Europe


Here’s how I keep AI-assisted coding fully under my control: Continue.dev with Codium, pointed at APIs I trust and models I host. Everything stays local or on endpoints I pick - no mistrius data blackholes, no pricy APIs with uncontrolled token usages. Just own hardware and local storage.

### Setting up the local model

`~/.continue/config.yaml`

```yaml
name: My Setup
version: 1.0.0
schema: v1

models:
  - name: "Tims Kimi"
    provider: openai
    model: moonshotai/Kimi-K2-Thinking
    apiBase: https://api.deepinfra.com/v1/openai
    apiKey: <DEEPINFRA_API_KEY>
    roles:
      - chat
      - edit
```

You can even use Google Models outside of Antrigravity:

```yaml
  - name: Gemini 3 Native
    provider: gemini
    model: gemini-3-pro-preview
    apiKey: <GOOGLEAI_API_KEY>
```

### Using self hosted models

There are several tools you can use here; the easiest is probably Ollama with its OpenAI-compatible backend.

e.g.: start qwen coder:

```bash
ollama run qwen3-coder:30b
```

Then include it in your contine.dev configuration:

```yaml
  - name: "Ollama self hosted"
    provider: openai
    model: qwen3-coder:30b
    apiBase: http://localhost:11434/v1
    roles:
      - chat
      - edit
```

And now you can edit the code completely privately using a 100% local model.


### Fixing Python Linting

Microsoft sometimes is a little b**ch, they block the pylint plugin from working with non-official VS Codes.
So I recommend using 'basedpyright'; it works with Codium, and honestly in some aspects is even better than pylint.


A comprehensive guide to setting up fully self-hosted AI code editing with Codium and Continue.dev, keeping your code and AI interactions completely private and under your control.

Ai

Announcing Open-Chat: A Sovereign, Local-First 'AI' Platform

The Commoditization of AI, Local AI and the Future of Europe

100% Open-Source Self-Hostable AI Code Editing: Codium & Continue.dev