No more adding MCP servers manually to ChatGPT, just give it a hint where to look (I assume with a more obvious or well-known domain, it would figure that out by itself). Maybe not "no more," but hopefully less setup and more discovery. Authentication is also usually solved with WebMCP in the way users are used to: it runs in a browser session, where you might need to log in to a site first. No more OAuth workflows that are obscure to the casual user.

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 approach 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.

From August 1 to November 1, I was in the Finance Circle. This is where it all started

I supported the move of the Finance area away from our Atlassian wiki. The new solution was not yet decided. So I put everything from it onto Google Drive for the time being. That sounds like a simple cleanup job. In fact, it was a good starting point to see how much knowledge actually comes together at Liip, and where it lives.

My tasks in the Circle:

• Responsibility for our Finance email, where all invoices arrive. I cleared them and entered them into RMA, our finance system.
• The monthly credit card reconciliation, where I always looked for automation potential too.
• Refreshing the NDA archive. I took over the entire history and built a few automations for it in Google Sheets, so nobody has to check by hand anymore where a contract sits.

I had the most fun whenever I could freely look for automation potential and research it. The big data transfers were less exciting. A good tip for that: put on a podcast, then it works out fine. The most typical Finance task for me was the monthly credit card reconciliation. Exactly the kind of work that keeps a company running in the background.

In the Finance Circle, I did not learn numbers first, I learned how Liip works as a company.

From November 1 to February 1, I was in the Drupal Zürich Circle. This is where things got more concrete

Here, for the first time, I got to take on a piece of the PO role. Together with Petra, I supported one project. On other projects, I first watched and took on smaller tasks to understand the business behind them. That was a different pace than the Finance Circle. Instead of taking over existing processes, I had to understand how a client project comes together in the first place, from the first requirement to implementation.

Later, bigger tasks were added:

• PO testing after the developers' first implementation
• A handbook for the Drupal backend, which I wrote from scratch

For that handbook, the explanations had to be simple enough that even someone without a coding background could work with it. That was the biggest exercise for me.

Even though this is a production Circle at Liip, I never coded myself there. In vocational school, I did work with Python. It was not really for me, though. What I do appreciate: Petra keeps pushing me toward code in our syncs, explaining or showing me things. In the Circle itself, I dealt a lot with the backend and frontend, but never in the code directly. The coolest moment for me was finishing the handbook. Afterward, a lot of positive, grateful reactions came in.

In the Drupal Zürich Circle, I learned what Liip as a company actually stands for.

From February 1 to August 1, I was in the Design and Content Circle. This is where I got to show what I had learned

In this Circle, a lot revolved around AI with a focus on content, whether creation, editing, or guidelines. For client projects, I got to:

• Write prompt sheets for Textmates
• Try out process optimizations
• Write my own blog post
• Build my own AI tools
• Help with trainings and workshops, and shape them myself in the end

That ranges from preparing the materials to actively supporting the workshop itself, when participants have questions or get stuck on an exercise.

The workshop I mentioned at the start was with Caritas St. Gallen und Appenzell. At the same time, it was our very first Responsible AI Workshop. In the very year I grew at Liip myself, our expertise on this topic grew a lot too.

I was in no other Circle this long. That made a difference. I was much more integrated into the Circle's work. Especially in the second half, I noticed how much trust and responsibility I was given to get things done on my own. Content-wise, the work here was especially exciting: it revolved a lot around Liip's internal content, combined with workshops for clients where we could pass on our knowledge. That was something different again from the two Circles before.

In the Design and Content Circle, I no longer just got to learn, I got to pass something on myself.

What built up over the year

When I put the three Circles side by side, I mostly see a curve in responsibility. In the Finance Circle, I took over processes that already existed, and got to know people, tools, and workflows at Liip along the way. In the Drupal Zürich Circle, it was more about Liip's actual business, web development, and I already got to make my own decisions in PO testing and even got to know clients. In the Design and Content Circle, I could use that knowledge to work on strategic tasks, build my own tools, and help shape workshops.

Each Circle prepared me for the next. Not because I planned it myself, but because that is exactly the system behind the Digital Business Developer apprenticeship at Liip. I see that most clearly with automation. In the Finance Circle, I learned through the credit card reconciliation how to break down a process and look for automation potential. I needed exactly that mindset again in the Design and Content Circle, when I built my own AI tools. Without the first step, I could not have approached the third the way I did.

One thing ran through all three Circles, and it has nothing to do with expertise. I learned that I can go to others and ask for help. Not because I am an apprentice and that is allowed, but because at Liip that is simply normal for everyone.

Trust did not come all at once for me, it came Circle by Circle, and that is what has changed me the most from last August until today.

What does your own learning curve look like? Does it build up step by step for you too, or more in leaps?

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.

The fr.ch portal brings together a vast amount of administrative information: procedures, legislation, forms, cantonal services, and municipal information. Finding the right answer within such a large website is not always straightforward.

Users simply ask their question in natural language, just as they would ask another person. Although fr.ch is available in French and German, as befits a bilingual canton, questions can be asked in any language, allowing people who do not speak either official language to access the information they need.

The AI chatbot identifies relevant content on fr.ch and within Fribourg’s legal database, then generates a written response while citing the official sources used.

This transparency is essential. AI does not replace official information; it makes it easier to access.

AI Designed for Digital Sovereignty

Data sovereignty was a central requirement of the project. The State Chancellery wanted to retain full control over both the infrastructure and data processing.

The chatbot is powered by LiipGPT, our generative AI platform. Our Retrieval-Augmented Generation (RAG) engine selects the official content most relevant to each question. The solution is hosted in Switzerland by Exoscale.

For the Large Language Model (LLM), we use Mistral AI, a leading European provider. The model is also hosted in Switzerland by Infomaniak, a pioneer in sustainable and environmentally responsible web hosting. The LLM servers run exclusively on renewable energy and combine natural cooling, heat recovery, optimised and recycled hardware, and local carbon offsetting.

This architecture reduces dependence on major US-based platforms and promotes a Swiss and European approach to generative AI. Requests are anonymised, and no personal data is shared with third parties. The entire solution remains under Swiss jurisdiction and complies with applicable data protection legislation.

A Collaboration Rooted in Western Switzerland

The State Chancellery of Fribourg led the project with a clear understanding of the administrative and political challenges involved. Our team, including colleagues based in Fribourg, developed the solution in close collaboration with the Chancellery, ensuring it addressed real-world needs as effectively as possible.

This close partnership enabled fast feedback loops and a strong focus on user experience. Beyond the technology itself, the goal was to create a tool that is useful, reliable, and easy for the people of Fribourg to understand and use.

A First Step Towards a More Accessible Administration

Since the initial launch in March, we have refined several aspects of the solution to further improve response quality. To support this process, our client benefits from our automated evaluation tools, which continuously monitor and assess the quality of generated responses.

This first version covers public information available on fr.ch as well as Fribourg’s legal database. However, the scope is not limited to the cantonal portal alone: it is gradually being extended to include information published by other cantonal institutions and selected municipalities. As new sources are added, maintaining response quality remains a key priority. The Canton of Fribourg also maintains a dedicated page for the chatbot, which sets out, amongst other things, the data sources used.

One conviction guides our work: AI in the public sector can be sovereign, transparent, and useful. Achieving this requires maintaining control over the infrastructure and always providing clear source references.

Interested in discussing AI for your institution? Don't hesitate to contact me