Kann KI ein Textadventure spielen?

Du wirst wahrscheinlich von einem Grue gefressen.

Textadventures sind eine Form interaktiver Fiktion. Man tippt Befehle wie „examine sword” oder „go north”, um eine Welt zu erkunden und Rätsel zu lösen. Sie sind stark inspiriert von Choose Your Own Adventure-Büchern und natürlich klassischen Pen-&-Paper-Rollenspielen.

Einige der frühesten Textadventures wie Colossal Cave Adventure (1976), Adventureland (1978) und Dungeon wurden auf Großrechnern wie dem PDP-10 gespielt, meist versteckt in den Computerräumen von Universitäten wie Stanford oder MIT.

Einer der einflussreichsten Titel war Zork, ursprünglich 1977–79 von Tim Anderson, Marc Blank, Bruce Daniels und Dave Lebling an der Dynamic Modeling Group des MIT entwickelt. Zork warf die Spieler ins „Great Underground Empire” – eine mysteriöse, monsterverseuchte Welt voller Rätsel, Schätze und kaum vorhandener Wegweiser. Nach seinem Erfolg als Mainframe-Spiel wurde es später auf Heimcomputer wie den Apple II und den Commodore 64 portiert und von Infocom vertrieben – es wurde eines der meistverkauften Textadventures aller Zeiten.

Ich wollte schon immer die Welt von Zork besuchen, ihre Dungeons und Gefahren erkunden, Schätze sammeln und uralte Rätsel lösen. Vor allem wollte ich dieses ikonische Stück Computergeschichte selbst erleben. Ich habe es mehrfach versucht, nur um etwas verbittert zuzugeben, dass ich bei Textadventures absolut versage. Ich kann mir keine Orte merken, lasse mich ablenken und – ehrlich gesagt – mir fehlt die Geduld, um richtig einzutauchen.

Trotzdem faszinieren sie mich. Es hat etwas Magisches, eine Welt, die nur im Kopf existiert. Als mein Sohn kleiner war, habe ich ihm Geschichten vorgelesen, und wir haben die Handlung oft umgebogen, neue Figuren erfunden und alberne Wendungen eingebaut. Ich liebe die Idee, Textadventures für Kinder zugänglicher zu machen – als Raum für Fantasie und Entdeckung.

Zork läuft im Terminal.

Aber neulich hatte ich eine andere Idee: Jetzt, wo KI so weit fortgeschritten ist – könnte sie ein Textadventure alleine spielen? Beschreibungen lesen, Kontext verstehen, die Welt navigieren, Objekte benutzen und tatsächlich Rätsel lösen? Bei modernen Context Windows, die schneller wachsen als meine Todo-Liste – könnte eine KI den gesamten Spielstand im Gedächtnis behalten und vielleicht sogar gewinnen?

Spoiler: kann sie nicht. Noch nicht jedenfalls. Aber es war ein faszinierendes Experiment und überraschend aufschlussreich. Den Versuch, ein Sprachmodell Zork spielen zu lassen, stellt sich als ziemlich guter Test für Reasoning, Gedächtnis und Interaktionsfähigkeit heraus. Versteht es die Aufgabe? Kann es seinen Fortschritt verfolgen? Kann es improvisieren? Kann es das Spiel tatsächlich beenden?

Unser KI-Abenteurer findet Freunde.

Proof of Concept 1: Human in the Loop

Ich beginne jedes Projekt gerne mit einem Proof of Concept, der die Kernidee mit möglichst wenig Aufwand testet. In diesem Fall war die Frage einfach: Kann eine KI das Konzept eines Textadventures überhaupt begreifen, geschweige denn eins spielen? Für dieses erste Experiment nutzte ich ChatGPT.

Ich startete das Spiel im Terminal und übernahm die Rolle einer menschlichen API – kopierte die Spielausgabe manuell in den Chat und fügte die Antworten der KI ins Spiel ein. Die Konversation sah ungefähr so aus, mit ChatGPT als ahnungslosem Abenteurer und mir als geduldigem Dungeon Master:

Proof of Concept 1 Ergebnis: Erfolg!

Die Konversation ging noch eine Weile weiter, bis ich den Test schließlich beendete. Die KI konnte im Spiel navigieren und mit der Welt und ihren Objekten interagieren. In diesem kurzen Gespräch konnten wir Folgendes validieren:

Das fühlte sich wie ein kleiner, aber bemerkenswerter Erfolg an. Ich war ehrlich beeindruckt. In den nächsten Minuten machte das LLM stetig Fortschritte und navigierte durch die unheimliche Welt von Zork wie ein leicht verwirrter, aber entschlossener Abenteurer.

Proof of Concept 2: Vibe Coding

Es ist immer verlockend, direkt vom Proof of Concept zum „richtigen” Produkt zu springen. Und genau das habe ich getan. Rückblickend hätte ich die KI wohl erst weiter manuell testen sollen, um sicherzugehen, dass sie das Spiel tatsächlich durchspielen kann. Aber ich wollte unbedingt in den Vibe-Coding-Modus, also siegte die Ungeduld.

Der nächste Schritt lag auf der Hand: den Human-in-the-Loop (mich) entfernen und das LLM direkt mit dem Spiel interagieren lassen.

Da ChatGPT den ersten Test so gut gemeistert hatte, bat ich es um einen letzten Gefallen: einen System Prompt zu schreiben – eine Art Bedienungsanleitung – damit andere LLMs seinem Beispiel folgen können.

Der System Prompt:

You are playing a classic text adventure game like Zork. Your objective is to explore, solve puzzles, and complete the adventure by issuing valid game commands.

Rules:
1. Respond ONLY with a SINGLE game command each turn. Do NOT include explanations, reasoning, or multiple commands.
2. Commands should be concise, typically one or two words, using standard adventure verbs (e.g., north, take lamp, open door, examine object).
3. Always consider the game's last output carefully to understand your surroundings and what actions are possible.
4. Avoid repeating identical commands that have already succeeded or failed; instead, try new logical actions or explore new areas.
5. If unsure, prioritize commands that gather information, such as "look", "examine [object]", or "inventory".
6. Use directions (north, south, east, west, up, down) to navigate through the environment.
7. When stuck, try interacting with objects in the environment or using items in your inventory.
8. Remember the goal: exploration, puzzle solving, and advancing the story.

Für den initialen Code starte ich normalerweise mit Claude. Aus irgendeinem Grund bekomme ich in der frühen Entwicklungsphase damit die besten Ergebnisse. Wenn mein Tageskontingent aufgebraucht ist, wechsle ich zu VSCode und arbeite mit Augment als KI-Coding-Agent weiter.

Mein erster Prompt zielt typischerweise darauf ab, ein grobes Verständnis des Konzepts und einen ersten Implementierungsentwurf zu bekommen:

I have a program running inside my mac terminal.
It is a text adventure which takes commands from the user and outputs the results of the instruction.
I want to create a script which let's a llm interact with the program and solve the text adventure.
What is the best technical approach to achieve this?

Claude schlug ein Python-Projekt mit den üblichen Libraries und einem Bash-Skript vor, was meinen Vorstellungen entsprach, also legte ich los:

create that script for me. some information
* use ollama API
* model name is mistral-small3.1:latest
* name of the terminal app is zork (typing "zork" into the terminal starts the game)
* create the requirements.txt file needed
* create a bash script which activates the virtual environment venv before launching the python script which calls main.py
* store the conversation in a log file

Interessanterweise lief das Skript nach nur ein paar kleinen Korrekturen und konnte mit dem Spiel interagieren. Ziemlich aufregend! Aber mit jeder Iteration wurde der Code komplexer – ein klassischer Nebeneffekt von Vibe Coding ohne zwischenzeitliches Refactoring. Das Beheben eines Problems brach oft etwas anderes. Trotzdem hielt die Kernfunktionalität zusammen, und ich konnte der KI tatsächlich beim Spielen zuschauen. \o/

Einer der besseren Durchläufe.

Das vollständige Transkript eines der besseren Durchläufe:

--- Turn 1 ---
🎯 LLM: 'open mailbox'
>Opening the mailbox reveals:
A leaflet.

--- Turn 2 ---
🎯 LLM: '[command]". so'
>I don't understand that.

--- Turn 3 ---
🎯 LLM: 'take leaflet'
>Taken.

--- Turn 4 ---
🎯 LLM: 'north'
>You are facing the north side of a white house.  There is no door here,
and all the windows are barred.

--- Turn 5 ---
🎯 LLM: 'south'
>The windows are all barred.

--- Turn 6 ---
🎯 LLM: 'east'
>You are behind the white house.  In one corner of the house
there is a window which is slightly ajar.

--- Turn 7 ---
🎯 LLM: 'go through'
>Huh?

--- Turn 8 ---
🎯 LLM: 'enter the'
>The window is closed.

--- Turn 9 ---
🎯 LLM: 'open window'
>With great effort, you open the window far enough to allow passage.

--- Turn 10 ---
🎯 LLM: 'go through'
>Huh?

--- Turn 11 ---
🎯 LLM: '<think>'
>I don't understand that.

--- Turn 12 ---
🎯 LLM: 'enter the'
>You are in the kitchen of the white house.  A table seems to have
been used recently for the preparation of food.  A passage leads to
the west, and a dark staircase can be seen leading upward.  To the
east is a small window which is open.
On the table is an elongated brown sack, smelling of hot peppers.
A clear glass bottle is here.
The glass bottle contains:
A quantity of water.

--- Turn 13 ---
🎯 LLM: 'take sack'
>Taken.

--- Turn 14 ---
🎯 LLM: 'open sack'
>Opening the brown sack reveals:
A clove of garlic.
A lunch.

--- Turn 15 ---
🎯 LLM: '<think>'
>I don't understand that.

--- Turn 16 ---
🎯 LLM: 'look around'
>I don't understand that.

--- Turn 17 ---
🎯 LLM: 'take glass'
>Huh?

--- Turn 18 ---
🎯 LLM: 'take bottle'
>Taken.

--- Turn 19 ---
🎯 LLM: 'go west'
>You are in the living room.  There is a door to the east.  To the west
is a wooden door with strange gothic lettering, which appears to be
nailed shut.
In the center of the room is a large oriental rug.
There is a trophy case here.
On hooks above the mantlepiece hangs an elvish sword of great antiquity.
A battery-powered brass lantern is on the trophy case.
There is an issue of US NEWS & DUNGEON REPORT dated 11-MAR-91 here.

--- Turn 20 ---
🎯 LLM: '<think>'
>I don't understand that.

--- Turn 21 ---
🎯 LLM: '<think>'
>I don't understand that.

--- Turn 22 ---
🎯 LLM: 'open trophy'
>Huh?

--- Turn 23 ---
🎯 LLM: 'open trophy'
>Huh?

--- Turn 24 ---
🎯 LLM: 'open trophy'
>Huh?

--- Turn 25 ---
🎯 LLM: 'open trophy'
>Huh?

^C
Game interrupted by user

Die besten Ergebnisse erzielte ich mit Qwen 3:8b, einem auf Reasoning spezialisierten Modell. Die meisten anderen scheiterten direkt am Start. Mistral 3.1 small kam qualitativ nah ran, aber die Inferenzzeit auf meinem MacBook fühlte sich an, als würde man Zork per Brieftaube spielen.

Nach unzähligen Testdurchläufen musste ich zugeben: Keines der Modelle kam über die allerersten Aufgaben hinaus – Mailbox öffnen, Flugblatt lesen, in die Küche gehen. Dass sie aber überhaupt so weit kamen, deutet darauf hin, dass es prinzipiell möglich ist, ein LLM ein Textadventure spielen zu lassen.

Natürlich war die Codebasis dank meines ungebremsten Vibe-Coding-Enthusiasmus ein glorreiches Chaos. Hier ein Beispiel – eine Funktion, die mit jeder Iteration aufgebläht wurde und wahrscheinlich nie hätte existieren sollen:

    def extract_command_from_thinking(self, response):
        """Extract final command from thinking model response"""
        if not response:
            return "look"

        import re

        # Strategy 1: Look for FINAL_COMMAND: marker
        final_command_match = re.search(r'FINAL_COMMAND:\s*([^\n]+)', response, re.IGNORECASE)
        if final_command_match:
            command = final_command_match.group(1).strip()
            words = command.lower().split()[:2]
            return " ".join(words) if words else "look"

        # Strategy 2: Look for content after </think> tag
        think_end_match = re.search(r'</think>\s*(.+)', response, re.IGNORECASE | re.DOTALL)
        if think_end_match:
            after_think = think_end_match.group(1).strip()
            # Take first meaningful line after thinking
            lines = after_think.split('\n')
            for line in lines:
                line = line.strip()
                if line and not line.startswith(('I', 'The', 'Based', 'Looking', 'Given', 'So')):
                    words = line.lower().split()[:2]
                    if words and len(words[0]) > 1:
                        return " ".join(words)

        # Strategy 3: Look for commands in the last part of the response
        # Split by sentences and look for command-like patterns
        sentences = re.split(r'[.!?]\s+', response)
        for sentence in reversed(sentences[-3:]):  # Check last 3 sentences
            sentence = sentence.strip()
            if sentence:
                # Look for patterns like "I should X" or "Let me X" or just "X"
                command_patterns = [
                    r'(?:i should|let me|i\'ll|i will)\s+([a-z\s]+)',
                    r'(?:try|do|use)\s+([a-z\s]+)',
                    r'^([a-z]+(?:\s+[a-z]+)?)$'  # Simple command at start of sentence
                ]

                for pattern in command_patterns:
                    match = re.search(pattern, sentence.lower())
                    if match:
                        command = match.group(1).strip()
                        words = command.split()[:2]
                        if words and words[0] in ['north', 'south', 'east', 'west', 'up', 'down', 'look', 'examine', 'take', 'open', 'close', 'read', 'inventory', 'drop', 'go', 'enter']:
                            return " ".join(words)

        # Strategy 4: Remove thinking tags and extract from remaining text
        clean_response = re.sub(r'<think>.*?</think>', '', response, flags=re.DOTALL | re.IGNORECASE)
        clean_response = clean_response.strip()

        if clean_response:
            lines = clean_response.split('\n')
            for line in lines:
                line = line.strip()
                if line and not line.startswith(('I', 'The', 'Based', 'Looking', 'Given')):
                    words = line.lower().split()[:2]
                    if words and len(words[0]) > 1:
                        return " ".join(words)

        # Strategy 5: Look for common Zork actions in the response
        game_commands = [
            'open mailbox', 'take leaflet', 'read leaflet', 'inventory', 'examine mailbox',
            'north', 'south', 'east', 'west', 'up', 'down', 'look', 'examine', 'take',
            'open', 'close', 'read', 'drop', 'go', 'enter'
        ]
        response_lower = response.lower()
        for cmd in game_commands:
            if cmd in response_lower:
                return cmd

        # Strategy 6: Handle incomplete responses (very common with long thinking)
        incomplete_endings = ('<think', '<think>', 'if', 'But', 'However', 'maybe', 'according', 'Let', 'Alternatively', 'should', 'try', 'go', 'the')
        if response.rstrip().endswith(incomplete_endings):
            print("🔍 Detected incomplete response - using smart fallback")

            # Analyze the thinking content for action hints
            response_lower = response.lower()

            # Check for specific action mentions in the thinking
            if 'go east' in response_lower or 'try east' in response_lower:
                return "east"
            elif 'go west' in response_lower or 'try west' in response_lower:
                return "west"
            elif 'go north' in response_lower or 'try north' in response_lower:
                return "north"
            elif 'go south' in response_lower or 'try south' in response_lower:
                return "south"
            elif 'inventory' in response_lower:
                return "inventory"
            elif 'look' in response_lower:
                return "look"
            elif 'mailbox' in response_lower and 'open' in response_lower:
                return "open mailbox"
            elif 'leaflet' in response_lower and 'take' in response_lower:
                return "take leaflet"
            elif 'read' in response_lower and 'leaflet' in response_lower:
                return "read leaflet"
            else:
                # Default exploration pattern
                return "north"

        return "look"  # Ultimate fallback

Was für ein Chaos.

Bei 700+ Zeilen Code war Schluss mit Vibing.

Irgendwann entfernte ich die gesamte LLM-spezifische Logik und konzentrierte mich auf reine Benutzereingabe. Das Ergebnis war ein sauberes Skript mit etwa 170 Zeilen. Aber sobald ich den LLM-Code wieder einbaute, explodierte die Komplexität erneut. Da wusste ich: Das Vibe-Coding-Experiment war beendet.

Proof of Concept 2 Ergebnis: Teilerfolg

Proof of Concept 3: Lokales LLM in Ollama

Ich begann mich zu fragen: War ChatGPT wirklich so viel besser als lokale LLMs, oder war meine erste Spielsitzung nur ein oberflächlicher Glückstreffer? (Spoiler: Letzteres.) Ungefähr zur gleichen Zeit veröffentlichte Ollama ein Update mit einer einfachen UI für die Interaktion mit lokalen Modellen – vorher ging das nur über die Kommandozeile. Also beschloss ich, das Experiment mit denselben lokalen Modellen zu wiederholen, die ich in der Vibe-Coding-Phase getestet hatte.

(Wer sich für meine Tests mit verschiedenen lokalen Modellen interessiert, findet sie hier: 🇩🇪 Germany’s next top model.)

• gemma3:12b
• qwen3:8b
• qwen3:14b
• deepseek-r1:14b
• mistral-small3.1:24b
• llama3.1:8b
• gpt-oss:20b

Ollamas neue UI.

Diesmal ignorierte ich, ob die Modellausgabe strikt der vom Spiel-Parser erwarteten Befehlssyntax folgte. Auch wenn das Modell eigene Gedanken oder internes Reasoning beifügte, ließ ich es durchgehen. Mein Fokus lag darauf, ob das Modell tatsächlich Fortschritte im Spiel machte. Auch die Inferenzzeit, die sich gelegentlich auf zehn Minuten und mehr streckte, blendete ich aus.

Wichtiger noch: Ich ersetzte den ursprünglichen System Prompt durch ein strukturiertes Regelwerk. Außerdem fügte ich eine umfassende Liste der in Zork verfügbaren Befehle hinzu (von einer Fan-Website), in der Hoffnung, dass das Modell lernt, sie effektiv einzusetzen.

Die rule.txt-Datei:

You are playing a text adventure game.
Your objective is to progress in the story and solve the quests and tasks.
The text adventure can be played by entering word combinations the text parser understands.
NEVER output anything other than the command (e.g. only output "open mailbox" instead of "The player should ask the game to open the mailbox next").
Do not think too long and always respond with a command.
When you are ready to start the game, write "I'm ready".

# General Approach
1. Always analyze the text from the game, it usually contains valuable information about how to progress, e.g. descriptions of the current location, directions to go, items which can be picked up and examined and so on.
2. Always try to pick up whatever is available and examine the object for new clues.
3. Only change the location when you do not have any other options in the current one.
4. Do not repeat the same actions, e.g. reading the same letter again and again.
5. Keep an inventory of your objects, they may be used in a location to progress, e.g. a ladder may later be used to access a roof.
6. Commands are usually one or two words, e.g. "open mailbox".
7. Never output multiple commands.

# Example
When you enter a new location:
- look around ("look")
- examine interesting objects from the given description
- if possible, pick up objects (e.g. "take ladder"), sometimes ("take all") works, too
- analyze if any object from your inventory is suitable to solve a task in the current location (e.g. "use ladder")

# List of common verbs the parser understands:
This list is incomplete, other commands can be tried, too.
Example commands:
north
go north
take leaflet
read leaflet

Movement Commands
north (move north.) south (move south.) east (move east.) west (move west.) northeast (move northeast.) northwest (move northwest.) southeast (move southeast.) southwest (move southwest.) up (move up.) down (move down.) look (looks around at current location.) save (save state to a file.) restore (restores a saved state.) restart (restarts the game.) verbose (gives full description after each command.) score (displays score and ranking.) diagnose (give description of health.) brief (give a description upon first entering an area.) superbrief (never describe an area.) quit (quit game.) climb (climbs up.) g (redo last command.) go (direction) (go towards direction (west/east/north/south/in/out/into).) enter (in to the place (window, etc.).) in (go into something (e.g. window).) out (go out of the place (e.g. kitchen).) hi / hello (say hello...)

Item Commands
get / take / grab (item) (removes item from current room; places it in your inventory.) get / take / grab all (takes all takeable objects in room.) throw (item) at (location) (throws the item at something.) open (container) (opens the container, whether it is in the room or your inventory.) open (exit) (opens the exit for travel.) read (item) (reads what is written on readable item.) drop (item) (removes item from inventory; places it in current room.) put (item) in (container) (removes item from inventory; places it in container.) turn (control) with (item) (attempts to operate the control with the item.) turn on / turn off (item) (turns the item on / off.) move (object) (moves a large object that cannot be picked up.) attack (creature) with (item) (attacks creature with the item.) examine (object) (examines, or looks, at an object or item or location.) inventory / i (shows contents of the inventory.) eat (eats item (specifically food).) shout / yell / scream (aaarrrrgggghhhh!) close [Door] (closes door.) tie (item) to (object) (ties item to object.) pick (item) (take / get item.) kill self with (weapon) (humorously commits suicide.) break (item) with (item) (breaks item.) kill (creature) with (item) (attacks creature with the item.) pray (when you are in temples...) drink (drink an item.) smell (smell an item.) cut (object/item) with (weapon) (strange concept, cutting the object/item. If object/item = self then you commit suicide.) bar (bar bar...) listen (target) (listens to a creature or an item.)

DeepSeek schaffte es, das Flugblatt zu lesen und ein wenig herumzuwandern, blieb dann aber in einer Schleife hängen. Als Reasoning-Modell verbrauchte es durchschnittlich etwa 1600 Tokens zum Nachdenken, nur um denselben „go east”-Befehl wie in den vorherigen Zügen zu wählen.

Mistral 3.1 reagierte in der UI nicht einmal – höchstwahrscheinlich, weil mein MacBook nicht genug RAM für das 24-Milliarden-Parameter-Modell hatte. Ich muss die Tests auf einem leistungsfähigeren Rechner wiederholen, da dieses Modell durchaus fähig ist und in einigen unserer Projekte am CityLAB Berlin eingesetzt wird.

qwen3:8b versuchte, die Mailbox mitzunehmen, dann die Mailbox zu lesen, öffnete sie schließlich, nur um danach ziellos in zufällige Richtungen zu wandern. Armes Qwen, der Inhalt der Mailbox muss es geschockt haben.

llama3.1:8b hatte einen vielversprechenden Start: Es las das Flugblatt und fand das leicht geöffnete Fenster. Allerdings versuchte es, Objekte mitzunehmen, die gar nicht da waren. Nachdem es merkte, dass nur die Mailbox funktionierte, versuchte es die Mailbox immer wieder mitzunehmen – ungefähr hundert Mal.

mistral-nemo versuchte als erste Aktion einen Schlüssel aufzuheben, der nicht existierte, und gab dann auf – Endlosschleife.

gemma3:12b versuchte wiederholt die Mailbox mitzunehmen, schaute sich um, versuchte wieder die Mailbox mitzunehmen, schaute sich um – und so weiter, endlos.

Na ja, das war nicht besonders erfolgreich.

Leicht enttäuscht versuchte ich erneut ChatGPT. Leider zeigt OpenAI seit August 2025 nicht mehr eindeutig an, welches Modell für eine Konversation verwendet wird. Da ich es an dem Tag bereits stark beansprucht hatte, wurde ich offenbar auf eine weniger leistungsfähige Version heruntergestuft. Anders als bei meinem ersten Experiment schnitt es diesmal nicht besser ab als die lokalen Modelle.

Update 6. August: Heute hat OpenAI aus dem Nichts sein erstes Open-Weight-Modell veröffentlicht, und natürlich musste ich es ausprobieren. Das Modell heißt gpt-oss und kommt in 20 und 120 Milliarden Parametern. Ich testete die kleinere Version. Wie die anderen Modelle löste es das Spiel weder noch machte es bedeutende Fortschritte, aber es schnitt am besten unter der Konkurrenz ab. Es nahm einen anderen Weg durch das Spiel und wanderte in den Wald. Es entdeckte das verschlossene Gitter unter dem Laubhaufen und fand den großen Baum. Es kam sogar zum richtigen Schluss, den Baum hochzuklettern – leider erst, nachdem es bereits woanders hingegangen war.

Das Modell versuchte einmal ein „examine leaves”-Assistant-Tool aufzurufen (was die UI einfriert) und musste etwa jeden zweiten Zug „look” eingeben. Allerdings fragte es das Spiel auch nach „help”, was nützliche Informationen lieferte und dem LLM ermöglichte, etwas voranzukommen.

gpt-oss ist das erste Modell, bei dem ich ernsthaft in Erwägung ziehe, die Regeldatei anzupassen und das Testsetup weiterzuentwickeln. Es zeigt echtes Potenzial.

Update 8. August: Ein neuer Tag, ein weiterer Meilenstein-Release von OpenAI – diesmal das lang erwartete gpt-5. Um es kurz zu machen, da dieser Artikel schon recht lang ist: gpt-5 schnitt deutlich besser ab als gpt-oss. Es las das Flugblatt, kletterte auf einen Baum im Wald, fand das juwelenbesetzte Ei, kletterte hinunter und entdeckte das unter dem Laubhaufen versteckte Gitter. Dann versuchte es, dieses mit Gegenständen aus dem Inventar zu öffnen. Etwa jeder zweite Befehl war tatsächlich nützlich (auch wenn es etwas zu viel herumschaute). Schließlich blieb es nach etwa 30 Zügen stecken und verlor seinen Fortschritt. Aber insgesamt ein großer Schritt in die richtige Richtung.

Proof of Concept 3 Ergebnis: Gescheitert

Damit waren meine LLM-Tests vorerst abgeschlossen. Obwohl kein Modell bedeutende Fortschritte im Spiel machen konnte, war klar, dass wir nah dran sind. Ich bin überzeugt, dass das sehr bald möglich sein wird.

Was blieb, war eine letzte Frage: Kann ich das Spiel selbst lösen?

Proof of Concept 4: Endlich selbst spielen

Ausgestattet mit einem Glas Rotwein und stimmungsvoller Abenteuermusik im Hintergrund war ich bereit, die Welt von Zork selbst zu betreten.

Ich las das Flugblatt, lief ums alte Haus, kletterte durchs Fenster und erkundete die Räume. Unter einem alten Teppich verbarg sich eine Falltür, die in den Keller führte. Kurz darauf traf ich den ersten Troll, den ich mit meinem kleinen leuchtenden Schwert prompt besiegte. Es lief großartig.

Eine Karte der Zork-Welt.

Jedenfalls bis ich merkte, dass meine Annahmen über die Richtungen im Spiel falsch waren. Manchmal führte der Weg von Raum A nach Westen zu Raum B, aber von Raum B zurück nach Osten nicht wieder zu Raum A. Ich verlief mich schnell. Im Web fand ich neben der wunderschön gezeichneten Karte oben, erstellt von Reddit-User ion_bond, die Bestätigung, dass das Spiel nicht immer logische Richtungen bietet. Die Karte löst das elegant mit verschlungenen Pfaden.

Ein Beispiel:

In Zork verläuft man sich leicht.

Startpunkt: Forest #2. Man geht nach Süden zu Forest #4. Geht man dann zurück nach Norden, landet man in Forest #3 statt Forest #2 – das wäre jetzt im Osten.

Irgendwann war der Wein alle, und ich musste aufhören. Das Spiel durchgespielt habe ich nicht – vor allem wegen meiner fehlenden Geduld, um ehrlich zu sein. Die Erzählung fand ich weniger fesselnd als erhofft. Manche Orte waren wunderbar detailliert beschrieben, andere hingegen ziemlich fad und einfallslos.

Proof of Concept 4 Ergebnis: Gescheitert

Fazit

Auch wenn meine ursprüngliche Idee, eine KI eigenständig ein Textadventure spielen und lösen zu lassen, nicht aufgegangen ist – ich bin ziemlich zufrieden damit, wie weit ich gekommen bin. Ich bin überzeugt, dass das in den nächsten Monaten möglich sein wird, und werde dieses Thema definitiv wieder aufgreifen, um neue Modelle gegeneinander zu benchmarken.

Wie bei jedem Projekt habe ich unterwegs viel gelernt und Ideen für Weiterentwicklungen sowie völlig neue Konzepte gesammelt:

Danke fürs Lesen. Ich hoffe, die Reise durch die Spielwelt und die LLM-Landschaft hat Spaß gemacht. Über Gedanken und Ideen zu diesem Thema freue ich mich – hinterlasst gerne einen Kommentar.