No more adding MCP servers manually to ChatGPT, just give it a hint where to look (I assume with a more obvious or known domain, it would figure that out by itself).

Example Question:

When is the next cardboard collection at Quellenstrasse? Check zuericitygpt.ch

Answer in ChatGPT:

The next cardboard collection on Quellenstrasse (8005) is Wednesday, 9 September 2026. (ZüriCityGPT)

And it didn't just hallucinate it, or somehow find it otherwise, it actually called the MCP tool get_waste_collection.

It also works for follow up questions for a different place or even to check out a City Council resolution (Stadtratsbeschluss), because ZüriCityGPT has maybe the best solution to search for them (and everything else on the City of Zurich website, but that a normal WebSearch usually also figures out).

And because I like the approach a lot, I also added WebMCP to our instance of the City of Zurich Open Data MCP Server at https://zurich-opendata-mcp.liipgpt.ch/

From the example question in their GitHub repo:

How many free parking spots are in Zurich right now, and what's the air quality like? Check on https://zurich-opendata-mcp.liipgpt.ch/

Answer in ChatGPT:

The service reports 6,862 free spaces across 36 parking facilities, but that figure is not genuinely current: its timestamp is 18 July 2026, 05:27, and several capacity figures are internally inconsistent. So there’s no trustworthy “right now” parking total from this feed.
Air quality is generally good, based on provisional hourly readings from 4 September 2026, 06:00:

• PM2.5: 4.2–7.0 µg/m³
• PM10: 8.1–16.6 µg/m³
• Ozone: 7.9–73.7 µg/m³
• NO₂: 4.9–49.4 µg/m³ — highest near Schimmelstrasse and Rosengartenstrasse

In short: low particulate pollution, with moderately elevated traffic-related NO₂ at central roadside stations. Source: Zürich Open Data MCP.

These examples are not groundbreaking, even if asking for "recycling collection times" is always a beloved topic on our public chatbots and Google also doesn't know them by heart. But if websites start adding more useful WebMCP endpoints to their websites, beyond just searching their content, it will enhance the experience for people using ChatGPT et al. Like adding items to a shopping cart or sending a report about a broken street sign or just help filling out a webform without actually sending it. Without them even knowing what WebMCP or MCP is or registering anything explicitly.

Very much looking forward to future use cases for WebMCP and how it will improve the experience with tools like ChatGPT (and others, when they implement it)

See also OpenAI's documentation about WebMCP for more about their implementation.

At Liip, we're glad to see this foundation model keep improving — it's what powers sovereign, ethical AI use cases for organizations in Switzerland and beyond. We wrote up our own hands-on comparison after running Apertus in production on ZüriCityGPT, so if you want the deep-dive data, that's the place to look. Here, in the spirit of our original "4 ways" post, we're keeping it practical: 6 ways to try Apertus 1.5 yourself, today.

1. Try Apertus 1.5 on Public AI

Use this when you just want to try the model in a chat window, right now, without installing anything or writing a line of code. Public AI's mission is to make open AI accessible to everyone, and it remains one of the easiest ways to access Switzerland's sovereign models. It runs on Public AI's own inference utility, hosted within Swiss jurisdiction, and with the 1.5 release you can put the improved multilingual handling — including the well-liked Schwizerdütsch toggle — to the test yourself.

Create a free account at chat.publicai.co to try the full 70B reasoning model, and make sure to switch on the new Thinking Mode. Prefer not to sign in? publicai.co/chat gives you the 8B version with no login required.

2. Try Apertus 1.5 with RAG using LiipGPT

Use this when you want to see Apertus power a real Retrieval-Augmented Generation (RAG) chatbot that answers questions grounded in your own documents, rather than a bare chat window. LiipGPT, our generative AI platform, also runs on open-source models, and we're updating our open-source implementations to use Apertus 1.5. The new 262,144-token context window — 4x the original — is especially useful here: it lets our RAG setups pull in much larger documents, reports, and datasets at once without losing detail.

You can see this in action in our open-source integration: oss.zuericitygpt.ch.

3. Try Apertus 1.5 in TextMate

Use this when you want to feel the model's improvements on your own everyday writing — a report to tidy up, a text to translate — without any setup at all. TextMate, our LiipGPT module for text correction, plain-language rewriting, and translation across 12+ languages, now offers Apertus 1.5 as a model option too. It's a good way to get a feel for the model's improved instruction-following on everyday editorial work — correcting, rewriting, or translating your own text.

Try it directly at liip-textmate.liipgpt.ch.

4. Download and test Apertus 1.5 locally

Use this when you need the model running fully under your own control — offline, air-gapped, or wired directly into your own application, with nothing sent to a third party. As with every Apertus release, the 1.5 model family — both the 8B and 70B versions — remains fully open: open weights, open data, open training recipes. You can download the models directly from Hugging Face (swiss-ai/Apertus-v1.5-8B and swiss-ai/Apertus-v1.5-70B). If you'd rather not manage inference yourself, Infomaniak also offers Apertus 1.5 70B through their API.

The 8B version is well-optimized and runs comfortably on modern hardware. On a Mac, mlx-lm gets you running locally via Apple Silicon's unified memory and Metal GPU acceleration; with quantization, people have gotten it working even on an 8GB laptop GPU. On other setups, vLLM is a solid way to serve it and explore the native image-understanding features.

5. Explore building your own chatbots with Open WebUI

Use this when you want to build a custom, self-hosted chatbot for your team or organization — and compare Apertus 1.5 against other models before committing to one. Open WebUI remains a great self-hosted, open-source platform for building ChatGPT-like custom chatbot experiences. With Apertus 1.5's improved tool use and instruction-following, it's easier than ever to build bespoke assistants tailored to your organization's workflows.

Apertus 1.5 plugs into Open WebUI just like any other model — it's one of the models available on our own internal Open WebUI instance. One of the platform's best features is the ability to run the same prompt against several LLMs at once — handy if your team wants to quickly see how Apertus 1.5 stacks up against other models for your specific use case.

6. Let Project Agent draft a ticket for you

Use this when you want to see Apertus 1.5 not just answer questions but actually do something — turning a rough problem description into a properly researched, ready-to-file ticket. Our internal Project Agent (PAL) — a conversational agent platform Liip teams use on their own projects — now runs on Apertus 1.5 too, and the model's improved tool use makes a real difference here. Point it at a rough problem description, and it uses tool calls to dig into the project itself: reading the git history, searching the issue tracker, and pulling in the relevant wiki pages, then drafts a properly scoped improvement ticket — priority, affected component, concrete impact — ready to send straight to YouTrack.

It's a good showcase of what "better tool use" actually buys you in practice: not a chatbot answering questions about tools, but a model reliably calling the right ones, in the right order, to produce something you'd otherwise have written by hand.

How do you want to put the new multimodal and reasoning capabilities of secure, sovereign large language models to work? Let's explore together how to build your own Open WebUI–based chatbot infrastructure, powered by Apertus 1.5.

Looking forward to hearing from you.

Next, we're looking forward to exploring Apertus 1.5's translation capabilities in more depth.

It was not just the open-source side that upgraded. The production system at zuericitygpt.ch switched from GPT-4o-mini to GPT-5.6 Luna — the cost-efficient tier in OpenAI's latest model family. So in the following, we will take a look at the effect of two simultaneous model upgrades on ZueriCityGPT, tested against the same knowledge base.

What is new in each model

Apertus 1.5 adds 2 trillion tokens of continued pretraining to the 70B model. For the first time, the model accepts images alongside text, and audio input is available experimentally. Instruction following — a clear weak spot in 1.0 — was a focus of the update. The model remains fully open-source under Apache 2.0, trained on the Alps supercomputer at CSCS.

GPT-5.6 Luna is the smallest model in OpenAI's GPT-5.6 family (Sol / Terra / Luna), released on July 9, 2026. It supports a million-token context window and is designed for high-volume, latency-sensitive workloads — the profile of a public-sector chatbot like ZüriCityGPT. The production system ran on GPT-5.4-nano for most of July before switching to Luna on July 31; our controlled test on August 7 ran against Luna.

A disclaimer about the comparison

An important point needs to be reiterated, as it was often misunderstood in the first Apertus release: it is not possible to directly compare the performance of a Large Language Model (LLM) like Apertus to an integrated solution like Luna, which does not provide access directly to the closed LLM inside of it. The software stack that is run by OpenAI to optimize interactions with their models is proprietary, whereas Apertus is running on an open-source stack that you can deploy in the cloud or on-premises.

Similarly, while ZueriCityGPT has an OSS model version, not all source code of the underlying system LiipGPT has been open-sourced at this point. LiipGPT ships with a lot of features that a sophisticated Retrieval-Augmented-Generation (RAG)-system needs in order to provide you with accurate answers based on a curated knowledge base.

Both models run on the same LiipGPT platform and the same knowledge base of official content from stadt-zuerich.ch. Note that the OSS version also uses different models for embedding (Qwen3-Embedding-0.6B) and reranking (BGE-Reranker), which can affect answer quality. Neither system uses web search — all answers are generated exclusively from documents retrieved from the stadt-zuerich.ch knowledge base via RAG.

The OSS version of ZüriCityGPT will add 16k tokens from the chunks into the prompt while the Luna version adds 32k tokens. This is because the price of Apertus tokens is roughly 4 times higher than Luna model tokens. We therefore actively choose to constrain the amount of tokens used for cost-control and to achieve a similar cost to question ratio.

The numbers

We have two data sources: historical quality metrics from real user traffic (measured automatically by the LiipGPT platform), and a controlled test where we asked 20 identical questions to both systems on the same day.

A note on how to read the comparisons: throughout this post, we make two kinds of comparison. Before → after compares the same system across its model upgrade (Apertus 1.0 → 1.5, or GPT-4o-mini → GPT-5.6 Luna). Head-to-head compares the two systems against each other on the same question, same day. We always name the specific models so it is clear which comparison we are making.

Historical metrics — real user traffic

Over the past months, the LiipGPT platform has scored every answer using our three established metrics:

• Match Rate (MR: is the answer acceptable?)
• Match Rate +1 (MR+1: is the answer actually good?)
• Faithfulness (Faith: does the answer stick to the source documents?).

In the following, we aggregate each model's entire deployment period. This gives the clearest before-and-after picture.

Apertus 1.5 made the bigger relative leap: Match Rate +1 jumped from 40% to 59% — a 19 percentage point improvement. GPT-5.6 Luna went from 70% to 87%, a 16 percentage point jump. The absolute gap narrowed only slightly, from 30 points to 27.

Controlled test — 20 identical questions

We repeated the exact same 20 questions from the original blog post, asking them on both systems on August 7, 2026. One person asked all 20 questions on each system — this is not a user study but a controlled comparison isolating model changes from knowledge-base changes.

Apertus 1.5 improved its average score from 4.40 to 4.70. GPT-5.6 Luna came in at 5.15.

How did the three key metrics change?

Our automated scoring scale runs from 1 (wrong or refuses to answer) through 3 (partially correct) to 6 (excellent). We define "acceptable" as any score above 2 — the answer is at least partially useful. "Good" means above 3 — the answer is substantively correct and helpful, not just borderline.

*The faithfulness delta for Luna is a measurement artifact — see the discussion in "What we learned" below.

Apertus 1.5 gives fewer acceptable answers (85% vs 100%) but more good ones (75% vs 65%). This is the "honest refusal" pattern: the model no longer produces borderline answers that scrape past the threshold. When it answers, it answers well; when it cannot, it says so. The Apertus team confirmed this matches their own testing with OR-Bench, a benchmark designed to measure over-refusal behaviour. GPT-5.6 Luna shows a milder version of the same trend.

In a head-to-head battle, GPT-5.6 Luna won 6 questions, Apertus 1.5 won 2, and 12 were ties. Compare that to the original: GPT-4o-mini won 9, Apertus 1.0 won 3, with 8 ties. Ties grew from 8 to 12 — meaning Apertus now matches the production model on most questions.

Matched questions — real users, same question, both systems

Twenty-five real user questions were asked on both systems during the Apertus 1.5 period. The questions from different users who but we chose to simulate them on both systems to achieve a comparison.

On matched questions, the gap in average score is just 0.16 points (4.92 vs 5.08). Match Rate: 96% vs 100%. Match Rate +1: 76% vs 92%. Faithfulness: 0.59 vs 0.83.

The example questions revisited

In the original blog, we highlighted specific scenarios to make the numbers tangible. Here is how they changed — plus two new ones that show the practical impact of both upgrades.

"Est-ce que tu parles français?" — both answer now

This was the most visible failure in the original comparison. When asked "Do you speak French?", GPT-4o-mini responded fluently in French. Apertus 1.0 declined, saying it could not answer questions about its own linguistic capabilities.

Apertus 1.5 now answers: "Oui, je parle français. Je suis à votre disposition pour vous aider dans la langue que vous préférez." The IFEval improvement that the Apertus team targeted has real practical impact.

Population — improved but still off

In the original test, GPT-4o-mini returned Zurich's current population (452,421), while Apertus gave a 2013 figure. Apertus 1.5 now returns a more up-to-date number but uses the wrong date. GPT-5.6 Luna cites the correct combination of time and population. Apertus 1.5 plays a part in this, but retrieval logs tell a different story: the OSS embedding model (Qwen3-Embedding-0.6B) ranks old statistical PDFs from 2010–2013 above current population pages, and because those PDFs are large, they fill the smaller context window (16k vs production) before up-to-date sources are included. The production system's embedding model (OpenAI text-embedding-3-small) retrieves the current data as its top result.

Waste dump — the tables turned

This was Apertus 1.0's showcase win in the original blog: scoring 6/6 where GPT-4o-mini scored 3/6. In 1.5, the roles reversed. GPT-5.6 Luna now delivers a comprehensive answer. Apertus 1.5 asks the user to specify what kind of waste they mean. This is the clearest example of Apertus 1.5's new pattern: better instruction following sometimes means it asks clarifying questions rather than making assumptions.

"Who is the mayor?" — the honest refusal in practice

This question illustrates why acceptable answers dropped from 100% to 85%. GPT-5.6 Luna correctly answered "Raphael Golta". Apertus 1.5 refused: "The provided information does not contain the name of the current mayor of the city." Rather than guessing like 1.0 did (which returned the outdated name "Corine Mauch"), 1.5 admits the gap. This is a retrieval issue, likely amplified by the smaller OSS embedding model.

"was gibts neues im zoo?" — Apertus finds its voice in German

Apertus 1.0 scored 3/6 — a vague, generic answer. Apertus 1.5 now delivers a detailed German response covering the Lewa Savanne, the Kaeng Krachan Elefantenpark, and the Zooseilbahn controversy. It scores 5/6, matching GPT-5.6 Luna.

This is notable because the knowledge base is predominantly German, and zoo news is the kind of practical, frequently-asked city question where a chatbot needs to perform. Apertus 1.0 struggled to synthesize multiple retrieved documents into a coherent answer; 1.5 does this naturally. The improvement is not about finding the right documents — the RAG pipeline retrieved them before, too — but about what the model does with them once retrieved.

What we learned

The quality gap is closing, from both sides. Apertus 1.5 narrowed the gap substantially — but both models got better at the same time. On matched real-user questions, the average score difference is just 0.16 points. On the controlled test, the gap went from 0.50 (4.40 vs 4.90) to 0.45 (4.70 vs 5.15).

Instruction following improved — with a tradeoff. Apertus 1.0 had a clear weakness in instruction following (IFEval 44%). In 1.5, the French language question works, the identity answer is clean, and the English responses are more natural. But the same improvement created a new pattern: when retrieved documents do not clearly contain the answer, the model now refuses rather than attempting to synthesize. This dropped the controlled-test Match Rate from 100% to 85%.

The English/German gap persists — but it is not the model. We asked "wie alt ist die stadt zürich?" in German and "How old is the city of Zurich?" in English. Apertus 1.5 scored 6/6 on the German version and 2/6 on the English version. The gap most likely comes from the OSS embedding model struggling with cross-lingual retrieval against the predominantly German knowledge base.

Faithfulness requires careful measurement. The faithfulness numbers initially included refusal answers, which led to low scores because the refusal obviously cannot be grounded in facts. On that basis, GPT-5.6 Luna scores 0.84 — essentially identical to GPT-4o-mini's 0.83. Apertus improved slightly (0.53 to 0.56 in production traffic, 0.60 to 0.61 in the controlled test). "Faithfulness" is our platform's metric for how well the answer sticks to the retrieved sources — it is not a term the Apertus team uses internally, but they confirmed that general accuracy improvement and alignment work are ongoing goals. The gap between Apertus and the production system (0.56 vs 0.84) depends as much on how the RAG pipeline surfaces and frames source material as on the model itself.

Both systems benefit equally from knowledge base updates. The knowledge base now correctly reflects that Raphael Golta replaced Corine Mauch as Stadtpräsident in May 2026. Both models handle this correctly — confirming that the LiipGPT platform's RAG pipeline works as designed: model-agnostic, with the knowledge base as the single source of truth.

Looking ahead

Compared to our recent test of Apertus 1.0, the picture has shifted meaningfully. Back then, Apertus was an experiment with many limitations. Apertus 1.5 seems to handle many questions at the same level as GPT-5.6 Luna. The cases where it still falls short (faithfulness, cross-lingual retrieval) are increasingly about other open-source components involved, less on the model itself. But in our test field of RAG application, the cost ratio is important. If you compare the token cost of GPT-5.6 Luna on Azure with the token cost of Apertus 1.5 70B on Infomaniak, the Apertus model will cost you roughly 4 times as much as the GPT model. Obviously there are other advantages like enhanced data sovereignty and higher ethical standards in training the model but still, being able to run Apertus 1.5 in sizes between 8B and 70B would help achieve a better cost to value ratio in our case.

We are sharing these results with the Apertus team and the wider community for review. As before, our aim is not to provide a scientific benchmark but a practical report from a production deployment. Consider that these are just our first impressions, and we are looking forward to further test Apertus with other RAG-deployments and in more use case scenarios. If you would like to test how Apertus 1.5 works when refining brand text, our latest TextMate has the model available as well.

The question from our last post — "how much quality gap are you willing to accept for full sovereignty?" — now has a different answer. On most questions, the answer quality is equivalent. The remaining gap is in faithfulness and source attribution — Apertus is improving, and GPT-5.6 Luna maintains the same level as its predecessor once measurement artifacts are accounted for. Closing that gap will require improvements to the open-source RAG stack (embedding, reranking) as well as finding a good mix between model size and speed / price and might be less focused on the language model itself.

Please do not hesitate to contact me if you have any questions about Apertus or AI solutions in general; I’d be delighted to discuss this with you.

Acknowledgements

Thank you to the Swiss AI Initiative — EPFL, ETH Zurich, and CSCS — for continuing to develop Apertus as a public good. Thank you Oleg Lavrovsky and Martin Renou for reviewing a draft of this post and providing feedback from the Apertus team's perspective.

Thank you Christian Stocker and the LiipGPT team for deploying the update within 24 hours of release.

Thank you Public AI and Infomaniak for hosting Apertus inference for us.

Parts of this analysis were prepared with the help of Claude. The data was collected and scored automatically by the LiipGPT platform.

Du 1er août au 1er novembre, j'étais dans le Finance Circle. C'est là que tout a commencé

J'ai accompagné le déménagement du domaine Finance hors de notre wiki Atlassian. La nouvelle solution n'était pas encore décidée. Alors j'ai d'abord tout mis sur Google Drive. Ça ressemble à un simple rangement. En réalité, c'était un bon point de départ pour voir à quel point les connaissances s'accumulent chez Liip, et où elles se trouvent.

Mes tâches dans le Circle :

• La responsabilité de notre adresse e-mail Finance, où arrivent toutes les factures. Je les ai vérifiées et saisies dans RMA, notre système de finance.
• Le rapprochement mensuel des cartes de crédit, pour lequel je cherchais chaque fois du potentiel d'automatisation.
• La mise à jour des archives NDA. J'ai repris tout l'historique et construit quelques automatisations dans Google Sheets, pour que plus personne n'ait à chercher à la main où se trouve tel ou tel contrat.

Ce que j'ai le plus aimé, c'était de pouvoir chercher librement du potentiel d'automatisation et faire des recherches là-dessus. Les grands transferts de données étaient moins passionnants. Un bon conseil pour ça : lancer un podcast, et ça passe tout seul. La tâche la plus typique du Finance Circle, pour moi, c'était le rapprochement mensuel des cartes de crédit. Exactement le genre de travail qui fait tourner une entreprise en arrière-plan.

Dans le Finance Circle, je n'ai pas appris des chiffres en premier lieu, j'ai appris comment Liip fonctionne comme entreprise.

Du 1er novembre au 1er février, j'étais dans le Drupal Zürich Circle. C'est là que les choses sont devenues plus concrètes

Ici, j'ai pu pour la première fois endosser un peu le rôle de PO. Avec Petra, j'ai accompagné un projet. Sur d'autres projets, j'ai d'abord observé et pris en charge de petites tâches pour comprendre le business derrière. C'était un rythme différent du Finance Circle. Au lieu de reprendre des processus existants, je devais comprendre comment un projet client naît, depuis la première demande jusqu'à la réalisation.

Plus tard, des tâches plus importantes sont arrivées :

• Le PO testing après la première réalisation par l'équipe de développement
• Un manuel pour le backend Drupal, que j'ai écrit de zéro

Pour ce manuel, les explications devaient être assez simples pour que même quelqu'un sans bagage en code puisse s'en servir. C'était le plus grand exercice pour moi.

Même si c'est un Circle de production chez Liip, je n'y ai jamais codé moi-même. À l'école professionnelle, j'ai eu affaire à Python. Ce n'était vraiment pas mon truc, cela dit. Ce que j'apprécie beaucoup : Petra me pousse toujours vers le code dans nos syncs, en m'expliquant ou en me montrant des choses. Dans le Circle lui-même, j'ai eu beaucoup à faire avec le backend et le frontend, mais jamais directement dans le code. Le moment le plus cool pour moi, c'était de terminer le manuel. Ensuite sont arrivées beaucoup de réactions positives et reconnaissantes.

Dans le Drupal Zürich Circle, j'ai appris ce que Liip représente vraiment comme entreprise.

Du 1er février au 1er août, j'étais dans le Design et Content Circle. C'est là que j'ai pu montrer ce que j'avais appris

Dans ce Circle, tout tournait beaucoup autour de l'IA avec un focus sur le contenu, que ce soit la création, le traitement ou les guidelines. Pour des projets clients, j'ai pu :

• Rédiger des prompt sheets pour des Textmates
• Tester des optimisations de processus
• Écrire mon propre article de blog
• Construire mes propres outils d'IA
• Aider lors de formations et de workshops, puis les co-construire moi-même

Ça va de la préparation des documents jusqu'au soutien actif pendant le workshop lui-même, quand des personnes ont des questions ou restent bloquées sur un exercice.

Le workshop que j'ai mentionné au début, c'était avec Caritas St. Gallen und Appenzell. C'était en même temps notre tout premier Responsible AI Workshop. Pendant l'année où j'ai moi-même grandi chez Liip, notre expertise sur ce sujet s'est aussi beaucoup développée.

Je n'étais resté aussi longtemps dans aucun autre Circle. Ça a fait une différence. J'étais beaucoup plus intégré dans le travail du Circle. Surtout dans la deuxième moitié, j'ai remarqué à quel point on m'a fait confiance et donné des responsabilités pour réaliser des choses seul. Sur le fond, le travail ici était particulièrement intéressant : il tournait beaucoup autour du contenu interne de Liip, combiné à des workshops pour des clients où on pouvait transmettre notre savoir. C'était encore différent des deux Circles précédents.

Dans le Design et Content Circle, je n'ai plus seulement pu apprendre, j'ai pu transmettre moi-même.

Ce qui s'est construit sur l'année

Quand je mets les trois cercles côte à côte, je vois surtout une courbe au niveau des responsabilités. Dans le cercle Finance, j'ai repris des processus déjà en place, et j'ai découvert au passage les personnes, les outils et le fonctionnement de Liip. Dans le cercle Drupal Zürich, il s'agissait davantage du vrai métier de Liip, le développement web, et j'ai déjà pu prendre mes propres décisions en PO testing, et même rencontrer des clients. Dans le cercle Design et Content, j'ai pu utiliser ce savoir pour travailler sur des tâches stratégiques, construire mes propres outils et co-construire des workshops.

Chaque cercle m'a préparé au suivant. Pas parce que je l'avais planifié moi-même, mais parce que c'est exactement le système derrière la formation d'Entwickler Digitales Business chez Liip. Je le vois le plus clairement avec l'automatisation. Dans le cercle Finance, j'ai appris avec le rapprochement des cartes de crédit à décomposer un processus et à chercher du potentiel d'automatisation. J'ai eu besoin exactement de cette façon de penser dans le cercle Design et Content, quand j'ai construit mes propres outils d'IA. Sans la première étape, je n'aurais pas pu aborder la troisième de cette façon.

Une chose s'est retrouvée dans les trois cercles, et elle n'a rien à voir avec des connaissances techniques. J'ai appris que je peux aller vers les autres et demander de l'aide. Pas parce que je suis apprenti et que c'est permis, mais parce que chez Liip, c'est simplement normal pour tout le monde.

La confiance n'est pas venue d'un coup chez moi, elle est venue cercle après cercle, et c'est ce qui m'a le plus changé depuis août dernier jusqu'à aujourd'hui.

Comment se présente ta propre courbe d'apprentissage? Est-ce qu'elle se construit aussi étape par étape chez toi, ou plutôt par sauts?

But anyone working in branding and corporate communications knows the dilemma:

• Faster and more consistent: yes, please!
• Losing control over positioning: no, thanks.

We revised our own content strategy — with the help of AI. And looked for a way to resolve that dilemma: an efficient process that keeps control in human hands.

Where to start

Liip sharpened its positioning goals, which meant our content strategy needed a revision too.

For this, I worked with Claude: we have Enterprise access at Liip, and I use the desktop app.

As a first step, I set up a new project. I give it a clear title and describe what I'm trying to achieve.

I can also feed the system context information that it takes into account across all the work within that project.

In this case, relevant context included:

• The organization's vision and strategy
• Positioning goals
• Existing personas
• Approval processes and relevant governance

Anything relevant to the content strategy goes into the project as context. This matters especially when several stakeholders or language regions have a say in the final result: the system proposes — but it knows the guardrails within which a proposal actually holds up.

This context provides a solid foundation for an approach that's both grounded and efficient.

From there, the actual work on the content strategy itself can begin.

I wanted to sharpen our core messages and target groups — two building blocks we'd been developing further as part of our new positioning.

Working with the system

For each building block, I had two options:

• Have Claude generate a first proposal, derived from the context I'd provided.
• Sketch out roughly what I had in mind, and let the system turn it into a full version.

Either way gives me a starting point I can refine further — alone, with the system, or with the team. The AI doesn't write my strategy; it simply supports me through the process.

What it takes is the moment where I step back from what's been generated, reflect on whether it actually serves our goals, and bring in my own judgment.

To get a fresh perspective on generated proposals, I like to pull in colleagues. Through this process, I developed a first complete version of our core messages, which I then took to the team for feedback.

Depending on where you're starting from, you can work through the different building blocks this way. The system makes sure everything builds on what came before in a meaningful way.

What's a system prompt?

Once my revised strategy is in place, I take it one step further: I derive a system prompt from it.

A system prompt is the overarching instruction you give a model once, which then automatically applies to every following interaction in that context — unlike the actual prompt, which you write fresh for each individual request.

In effect, I've built myself an assistant that supports me — or others on the team — in creating new content, while automatically paying into our content strategy:

• The system asks me who the content is for, and surfaces the pain points and content needs that fit.
• The system asks which core message should take the lead, and helps me align the content with it.
• The system walks me through every other relevant dimension — step by step.

From there, the system prompt can keep being refined as you work with it — for instance, once you realize that the channel you're writing for actually matters.

More than a tool trick

This is where, for me, the point that often gets missed becomes visible: automation only scales what's already structurally sound.

The system prompt is only ever as good as the content strategy it's derived from. The real work wasn't the prompting — it was sharpening the strategy. The strategic decisions — what we stand for, who we want to reach, with which message — were made by the team.

If you're curious, try it on a single building block: bring in the context, pick a topic, let it generate a proposal or sketch, fine-tune it with a colleague.

If you're already working with us and your content strategy could use a reality check, reach out: together, we can gather and review what you already have, then set it up in whichever AI tool your team prefers.

Working in the public sector and wondering how a process like this fits with your approval and compliance requirements? Let's talk — we have experience setting up AI-supported processes within existing governance structures.

Nevertheless, there is a lot of knowledge involved in getting something basic working in any of these frameworks. In this blog post I will explore what the most stripped down version of such a framework could look like, while still keeping the ergonomics of a reactive framework.

Let's get right into it.

Imagining the framework

To make this concrete, I built a small framework called effectlayer. I will explain its building blocks in this blog post.

Building blocks

The framework is built around a single JavaScript class, which the framework enhances with reactive behavior. That reactivity is powered by Signals, a common primitive used in frameworks such as Vue, Svelte, and SolidJS.

State

All class properties are treated as state. The framework turns them into Signals, so no state annotations are needed here:

class MoodSwing {
  energy = 5;
  coffee = 0;
}

Computed Values

Computed values use standard JavaScript getters. The framework treats them as derived Signals that update automatically when their dependencies change:

  get mood() {
    if (this.energy > 8) return "🤪";
    if (this.energy > 4) return "😀";
    if (this.energy > 0) return "😑";
    return "😴";
  }

Mutations

Methods are a natural fit for mutations:

  drinkCoffee() {
    this.coffee++;
    this.energy = Math.min(10, this.energy + 3);
  }

  work() {
    this.energy = Math.max(0, this.energy - 2);
  }

Effects

The last concept we need is effects. Effects are a fancy way of saying "a thing that executes when dependent Signals change".

I chose methods starting with $ for annotating them:

  $monitor() {
    if (this.coffee > 10) console.warn("You may want to slow down.");
  }

The framework sees that $monitor() uses coffee. After coffee changes, it calls the method again.

HTML

Rendering HTML is also an effect that just returns JSX.

  $ui() {
    return (
      <main>
        <h1>{this.mood}</h1>
        <button onClick={() => this.drinkCoffee()}>☕ Coffee</button>
        <button onClick={() => this.work()}>💻 Work</button>
      </main>
    );
  }

All that is left is to make the class reactive by wrapping it in an effectlayer call:

const moodSwing = effectlayer(MoodSwing);
moodSwing.$monitor();
document.body.appendChild(moodSwing.$ui());

Calling an effect once activates it. This means $monitor() will now run whenever coffee changes.

The $ui() call returns an HTML element and keeps it up to date.

All the concepts we need

So basically the framework only needs four concepts:

• properties for state
• getters for computed values
• methods for mutations
• methods starting with $ for effects

If you want to try out this experimental framework use:

npm create effectlayer

Or check it out on npm.

Deep Dive?

Let me know if you want to see a deep dive into how I built this framework: falk.zwimpfer@liip.ch

Let's be honest: the gen-AI hype is a threat to my content business. We're seeing companies hold back investment in their content. Why?

The capabilities of generative AI make it clear that our field is about to change significantly. But this field is broad — it brings together very different skill sets and areas of work.

So the interesting question becomes: how exactly will content work in organizations change?

A shift in roles

A study by AG CommTech and GK Personalberatung looks at how roles and skills are shifting in the communications profession. Their meta-study shows that what's needed today is a combination of technological efficiency and human authenticity — a growing need for experts who can interpret data, use AI to extract relevant insights from it, and translate those insights into effective communication strategies.

In other words, strategic skills matter more than ever.

More quantity, less quality?

Why is that?
Let's look at one visible area: generated text.

A Stanford study from early 2026 shows that around 35% of all newly published websites are now AI-generated or at least AI-assisted.

The volume of generated content is growing fast. But what about quality?

That's not a simple question, since quality has several dimensions.

Let's ask Claude about it. The bot points to a survey by the Content Marketing Institute, in which only 17% of B2B marketers rate the quality of AI-generated content as excellent or very good. 44% rate it as good, 35% as "fair," and 4% as poor. At the same time, 67% say they trust AI output only moderately, and 28% say they trust it little.

That's not exactly a robust finding, but it matches my own experience. So let's dig into the question: how does this middling track record come about?

Input quality equals output quality

AI can do a lot, but it can't work miracles. LLMs need a solid foundation to produce good results.

If I want to generate content for my company's channels, a solid foundation means the following:

• Complete data — AI can't generate reliable content if it can't find the relevant information in your existing content.
• Target group needs and questions as the central point of reference for the content.
• A content playbook that personalizes the output and aligns it with the organization's communication rules and goals.

That's a fairly sobering realization if you were hoping gen-AI would simply take the work off your hands. Depending on where you're starting from, meeting these requirements actually creates new work first.

But it also shows exactly where you can start to raise the quality of your generated content.

These requirements put user-centricity and content strategy & guidelines squarely at the center — which brings us right back to strategic skills.

In an upcoming post, I'll describe what belongs in a content strategy, in my view, and which elements deserve priority.

As the cost of content production trends toward zero, two things gain massively in importance:

• Quality of content
• Visibility and findability of content

Generative Engine Optimization (GEO) for the benefit of users

Visibility and findability of content is increasingly becoming a question of AI visibility: whether your own content and your own brand show up in the answers and results of AI chatbots and agents.

Here's some reassurance: LLMs prioritize content based on criteria that are also relevant to users.

Beyond the technical dimension – content must be readable and usable for AI systems – content also needs to meet the following dimensions:

• Built around the user
• Trustworthy
• Clear thematic positioning

This means the two aspects – quality and findability of content – are closely linked.

For a team to reach the point of producing content at this level of quality, we first need to clarify the fundamentals: without a clean alignment, no content team in the world is able to produce content of this quality in the medium term.

The Triple Content Line

We define our alignment as a content team across the following elements:

• Content strategy
• Content guidelines
• Content governance

As a team, this is where we agree on the common denominator for our content work. Only this way can we produce quality content that meets both internal and external requirements.

The line between content strategy and content guidelines isn't always easy to draw.

What belongs in a content strategy?

There's no definitive answer to what belongs in a content strategy. And beyond that, I'd describe a content strategy more as an ongoing area of work than as a finished document.

For me, the following elements belong in a content strategy:

• Content goals: What do I actually want to achieve with my content?
• Target audiences and their content needs
• Content journeys of the target audiences
• Channel strategy: Which channels do we work with, and how do they play together?
• Key messages
• Success measurement
• Interfaces to content governance and content lifecycle management

What belongs in content guidelines?

Unlike content strategy, content guidelines need to be embedded in day-to-day work. Alongside fixed reference points (e.g. the targeted language level), they often contain principles for us:

• Language level
• Language rules (e.g. consistent formatting of dates, currencies, and similar, but also topics like gender-neutral language or how to address target audiences)
• Tone of voice
• Page types
• Tools
• ...

What belongs in content governance?

Content governance defines who on the content team is responsible for what – and how we work together to make sure strategy and guidelines are actually put into practice. Without governance, strategy and guidelines remain well-intentioned documents that get lost in day-to-day business.

For me, the following elements belong in content governance:

• Roles and responsibilities: Who creates, who reviews, who approves?
• Approval processes: How does content move from idea to publication?
• Maintenance and update processes: Who is responsible for updates, and when?
• Quality assurance: How do we ensure guidelines are being followed?
• Escalation paths: What happens in case of disagreement or edge cases?
• Interfaces to other teams (e.g. design, product, marketing)

The goal? Interplay

Content strategy, content guidelines, and content governance work together: strategy sets the direction, guidelines translate it into daily practice, and governance ensures that both actually happen rather than just existing on paper. Only through the interplay of these three elements does content emerge that is consistent, trustworthy, and findable – both for users and for AI systems – while also meeting the positioning goals of your own organization.

Content production is getting cheaper. But without these fundamentals, it stays arbitrary – no matter how powerful the tools become. Whoever invests in strategy, guidelines, and governance now is laying the foundation for content that will still be found, understood, and trusted tomorrow.

How Generative Engine Optimization (GEO) works in practice will follow in upcoming posts.

A brief history of LiipGPT and ZüriCityGPT

2023, Chregu released the first version of LiipGPT. 2024, we were able to use only open-source models on ZüriCityGPT. 2025, we switched the open-source version to the newly released Apertus model. In this blog post, we talk about the insights gained since then.

Setting up the experiment

LiipGPT, our generative AI framework, has a pluggable model layer. That means we can swap the underlying language model without changing anything else — same Retrieval-Augmented Generation (RAG) pipeline, same knowledge base of official content from stadt-zuerich.ch. This gave us a straightforward way to compare models in a real deployment.

The production system at zuericitygpt.ch runs GPT-4o-mini on Azure Europe. Alongside it, we run an open-source variant at oss.zuericitygpt.ch where in the past we compared Llama and Mixtral models. We switched the open-source variant to Apertus-70B when it was released in September 2025, then moved to Infomaniak-hosted Apertus in April 2026. (To be clear: ZüriCityGPT itself and the LiipGPT platform are not open source — but the underlying language model on the OSS variant is.)

We run Apertus as the 70-billion-parameter model. It was trained from scratch on the Alps supercomputer using Swiss hydroelectricity, with 15 trillion tokens of training data spanning over 1,800 languages. It is fully open-source under an Apache 2.0 licence.

Over the last eight months, we collected over 39,000 conversations on the production side and 3,400 on the open-source side. Quality is measured using three metrics: how often an answer is acceptable (Match Rate), how often it is actually good (Match Rate +1), and how faithfully it reflects the source documents (Faithfulness). These are metrics our LiipGPT team has established as practical product metrics, not scientific benchmarks — the data is calculated real-time and asynchronously by the LiipGPT platform while users ask different questions over time, evolving website content, and model endpoint changes. Parts of the analysis were prepared with the help of Claude. Our aim is not to provide a scientific study but more a practical report. I share these results with the Apertus community because real-world deployment data of this open-source model is rare — and we think it's useful.

What we observed

Both models get the job done. On the basic question — does the user get an acceptable answer? — both models perform similarly. GPT-4o-mini scores 81%, Apertus 82% on historically matched questions. In a controlled test with 20 identical questions asked at the same moment, both hit 100%. Both models generally work as expected.

The gap shows up in answer quality. When we raise the bar to "is this answer actually good?", GPT-4o-mini scores 72% and Apertus 55%. That is a noticeable difference, and it matters for users who expect precise, well-structured responses.

Faithfulness is more nuanced than we expected. GPT-4o-mini averages 0.79, Apertus 0.50 on our faithfulness metric. But these numbers need context. We noticed something we started calling the "faithfulness paradox": when a model says "I cannot answer this," you might expect high faithfulness — no hallucination, after all. In practice, these evasive answers score low because the model is failing to use information that is available. A model that engages with its sources and cites them scores higher, even though it is making more verifiable claims. Both behaviours have tradeoffs, and both showed up across the two systems.

Sometimes Apertus gave the better answer. The most striking example was the waste dump question: "What are the rules for using the Zurich waste dump?" GPT-4o-mini responded cautiously, saying it could not provide specific rules. Apertus gave a detailed, structured answer with recycling centre details, phone numbers, and cited sources — scoring 6/6 on quality where GPT-4o-mini scored 3/6. When the knowledge base contains a clear, structured answer, Apertus can be surprisingly good at extracting and presenting it.

That said, this willingness to commit cuts both ways. In cases where the source material is ambiguous, Apertus can feel more helpful while being less strictly grounded — and for public-sector chatbots, traceability matters as much as helpfulness.

GPT-4o-mini is more concise and better at synthesis. Apertus tends to produce longer, more verbose answers. In a public-service chatbot, that is a real UX issue — users want a direct answer with clear next steps, not three paragraphs of context.

GPT-4o-mini also handles factual freshness better: it returned Zurich's current population (452,421), while Apertus fell back to a 2013 figure. When information has changed or the answer requires connecting multiple sources, GPT-4o-mini felt more reliable.

Language switching is a weak spot. When we asked "Est-ce que tu parles français?", GPT-4o-mini responded fluently in French. Apertus declined, saying it could not answer questions about its own linguistic capabilities. In more recent tests we saw that Apertus followed the language instructions in better ways, so we are looking forward to see this further improve.

The Apertus-70B IFEval score of 44% (vs 58% for comparable models) confirms that instruction following is an area where the model has room to grow.

The trend is positive. In October 2025, Apertus achieved a Match Rate +1 of 59%. By June 2026, it had climbed to 63% — the best month on record. That is not a dramatic leap, but the direction is consistent and it came without a major model update. Meanwhile, GPT-4o-mini has been stable at 63–83% throughout. The gap is narrowing.

What we are looking forward to

The Apertus team is preparing version 1.5, with improvements expected in multimodal support, agentic capabilities, tool calling, enhanced reasoning, and better training for regional Swiss languages. We plan to update ZüriCityGPT's open-source instance as soon as it becomes available and continue our quality monitoring.

What encourages us most is that the collaboration is flowing in both directions. After our aiLights talk, the Apertus team shared our findings with their staff. This close feedback loop between research and practice is exactly what makes the Swiss AI ecosystem worth investing in.

My practical advice, for anyone considering sovereign AI: start with the use case, then choose the model. If your priority is maximum answer quality today, more popular models are usually the stronger choice. If your priority is data sovereignty, transparency, and independence — and your knowledge base is well-curated — Apertus already delivers. The question is not "sovereign AI or quality" but "how much quality gap are you willing to accept for full sovereignty?" And that gap is closing.

Check the Slides and Recording for further details.

Acknowledgements

I would like to thank the ETH Zurich, EPFL, and the wider Swiss AI Initiative community for making Apertus available as a public good. As Martin Jaggi from EPFL put it: "We aim to provide a blueprint for how a trustworthy, sovereign, and inclusive AI model can be developed." (source) Eight months in, we can see that blueprint taking shape and are looking forward to test the 1.5 model in practice as well.

• Thank you Christian Stocker and the LiipGPT team for your dedication to build a practical, experiment-driven and scalable solution for AI chat and search.

• Thank you Sabine Wildemann and the aiLights team for hosting our talk.

• Thank you Oleg Lavrovsky and the Apertus community for your feedback and support.

• Thank you Public AI and our partner Infomaniak for providing the infrastructure.

Build with Apertus: join Hack Apertus

Want to get hands-on with sovereign Swiss AI? Hack Apertus is a two-stage open-source hackathon series where teams build on Apertus to develop blueprints for sovereign infrastructure across the public and private sector. Liip is a partner — we are excited to see what the community builds.

Sign up at hackapertus.ch.

Le portail fr.ch rassemble une grande quantité de contenus administratifs: démarches, législation, formulaires, prestations cantonales, informations communales. Trouver la bonne réponse dans un site aussi vaste n'est pas toujours chose aisée.

Il suffit de poser sa question en langage naturel, comme on le ferait à une personne. Si le site fr.ch est rédigé en français et allemand, canton bilingue oblige, on peut poser sa question dans n’importe quelle autre langue, pour que les citoyen·ne·s ne parlant ces langues puissent tout de même trouver les informations nécessaires.

Le chatbot IA identifie les contenus pertinents sur fr.ch et dans la base légale fribourgeoise, puis génère une réponse écrite, en citant les sources officielles utilisées.

Cette transparence est essentielle. L'IA ne remplace pas les contenus officiels, elle en facilite l'accès.

Une IA pensée pour la souveraineté numérique

La souveraineté des données est au cœur du projet. La Chancellerie souhaitait en effet absolument garder la maîtrise complète de l'infrastructure et du traitement.

Le chatbot s'appuie sur LiipGPT, notre plateforme d'IA générative. Notre moteur de Retrieval Augmented Generation (RAG) sélectionne les contenus officiels pertinents pour chaque question. Il est hébergé en Suisse chez Exoscale.

Côté modèle de langage (Large Language Model, LLM), nous utilisons Mistral AI, un outil européen majeur. Le modèle est lui aussi hébergé en Suisse, chez Infomaniak, pionnier de l'hébergement web éco-responsable et durable s’il en est. Les serveurs du LLM utilisent exclusivement des énergies renouvelables, avec refroidissement naturel et réutilisation de la chaleur, sans oublier l’utilisation de matériel recyclé et optimisé ainsi qu’une compensation carbone locale.

Cette architecture réduit la dépendance aux grandes plateformes américaines et privilégie une approche suisse et européenne de l'IA générative. Les requêtes sont anonymisées et aucune donnée personnelle n'est transmise à des tiers. L'ensemble reste sous juridiction suisse, conformément à la législation en vigueur sur la protection des données.

Une collaboration ancrée en Suisse romande

La Chancellerie d'Etat de Fribourg a piloté le projet, avec une vision claire des enjeux administratifs et politiques. Notre équipe, notamment active à Fribourg, a développé la solution en étroite collaboration avec la Chancellerie. Ceci a permis de répondre au mieux aux besoins réels issus du terrain.

Cette proximité a permis des échanges rapides et une attention forte portée à l'expérience utilisateur·rice. Au-delà de la technologie, l'enjeu était de créer un outil qui soit à la fois utile, fiable et compréhensible pour la population fribourgeoise.

Une première étape vers une administration plus accessible

Depuis le premier déploiement en mars, nous avons retravaillé certains éléments afin d’améliorer la qualité des réponses. Pour ce faire, notre client bénéficie notamment de nos solutions d'évaluation automatisées afin de contrôler en continu le niveau de qualité des réponses.

Cette première version couvre les informations publiques se trouvant sur fr.ch et la base légale fribourgeoise. Mais le périmètre ne se limite pas au seul portail cantonal: il s'élargit progressivement aux informations publiées par d'autres institutions cantonales et par certaines communes. Qui dit nouvelles sources, dit bien sûr vigilance accrue pour s’assurer que le niveau de qualité des réponses demeure. L'Etat de Fribourg tient d'ailleurs à jour une page dédiée au chatbot, qui détaille notamment les sources de données utilisées.

Une conviction guide ce travail. L'IA dans le secteur public peut être souveraine, transparente et utile. Pour y parvenir, il est nécessaire de toujours garder la maîtrise de l'infrastructure et de citer ses sources.

Envie d'échanger sur l'IA pour votre institution? N'hésitez pas à me contacter.