Das Wichtigste in Kürze

  • OpenUI 1.0 ist ein quelloffenes Framework von Thesys, das Agenten-Antworten in strukturierte UI-Spezifikationen übersetzt, die deine eigene Komponentenbibliothek live rendert.
  • Statt Text in eine Chatbox zu kippen, liefert der Agent Spezifikationen für Diagramme, Formulare oder Karten, die direkt in deiner App erscheinen und interaktiv bleiben.
  • Der Einstieg läuft über das offene Repository: klonen, wenige bestehende Komponenten an den Renderer anbinden, eine Grafik oder ein Formular testen und erst dann ausbauen.
  • Ein öffentlicher Build, Download oder eine offizielle Produktseite ist bisher nicht veröffentlicht; bislang wurde OpenUI 1.0 nur in einer kurzen Vorschau vorgestellt.

Kurzüberblick

TypOpen-Source-Framework für generative UI
GeräteWeb, im Browser lauffähig
KostenQuellcode offen; Details auf der offiziellen Seite prüfen
SprachenDokumentation überwiegend englisch
HighlightEigene Komponenten rendern Agent-Antworten live
EinstiegRepository klonen, Komponenten mappen, testen
KategorieDev- & Web-Tools
UrheberRabi Shanker Guha
Trend-Index🔥 2,1 Mio. Trend-Index
Zuletzt aktualisiert

Warum OpenUI 1.0 generative UI für jeden Agenten öffnet

Seit rund 30 Jahren bewegt sich Technik in eine Richtung: Informationen werden zu intuitiven Oberflächen. Doch die klügste Software, die wir je gebaut haben, führte uns zurück zu einem Textfeld. Genau dieses Problem greift OpenUI 1.0 auf. Thesys arbeitet seit zwei Jahren daran, und vor sechs Monaten wurde das Projekt quelloffen veröffentlicht, mit nach eigenen Angaben über 10.000 GitHub-Sternen und mehr als sechs Millionen Downloads.

Der Auslöser für den aktuellen Schub: ChatGPT brachte Intelligent UI und zeigte damit allen, wie sich Antworten als echte Oberfläche anfühlen. OpenUI 1.0 führt diesen Gedanken weiter, indem es generative UI nicht an ein einzelnes Produkt bindet, sondern für jeden anderen Agenten verfügbar macht. Die Ankündigung erfolgte am 15. Oktober 2026 durch Rabi Shanker Guha.

Wichtig für die Einordnung: Bisher gibt es keinen öffentlichen Build, keinen Download und keine offizielle Produktseite. Gezeigt wurde OpenUI 1.0 nur in einer kurzen Vorschau. Wer es ausprobieren will, sollte den offiziellen Kanal von Thesys im Blick behalten und dort prüfen, wann ein nutzbarer Stand erscheint.

  • Vom Textfeld zur Oberfläche

    Der Kern des Problems ist, dass Agenten ihr Wissen als Fließtext ausgeben, obwohl eine Tabelle oder ein Diagramm oft schneller verständlich wäre.

  • Offen statt geschlossen

    OpenUI 1.0 ist quelloffen und soll laut Ankündigung mit jedem Agenten funktionieren, nicht nur mit einem bestimmten Anbieter.

  • Thesys als Entwickler

    Hinter dem Projekt steht Thesys; die zweijährige Entwicklungszeit und die offene Veröffentlichung vor sechs Monaten stammen aus der Ankündigung.

So funktioniert der Renderer: Spezifikationen statt Textblöcke

Im Kern gibt der Agent keine fertige HTML-Seite aus, sondern strukturierte UI-Spezifikationen. Diese Spezifikationen beschreiben, welche Komponente mit welchen Daten dargestellt werden soll. Deine Komponentenbibliothek übernimmt das Rendern und zeigt das Ergebnis live in der Oberfläche an. Dadurch bleibt die Darstellung in deinem Design und deiner Technik verankert.

Entwickler binden ihre eigenen React-Komponenten in die Pipeline ein. Antworten erscheinen dann als interaktive Diagramme, Formulare oder Karten statt als reiner Text. Der Agent liefert also Daten und Struktur, die Kontrolle über Aussehen und Verhalten bleibt beim Team, das die Komponenten bereitstellt.

Vergleiche in der Community stellen generierte Dashboards und Formulare direkten Chatbot-Antworten gegenüber, um den Unterschied sichtbar zu machen. Ein wichtiger Hinweis: Die genauen Spezifikationsformate, unterstützten Komponententypen und Grenzen sind aus der Vorschau nicht vollständig belegt. Verbindliche Angaben findest du erst auf der offiziellen Seite von Thesys.

  • Agent liefert Struktur

    Der Agent entscheidet, welche Art von Oberfläche passt, und beschreibt sie als Spezifikation, nicht als fertigen Text.

  • Deine Komponenten rendern

    Eigene React-Komponenten werden an den Renderer gemappt, sodass Charts, Formulare und Karten im eigenen Design erscheinen.

  • Interaktiv statt statisch

    Weil echte Komponenten gerendert werden, können Nutzer mit Diagrammen und Formularen arbeiten, statt nur zu lesen.

Praktischer Einstieg: Repository klonen, Komponenten mappen, testen

Der empfohlene Weg beginnt mit dem Klonen des quelloffenen Repositorys. Danach mappst du zunächst nur wenige deiner bestehenden Komponenten auf den Renderer, statt sofort die ganze Bibliothek anzubinden. So siehst du schnell, ob die Pipeline zu deinem Stack passt, und hältst den Aufwand klein.

Teste anschließend genau einen Anwendungsfall, etwa ein Diagramm oder ein Formular. Erst wenn dieser Fall zuverlässig läuft, skalierst du auf weitere Komponenten und komplexere Oberflächen. Dieser schrittweise Aufbau passt zur offenen Struktur des Projekts und verhindert, dass Fehler in der Spezifikation erst spät auffallen.

Laut den vorliegenden Hinweisen läuft OpenUI 1.0 im Browser flüssig. Da es aber noch keinen öffentlichen Build gibt, ist der konkrete Startablauf bis zur Veröffentlichung nicht bestätigt. Prüfe auf der offiziellen Seite, welche Voraussetzungen, Versionen und Beispielprojekte tatsächlich bereitstehen, bevor du es in eine produktive Anwendung einplanst.

  • Klein anfangen

    Binde zuerst ein bis zwei Komponenten an und prüfe die Ausgabe, bevor du die gesamte Bibliothek migrierst.

  • Einen Fall testen

    Ein einzelnes Diagramm oder Formular zeigt schneller, ob Spezifikation und Renderer zusammenpassen, als ein großes Dashboard.

  • Offiziellen Stand prüfen

    Da kein öffentlicher Build existiert, solltest du Voraussetzungen und Startanleitung direkt bei Thesys nachlesen.

Anwendungsfälle, Alternativen und Grenzen

Typische Szenarien sind Analyse-Agenten, die Ergebnisse als Diagramm ausgeben, Assistenten, die Eingaben über ein Formular einsammeln, und Anwendungen, die Orte oder Routen auf einer Karte zeigen. Der Vorteil liegt jedes Mal darin, dass die Antwort nicht nur beschrieben, sondern direkt bedienbar wird. Für Teams, die bereits eine eigene Komponentenbibliothek pflegen, ist das der naheliegendste Gewinn.

Der Vergleich mit Alternativen hängt vom Ansatz ab: Manche Produkte liefern generative UI fest in ihre eigene Oberfläche eingebaut, während OpenUI 1.0 offen ist und laut Ankündigung mit jedem Agenten zusammenspielen soll. Genau diese Offenheit ist der Unterschied, den Thesys betont. Ob und wie gut das in der Praxis mit fremden Agenten funktioniert, lässt sich erst nach einer Veröffentlichung beurteilen.

Zu den Grenzen gehört der aktuelle Status: Es gibt noch keinen öffentlichen Build und keine offizielle Seite, also auch keine belastbaren Angaben zu Lizenzen, unterstützten Frameworks, Grenzfällen oder Performance. Wer OpenUI 1.0 einplanen will, sollte es als vielversprechendes, aber noch nicht nutzbares Projekt behandeln und die Ankündigung von Thesys weiterverfolgen.

  • Analyse und Reporting

    Agenten können Kennzahlen als Diagramm ausgeben, statt sie in Absätzen zu erklären.

  • Datenerfassung

    Formulare als generierte Oberfläche eignen sich, wenn ein Assistent strukturierte Eingaben braucht.

  • Standort und Karten

    Karten-Komponenten helfen, sobald Antworten einen räumlichen Bezug haben.

  • Noch nicht produktiv

    Ohne öffentlichen Build fehlen belastbare Angaben zu Lizenz, Kompatibilität und Grenzen; diese Punkte erst nach Veröffentlichung prüfen.

Schritt-für-Schritt-Anleitung

  1. Ankündigung und Status prüfen

    Verschaffe dir zuerst einen Überblick über die Ankündigung von Thesys vom 15. Oktober 2026 und die kurze Vorschau. Dort siehst du, was OpenUI 1.0 leisten soll und dass bisher kein öffentlicher Build veröffentlicht wurde.

  2. Repository klonen

    Sobald ein nutzbarer Stand verfügbar ist, klonst du das quelloffene Repository von Thesys. Prüfe dabei die angegebene Version und die Voraussetzungen, damit dein Projekt zur veröffentlichten Struktur passt.

  3. Komponenten mappen

    Binde zunächst nur wenige deiner bestehenden Komponenten an den Renderer an. So erkennst du früh, ob die Spezifikationen zu deinem Komponentenmodell passen, ohne gleich die ganze Bibliothek umzubauen.

  4. Ersten Fall testen

    Wähle ein einzelnes Diagramm oder Formular und prüfe, ob der Agent die passende Spezifikation liefert und deine Komponente korrekt rendert. Vergleiche das Ergebnis mit einer reinen Textantwort, um den Mehrwert zu beurteilen.

  5. Schrittweise ausbauen

    Wenn der erste Fall stabil läuft, erweiterst du auf weitere Komponenten und komplexere Oberflächen wie Karten oder Dashboards. Behalte die offizielle Dokumentation im Blick, weil sich Details vor der Veröffentlichung noch ändern können.

Häufige Fragen

Was ist OpenUI 1.0 genau?

OpenUI 1.0 ist ein quelloffenes Framework von Thesys für generative UI. Es lässt Agenten strukturierte UI-Spezifikationen ausgeben, die deine eigene Komponentenbibliothek live rendert. Statt Text in eine Chatbox zu schreiben, erscheinen Antworten als interaktive Diagramme, Formulare oder Karten. Die Ankündigung erfolgte am 15. Oktober 2026 durch Rabi Shanker Guha.

Kann ich OpenUI 1.0 schon kostenlos nutzen oder herunterladen?

Aktuell nicht. Laut den vorliegenden Informationen gibt es noch keinen öffentlichen Build, keinen Download und keine offizielle Produktseite. Bisher wurde OpenUI 1.0 nur in einer kurzen Vorschau gezeigt. Ob und zu welchen Bedingungen es später kostenlos nutzbar sein wird, solltest du auf der offiziellen Seite von Thesys prüfen, sobald dort Angaben veröffentlicht werden.

Wie funktioniert die generative UI technisch?

Der Agent gibt keine fertige Seite aus, sondern eine Spezifikation, die beschreibt, welche Komponente mit welchen Daten dargestellt werden soll. Entwickler binden ihre eigenen React-Komponenten in die Pipeline ein, und der Renderer erzeugt daraus die sichtbare Oberfläche. Dadurch bleiben Design und Verhalten unter Kontrolle des Teams, das die Komponenten bereitstellt.

Für wen lohnt sich OpenUI 1.0 und was sind die Grenzen?

Besonders interessant ist es für Teams, die Agenten in eigene Anwendungen einbetten und bereits eine Komponentenbibliothek pflegen. Der offene Ansatz soll laut Ankündigung mit jedem Agenten funktionieren, nicht nur mit einem bestimmten Produkt. Grenzen sind der fehlende öffentliche Build und die daraus folgende Unsicherheit bei Lizenz, Kompatibilität und Performance; diese Punkte lassen sich erst nach einer Veröffentlichung bewerten.

Wie unterscheidet sich OpenUI 1.0 von eingebauter generativer UI?

Eingebaute generative UI ist fest an die Oberfläche eines bestimmten Produkts gebunden. OpenUI 1.0 setzt dagegen auf Offenheit: Der Quellcode ist verfügbar, und die Ausgabe wird über deine eigenen Komponenten gerendert. Damit soll generative UI auch für andere Agenten nutzbar werden. Wie gut das mit fremden Agenten in der Praxis klappt, ist ohne veröffentlichten Build noch nicht belegt.