🦞 OpenClaw auf dem Mac — von Null auf laufend

Willkommen! Bevor wir irgendetwas installieren, klären wir in Ruhe, worum es hier eigentlich geht. Du musst dafür nichts können – wir fangen ganz vorne an.

Die Kurzfassung

OpenClaw ist ein persönlicher KI-Assistent, der auf deinem eigenen Mac läuft. Stell ihn dir wie einen digitalen „Büroleiter“ vor (im Englischen sagt man dazu chief of staff): Du gibst ihm Aufgaben, und er erledigt sie für dich – Texte schreiben, Dinge nachschlagen, wiederkehrende Aufgaben automatisieren oder mit anderen Programmen auf deinem Computer arbeiten.

Das Besondere: OpenClaw wohnt nicht irgendwo in einer fremden Cloud, sondern direkt bei dir zu Hause auf dem Rechner. Man nennt das „self-hosted“ (selbst betrieben) oder „lokal“ (auf dem eigenen Gerät). Eine Cloud ist einfach ein Computer von jemand anderem, irgendwo im Internet. „Lokal“ heißt: alles passiert auf deinem Tisch.

Warum „lokal“ und „self-hosted“ wichtig sind

• Privatsphäre: Deine Dateien, Notizen und Aufgaben bleiben bei dir. Sie wandern nicht automatisch auf fremde Server.
• Kontrolle: Du entscheidest, worauf der Assistent zugreifen darf – und worauf nicht.
• Deine Daten gehören dir: Es gibt keinen Anbieter, der zwischen dir und deinen Daten sitzt und alles mitliest.

Was du damit machen kannst

• Chatten: Stell Fragen oder bitte um Hilfe – wie bei einem Chat-Programm, nur eben auf deinem Mac.
• Aufgaben automatisieren: Wiederkehrende Dinge laufen lassen, ohne dass du sie jedes Mal von Hand machst.
• Werkzeuge anbinden: Mit sogenannten Skills (kleine Erweiterungen, also Zusatzfähigkeiten) kann OpenClaw z. B. Kalender, Mails oder Dateien bedienen.
• Per Telegram reden: Telegram ist eine kostenlose Chat-App fürs Handy. Du kannst OpenClaw darüber Nachrichten schicken – auch von unterwegs – und er antwortet dir, als würdest du einer Person schreiben.

Wie unterscheidet sich das von ChatGPT im Browser?

Vielleicht kennst du KI-Chats, die man im Browser (dem Programm zum Surfen im Internet, z. B. Safari) benutzt. Der Unterschied:

Der „Gateway“ (sprich: Gäit-wäi, engl. für „Tor“) ist das Herzstück von OpenClaw: ein kleines Programm, das im Hintergrund läuft und alle Anfragen entgegennimmt. Es lauscht auf deinem Mac am sogenannten Port 18789. Ein Port ist wie eine Türnummer am Computer, über die Programme miteinander sprechen – mehr musst du dazu vorerst nicht wissen.

So spielt alles zusammen

Dieses Schaubild zeigt, wer mit wem redet. Lies es von links nach rechts:

flowchart LR
A[Du] --> B[Telegram oder Dashboard]
B --> C[OpenClaw Gateway auf deinem Mac]
C --> D[KI Anbieter z B Anthropic]
C --> E[Deine Tools und Dateien]

Du sprichst also über Telegram oder das Dashboard (eine Bedienoberfläche im Browser, die OpenClaw selbst mitbringt) mit dem Gateway. Der Gateway holt sich die „Denkleistung“ von einem KI-Anbieter und greift bei Bedarf auf deine Werkzeuge und Dateien zu.

Was du brauchst

Die Reise, die vor dir liegt

Dieses Handbuch begleitet dich in 19 Kapiteln vom blanken, frisch ausgepackten MacBook bis zu einer laufenden OpenClaw-Installation. Wir gehen wirklich jeden Schritt gemeinsam:

• Zuerst lernst du die Grundlagen von macOS kennen (Kapitel 3) – damit du dich auf deinem Mac sicher bewegst.
• Dann öffnen wir vorsichtig das Terminal (das Texteingabe-Fenster für Befehle) und installieren die nötigen Bausteine.
• Schließlich richten wir OpenClaw ein, verbinden Telegram und probieren alles aus.

Keine Sorge, wenn dir jetzt noch Begriffe fremd sind – jeder davon wird erklärt, bevor du ihn brauchst.

Keine Sorge — das Terminal sieht auf den ersten Blick aus wie etwas aus einem alten Film über Hacker. In Wahrheit ist es nur eine andere Art, mit deinem Mac zu reden. Statt mit der Maus auf bunte Symbole zu klicken, tippst du kurze Anweisungen als Text und dein Mac führt sie aus. In diesem Kapitel lernst du das Terminal Schritt für Schritt kennen. Du musst nichts auswendig können — wir erklären jeden einzelnen Befehl ganz langsam.

Was ist das Terminal überhaupt?

Das Terminal ist ein Programm auf deinem Mac, das dir eine textbasierte Verbindung zum Computer gibt. Du schreibst einen Befehl, drückst Enter, und der Mac antwortet — meistens auch mit Text. Mehr ist es nicht. Es ist wie ein Chat zwischen dir und deinem Computer.

Warum benutzen wir das überhaupt?

Gute Frage! Mit der Maus geht doch alles? Stimmt — aber das Terminal hat drei große Vorteile:

• Kraft: Viele Dinge gehen über Text viel schneller und präziser als durch Klicken.
• Automatisierung: Du kannst Aufgaben so aufschreiben, dass der Computer sie immer wieder selbst erledigt.
• OpenClaw braucht es: Das Programm, das wir am Ende installieren, wird über das Terminal gestartet und gesteuert. Deshalb lernen wir es jetzt — Schritt für Schritt.

So öffnest du das Terminal

Am einfachsten geht das über die Suche, die Spotlight heißt:

1. Drücke gleichzeitig Cmd + Leertaste. In der Bildschirmmitte erscheint ein Suchfeld.
2. Tippe das Wort Terminal.
3. Drücke Enter.

Es öffnet sich ein Fenster mit einem mehr oder weniger leeren Hintergrund und ein bisschen Text. Geschafft — das ist das Terminal!

Der Prompt und die Befehlszeile

Wenn das Terminal offen ist, siehst du eine Zeile, die mit etwas Text endet und dann blinkt. Dieser Text heißt Prompt (sprich: „prompt"). Der Prompt ist die freundliche Einladung des Computers: „Ich bin bereit — tipp deinen Befehl ein." Oft endet der Prompt mit einem %-Zeichen. Dahinter blinkt der Cursor und wartet auf dich.

Die Zeile, in die du tippst, heißt Befehlszeile (englisch: command line). Alles, was du dort eingibst und mit Enter bestätigst, wird ausgeführt.

Was ist die „Shell"?

Hinter dem Terminal-Fenster arbeitet ein kleines Programm, das deine getippten Wörter versteht und in Aktionen übersetzt. Dieses Programm heißt Shell (englisch für „Schale"). Auf modernen Macs ist die Shell standardmäßig zsh (sprich: „Z-Schell"). Du musst dazu nichts einstellen — sie ist schon da und läuft.

Der Aufbau eines Befehls

Fast jeder Befehl besteht aus bis zu drei Teilen, immer durch Leerzeichen getrennt:

• Der Befehl selbst — das Wort, das sagt, was getan werden soll. Zum Beispiel ls.
• Optionen (oder Flags) — kleine Zusätze, meist mit einem Bindestrich, die wie etwas getan wird. Zum Beispiel -l.
• Argumente — das woran der Befehl arbeiten soll, etwa ein Ordnername. Zum Beispiel Dokumente.

Zusammengesetzt sieht das so aus:

ls -l Dokumente

Das heißt sinngemäß: „Zeige (ls) mir die Inhalte in ausführlicher Form (-l) des Ordners Dokumente."

So führst du einen Befehl aus

Ganz einfach: tippen und Enter drücken. Solange du nicht Enter drückst, passiert nichts — du kannst also in Ruhe nachschauen, ob du dich vertippt hast.

Groß- und Kleinschreibung ist wichtig

Das Terminal ist genau. ls und LS sind für den Computer zwei verschiedene Dinge. Auch Ordnernamen unterscheiden sich: Dokumente ist nicht dasselbe wie dokumente. Tippe deshalb genau so, wie es geschrieben steht.

Das aktuelle Verzeichnis (Working Directory)

Stell dir vor, du stehst in einem Haus immer in genau einem Raum. Im Terminal stehst du immer in genau einem Ordner — dem aktuellen Verzeichnis (englisch: working directory). Befehle beziehen sich standardmäßig auf diesen Ordner. Wenn du also nach Dateien fragst, zeigt dir der Mac die Dateien in deinem aktuellen Raum. Du kannst von Raum zu Raum wechseln — wie, lernst du gleich mit dem Befehl cd.

Der Kreislauf: Befehl → Shell → Ausgabe

So spielt alles zusammen — du tippst, die Shell versteht, der Mac antwortet, und dann bist du wieder dran:

flowchart LR
A[Du tippst Befehl] --> B[Shell versteht]
B --> C[Mac fuehrt aus]
C --> D[Ausgabe erscheint]
D --> A

Die wichtigsten Befehle — einer nach dem anderen

Jetzt geht es los. Für jeden Befehl bekommst du: was er bedeutet, eine einfache Erklärung, ein Beispiel zum Ausprobieren und einen typischen Fehler, den du so vermeidest.

pwd

ls -la

cd Dokumente
cd ..
cd ~
cd /Users

clear

mkdir Testordner

rm alte-datei.txt

cp brief.txt brief-kopie.txt

mv brief.txt Dokumente/
mv brief.txt brief-neu.txt

cat notizen.txt

nano meine-notiz.txt

touch neue-datei.txt

find . -name "notizen.txt"

history

exit

Tab-Vervollständigung & Pfeiltasten

Zwei kleine Tricks, die dir das Leben sehr viel leichter machen:

• Tab-Vervollständigung: Tippe die ersten Buchstaben eines Ordner- oder Dateinamens und drücke dann die Tab-Taste. Der Mac vervollständigt den Namen automatisch für dich. Das spart Tippen und vermeidet Tippfehler.
• Pfeil nach oben: Drücke die ↑-Taste, um deinen letzten Befehl wieder hervorzuholen. Nochmal drücken holt den davor. So musst du Befehle nicht neu tippen.

Absolute und relative Pfade

Ein Pfad ist die Adresse einer Datei oder eines Ordners. Es gibt zwei Arten, eine solche Adresse anzugeben:

• Ein absoluter Pfad beginnt immer mit einem Schrägstrich / (oder mit ~ für dein Zuhause). Er gilt von überall aus — wie eine komplette Postadresse mit Straße und Stadt.
• Ein relativer Pfad startet von deinem aktuellen Ordner aus — wie „zwei Türen weiter links". Er hängt davon ab, wo du gerade stehst.

Geschafft! Du kennst jetzt das Terminal, weißt, wie ein Befehl aufgebaut ist, und hast die wichtigsten Werkzeuge in der Hand. Das ist die Grundlage für alles, was kommt — und du brauchst dir nichts davon merken: Du kannst jederzeit hierher zurückblättern.

Bevor wir später Befehle eintippen, machen wir dich mit deinem Mac vertraut. macOS ist der Name des Betriebssystems – also der Software, die deinen Mac steuert und mit der du täglich arbeitest. Dieses Kapitel zeigt dir die wichtigsten Bausteine. Du brauchst nichts auswendig zu lernen; es reicht, wenn du weißt, wo du nachschauen kannst.

Die Menüleiste (Menu Bar)

Ganz oben am Bildschirmrand siehst du eine schmale Leiste – die Menüleiste. Links steht immer das Apple-Logo (🍎), daneben der Name des gerade aktiven Programms und dessen Menüs (z. B. „Ablage“, „Bearbeiten“). Rechts findest du Uhrzeit, WLAN, Lautstärke und Akku. Die Menüleiste ändert sich je nachdem, welches Programm gerade vorne ist – das ist normal.

Der Schreibtisch (Desktop)

Der Schreibtisch ist die Fläche, die du nach dem Anmelden siehst. Hier können Dateien und Ordner liegen. Tipp: Halte den Schreibtisch aufgeräumt, dann findest du dich leichter zurecht.

Der Finder – dein Dateimanager

Der Finder ist das Programm, mit dem du deine Dateien und Ordner durchstöberst – vergleichbar mit einem Aktenschrank. Sein Symbol im Dock ist das blau-weiße, lächelnde Gesicht.

So öffnest du ein Finder-Fenster

• Klicke unten auf das Finder-Symbol (das lächelnde Gesicht), oder
• klicke auf eine freie Stelle des Schreibtischs und drücke dann Cmd + N (das öffnet ein neues Fenster).

Aufbau eines Finder-Fensters

• Seitenleiste (Sidebar) links: deine Schnellzugriffe, z. B. „Dokumente“, „Downloads“, „Schreibtisch“. Diese Einträge nennt man Favoriten.
• Hauptbereich rechts: zeigt den Inhalt des gerade gewählten Ordners.
• Du kannst einen Ordner per Maus in die Seitenleiste ziehen, um ihn als Favorit hinzuzufügen.

Das Dock

Das Dock ist die Leiste mit den Programmsymbolen, meist am unteren Bildschirmrand. Ein Klick auf ein Symbol startet das Programm.

• App hinzufügen: Ziehe ein Programmsymbol ins Dock, oder klicke bei einem laufenden Programm mit der rechten Maustaste auf sein Dock-Symbol und wähle Optionen → Im Dock behalten.
• App entfernen: Ziehe das Symbol aus dem Dock heraus, bis „Entfernen“ erscheint, und lass los. Keine Sorge – das löscht das Programm nicht, es nimmt nur die Verknüpfung aus dem Dock.

Spotlight – die schnellste Suche

Spotlight ist die eingebaute Suche von macOS. Damit findest und startest du alles blitzschnell: Programme, Dateien, Einstellungen.

• Drücke Cmd + Leertaste (engl. Space). In der Bildschirmmitte erscheint ein Suchfeld.
• Tippe einfach los, z. B. den Namen eines Programms.
• Drücke Enter (die große Eingabetaste), um den obersten Treffer zu öffnen.

Launchpad

Das Launchpad zeigt alle installierten Programme als große Symbole, ähnlich wie der Startbildschirm eines iPhones. Du öffnest es über das Dock (Symbol mit den bunten Kacheln) oder über Spotlight. Ein Klick auf ein Symbol startet das Programm. Für den schnellen Start ist Spotlight aber meist bequemer.

Systemeinstellungen (System Settings)

In den Systemeinstellungen änderst du, wie sich dein Mac verhält – etwa WLAN, Bildschirmhelligkeit, Tastatur oder Sicherheit. So öffnest du sie:

• Klicke oben links auf das 🍎-Menü und wähle Systemeinstellungen…, oder
• nutze Spotlight: Cmd + Leertaste, dann Systemeinstellungen tippen.

Dein Benutzerordner (Home-Ordner)

Jeder Benutzer hat einen persönlichen Benutzerordner, auch Home-Ordner genannt. Hier liegen deine eigenen Dateien. In der Fachsprache schreibt man ihn als Tilde-Zeichen ~ (das Zeichen erzeugst du mit Alt + N). ~ bedeutet also schlicht „mein persönlicher Ordner“.

Darin findest du diese wichtigen Unterordner:

Dateipfade – wie macOS Ordner ordnet

Ein Dateipfad (engl. path) ist die „Adresse“ einer Datei. Die einzelnen Ordner werden durch einen Schrägstrich / getrennt – von außen nach innen gelesen. Beispiel:

~/Documents/Briefe/rechnung.pdf

Das heißt: in deinem Home-Ordner ~ liegt der Ordner Documents, darin der Ordner Briefe, und darin die Datei rechnung.pdf. Genau so eine Adresse tippen wir später manchmal ins Terminal ein.

flowchart TD
A[Home Ordner ~] --> B[Documents]
A --> C[Downloads]
A --> D[Desktop]
A --> E[Library versteckt]
B --> F[deine Dateien]

Der versteckte Library-Ordner

In deinem Home-Ordner gibt es einen besonderen Ordner namens Library (deutsch: „Mediathek“). Darin speichern Programme ihre Einstellungen und Hilfsdateien. macOS versteckt diesen Ordner absichtlich, damit normale Nutzer dort nicht versehentlich etwas verändern. Für OpenClaw wirst du ihn aber gelegentlich brauchen.

So machst du Library sichtbar

• Im Finder: Klicke in der Menüleiste auf Gehe zu (Go). Halte jetzt die Taste Alt (engl. Option) gedrückt – dann erscheint plötzlich der Eintrag Library / Mediathek im Menü. Klick ihn an.
• Über die Pfad-Eingabe: Drücke im Finder Cmd + Shift + G, tippe ~/Library ein und drücke Enter.

Versteckte Dateien im Finder anzeigen

Manche Dateien und Ordner beginnen mit einem Punkt (z. B. .config) und sind deshalb normalerweise unsichtbar. So blendest du sie ein und wieder aus:

• Drücke in einem Finder-Fenster Cmd + Shift + . (der Punkt auf der Tastatur).
• Versteckte Einträge erscheinen nun leicht ausgegraut. Dieselbe Tastenkombination blendet sie wieder aus.

Wichtige Tastenkürzel

Ein Tastenkürzel (engl. shortcut) ist eine Tastenkombination, die etwas schneller erledigt als die Maus. Cmd ist die Befehlstaste neben der Leertaste (sie trägt das Symbol ⌘).

Was ist Homebrew?

Stell dir vor, dein Mac hätte einen eigenen App Store – aber nicht für bunte Programme mit Fenstern, sondern für Werkzeuge, die du im Terminal nutzt. Genau das ist Homebrew. Man nennt so etwas einen Paketmanager (englisch package manager): ein Programm, das andere Programme für dich herunterlädt, sauber installiert, aktuell hält und auf Wunsch auch wieder entfernt.

Ein Paket ist dabei einfach ein Stück Software – zum Beispiel git oder node –, das jemand schon fertig zum Installieren vorbereitet hat. Du musst nichts selbst zusammenbauen.

Warum brauchen wir es?

Für OpenClaw brauchst du später mehrere Werkzeuge, zum Beispiel Git und Node. Du könntest jedes einzeln aus dem Internet suchen und installieren – das ist aber mühsam und fehleranfällig. Mit Homebrew tippst du stattdessen einen kurzen Befehl, und alles wird korrekt eingerichtet. Außerdem kannst du alle Programme später mit einem einzigen Befehl gleichzeitig aktualisieren.

Homebrew installieren

Öffne dein Terminal (Programme → Dienstprogramme → Terminal) und füge den folgenden Befehl ein. Markiere ihn am besten mit dem Kopier-Knopf rechts oben am grauen Kasten, klicke ins Terminal und drücke Cmd + V zum Einfügen. Danach bestätigst du mit Enter.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Dieser Befehl lädt ein kleines Installationsskript aus dem Internet und führt es aus. Das Skript erklärt dir Schritt für Schritt, was es tun wird, und wartet auf deine Bestätigung. Wenn es fragt, drückst du einfach Enter.

Nach der Installation: PATH einrichten (Apple Silicon)

Hat dein Mac einen Apple-Chip (M1, M2, M3 und so weiter – das haben fast alle neueren Macs), legt Homebrew sich in den Ordner /opt/homebrew. Damit dein Terminal das Programm brew auch findet, musst du noch einen kleinen Schritt machen.

Am Ende der Installation zeigt dir Homebrew selbst genau diese zwei Befehle an („Next steps“). Kopiere sie und führe sie nacheinander aus:

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

Was passiert hier eigentlich?

• PATH ist eine Liste von Ordnern, in denen das Terminal nach Programmen sucht, wenn du einen Befehl eintippst. Ist /opt/homebrew/bin nicht in dieser Liste, sagt das Terminal „command not found“ (Befehl nicht gefunden), obwohl Homebrew installiert ist. Wir müssen den Ordner also bekannt machen.
• ~/.zprofile ist eine kleine Startdatei deiner Kommandozeile. Das ~ steht für deinen Benutzerordner. Diese Datei wird jedes Mal automatisch gelesen, wenn du ein Terminal-Fenster öffnest. Der erste Befehl (echo ... >> ~/.zprofile) schreibt eine Zeile ans Ende dieser Datei – damit der PATH in Zukunft dauerhaft richtig gesetzt ist.
• eval "$(...)" sorgt dafür, dass die Einstellung sofort im aktuellen Fenster aktiv wird, ohne dass du das Terminal neu starten musst. Den ersten Befehl brauchst du für die Zukunft, den zweiten für jetzt.

Überprüfen, ob alles funktioniert

Tippe diesen Befehl ein und drücke Enter. Du solltest eine Versionsnummer sehen (zum Beispiel Homebrew 4.x.x):

brew --version

Danach lass Homebrew sich selbst durchchecken. Das prüft, ob alles sauber installiert ist:

brew doctor

Im besten Fall antwortet es: Your system is ready to brew. („Dein System ist bereit zum Brauen.“) Dann ist alles perfekt.

Wie funktioniert eine Installation?

flowchart TD
A[Du tippst brew install werkzeug]-->B[Homebrew laedt das Paket herunter]
B-->C[Homebrew installiert es sauber]
C-->D[Das Werkzeug ist im Terminal verfuegbar]

Homebrew im Alltag

Hier sind die Befehle, die du im täglichen Gebrauch brauchst. <x> ist dabei ein Platzhalter – du ersetzt ihn durch den echten Namen des Programms, zum Beispiel git.

brew install git

brew uninstall git

brew list

brew update

brew upgrade

brew search node

Was ist Git?

Git ist ein Werkzeug zur Versionsverwaltung (englisch version control). Das bedeutet: Git merkt sich jede Änderung an deinen Dateien – wer was wann geändert hat. Du kannst dir das wie eine sehr clevere „Rückgängig“-Funktion für ganze Projekte vorstellen. Du kannst jederzeit nachschauen, was sich geändert hat, oder zu einem früheren Stand zurückkehren.

Vor allem bei Programmcode ist das Gold wert: Du kannst gefahrlos etwas ausprobieren, denn der alte Stand ist immer sicher gespeichert.

Was ist ein Repository?

Ein Repository (kurz Repo, gesprochen „Ripossitori“) ist einfach ein Projekt-Ordner, den Git überwacht. In diesem Ordner liegen deine Dateien und die gesamte Änderungsgeschichte dazu. Wenn du dir OpenClaw holst, holst du dir genau so ein Repository auf deinen Mac.

Git oder GitHub – was ist der Unterschied?

Diese beiden Begriffe werden oft verwechselt:

• Git ist das Werkzeug auf deinem Computer. Es arbeitet auch ohne Internet.
• GitHub ist eine Website im Internet (github.com), auf der Repositories online gespeichert und geteilt werden. Es ist wie eine Cloud-Ablage für Git-Projekte. Es gibt auch ähnliche Seiten wie GitLab.

Kurz gesagt: Git ist das Programm, GitHub ist der Ort im Internet, von dem du Projekte herunterlädst.

Git installieren

Dank Homebrew aus dem vorigen Kapitel ist das ein Einzeiler:

brew install git

Danach prüfst du, ob es geklappt hat. Du solltest eine Versionsnummer sehen:

git --version

Einmalige Erst-Einrichtung

Git möchte wissen, wer du bist – damit es bei Änderungen deinen Namen vermerken kann. Das richtest du einmalig ein. Ersetze Name und E-Mail durch deine eigenen Angaben (die Anführungszeichen bleiben stehen):

git config --global user.name "Dein Name"
git config --global user.email "du@example.com"

Das Wort --global bedeutet: Diese Einstellung gilt für alle deine Projekte auf diesem Mac. Du musst sie also nur ein einziges Mal machen.

Der grundlegende Ablauf

Wenn du selbst an einem Projekt arbeitest, wiederholt sich immer derselbe Ablauf: Du änderst Dateien, markierst die Änderungen (add), speicherst sie als festen Punkt (commit) und lädst sie ins Internet hoch (push).

flowchart TD
A[Datei aendern]-->B[git add . - Aenderungen vormerken]
B-->C[git commit - als Stand speichern]
C-->D[git push - ins Internet hochladen]

Als Einsteiger wirst du am Anfang vor allem die ersten zwei Befehle aus der nächsten Liste brauchen: clone und pull.

Die wichtigsten Befehle

git clone https://github.com/benutzer/projekt.git

git status

git pull

git add .

git commit -m "Beschreibung der Aenderung"

git log

git push

Was ist Visual Studio Code?

Visual Studio Code (fast alle sagen kurz VS Code) ist ein kostenloser, freundlicher Editor für Text und Programmcode von Microsoft. Ein Editor ist ein Programm zum Schreiben und Bearbeiten von Dateien – ähnlich wie ein Schreibprogramm, aber speziell für Konfigurationen und Code gemacht.

Bisher hast du vielleicht nano im Terminal benutzt, um Dateien zu bearbeiten. nano funktioniert, ist aber spartanisch und unübersichtlich. VS Code ist viel angenehmer: Es zeigt dir farbige Hervorhebungen, lässt dich mit der Maus klicken, hat eine Suche und vieles mehr. Für Einsteiger ist es deutlich entspannter.

Installieren

Am einfachsten geht es wieder über Homebrew. Für Programme mit richtigem Fenster (also „normale“ Mac-Apps) nutzt Homebrew das Schlüsselwort --cask:

brew install --cask visual-studio-code

Ein Cask ist einfach Homebrews Bezeichnung für ein fertiges Programm mit grafischer Oberfläche. Alternativ kannst du VS Code auch ganz normal als App von der offiziellen Seite herunterladen: code.visualstudio.com

Einen Ordner öffnen

VS Code arbeitet am liebsten mit einem ganzen Ordner (deinem Projekt), nicht nur mit einzelnen Dateien. So öffnest du einen:

1. Starte VS Code.
2. Klicke oben im Menü auf File → Open Folder… (Datei → Ordner öffnen).
3. Wähle deinen Projektordner aus und bestätige.

Links siehst du danach alle Dateien des Ordners und kannst sie mit einem Klick öffnen.

Das eingebaute Terminal

Das Praktische: VS Code hat ein Terminal eingebaut. Du musst also nicht zwischen zwei Programmen hin- und herwechseln. So öffnest du es:

• Über das Menü: View → Terminal (Ansicht → Terminal), oder
• mit der Tastenkombination Ctrl + ` (das Zeichen ` findest du oben links auf der Tastatur, neben der Zahl 1).

Das Terminal öffnet sich praktischerweise gleich im richtigen Ordner – nämlich dem, den du gerade in VS Code geöffnet hast.

Der Befehl code .

Es gibt einen sehr nützlichen Trick: Wenn du im Terminal in einem Ordner stehst, kannst du diesen mit einem kurzen Befehl direkt in VS Code öffnen. Der Punkt . bedeutet dabei „der aktuelle Ordner“:

code .

Damit das funktioniert, musst du diesen Befehl in VS Code einmalig aktivieren:

1. Öffne in VS Code die Befehlspalette mit Cmd + Shift + P.
2. Tippe: Shell Command: Install 'code' command in PATH und drücke Enter.

Ab jetzt kennt dein Terminal den Befehl code. (Erinnerst du dich an PATH aus dem Homebrew-Kapitel? Genau dort wird der Befehl eingetragen, damit das Terminal ihn findet.)

Erweiterungen (Extensions)

Eine Erweiterung (englisch extension) ist ein kleines Zusatzprogramm, das du in VS Code installieren kannst, um neue Fähigkeiten freizuschalten – zum Beispiel bessere Unterstützung für eine bestimmte Programmiersprache. Du installierst sie über das Erweiterungs-Symbol in der linken Leiste (die vier Quadrate) oder über die Befehlspalette.

Diese Erweiterungen sind für die Arbeit mit OpenClaw empfehlenswert:

In diesem Kapitel lernst du Docker kennen. Der Name klingt technisch, aber das Grundprinzip ist erstaunlich einfach – und sobald du es einmal verstanden hast, nimmt dir Docker eine Menge Arbeit ab. Wir gehen alles ganz langsam durch. Du musst nichts auswendig lernen.

Was ist Docker überhaupt?

Docker ist ein Programm, das andere Programme in kleinen, abgeschlossenen „Kisten“ laufen lässt. Diese Kisten nennt man Container (englisch für „Behälter“). Jeder Container ist von deinem restlichen System abgeschottet – wie ein eigenes kleines Zimmer mit verschlossener Tür.

Stell dir vor, du möchtest ein neues Programm ausprobieren. Ohne Docker müsstest du es direkt auf deinem Mac installieren. Dabei legt es überall Dateien ab, ändert vielleicht Einstellungen und kann im schlimmsten Fall mit anderen Programmen in Konflikt geraten. Mit Docker passiert das nicht: Das Programm lebt sauber abgekapselt in seinem Container. Räumst du den Container weg, ist auch alles wieder weg – dein Mac bleibt unverändert und sauber.

Ein schönes Bild dafür: Docker ist wie ein Hafen voller Schiffscontainer. Jeder Container ist gleich genormt, lässt sich überallhin transportieren und sein Inhalt vermischt sich nie mit dem der Nachbar-Container. Genau deshalb ist auf dem Docker-Logo ein Wal mit Containern abgebildet. 🐳

Die fünf wichtigsten Begriffe

Docker hat eine eigene Sprache. Hier sind die fünf Wörter, die du immer wieder hören wirst – jeweils mit einem Bild aus dem Alltag.

Image – die Vorlage

Ein Image (sprich: Imitsch, englisch für „Abbild“) ist eine fertige Vorlage für ein Programm. Man kann es sich wie einen Bauplan oder ein Backrezept vorstellen: Im Image steckt genau beschrieben, was alles dazugehört, damit das Programm laufen kann. Ein Image läuft selbst noch nicht – es ist nur die Schablone. Du kannst aus einem Image beliebig viele laufende Kopien erzeugen, so wie du aus einem Rezept beliebig viele Kuchen backen kannst.

Container – die laufende Kopie

Ein Container ist eine laufende Instanz eines Images – also der fertig gebackene Kuchen, nicht mehr nur das Rezept. Wenn du ein Image „startest“, entsteht daraus ein Container, in dem das Programm wirklich läuft. Du kannst mehrere Container aus demselben Image starten, genau wie du mehrere Kuchen aus einem Rezept backen kannst. Jeder Container läuft für sich und stört die anderen nicht.

Volume – der dauerhafte Speicher

Ein Volume (sprich: Wolljuum, englisch für „Datenträger“) ist ein dauerhafter Speicherort für die Daten eines Containers. Das ist wichtig, denn: Wenn du einen Container löschst, ist normalerweise auch sein Inhalt weg. Ein Volume ist wie ein externer USB-Stick, den du an den Container ansteckst. Die Daten auf dem Stick bleiben erhalten, auch wenn der Container neu gestartet oder ersetzt wird. So gehen z. B. deine Einstellungen oder Datenbanken nicht verloren.

Port – die Türnummer nach außen

Ein Port ist eine Türnummer, über die ein Container seinen Dienst nach außen anbietet. Da ein Container abgeschottet ist, kommst du normalerweise nicht an das Programm darin heran. Über einen Port öffnest du gezielt eine Tür. Man schreibt das als Host:Container, also außen:innen.

Beispiel: 8080:80 bedeutet „Tür 8080 auf deinem Mac (dem Host, also dem Wirtsrechner) wird mit Tür 80 im Container verbunden“. Rufst du dann im Browser localhost:8080 auf, landest du beim Programm, das im Container an Tür 80 lauscht. Die linke Zahl ist die, die du benutzt; die rechte Zahl ist die, die das Programm im Container intern verwendet.

Docker Compose – das Zusammenspiel mehrerer Container

Oft braucht eine Anwendung nicht nur einen, sondern mehrere Container, die zusammenarbeiten – etwa einen für die App und einen für die Datenbank. Docker Compose ist ein Werkzeug, mit dem du all diese Container in einer einzigen Textdatei beschreibst. Diese Datei heißt fast immer docker-compose.yml.

Stell dir Compose wie eine Bestellliste fürs ganze Menü vor: Statt jeden Gang einzeln zu bestellen, gibst du eine Liste ab, und alles kommt aufeinander abgestimmt auf den Tisch. Mit einem einzigen Befehl startest du dann alle beschriebenen Container gemeinsam.

So hängt alles zusammen

Dieses Schaubild zeigt das Zusammenspiel. Aus einem Image entsteht ein Container. An den Container hängst du ein Volume für die Daten, und über einen Port machst du ihn von außen erreichbar:

flowchart TD
A[Image Vorlage] --> B[Container laeuft]
C[Volume Daten] --> B
D[Port aussen 8080] --> B
B --> E[Port innen 80]

Lies es so: Das Image ist die Vorlage, daraus wird der laufende Container. Das Volume liefert ihm seinen dauerhaften Speicher, und der Port verbindet die Außenwelt (Tür 8080) mit dem Dienst im Inneren (Tür 80).

Docker auf dem Mac installieren

Auf dem Mac benutzt man Docker Desktop. Das ist ein normales Mac-Programm mit einem kleinen Wal-Symbol in der Menüleiste oben. Es bringt alles mit, was du brauchst. Es gibt zwei Wege, es zu installieren – such dir einen aus.

Weg 1: Über die Webseite (am einfachsten)

1. Öffne deinen Browser und gehe auf docker.com.
2. Suche dort die Schaltfläche „Download Docker Desktop“ und wähle die Version für Mac mit Apple Silicon (das sind die Macs mit M-Chip).
3. Es wird eine Datei mit der Endung .dmg heruntergeladen. Öffne sie per Doppelklick und ziehe das Docker-Symbol wie gewohnt in den Ordner Programme.
4. Starte Docker Desktop einmal aus dem Programme-Ordner. Beim ersten Start musst du eventuell den Bedingungen zustimmen und dein Mac-Passwort eingeben – das ist normal.

Weg 2: Über Homebrew (im Terminal)

Wenn du in einem früheren Kapitel Homebrew installiert hast (das Werkzeug, mit dem man Programme per Befehl installiert), geht es auch so. Tippe diesen Befehl ins Terminal und drücke Enter:

brew install --cask docker

Das lädt Docker Desktop herunter und legt es in deinen Programme-Ordner. Wichtig: Auch danach musst du das Programm einmal von Hand starten (im Programme-Ordner doppelklicken), damit Docker im Hintergrund läuft.

Prüfen, ob es funktioniert

Sobald Docker Desktop läuft, öffne das Terminal und gib diesen Befehl ein:

docker --version

Wenn eine Zeile mit einer Versionsnummer erscheint (z. B. Docker version 27.x.x), ist Docker korrekt installiert. Prüfe als Nächstes, ob Docker auch wirklich bereit ist:

docker ps

Wenn eine Tabelle mit Spaltenüberschriften erscheint (auch wenn sie noch leer ist), funktioniert alles. Du hast noch keine Container laufen – das ist beim ersten Mal völlig richtig.

Die wichtigsten Befehle als Karten

Hier kommen die Befehle, die du am häufigsten brauchst. Jeder ist eine kleine „Karte“ mit Erklärung und einem typischen Anfängerfehler. <name> ist immer ein Platzhalter – dort setzt du den echten Namen deines Containers ein (ohne die spitzen Klammern).

docker ps
docker ps -a

docker images

docker logs <name>

docker stop <name>

docker start <name>

docker exec -it <name> bash

docker compose up -d

docker compose down

Was bedeutet „detached mode“ (-d)?

Du hast es bei docker compose up -d schon gesehen: Das kleine -d steht für detached, also „abgekoppelt“. Ohne -d bleibt das Terminal an den Container „angeklebt“ – es zeigt fortlaufend dessen Ausgaben an und du kannst nichts anderes tippen. Mit -d startet der Container im Hintergrund, das Terminal ist sofort wieder frei, und der Dienst läuft trotzdem weiter. Für dauerhaft laufende Dienste benutzt man fast immer -d.

Ein einfaches Beispiel für eine docker-compose.yml

Damit du ein Gefühl bekommst, wie so eine Datei aussieht: Hier ist ein kleines Beispiel mit zwei Diensten. Die Zeilen, die mit # beginnen, sind Kommentare – Notizen für Menschen, die Docker einfach ignoriert. Die Einrückung (die Leerzeichen am Zeilenanfang) ist bei diesem Dateiformat wichtig: Sie zeigt, was zu was gehört. Benutze immer Leerzeichen, niemals Tabulatoren.

# Beschreibt zwei Container, die zusammen laufen sollen
services:

  web:                      # Name des ersten Dienstes frei waehlbar
    image: nginx:latest     # Vorlage Image die benutzt wird hier ein Webserver
    ports:
      - "8080:80"           # Tuer 8080 auf dem Mac fuehrt zu Tuer 80 im Container
    volumes:
      - web-daten:/usr/share/nginx/html   # dauerhafter Speicher fuer die Webseiten

  datenbank:                # Name des zweiten Dienstes
    image: postgres:16      # Vorlage fuer eine Datenbank
    environment:
      POSTGRES_PASSWORD: geheim   # ein Startpasswort fuer die Datenbank
    volumes:
      - db-daten:/var/lib/postgresql/data  # damit die Daten erhalten bleiben

# Hier werden die oben benutzten Volumes angemeldet
volumes:
  web-daten:
  db-daten:

Lies es von oben nach unten: Unter services stehen zwei Dienste, web und datenbank. Jeder bekommt ein Image (die Vorlage), der Webdienst zusätzlich einen Port, und beide ein Volume für ihre Daten. Ganz unten werden die Volumes noch einmal angemeldet, damit Docker sie anlegt. Mit docker compose up -d im selben Ordner würden beide Container gemeinsam starten.

In diesem Kapitel lernst du tmux kennen. Das ist ein kleines, aber unglaublich nützliches Werkzeug fürs Terminal. Es löst ein Problem, über das früher oder später jeder stolpert: „Wie lasse ich ein Programm weiterlaufen, auch wenn ich das Terminal-Fenster schließe?“ Genau dafür ist tmux gemacht.

Was ist tmux?

tmux steht für terminal multiplexer (sprich: Terminal-Multipleckser). Das Wort „Multiplexer“ bedeutet einfach: ein Gerät, das mehrere Dinge gleichzeitig verwalten kann. Übersetzt heißt das: tmux kann mehrere Terminal-Sitzungen gleichzeitig führen und – das ist der entscheidende Trick – sie am Leben halten, selbst wenn du das Terminal-Fenster schließt oder die Internetverbindung abbricht.

Ein normales Terminal-Fenster funktioniert so: Schließt du das Fenster, werden alle Programme darin sofort beendet. Das ist ärgerlich, wenn gerade etwas Wichtiges läuft. tmux dreht das um: Es startet eine sogenannte Sitzung (englisch session), in der deine Programme laufen. Diese Sitzung lebt unabhängig vom Fenster weiter. Du kannst dich von ihr „abkoppeln“, das Fenster schließen, später ein neues Fenster öffnen und dich wieder „andocken“ – und findest alles genau so vor, wie du es verlassen hast.

Ein Bild aus dem Alltag

Stell dir tmux wie ein Büro mit einem Lautsprecher-Telefon vor. In deinem Büro läuft die Arbeit weiter, egal ob du gerade davorsitzt oder nicht. Du kannst den Hörer auflegen (dich abkoppeln) und nach Hause gehen – die Maschinen im Büro laufen weiter. Später rufst du wieder an (du dockst wieder an) und bist sofort mittendrin, wo du aufgehört hast. Erst wenn du das Büro abschließt und alle Maschinen ausschaltest (du beendest die Sitzung), ist wirklich Schluss.

Warum ist das für OpenClaw wichtig?

OpenClaw und viele andere Werkzeuge laufen als Dauerprozesse – also Programme, die rund um die Uhr im Hintergrund weiterlaufen sollen, nicht nur ein paar Sekunden. Es gibt drei typische Situationen, in denen tmux Gold wert ist:

• OpenClaw laufen lassen: Du startest OpenClaw in einer tmux-Sitzung. Dann kannst du das Terminal-Fenster bedenkenlos schließen – OpenClaw läuft munter weiter.
• Lange Aufgaben: Wenn ein Befehl viele Minuten oder Stunden braucht (z. B. ein großer Download oder eine Installation), möchtest du nicht die ganze Zeit davorsitzen. In tmux läuft er weiter, auch wenn du den Mac-Bildschirm sperrst.
• SSH (Fernzugriff): SSH ist eine Technik, mit der du dich vom eigenen Mac aus auf einen anderen Computer (z. B. einen kleinen Server) einloggst und ihn fernsteuerst. Bricht dabei die Verbindung ab, würden normalerweise alle deine Programme sterben. Läuft alles in tmux, überlebt es den Verbindungsabbruch – du loggst dich einfach neu ein und dockst wieder an.

tmux installieren

Wir installieren tmux mit Homebrew (dem Werkzeug, mit dem man Programme per Befehl installiert – das hast du in einem früheren Kapitel eingerichtet). Tippe ins Terminal:

brew install tmux

Wenn die Installation durchgelaufen ist, kannst du sofort loslegen. Eine Versionsabfrage zur Kontrolle geht so:

tmux -V

Erscheint eine Versionsnummer (z. B. tmux 3.x), ist alles bereit. Achte auf das große V – bei tmux ist genau auf Groß- und Kleinschreibung zu achten.

Der wichtigste Begriff: die Präfix-Taste

tmux wird über Tastenkürzel gesteuert. Damit diese Kürzel nicht mit den Tasten der Programme in tmux durcheinanderkommen, gibt es eine besondere „Anklopf-Taste“: die Präfix-Taste (englisch prefix, „Vorzeichen“). Standardmäßig ist das Ctrl + B.

Und so geht es Schritt für Schritt – das ist anfangs ungewohnt, aber wichtig:

1. Du drückst Ctrl + B gleichzeitig.
2. Du lässt beide Tasten wieder los.
3. Danach drückst du eine zweite, einzelne Taste – die sagt tmux, was es tun soll.

Beispiel: Ctrl + B drücken, loslassen, dann d drücken. Das ist der Befehl zum „Abkoppeln“ (gleich mehr dazu). Merke dir das Muster: erst anklopfen (Präfix), dann den Wunsch äußern (zweite Taste).

Abkoppeln (detach) vs. Beenden (kill)

Diese beiden Dinge werden gerne verwechselt – dabei ist der Unterschied riesig:

Im Alltag willst du fast immer abkoppeln, nicht beenden. Abkoppeln ist die freundliche Variante: nichts geht verloren.

Die wichtigsten Schritte und Befehle

Hier sind die fünf Handgriffe, mit denen du tmux komplett bedienen kannst. arbeit ist dabei nur ein selbst gewählter Name – du kannst ihn frei ändern.

tmux new -s arbeit

Ctrl+B   d

tmux ls

tmux attach -t arbeit

tmux kill-session -t arbeit

So sieht der Ablauf aus

Dieses Schaubild zeigt den typischen Weg: Du startest aus dem Terminal eine tmux-Sitzung, koppelst dich ab, schließt das Fenster – und dockst später wieder an:

flowchart TD
A[Terminal Fenster] --> B[tmux Sitzung laeuft weiter]
B --> C[abkoppeln mit Ctrl B d]
C --> D[Terminal schliessen]
D --> E[spaeter neues Terminal oeffnen]
E --> F[wieder andocken mit tmux attach]
F --> B

Beachte den Pfeil ganz unten zurück nach oben: Die Sitzung im Kasten B hat die ganze Zeit weitergelaufen. Du bist nur weg- und wieder hingegangen.

Schritt für Schritt zum Ausprobieren

Am besten verstehst du tmux, wenn du es einmal selbst machst. Folge diesen Schritten in Ruhe nach:

1. Sitzung starten. Tippe im Terminal:

   tmux new -s arbeit

   Unten erscheint jetzt eine farbige Leiste – das Zeichen, dass du in tmux bist.
2. Etwas laufen lassen. Starte einen kleinen Dauerläufer als Test. Dieser Befehl zeigt jede Sekunde die Uhrzeit an:

   while true; do date; sleep 1; done

   Du siehst, wie die Zeit fortlaufend mitgeschrieben wird.
3. Abkoppeln. Drücke Ctrl + B, lass los, dann d. Die farbige Leiste verschwindet, du bist zurück im normalen Terminal. Der Uhren-Befehl läuft im Hintergrund weiter.
4. Terminal schließen. Schließe nun ruhig das ganze Terminal-Fenster (oder den Tab). Keine Sorge – deine Sitzung lebt weiter.
5. Terminal neu öffnen. Öffne ein frisches Terminal-Fenster. Prüfe, ob deine Sitzung noch da ist:

   tmux ls

   Du solltest arbeit in der Liste sehen.
6. Wieder andocken. Tippe:

   tmux attach -t arbeit

   Und – Überraschung – die Uhr tickt munter weiter, als wäre nie etwas gewesen. Genau das ist die Magie von tmux.
7. Aufräumen. Den Uhren-Test stoppst du mit Ctrl + C. Wenn du die ganze Sitzung loswerden willst, kopple erst ab (Ctrl + B, dann d) und beende sie dann:

   tmux kill-session -t arbeit

Was ist SSH?

SSH steht für Secure Shell. Das ist eine Technik, mit der du dich von deinem Mac aus sicher auf einen anderen Computer im Netzwerk einloggen kannst – zum Beispiel auf deinen NAS (das ist ein Netzwerk-Speicher bei dir zu Hause) oder auf einen Server irgendwo im Internet.

Stell dir vor, du setzt dich vor deinen Mac, tippst einen Befehl ein – und dieser Befehl wird in Wirklichkeit auf einem ganz anderen Rechner ausgeführt. Genau das macht SSH möglich. Und das Beste: Die gesamte Verbindung ist verschlüsselt, also abhörsicher. Niemand auf dem Weg kann mitlesen, was du tust oder welches Passwort du verwendest.

Das Schlüsselpaar – einfach erklärt

SSH benutzt am liebsten keine Passwörter, sondern sogenannte Schlüssel. Davon gibt es immer zwei, die zusammengehören – man nennt das ein Schlüsselpaar:

• Privater Schlüssel (id_ed25519): Das ist dein geheimer Schlüssel. Er bleibt für immer auf deinem Mac. Du gibst ihn niemals jemandem – auch nicht per E-Mail, Chat oder USB-Stick.
• Öffentlicher Schlüssel (id_ed25519.pub): Den darfst du frei verteilen. Du legst ihn auf jedem Server ab, auf den du dich einloggen möchtest.

Eine schöne Eselsbrücke: Stell dir den öffentlichen Schlüssel als ein Vorhängeschloss vor, das du anderen geben kannst. Jeder darf es haben und an seine Tür hängen. Aufschließen kann das Schloss aber nur dein privater Schlüssel – und den hast nur du. Egal, wie viele Schlösser (öffentliche Schlüssel) du verteilst: Ohne deinen geheimen Schlüssel kommt niemand rein.

flowchart LR
A[Dein Mac
privater Schluessel]-->|SSH verschluesselt|B[Server
oeffentlicher Schluessel]
A-->|gibt oeffentlichen Schluessel ab|B

Einen Schlüssel erzeugen

Bevor du SSH nutzt, brauchst du dein eigenes Schlüsselpaar. Das erzeugst du einmalig mit diesem Befehl. Ersetze die E-Mail-Adresse durch deine eigene – sie dient nur als Notiz, damit du später weißt, zu wem der Schlüssel gehört:

ssh-keygen -t ed25519 -C "du@example.com"

Nach dem Eintippen stellt dir der Mac ein paar Fragen. Lass dich davon nicht erschrecken – hier ist, was gemeint ist:

• „Enter file in which to save the key" (Wo soll der Schlüssel gespeichert werden?): Drücke einfach Enter, um den Standard-Ort zu übernehmen. Das ist fast immer richtig.
• „Enter passphrase" (Passwort für den Schlüssel): Hier kannst du ein zusätzliches Passwort vergeben, das deinen privaten Schlüssel schützt – falls jemand deinen Mac in die Hände bekommt. Tippe ein Passwort ein (du siehst beim Tippen nichts auf dem Bildschirm, das ist normal!) und bestätige es noch einmal. Wir empfehlen dringend, hier eine Passphrase zu setzen.

Wo liegen die Schlüssel?

Deine Schlüssel landen in einem versteckten Ordner namens .ssh in deinem Benutzerverzeichnis. Die Tilde ~ ist eine Abkürzung für „mein Benutzerordner":

Öffentlichen Schlüssel auf einen Server kopieren

Damit du dich ohne Passwort einloggen kannst, muss der Server deinen öffentlichen Schlüssel kennen. Das erledigt ein einziger Befehl. Ersetze user durch deinen Benutzernamen auf dem Server und die IP-Adresse durch die deines Servers oder NAS:

ssh-copy-id user@192.168.1.100

Beim ersten Mal fragt der Server noch nach deinem normalen Passwort. Danach ist der Schlüssel hinterlegt und du brauchst es nicht mehr.

Verbinden

Jetzt kannst du dich einloggen – ganz ohne Passwort (oder nur mit deiner Passphrase, falls du eine gesetzt hast):

ssh user@192.168.1.100

Bist du verbunden, ändert sich die Eingabezeile im Terminal: Sie zeigt nun den Namen des Servers an. Alles, was du jetzt tippst, passiert auf dem entfernten Rechner. Mit dem Befehl exit beendest du die Verbindung und bist wieder auf deinem Mac.

Dateien kopieren mit scp

Mit scp (Secure Copy) schickst du Dateien über dieselbe sichere Verbindung hin und her.

Eine Datei von deinem Mac auf den Server:

scp datei.txt user@192.168.1.100:/pfad/

Eine Datei vom Server zurück auf deinen Mac (der Punkt am Ende bedeutet „in den aktuellen Ordner hier"):

scp user@192.168.1.100:/pfad/datei.txt .

Befehlskarten

ssh user@192.168.1.100

ssh-keygen -t ed25519 -C "du@example.com"

ssh-copy-id user@192.168.1.100

scp datei.txt user@192.168.1.100:/pfad/

Typische Fehler und ihre Lösung

• „Permission denied (publickey)" – Der Server akzeptiert deinen Schlüssel nicht. Meist ist der öffentliche Schlüssel dort noch nicht hinterlegt. Führe noch einmal ssh-copy-id user@… aus.
• „Host key verification failed" – Der Server hat eine neue Identität (z. B. nach einer Neuinstallation), die nicht zu der passt, die dein Mac sich gemerkt hat. Das kann ein harmloser Grund sein, aber auch ein Warnsignal. Bist du sicher, dass alles in Ordnung ist, lösche den alten Eintrag mit dem Befehl, den die Fehlermeldung dir vorschlägt (er beginnt mit ssh-keygen -R).
• Falsche Berechtigungen im ~/.ssh-Ordner – SSH ist streng: Wenn dein .ssh-Ordner oder dein privater Schlüssel für andere lesbar sind, verweigert es den Dienst. So setzt du die Rechte korrekt:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519

Was ist Tailscale?

Tailscale ist ein verblüffend einfaches VPN. Ein VPN (Virtual Private Network, also „virtuelles privates Netzwerk") verbindet Geräte über das Internet so, als ständen sie direkt nebeneinander im selben Raum – sicher und verschlüsselt.

Das Besondere an Tailscale: Es verbindet all deine eigenen Geräte – deinen Mac, deinen NAS, dein Home Assistant, dein iPhone – zu einem einzigen privaten Netzwerk. Dieses persönliche Netzwerk heißt bei Tailscale Tailnet. Egal, wo auf der Welt du gerade bist: Deine Geräte können sich gegenseitig erreichen, als wärst du zu Hause.

Unter der Haube nutzt Tailscale eine moderne, sehr schnelle Technik namens WireGuard. Aber das Schöne ist: Du musst davon nichts verstehen. Tailscale nimmt dir die ganze komplizierte Einrichtung ab.

Warum ist das so praktisch?

Stell dir vor, du bist im Urlaub und möchtest:

• auf die Dateien deines NAS zu Hause zugreifen,
• dein Home Assistant (deine Smart-Home-Zentrale) bedienen,
• oder dich per SSH auf deinen Mac einloggen.

Mit Tailscale geht das alles, als säßest du auf deinem Sofa – sicher verschlüsselt und ohne dein Heimnetz für das ganze Internet öffnen zu müssen. Nur deine eigenen Geräte sind Teil deines Tailnets.

flowchart TD
T[Dein Tailnet
privates Mesh-Netzwerk]
M[MacBook]---T
N[NAS]---T
H[Home Assistant]---T
P[iPhone]---T

Tailscale auf dem Mac installieren

Du hast zwei Wege. Am einfachsten über den Paket-Manager Homebrew im Terminal:

brew install --cask tailscale

Alternativ kannst du die App auch im App Store suchen und installieren – ganz wie jede andere Mac-App. Danach öffnest du Tailscale und meldest dich an (zum Beispiel mit deinem Google- oder Apple-Konto). Das war's schon: Dein Mac ist jetzt Teil deines Tailnets.

Tailscale auf dem NAS installieren

Die meisten NAS-Hersteller (z. B. Synology oder QNAP) bieten Tailscale als fertiges Paket in ihrem App-Center an. Such dort einfach nach „Tailscale", installiere es und melde dich mit deinem Konto an. Bei manchen NAS-Systemen läuft Tailscale auch in einem sogenannten Container – die Hersteller-Anleitung führt dich Schritt für Schritt durch.

Tailscale auf Home Assistant installieren

Für Home Assistant gibt es Tailscale als offizielles Add-on (eine Erweiterung, die man mit wenigen Klicks dazuinstalliert):

1. Öffne in Home Assistant die Einstellungen.
2. Gehe zu Add-ons und dann zum Add-on Store.
3. Suche nach Tailscale und klicke auf Installieren.
4. Starte das Add-on und folge dem Anmelde-Link, um dich mit deinem Konto anzumelden.

Danach erreichst du deine Smart-Home-Zentrale von überall sicher – ohne dein Heimnetz nach außen öffnen zu müssen.

Tailscale auf dem iPhone installieren

Lade die Tailscale-App aus dem App Store, öffne sie und melde dich mit demselben Konto an. Schon ist dein iPhone Teil deines Tailnets und kann von unterwegs auf alle deine Geräte zugreifen.

Wichtige Funktionen einfach erklärt

MagicDNS – Geräte beim Namen ansprechen

Normalerweise müsstest du dir IP-Adressen wie 100.101.102.103 merken, um ein Gerät zu erreichen. Das ist mühsam. Mit MagicDNS kannst du stattdessen einfach den Namen des Geräts verwenden – zum Beispiel mein-nas statt einer kryptischen Zahlenfolge. Du aktivierst MagicDNS einmalig in den Tailscale-Einstellungen im Browser (im sogenannten Admin-Bereich).

Exit Node – den gesamten Verkehr über ein Gerät leiten

Ein Exit Node („Ausgangsknoten") ist ein Gerät in deinem Tailnet, über das du deinen kompletten Internetverkehr leiten kannst. Beispiel: Du machst dein Gerät zu Hause zum Exit Node. Bist du dann unterwegs im unsicheren Café-WLAN, surfst du so, als wärst du zu Hause – dein gesamter Datenverkehr läuft verschlüsselt über dein Heimgerät. Das wirkt wie ein klassisches VPN nach Hause.

Subnet Router – ein ganzes Heimnetz erreichen

Manchmal hast du Geräte zu Hause, auf denen Tailscale gar nicht laufen kann – etwa ein Drucker oder eine smarte Steckdose. Ein Subnet Router löst das: Ein einziges Tailscale-Gerät (z. B. dein NAS) gibt den Zugang zu deinem gesamten Heimnetzwerk frei. So erreichst du über diesen einen Knoten auch Geräte, die selbst kein Tailscale haben.

Nützliche Befehle

Mit diesem Befehl siehst du, welche Geräte gerade in deinem Tailnet sind und ob sie erreichbar sind:

tailscale status

Und so findest du die Tailscale-Adresse (IP) deines aktuellen Geräts heraus:

tailscale ip

tailscale status

tailscale ip

Was ist ein VPN?

Ein VPN (Virtual Private Network, „virtuelles privates Netzwerk") ist ein Dienst, der zwei Dinge für dich tut:

• Es verschlüsselt deinen Internetverkehr. Alles, was du im Netz tust, wird in einen sicheren „Tunnel" gepackt, den niemand von außen einsehen kann – auch nicht dein Internetanbieter oder der Betreiber eines öffentlichen WLANs.
• Es verbirgt deine IP-Adresse. Deine IP-Adresse ist so etwas wie die Postanschrift deines Internetanschlusses. Ein VPN leitet deinen Verkehr über einen Server an einem anderen Ort. Webseiten sehen dann die Adresse dieses Servers statt deiner eigenen.

Bildlich gesprochen: Statt einen offenen Brief zu verschicken, auf dem dein Absender steht, steckst du ihn in einen blickdichten Umschlag, der über eine andere Adresse weitergeleitet wird.

VPN oder Tailscale – wo ist der Unterschied?

Beides nennt sich „VPN", verfolgt aber unterschiedliche Ziele:

• Tailscale (Kapitel 10) baut ein privates Netz zwischen deinen eigenen Geräten auf. Ziel: Du erreichst deinen Mac, NAS oder Home Assistant von überall. Es geht ums Verbinden deiner Geräte untereinander.
• Ein kommerzielles VPN (wie die unten genannten Anbieter) verbindet dich mit dem öffentlichen Internet über einen fremden Server. Ziel: Privatsphäre und Anonymität gegenüber Webseiten, Anbietern und Mitlesern.

Anbieter im Vergleich

Es gibt viele VPN-Anbieter. Die folgende Übersicht ist neutral und gibt dir einen ersten Eindruck. Welcher zu dir passt, hängt davon ab, was dir wichtig ist.

Wichtige Begriffe

Port Forwarding

Port Forwarding („Portweiterleitung") bedeutet, dass der VPN-Server eingehende Verbindungen von außen gezielt zu dir durchreicht. Warum will man das? Vor allem bei Torrents oder einer Seedbox (also beim Teilen von Dateien über Peer-to-Peer-Netze) sorgt Port Forwarding dafür, dass andere Teilnehmer dich besser erreichen – das macht Verbindungen schneller und zuverlässiger. Nicht jeder Anbieter bietet das an; in der Tabelle oben unterstützen es zum Beispiel AirVPN und ProtonVPN.

Kill Switch

Ein Kill Switch („Notausschalter") ist eine Schutzfunktion in der VPN-App. Sollte die VPN-Verbindung plötzlich abbrechen, blockiert der Kill Switch sofort deinen gesamten Internetverkehr. So wird verhindert, dass auch nur für einen Moment unverschlüsselte Daten oder deine echte IP-Adresse nach außen „durchsickern". Das ist wichtig, weil so ein Abbruch sonst unbemerkt bleiben könnte – und genau in diesem Moment würde deine Tarnung auffliegen.

Worauf du achten solltest

Was ist Node.js?

Du kennst sicher JavaScript – das ist die Programmiersprache, die normalerweise im Browser läuft und Webseiten lebendig macht (Knöpfe, Animationen, Formulare). Lange Zeit konnte JavaScript nur im Browser laufen. Node.js hat das geändert: Es ist eine sogenannte Laufzeitumgebung (englisch runtime) – ein Programm, das JavaScript auch außerhalb des Browsers ausführen kann, also direkt auf deinem Mac.

Warum interessiert uns das? Ganz einfach: OpenClaw ist in JavaScript geschrieben und braucht Node.js, um zu laufen. Ohne Node.js startet OpenClaw nicht. Node.js ist also kein „Extra“, sondern der Motor, auf dem OpenClaw fährt. Du musst Node.js nicht verstehen oder selbst benutzen – es muss nur vorhanden sein.

Was ist npm?

Zusammen mit Node.js bekommst du automatisch ein zweites Werkzeug: npm. Das ist Nodes Paketmanager – ähnlich wie Homebrew, nur speziell für JavaScript-Programme. Während Homebrew Werkzeuge für deinen ganzen Mac installiert, holt npm kleine JavaScript-Bausteine und -Programme aus dem Internet.

Auch npm musst du als Anfänger nicht selbst bedienen. Aber gut zu wissen: Wenn der OpenClaw-Installer im Hintergrund etwas „über npm installiert“, dann weißt du jetzt, was gemeint ist.

Node.js installieren

Weil du in Kapitel 4 bereits Homebrew eingerichtet hast, ist die Installation jetzt ein Einzeiler. Öffne dein Terminal und führe aus:

brew install node

Homebrew lädt Node.js (und damit automatisch npm) herunter und installiert beides sauber. Das kann ein paar Minuten dauern – warte einfach, bis du wieder die Eingabezeile siehst.

Überprüfen, ob alles funktioniert

Nach der Installation prüfst du mit zwei kurzen Befehlen, ob Node.js und npm da sind. Bei beiden sollte eine Versionsnummer erscheinen – das ist das Zeichen, dass alles geklappt hat.

node --version

Antwort etwa: v22.3.0 (deine Zahl kann anders sein – Hauptsache, da steht eine Versionsnummer).

npm --version

Antwort etwa: 10.8.1.

Die wichtigsten Befehle

Hier die drei Befehle rund um Node.js, die dir begegnen. <pkg> ist ein Platzhalter für den Namen eines Pakets (englisch package = Paket).

node --version

npm --version

npm install -g <pkg>

Das ist das Herzstück dieses Handbuchs. Bisher hast du nur Werkzeuge vorbereitet – jetzt installierst du endlich OpenClaw selbst und bringst es zum Laufen. Nimm dir hierfür in Ruhe Zeit und arbeite die Schritte der Reihe nach ab. Am Ende chattest du mit deinem eigenen, laufenden OpenClaw. Los geht's. 🦞

1) Voraussetzungen

Bevor du startest, geh diese kurze Checkliste durch. Wenn alles abgehakt ist, läuft die Installation fast von selbst:

• Ein Mac mit Apple-Chip (Apple Silicon: M1, M2, M3 oder neuer). Das haben fast alle Macs der letzten Jahre.
• Homebrew ist installiert – das hast du in Kapitel 4 erledigt. Prüfen kannst du es mit brew --version.
• Node.js (optional, aber empfohlen) – siehe Kapitel 12. Falls du es übersprungen hast: kein Problem, der OpenClaw-Installer installiert Node bei Bedarf selbst.
• Ein API-Schlüssel liegt bereit. Das ist eine Art Passwort, mit dem OpenClaw mit einem KI-Anbieter (zum Beispiel Anthropic, OpenAI oder Google) sprechen darf. Wie du einen bekommst, steht im jeweiligen Anbieter-Kapitel. Leg ihn dir griffbereit – du brauchst ihn gleich beim Onboarding.
• Eine Internetverbindung, denn der Installer lädt OpenClaw aus dem Netz.

2) Installation

Öffne dein Terminal und füge den folgenden einen Befehl ein (Kopier-Knopf oben rechts am Kasten, dann Cmd + V im Terminal, danach Enter):

curl -fsSL https://openclaw.ai/install.sh | bash

Was passiert hier? curl lädt ein kleines Installationsskript von der OpenClaw-Webseite herunter, und bash führt es sofort aus. Das Skript erledigt für dich:

• Es prüft, ob Node.js vorhanden ist, und installiert es bei Bedarf automatisch (über npm).
• Es lädt OpenClaw herunter und richtet es ein.

Das kann ein paar Minuten dauern. Während dieser Zeit laufen viele Textzeilen durch – das ist normal. Warte einfach, bis der Vorgang fertig ist und du wieder die normale Eingabezeile siehst.

3) Onboarding (Ersteinrichtung)

Jetzt richtest du OpenClaw mit einem freundlichen Einrichtungs-Assistenten ein. „Onboarding“ ist Englisch und bedeutet so viel wie „an Bord holen“ – der Assistent stellt dir ein paar Fragen und konfiguriert alles für dich. Führe aus:

openclaw onboard --install-daemon

Der Zusatz --install-daemon sorgt dafür, dass gleich auch der Hintergrunddienst eingerichtet wird (mehr dazu in Schritt 4). Der Assistent fragt dich nun nacheinander unter anderem:

• Wo soll dein Arbeitsverzeichnis liegen? Das ist der Ordner, in dem OpenClaw seine Einstellungen und seinen „Gedächtnis“-Stand ablegt (englisch workspace). In den allermeisten Fällen kannst du den Vorschlag einfach mit Enter bestätigen.
• Welchen KI-Anbieter möchtest du nutzen, und wie lautet dein API-Schlüssel? Wähle deinen Anbieter (z. B. Anthropic, OpenAI, Google) und füge dann deinen vorbereiteten API-Schlüssel ein. Auch hier gilt: Beim Einfügen des Schlüssels siehst du eventuell nichts – das ist gewollt.
• Möchtest du einen Nachrichten-Kanal verbinden? (optional) Damit kannst du später z. B. über Telegram mit OpenClaw schreiben. Das ist kein Muss – du kannst es jetzt überspringen und später nachholen.

4) Gateway prüfen

OpenClaw läuft im Hintergrund als sogenannter Daemon (sprich „die-mön“) – ein Programm, das ständig und unsichtbar im Hintergrund läuft, ohne dass ein Fenster offen sein muss. Diesen Hintergrunddienst nennt OpenClaw das Gateway (englisch für „Tor“). Er ist sozusagen die immer wache Schaltzentrale, über die alles läuft.

Prüfe, ob das Gateway läuft:

openclaw gateway status

Du solltest eine Meldung sehen, dass das Gateway läuft und auf Port 18789 lauscht. Ein „Port“ ist wie eine Hausnummer für Programme auf deinem Computer – über Port 18789 ist OpenClaw erreichbar. Steht dort, dass alles läuft, ist die Hauptarbeit geschafft.

5) Dashboard öffnen

Das Dashboard ist die freundliche Web-Oberfläche von OpenClaw – sie öffnet sich in deinem normalen Browser (Safari, Chrome, …). Hier chattest du mit OpenClaw, ganz ohne Terminal. Öffne sie mit:

openclaw dashboard

Dein Browser öffnet sich nun mit der OpenClaw-Oberfläche. Du siehst ein Chat-Fenster, das aussieht wie ein gewöhnlicher Messenger. Tippe einfach eine erste Nachricht hinein – zum Beispiel: „Hallo, stell dich kurz vor.“ – und drücke Enter. Bekommst du eine Antwort, läuft dein OpenClaw. Herzlichen Glückwunsch! 🎉

6) Konfiguration

Alle Einstellungen von OpenClaw liegen in deinem Arbeitsverzeichnis (dem Workspace aus Schritt 3). Als Anfänger musst du dort normalerweise nichts von Hand ändern – das Onboarding hat alles Wichtige erledigt.

Falls du doch einmal etwas an der Konfiguration änderst, gilt eine einfache Regel: Nach Änderungen das Gateway neu starten, damit OpenClaw die neuen Einstellungen übernimmt. Das geht so:

openclaw gateway restart

Danach öffnest du das Dashboard bei Bedarf wieder mit openclaw dashboard.

7) Updaten (Aktualisieren)

OpenClaw wird weiterentwickelt. Um auf die neueste Version zu kommen, führst du einfach denselben Installations-Befehl wie in Schritt 2 noch einmal aus:

curl -fsSL https://openclaw.ai/install.sh | bash

Danach startest du den Hintergrunddienst einmal neu, damit die neue Version aktiv wird:

openclaw gateway restart

Das war's – mehr braucht ein Update nicht.

Der ganze Ablauf auf einen Blick

flowchart TD
A[Install per Einzeiler]-->B[Onboard mit Assistent]
B-->C[Gateway laeuft auf Port 18789]
C-->D[Dashboard im Browser]
D-->E[Mit OpenClaw chatten]

Wenn etwas nicht klappt

Keine Panik – die meisten Stolpersteine sind harmlos und schnell behoben. Hier die häufigsten Fälle und ihre Lösung:

Warum überhaupt Ordnung?

Sobald du anfängst, mit KI-Werkzeugen wie OpenClaw und Claude zu arbeiten, sammelt sich erstaunlich schnell allerhand an: kleine Projekte, gespeicherte Texte, Hilfsprogramme, heruntergeladene Dateien. Wenn alles wild über deinen Schreibtisch und den Downloads-Ordner verstreut liegt, findest du nach zwei Wochen nichts mehr wieder.

Deshalb richten wir von Anfang an einen klaren, aufgeräumten Platz ein. Ein Ordner (englisch folder oder directory) ist einfach ein Behälter für Dateien – wie eine Schublade. Wir bauen uns eine kleine Schubladen-Sammlung, in der jedes Thema seinen festen Platz hat.

Der zentrale Ort: ~/AI

Wir legen alles unter einem einzigen Hauptordner namens AI in deinem Benutzerordner ab. Das Zeichen ~ (die „Tilde“) ist eine Abkürzung für deinen persönlichen Benutzerordner – also dort, wo auch Dokumente, Schreibtisch und Downloads liegen. ~/AI heißt also schlicht: „der Ordner AI in meinem Benutzerordner“.

Alle Ordner auf einmal anlegen

Öffne dein Terminal (Programme → Dienstprogramme → Terminal), kopiere den folgenden Befehl mit dem Kopier-Knopf, füge ihn mit Cmd + V ein und drücke Enter:

mkdir -p ~/AI/OpenClaw ~/AI/Claude ~/AI/Projects ~/AI/Prompts ~/AI/Scripts ~/AI/Backups ~/AI/Downloads

Was bedeutet das? mkdir steht für make directory, also „Ordner erstellen“. Der Zusatz -p sorgt dafür, dass der Hauptordner ~/AI bei Bedarf gleich mitangelegt wird und dass es keine Fehlermeldung gibt, falls ein Ordner schon existiert. In einem Rutsch entstehen so der Ordner AI und alle sieben Unterordner.

Was kommt in welchen Ordner?

So sieht deine Struktur aus

flowchart TD
A[~/AI]-->B[OpenClaw]
A-->C[Claude]
A-->D[Projects]
A-->E[Prompts]
A-->F[Scripts]
A-->G[Backups]
A-->H[Downloads]

Software ist nie ganz „fertig“. Programme bekommen laufend Verbesserungen, Fehlerbehebungen und Sicherheits-Updates. Wartung bedeutet einfach: deine Werkzeuge regelmäßig aktualisieren und kleine Aufräumarbeiten machen, damit alles flott und sicher bleibt. Keine Sorge – das sind nur ein paar kurze Befehle, und du musst sie nicht jeden Tag ausführen.

Homebrew aktuell halten

Homebrew ist dein Paketmanager (siehe Kapitel 4). Du aktualisierst ihn in zwei Schritten. Zuerst holst du die neuesten Informationen darüber, welche Versionen es gibt:

brew update

Danach bringst du deine installierten Programme tatsächlich auf den neuesten Stand:

brew upgrade

Zum Schluss räumst du alte, nicht mehr benötigte Versionen weg, die nur Platz auf der Festplatte belegen:

brew cleanup

Docker-Images aktualisieren

Docker führt Programme in abgeschlossenen Behältern aus, die auf sogenannten Images beruhen (eine Vorlage, aus der ein Behälter gebaut wird). Auch diese Images bekommen Updates. Wechsle dazu zuerst in den Ordner, in dem deine docker-compose.yml-Datei liegt. Dann holst du die neuen Images:

docker compose pull

Und startest deine Dienste mit den frischen Images neu:

docker compose up -d

Das -d steht für detached – die Dienste laufen danach im Hintergrund weiter, und dein Terminal ist wieder frei.

Node aktualisieren

Node (Node.js) ist die Laufzeitumgebung für viele Werkzeuge. Da du es über Homebrew installiert hast, aktualisierst du es ganz einfach mit:

brew upgrade node

OpenClaw aktualisieren

OpenClaw aktualisierst du, indem du denselben Installations-Befehl noch einmal ausführst, mit dem du es installiert hast. Er erkennt eine bestehende Installation und bringt sie auf die neueste Version:

curl -fsSL https://openclaw.ai/install.sh | bash

Danach startest du das sogenannte Gateway (den Dienst, der OpenClaw im Hintergrund am Laufen hält) einmal neu, damit die neue Version wirklich greift:

openclaw gateway restart

Ob danach alles läuft, prüfst du mit:

openclaw gateway status

Backups

Ein Backup ist eine Sicherheitskopie deiner Daten. Falls einmal etwas kaputtgeht, du eine Datei aus Versehen löschst oder ein Update schiefläuft, kannst du damit alles wiederherstellen. Backups sind die billigste Versicherung, die es gibt.

Sichern solltest du vor allem:

• deinen kompletten Ordner ~/AI – darin steckt deine ganze KI-Arbeit (siehe Kapitel 14),
• den Arbeits- und Konfigurationsbereich von OpenClaw (sein Workspace-/Config-Ordner) – darin stecken deine Einstellungen.

Am einfachsten kopierst du diese Ordner regelmäßig in deinen ~/AI/Backups-Ordner oder, noch besser, auf ein externes Ziel wie eine externe Festplatte oder ein NAS (ein Netzwerkspeicher – ein kleines Gerät im Heimnetz, das wie eine zentrale Festplatte für alle Geräte funktioniert). So ist deine Kopie auch dann sicher, wenn dem Mac selbst etwas passiert.

tmux-Sessions verwalten

Mit tmux lässt du Programme im Terminal auch dann weiterlaufen, wenn du das Fenster schließt (siehe Kapitel 8). Im Rahmen der Wartung ist es gut, ab und zu nachzusehen, was noch läuft, und Überflüssiges zu beenden. Alle laufenden Sitzungen anzeigen:

tmux ls

Dich wieder mit einer bestimmten Sitzung verbinden (name durch den echten Namen ersetzen):

tmux attach -t name

Eine Sitzung, die du nicht mehr brauchst, beenden:

tmux kill-session -t name

Wöchentliche Wartungs-Checkliste

Wenn du einmal pro Woche kurz diese Liste durchgehst, bleibt dein System dauerhaft gesund:

1. Homebrew aktualisieren: brew update, dann brew upgrade, dann brew cleanup.
2. Docker-Images aktualisieren: docker compose pull, dann docker compose up -d.
3. Node aktualisieren: brew upgrade node.
4. OpenClaw aktualisieren und Gateway neu starten, dann Status prüfen.
5. Backup machen: ~/AI und den OpenClaw-Bereich sichern.
6. Mit tmux ls aufräumen und nicht mehr benötigte Sitzungen beenden.

Sicherheit klingt erst einmal nach einem großen, kompliziertem Thema – ist es aber nicht. Für den Anfang reichen ein paar einfache, klare Grundregeln. Wenn du sie beherzigst, bist du den allermeisten Problemen schon aus dem Weg gegangen. Dieses Kapitel ist nicht zum Erschrecken da, sondern zum Selbstbewusst-Werden: Du sollst verstehen warum, damit du entspannt arbeiten kannst.

Regel 1: Nur ausführen, was du verstehst

Im Terminal hat ein Befehl viel Macht – er kann Dateien anlegen, ändern und löschen. Deshalb gilt: Führe niemals einen Befehl oder ein Skript aus, das du nicht zumindest grob verstehst, vor allem nicht aus fremden oder unbekannten Quellen.

Besonders riskant sind Befehle der Form curl irgendeine-adresse | bash. Das bedeutet: „Lade etwas aus dem Internet herunter und führe es sofort ungeprüft aus.“ Bei einer vertrauenswürdigen, offiziellen Quelle (wie der OpenClaw-Installation) ist das in Ordnung. Bei einem zufälligen Tipp aus einem Forum, einem Chat oder einer fremden Webseite kann sich dahinter Schadsoftware verbergen.

Regel 2: Geheimnisse niemals veröffentlichen

Ein API-Key (auch API-Schlüssel genannt) ist eine lange, zufällige Zeichenkette, mit der sich ein Programm bei einem Dienst ausweist – zum Beispiel bei einem KI-Anbieter. Stell ihn dir wie einen Passwort-Ersatz vor: Wer ihn hat, kann sich als du ausgeben und in deinem Namen Dienste nutzen – unter Umständen auf deine Kosten.

Genauso sind Tokens (ähnliche Zugangs-Zeichenketten) und natürlich echte Passwörter zu behandeln. Veröffentliche oder „committe“ sie niemals. „Committen“ bedeutet, eine Datei in die Versionsverwaltung Git aufzunehmen – landet diese dann auf einer öffentlichen Plattform wie GitHub, kann sie jeder lesen. Solche Geheimnisse werden im Internet automatisch von Bots gesucht und innerhalb von Minuten missbraucht.

Regel 3: .env-Dateien für dich behalten

Eine .env-Datei (gesprochen „dot-env“) ist eine kleine Textdatei, in der Programme ihre Geheimnisse aufbewahren – also genau solche API-Keys, Tokens und Passwörter. Der Name beginnt mit einem Punkt, weshalb sie im Finder normalerweise versteckt ist. Sie ist quasi der Tresor deines Projekts.

Eine .env-Datei gibst du niemals weiter und committest sie nie. Üblicherweise trägt man ihren Namen in eine Datei namens .gitignore ein – das ist eine Liste von Dingen, die Git absichtlich ignorieren soll, damit sie gar nicht erst versehentlich mitgesichert werden.

Regel 4: Vorsicht mit sudo

sudo bedeutet, einen Befehl mit Administrator-Rechten (auch root genannt) auszuführen. Damit darf der Befehl alles auf deinem Mac – auch Dinge ändern oder löschen, die normalerweise geschützt sind. Das ist mächtig und manchmal nötig, aber eben auch gefährlich: Ein falscher Befehl mit sudo kann echten Schaden anrichten.

Regel 5: Unbekannte Skills und Plugins prüfen

OpenClaw lässt sich durch Skills und Plugins erweitern – kleine Zusatzbausteine, die neue Fähigkeiten bringen. Das Praktische daran: Sie können auf deinem Rechner Code ausführen. Genau das ist aber auch der Haken: Ein bösartiges oder schlampig gebautes Plugin kann denselben Schaden anrichten wie jedes andere Programm.

Sicherheits-Checkliste

Diese Punkte fassen die wichtigsten Regeln zusammen. Geh sie im Kopf durch, bevor du etwas Riskantes tust:

• Ich führe keine Befehle oder Skripte aus, die ich nicht verstehe – besonders kein curl ... | bash aus unbekannter Quelle.
• Ich veröffentliche und committe niemals API-Keys, Tokens oder Passwörter.
• Ich teile keine .env-Dateien und schließe sie über .gitignore aus.
• Ich nutze sudo nur, wenn ich verstehe, warum es nötig ist.
• Ich installiere nur geprüfte Skills und Plugins aus vertrauenswürdigen Quellen.
• Ich mache regelmäßig Backups (siehe Kapitel 15) – falls doch einmal etwas schiefgeht.

Was ist geheim?

Zur Orientierung: Diese Dinge sind Geheimnisse. Sie gehören niemals in fremde Hände, in einen Chat oder ins Internet.

Das war es schon. Mit diesen wenigen Gewohnheiten arbeitest du sicher und souverän. Sicherheit ist kein Hexenwerk – sie ist vor allem eine Frage von ein bisschen Aufmerksamkeit im richtigen Moment.

Dieses Kapitel ist dein Nachschlagewerk. Du musst diese Befehle nicht auswendig lernen! Komm einfach hierher zurück, wann immer du wissen willst, was ein Befehl tut. Jeder Befehl wird einfach erklärt, mit einem realistischen Beispiel und dem häufigsten Anfängerfehler.

📂 Navigation & Dateien

Mit diesen Befehlen bewegst du dich durch die Ordner deines Macs und verwaltest Dateien – wie im Finder, nur getippt.

pwd

ls -la

cd ~/Documents

mkdir mein-projekt

rmdir alter-ordner

rm notizen.txt

cp original.txt kopie.txt

mv alt.txt neu.txt

touch notizen.txt

cat notizen.txt

less langetextdatei.txt

head -n 20 logdatei.txt

tail -f logdatei.txt

find . -name "*.txt"

tree

open bericht.pdf

open .

📝 Anzeigen & Bearbeiten

Texte ansehen, schreiben und einfache Auswertungen machen – das geht direkt im Terminal.

nano notizen.txt

code .

echo "Hallo Welt"

printf "Zeile 1\nZeile 2\n"

wc -l notizen.txt

sort namen.txt

sort namen.txt | uniq

diff alt.txt neu.txt

🔍 Suche & Text

So findest du Inhalte, Programme und das, was du vorhin getippt hast.

grep "Fehler" logdatei.txt

which git

file bild.jpg

history

clear

⚙️ System & Prozesse

Hier siehst du, was auf deinem Mac läuft, wie es ihm geht und wie du Programme stoppst.

top

htop

ps aux | grep node

kill 12345

killall Safari

df -h

du -sh ~/Downloads

uname -a

sw_vers

whoami

date

uptime

sudo befehl

caffeinate

🌐 Netzwerk

Internetverbindung prüfen, Dateien herunterladen und dich mit anderen Rechnern verbinden.

ping google.com

curl https://example.com

wget https://example.com/datei.zip

ifconfig

ipconfig getifaddr en0

ssh benutzer@192.168.1.50

scp datei.txt benutzer@192.168.1.50:/home/benutzer/

ssh-keygen -t ed25519

netstat -an

📦 Pakete & Entwicklung

Programme installieren und mit den Werkzeugen arbeiten, die OpenClaw braucht.

brew --version

brew install git

brew upgrade

git --version

git status

git clone https://github.com/benutzer/projekt.git

node --version

npm install

docker --version

docker ps

docker compose up -d

tmux

tmux ls

🔐 Berechtigungen & Pfade

Rechte setzen, Verknüpfungen anlegen und dem Terminal sagen, wo es Dinge findet.

chmod +x skript.sh

sudo chown $(whoami) datei.txt

ln -s /pfad/zum/original verknuepfung

export MEIN_SCHLUESSEL="abc123"

source ~/.zshrc

env

alias ll="ls -la"

Alle Fachbegriffe auf einen Blick

In diesem Handbuch tauchen immer wieder englische Fachwörter und Abkürzungen auf. Das ist normal – in der Computerwelt wird viel Englisch benutzt. In dieser Tabelle findest du alle wichtigen Begriffe kurz und in einfachen Worten erklärt. Du musst das hier nicht auswendig lernen. Schlag einfach nach, wann immer dir ein Wort begegnet, das du nicht kennst.

Keine Panik – fast alles lässt sich lösen

Wenn etwas nicht funktioniert, ist das völlig normal und kein Grund zur Sorge. Die allermeisten Probleme sind kleine Stolpersteine mit einer einfachen Lösung. In diesem Kapitel findest du die häufigsten Fehlermeldungen, was sie bedeuten und wie du sie behebst – Schritt für Schritt. Atme tief durch und arbeite den passenden Abschnitt in Ruhe durch.

„command not found: brew“ – Homebrew wird nicht gefunden

Du hast Homebrew installiert, aber beim Eintippen von brew kommt command not found: brew (Befehl nicht gefunden). Das heißt fast immer: Die Installation hat geklappt, aber dein Terminal weiß noch nicht, wo Homebrew liegt. Es fehlt der Eintrag im PATH (der Suchliste deines Terminals). Das passiert oft, wenn nach der Installation der letzte Einrichtungsschritt vergessen wurde.

So aktivierst du Homebrew sofort in deinem aktuellen Terminal:

eval "$(/opt/homebrew/bin/brew shellenv)"

Damit es dauerhaft bei jedem neuen Terminal funktioniert, fügst du dieselbe Zeile zu deiner Konfigurationsdatei ~/.zprofile hinzu:

echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile

Schließe danach das Terminal und öffne es neu. Tippe zur Kontrolle brew --version – jetzt sollte eine Versionsnummer erscheinen.

„command not found“ allgemein – PATH-Fehler

Die Meldung command not found kann bei jedem Befehl auftauchen, nicht nur bei brew. Sie bedeutet immer dasselbe: Dein Terminal hat dieses Programm in seiner Suchliste, dem PATH, nicht gefunden. Der PATH ist eine Liste von Ordnern, die das Terminal nach Programmen durchsucht. Entweder ist das Programm gar nicht installiert, oder es liegt in einem Ordner, der nicht im PATH steht.

Erster Schritt: Terminal komplett schließen und neu öffnen. Frisch installierte Programme werden oft erst dann erkannt. Hilft das nicht, sieh dir deinen aktuellen PATH an:

echo $PATH

Das zeigt dir alle Ordner an, durch Doppelpunkte getrennt, in denen gesucht wird. Fehlt der Ordner deines Programms in dieser Liste, ist das die Ursache.

Docker startet nicht – „Cannot connect to the Docker daemon“

Wenn beim Eintippen eines Docker-Befehls die Meldung Cannot connect to the Docker daemon (Kann keine Verbindung zum Docker-Dienst herstellen) erscheint, bedeutet das: Der Docker-Hintergrunddienst läuft gerade nicht. Bei Docker auf dem Mac steckt dieser Dienst in der App Docker Desktop – und diese App muss geöffnet sein, damit Docker-Befehle funktionieren.

Starte die App Docker Desktop über dein Launchpad oder den Ordner „Programme“. Warte, bis das kleine Wal-Symbol 🐳 oben in der Menüleiste ruhig (nicht mehr animiert) ist – das heißt: Docker läuft jetzt. Prüfe dann im Terminal:

docker ps

Wenn statt einer Fehlermeldung eine (meist leere) Tabelle erscheint, ist alles in Ordnung. docker ps listet die gerade laufenden Container auf.

VS Code: Der Befehl „code“ funktioniert nicht

Du möchtest VS Code aus dem Terminal heraus mit code öffnen, aber es kommt command not found: code. Der Grund: Der praktische Terminal-Befehl code muss in VS Code einmal aktiviert werden – er ist nicht von Anfang an eingerichtet.

So aktivierst du ihn, ganz ohne Terminal:

1. Öffne VS Code wie gewohnt per Doppelklick.
2. Drücke Cmd + Shift + P. Das öffnet oben die sogenannte Command Palette (Befehlsübersicht) – ein Suchfeld für alle VS-Code-Befehle.
3. Tippe dort: Shell Command: Install 'code' command in PATH und klicke den Eintrag an.

Schließe danach das Terminal und öffne es neu. Jetzt funktioniert code ., um VS Code im aktuellen Ordner zu starten.

tmux-Session verloren

Du hattest in tmux etwas am Laufen, aber das Fenster ist weg oder du findest die Sitzung nicht wieder. Keine Sorge – tmux-Sitzungen laufen im Hintergrund weiter, auch wenn du das Fenster schließt. Sieh zuerst nach, welche Sitzungen noch existieren:

tmux ls

Du bekommst eine Liste mit Namen, zum Beispiel 0: oder einen selbst vergebenen Namen. Mit diesem Namen verbindest du dich wieder mit der Sitzung (englisch attach = anhängen):

tmux attach -t name

Ersetze name durch den Namen aus der Liste. Bekommst du bei tmux ls die Meldung „no server running“ oder eine leere Liste, war die Sitzung leider schon beendet – dann startest du sie einfach neu.

SSH: „Permission denied (publickey)“

Diese Meldung beim Verbinden mit SSH bedeutet: Der andere Computer hat deine Anmeldung abgelehnt, weil dein digitaler Schlüssel (englisch key) dort nicht akzeptiert wurde. Geh die folgenden Punkte der Reihe nach durch:

• Richtiger Benutzername und Adresse? Prüfe, ob du dich beim richtigen Benutzer und der richtigen Adresse anmeldest, z. B. ssh benutzer@adresse.
• Schlüssel hinterlegt? Dein öffentlicher Schlüssel muss auf dem Zielcomputer bekannt sein. Das erledigst du am einfachsten so (ersetze die Werte durch deine eigenen):

ssh-copy-id benutzer@adresse

• Stimmen die Dateirechte? SSH ist streng: Sind die Rechte zu offen, verweigert es aus Sicherheitsgründen die Arbeit. So setzt du sie korrekt:

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519

Die zweite Zeile bezieht sich auf deine private Schlüsseldatei – passe den Dateinamen ggf. an deinen Schlüssel an. 700 und 600 sind Rechte-Codes, die bedeuten: „nur ich selbst darf darauf zugreifen“.

Node.js fehlt oder hat die falsche Version

Wenn OpenClaw oder ein anderes Programm meldet, dass Node.js fehlt oder zu alt ist, installierst oder aktualisierst du es bequem über Homebrew. Zum Installieren:

brew install node

Ist Node bereits da, aber zu alt, aktualisierst du es:

brew upgrade node

Danach prüfst du die Version:

node --version

Es sollte eine Versionsnummer wie v22.3.0 erscheinen. Kommt stattdessen command not found, schließe das Terminal und öffne es neu – dann wird das frisch installierte Node erkannt.

OpenClaw startet nicht

Wenn OpenClaw nicht reagiert oder sich nicht starten lässt, prüfe zuerst den Zustand des Gateways – das ist der Hintergrunddienst, der OpenClaw am Leben hält:

openclaw gateway status

Steht dort, dass das Gateway nicht läuft, starte es neu:

openclaw gateway restart

Hilft das nicht, schließe das Terminal komplett, öffne es neu und prüfe den Status erneut. In den allermeisten Fällen ist OpenClaw danach wieder einsatzbereit.

Gateway startet nicht / Port belegt

Manchmal lässt sich das Gateway nicht starten, weil seine „Tür“ – der Port 18789 – schon von einem anderen Programm besetzt ist. Oft ist das eine alte, hängengebliebene OpenClaw-Instanz. Ein Neustart räumt das in der Regel auf:

openclaw gateway restart

Prüfe danach erneut den Status:

openclaw gateway status

Bleibt das Problem bestehen, schließe das Terminal, öffne es neu und versuche den Neustart noch einmal. So ist sichergestellt, dass keine alte Sitzung mehr im Weg ist.

Dashboard öffnet nicht

Das OpenClaw-Dashboard ist eine Bedienoberfläche, die in deinem Browser läuft. Öffne es mit:

openclaw dashboard

Normalerweise öffnet sich dein Browser dann von selbst. Passiert nichts, sieh dir den Link an, den der Befehl im Terminal anzeigt (meist beginnt er mit http://localhost oder http://127.0.0.1 – beides bedeutet „dein eigener Mac“). Kopiere diesen Link und füge ihn von Hand in die Adresszeile deines Browsers ein.

Lädt die Seite trotzdem nicht, prüfe, ob das Gateway überhaupt läuft (siehe oben, openclaw gateway status) – ohne Gateway gibt es kein Dashboard. Selten blockiert auch eine Firewall (eine Schutzfunktion deines Macs) die Verbindung; erlaube sie in diesem Fall in den Systemeinstellungen unter „Netzwerk“ → „Firewall“.

Übersicht: Symptom und Lösung

Hier findest du kurze, klare Antworten auf die Fragen, die fast alle am Anfang stellen. Wenn dich etwas verunsichert hat – wahrscheinlich steht es hier.

Brauche ich Programmiererfahrung?

Nein. Du musst nicht programmieren können. In dieser Anleitung kopierst du fertige Befehle in dein Terminal und drückst Enter – mehr nicht. Es schadet nicht, neugierig zu sein, aber Vorwissen ist nicht nötig.

Was kostet das?

OpenClaw selbst läuft lokal auf deinem Mac und kostet dich nichts. Geld kann nur an einer Stelle anfallen: beim Modellanbieter (zum Beispiel Anthropic für Claude). Diese Anbieter rechnen die Nutzung ihres KI-Modells über einen sogenannten API-Key ab – je nachdem, wie viel du nutzt. Wer wenig nutzt, zahlt wenig.

Brauche ich einen API-Key?

Ja, in der Regel schon. Ein API-Key ist eine Art Passwort, mit dem sich OpenClaw beim Modellanbieter anmeldet, damit du das KI-Modell benutzen darfst. Du holst dir diesen Schlüssel beim Anbieter deiner Wahl ab und hinterlegst ihn einmalig in OpenClaw.

Welchen Modellanbieter soll ich nehmen?

Du hast die Wahl. Eine gängige und gut funktionierende Option ist Anthropic mit Claude. OpenClaw kann aber mit verschiedenen Anbietern zusammenarbeiten – du legst dich nicht für immer fest und kannst später wechseln.

Ist OpenClaw sicher? Wo laufen meine Daten?

OpenClaw selbst läuft lokal auf deinem Mac. Der Gateway (das Herzstück) arbeitet auf deinem eigenen Rechner und ist standardmäßig nur über deinen Mac erreichbar (Port 18789). Nur die Anfragen, die du tatsächlich an das KI-Modell schickst, gehen an den Modellanbieter. Mehr zum Thema Schutz findest du im Sicherheits-Kapitel.

Funktioniert das auch auf einem Intel-Mac oder unter Windows?

Diese Anleitung ist für Apple Silicon geschrieben (Macs mit M1, M2, M3 und neuer). Das Installations-Skript install.sh läuft grundsätzlich auch unter Linux und unter Windows mit WSL (dem Linux-Unterbau für Windows). Auf älteren Intel-Macs kann einzelnes abweichen – die hier gezeigten Schritte beziehen sich auf Apple Silicon.

Muss mein Mac immer laufen, damit OpenClaw funktioniert?

Ja. Der Gateway läuft lokal auf deinem Mac. Solange er laufen soll, muss der Mac eingeschaltet und wach sein. Wenn du rund um die Uhr darauf zugreifen möchtest, lass den Mac dauerhaft an (Ruhezustand abschalten), nutze tmux, damit Sitzungen weiterlaufen, oder betreibe das Ganze auf einem immer laufenden Gerät wie einem NAS.

Wie aktualisiere ich OpenClaw?

Ganz einfach: Du führst den Installationsbefehl noch einmal aus. Er holt automatisch die neueste Version:

curl -fsSL https://openclaw.ai/install.sh | bash

Wie deinstalliere ich es grob?

Du entfernst den OpenClaw-Daemon (den im Hintergrund laufenden Dienst) und löschst den zugehörigen OpenClaw-Ordner. Die genauen Schritte hängen von deiner Installation ab – orientiere dich an der offiziellen Dokumentation. Da OpenClaw lokal arbeitet, bleibt nichts auf fremden Servern zurück.

Kann ich auch per Handy mit OpenClaw chatten?

Ja. OpenClaw lässt sich mit Nachrichten-Kanälen verbinden, zum Beispiel mit einem Telegram-Kanal. Dann schreibst du deinem OpenClaw bequem vom Smartphone aus – die Arbeit erledigt weiterhin dein Mac zu Hause.

Was ist der Unterschied zu ChatGPT?

ChatGPT ist ein fertiger Chat-Dienst, der auf den Servern des Anbieters läuft. OpenClaw ist dagegen ein Werkzeug, das du selbst auf deinem Mac betreibst: Es steuert KI-Modelle, kann auf deinem Rechner Aufgaben erledigen (Dateien, Befehle, eigene „Skills“) und du behältst die Kontrolle über deine Daten. Kurz: ChatGPT ist eine Website, OpenClaw ist deine eigene KI-Schaltzentrale.

Was ist eine „Skill“?

Eine Skill (englisch für „Fähigkeit“) ist eine zusätzliche Fertigkeit, die OpenClaw beibringt, etwas Bestimmtes besonders gut zu tun – zum Beispiel Bilder erstellen, das Wetter abrufen oder Notizen verwalten. Du musst Skills nicht selbst bauen; viele sind bereits fertig vorhanden und du aktivierst sie nur bei Bedarf.

Wie bekomme ich Hilfe, wenn ich nicht weiterkomme?

Zwei zuverlässige Anlaufstellen: die offizielle Dokumentation von OpenClaw und die Community rund um das Projekt. Dort findest du Anleitungen, Beispiele und Menschen, die ähnliche Fragen schon gelöst haben. Und: Du kannst OpenClaw selbst fragen – oft hilft es dir direkt weiter.

Diese Seite ist deine Spickzettel-Sammlung: die wichtigsten Befehle kurz und übersichtlich zum Nachschlagen. Du musst nichts auswendig lernen – komm einfach hierher zurück, wenn du einen Befehl brauchst.

Terminal-Basics

Homebrew

Homebrew ist der „App-Store für die Kommandozeile“. Damit installierst du Programme.

brew install programmname     # Programm installieren
brew upgrade                  # alle Programme aktualisieren
brew list                     # installierte Programme anzeigen
brew search begriff           # nach einem Programm suchen
brew doctor                   # Probleme aufspüren

Git

Git verwaltet Versionen von Dateien und Projekten.

Docker

Docker führt Programme in abgekapselten „Containern“ aus.

docker ps                     # laufende Container anzeigen
docker images                 # heruntergeladene Images anzeigen
docker logs name              # Protokoll eines Containers ansehen
docker compose up -d          # Dienste im Hintergrund starten
docker compose down           # Dienste stoppen und aufräumen

tmux

tmux hält Terminal-Sitzungen am Leben, auch wenn du das Fenster schließt.

SSH

SSH verbindet dich sicher mit einem anderen Computer (zum Beispiel einem Server oder NAS).

ssh-keygen -t ed25519         # Schlüsselpaar erzeugen
ssh-copy-id benutzer@server   # Schlüssel auf den Server kopieren
ssh benutzer@server           # mit dem Server verbinden
scp datei benutzer@server:~/  # Datei zum Server kopieren

OpenClaw

Die wichtigsten OpenClaw-Befehle auf einen Blick.

curl -fsSL https://openclaw.ai/install.sh | bash   # installieren / aktualisieren
openclaw onboard --install-daemon                  # Ersteinrichtung
openclaw gateway status                            # Status prüfen (Port 18789)
openclaw gateway restart                           # Gateway neu starten
openclaw dashboard                                 # Übersicht im Browser öffnen

Geschafft! Du bist am Ende dieses Handbuchs angekommen. Hier erfährst du, wie du das Handbuch speicherst und ausdruckst – und wie es nach der Installation für dich weitergeht.

Das ganze Handbuch als PDF speichern oder drucken

Du kannst dieses komplette Handbuch als PDF-Datei sichern, um es offline zu lesen oder auszudrucken. Es gibt zwei Wege:

1. Klicke oben in der Kopfzeile auf den 🖨️ PDF-Knopf. Er klappt automatisch alle Kapitel auf, damit wirklich der gesamte Inhalt mit ausgedruckt wird.
2. Oder nutze die Druckfunktion deines Browsers: Cmd + P drücken und im Druckdialog „Als PDF sichern“ auswählen.

Werden meine Häkchen gespeichert?

Ja. Die Fortschritts-Häkchen („erledigt“) bei jedem Kapitel werden lokal in deinem Browser gespeichert. Wenn du die Seite schließt und später wieder öffnest, sind deine Häkchen noch da – ganz ohne Konto oder Anmeldung. Wichtig: Sie hängen am jeweiligen Browser auf diesem Gerät. Öffnest du das Handbuch auf einem anderen Computer oder löschst du die Browser-Daten, fängst du dort wieder bei null an.

Nächste Schritte

Sobald OpenClaw läuft, gibt es ein paar lohnende erste Dinge zu tun:

• Das Dashboard erkunden: Öffne mit openclaw dashboard die Übersicht im Browser und schau dich in Ruhe um.
• Einen Nachrichten-Kanal verbinden: Richte zum Beispiel einen Telegram-Kanal ein, damit du auch vom Handy aus mit OpenClaw schreiben kannst.
• Eine erste Aufgabe ausprobieren: Stell OpenClaw eine kleine, konkrete Aufgabe und sieh zu, wie es arbeitet. So bekommst du am schnellsten ein Gefühl dafür.
• Die offizielle Dokumentation lesen: Dort findest du vertiefende Anleitungen und entdeckst, was noch alles möglich ist.

Schnellstart in 6 Schritten

Hier noch einmal der rote Faden zum Nachschlagen. Jeder Punkt führt dich direkt zum passenden Kapitel:

1. Homebrew installieren – die Grundlage für alle weiteren Programme.
2. OpenClaw installieren – mit dem Installations-Einzeiler.
3. Die Ersteinrichtung durchlaufen: openclaw onboard --install-daemon
4. Prüfen, ob alles läuft: openclaw gateway status (Port 18789).
5. Das Dashboard öffnen: openclaw dashboard
6. Einen Nachrichten-Kanal verbinden und die erste Aufgabe ausprobieren.

Und jetzt: Trau dich! Du hast vom ersten Terminal-Befehl bis zum laufenden OpenClaw alles selbst geschafft – das ist eine Menge. Bleib neugierig, probiere aus, und scheue dich nicht, OpenClaw einfach zu fragen, wenn du nicht weiterkommst. Viel Freude beim Entdecken! 🎉