Terminal • Ablösbar • Mobil

Dev Terminals
für all deine Services

Dein Projekt hat ein Backend, ein Frontend, eine Mobile App, einen Relay-Server. Früher hast du 4 Terminal-Tabs geöffnet und jeden Startbefehl manuell eingetippt. Jetzt drückst du einen Knopf.

Und das Einzigartige: Mit der mobilen iOS- und Android-App löst du Befehle aus der Ferne auf deinem Rechner aus. Starte eine localhost-Website aus der U-Bahn, dem Fitnessstudio oder einem Café, und öffne sie dann über 4G/5G auf deinem Telefon durch den integrierten Live-Preview-Tunnel.

Screenshots

Echte Aufnahmen der App, ergänzt, wenn sich diese Funktion weiterentwickelt.

  • Abgetrenntes Terminalfenster mit einem gestrichelten Plus-Button nach den Terminal-Kacheln
    Öffnen Sie ein neues Terminal im Projektordner direkt aus dem abgetrennten Terminalfenster.
  • Agenten-Terminal, dessen Text ganz oben im Bereich unter der schwebenden Kopfzeile beginnt
    Das Terminal des Agenten nutzt jetzt die volle Höhe seines Bereichs, ohne leeren Streifen oben.
  • Einstellungen des Agentenverhaltens mit dem Schalter, der entscheidet, ob von Agenten gestartete Terminal-Tabs in den Vordergrund kommen
    Halten Sie die Terminal-Tabs, die Ihre Agenten öffnen, im Hintergrund, damit sie Sie nie von Ihrer Arbeit ablenken.
  • Ein gestoppter Befehl im Panel mit einem Ausführen-Button in der Mitte
    Ein gestoppter Befehl zeigt einen sauberen Bildschirm mit einem Ausführen-Button direkt im Panel.
1 / 4

Eine echte Sitzung, in der App gefilmt: Ein kleines Shop-Projekt mit einer API und einem Storefront hat noch keinen gespeicherten Befehl. Ein Klick auf den Zauberstab, und ein KI-Agent liest das Repository und schreibt die zwei Startbefehle, jeden mit seinem eigenen Ordner. Start in jeder Zeile führt den Server in einem echten Terminal-Tab aus, und der Zähler zeigt zwei laufende Server, ohne ein einziges cd zu tippen.

Auf YouTube ansehen

Dev Terminals ist weit mehr als ein Terminal-Emulator. Es ist ein echter Befehlsmanager pro Projekt, der den Dschungel aus iTerm2-, Warp-, Ghostty-, Kitty-, Alacritty- und Terminal.app-Tabs ersetzt, den du jeden Morgen öffnest. Jedes Projekt hat seine eigene Befehlsliste: Dev-Server, Backend, Mobile-Bundler, Worker, Datenbank, interne Skripte. Du benennst sie einmal und startest sie für immer.

UX und UI sind bewusst kompromisslos auf maximale Geschwindigkeit beim Befehlsmanagement ausgelegt. Jeder Befehl merkt sich seinen Namen, seinen Shell-Befehl, sein Arbeitsverzeichnis (relativ zum Projektstamm), seine Framework-Kategorie (React, Next.js, Django, Rails, Go, Rust, Docker…) und seine Art (langlebiger Prozess oder einmaliges Snippet). Aktive Befehle wandern an den Anfang der Liste, und farbige Framework-Icons lassen dich dein React-Frontend, dein Django-Backend und deine Docker-Services auf einen Blick erkennen.

Der große Vorteil eines direkt in AgentsRoom integrierten Terminals ist, dass Befehle im exakten Kontext deines Projekts laufen: gleicher Pfad, gleiche Umgebung, gleiches cwd. Null Reibung, kein endloses cd, keine Verwechslung zwischen Projekten. Und weil alles direkt neben deinen KI-Agenten Claude, Codex und Antigravity liegt, hörst du auf, zwischen fünfzehn verschiedenen Tools zu jonglieren, nur um Code auszuliefern.

AgentsRoom Multi-Terminal-Arbeitsbereich mit Drag-and-drop split panes und einem abgetrennten Terminal-Fenster auf einem vertikalen Monitoring-Bildschirm, eine moderne Alternative zu iTerm2, Warp und WezTerm

Multi-Pane-Terminal-Layout in AgentsRoom: Terminals aufteilen, auf einen zweiten Bildschirm auslagern und Agenten, Logs und Builds nebeneinander überwachen.

Ein echtes integriertes Terminal, kein Spielzeug

Jeder Befehl öffnet ein vollständiges xterm.js-Terminal mit ANSI-Farben, Scrollback, klickbaren Links, PTY-Resize und Unicode-Unterstützung. Das ist keine vorgetäuschte Log-Ansicht: Es ist ein echtes Pseudo-Terminal, identisch mit dem, was du in iTerm2 oder Terminal.app bekommst, nur für dich verwaltet.

Der Status jedes Prozesses wird live angezeigt: laufend, startend, gestoppt, abgestürzt. Wenn ein Dev-Server zusammenbricht, siehst du es sofort. Ein Klick zum Neustart. Und wenn du mehrere Terminals parallel brauchst (Backend + Frontend + Mobile + Relay), hat jeder Befehl seinen eigenen Knopf „Starten“ und seinen eigenen Terminal-Tab. So laufen sie nebeneinander in den richtigen Ordnern, ohne dass du ein einziges cd tippst.

Befehle werden in Ordnern gruppiert, lassen sich mit der Maus umsortieren und werden in `.agentsroom/commands.json` im Stammverzeichnis deines Projekts gespeichert. Committe diese Datei: Dein ganzes Team erbt dasselbe Terminal-Setup. Persönliche Befehle (lokale Debug-Skripte, private Umgebungsvariablen) gehen in `commands-personal.json`, das automatisch zur `.gitignore` innerhalb von `.agentsroom` hinzugefügt wird. Niemand muss beim Beitritt zu einem neuen Repo jemals wieder `yarn dev --port 2203` aus dem Gedächtnis tippen.

Schließlich ist alles vereint: Deine KI-Agenten, deine Terminals, deine Prompts, dein Backlog und deine Live-Preview leben alle im selben Fenster. Du sparst enorm viel Zeit, indem du das Hin und Her zwischen AgentsRoom, deinem Terminal-Emulator, deiner IDE und deinem Browser abschaffst. Ein Bildschirm, alles nur einen Klick entfernt.

Abgetrennte Befehle und Multi-Screen-Setup

Dev Commands können jetzt vollständig in ein eigenständiges Fenster ausgelagert werden, getrennt von der Haupt-AgentsRoom-Oberfläche. Löse deine Terminals heraus und verschiebe sie dorthin, wo du am besten arbeitest: ein zweiter Bildschirm, ein Ultrawide oder ein vertikaler Monitor für Monitoring, Logs, Builds und KI-Agenten.

Ein vertikaler Bildschirm an der Seite wird zu einer Live-Wand für deine laufenden Prozesse. Behalte deinen Editor und deine Agenten im Hauptfenster und beobachte jeden Server, jeden Build und jeden Log-Stream in Echtzeit auf dem Nebenpanel. Kein alt-tab, kein verlorener Kontext.

Bessere Arbeitsbereichsorganisation

Befreie dein Hauptfenster für Code und Agenten. Abgetrennte Terminals leben eigenständig, sodass deine Entwicklungsoberfläche sauber und fokussiert bleibt, anstatt in einem einzigen Panel zusammengepfercht zu sein.

Optimiertes Multi-Screen-Layout

Platziere das abgetrennte Fenster auf einem zweiten Bildschirm oder einem vertikalen Monitor. Deine Build-Ausgabe, Dev-Server und agent logs erhalten einen dedizierten Bildschirm, während du auf dem Hauptbildschirm weiterprogrammierst.

Echtzeit-Monitoring

Behalte deine Agenten und Befehle ständig im Blick. Beobachte, wie Prozesse starten, ausgeben und abstürzen auf einem Seitenbildschirm und reagiere sofort, wenn etwas schiefläuft.

Höhere Produktivität

Entwickler, die mehrere Projekte oder Umgebungen jonglieren, wechseln den Kontext nicht mehr. Alles, was überwacht werden muss, bleibt sichtbar, sodass du schneller lieferst und weniger unterbrochen werden.

Erweiterte Terminal-Layouts per Drag-and-drop erstellt

Du kannst jetzt mehrere Terminals über eine äußerst intuitive Drag-and-drop-Oberfläche in einem einzigen Pane zusammenführen. Greife ein Terminal, lege es dort ab, wo du es haben möchtest, und AgentsRoom erstellt das Layout für dich. Keine Konfigurationsdateien, keine Tastenkürzel zum Auswendiglernen.

Stelle den Arbeitsbereich zusammen, der zur aktuellen Aufgabe passt:

Vertikale Teilungen

Platziere zwei Terminals nebeneinander, um Backend und Frontend gleichzeitig zu beobachten.

Horizontale Teilungen

Stapele Terminals übereinander, um Logs und einen laufenden Server in derselben Spalte zu behalten.

Komplexe kombinierte Layouts

Mische vertikale und horizontale Teilungen, um ein vollständiges Terminal-Raster für deinen Stack zu erstellen.

In Sekunden neu anordnen

Zieh ein Terminal an eine neue Position und das Layout ordnet sich sofort neu an. Strukturiere dein gesamtes Setup in wenigen Sekunden um.

Alles auf einmal überwachen

Behalte mehrere Agenten, Server, Logs und Befehle gleichzeitig im Blick, alles innerhalb eines einzigen Panes.

Kein komplexes Setup, keine tmux-Konfiguration zu erlernen. Die Erfahrung ist so gestaltet, dass sie sich sofort und natürlich anfühlt, damit du deine Zeit mit Programmieren verbringst, anstatt Fenster zu arrangieren.

Weitere Möglichkeiten, deine Terminals zu steuern

Das abtrennbare Fenster, die KI-Befehlsgenerierung und der Remote-Start vom Mobilgerät sind alle Teil derselben Dev Terminals-Erfahrung. Hier ist der ursprüngliche Überblick.

AgentsRoom Terminal-Manager: abgetrenntes Terminal auf einem zweiten Bildschirm, remote ausgelöste Befehle vom Mobilgerät, integriertes xterm.js-Terminal pro Projekt.

AgentsRoom Terminal-Manager mit abgetrenntem Fenster auf einem zweiten Monitor, Projekt-Befehlsliste, KI-Befehlsgenerierung und Claude-Agenten

AgentsRoom Pro-Projekt-Terminal-Manager: abtrennbares Fenster, integriertes Terminal pro Befehl, KI-generierte Befehle, alles am selben Ort wie deine Agenten.

Jeden Service, jeden Befehl verwalten

Langlebige Prozesse, schnelle Skripte, Build-Befehle, Dev-Server. Alles pro Projekt organisiert, mit Live-Statusverfolgung, integrierter KI und mobiler Fernsteuerung.

Pro Projekt zugeordnet

Jedes Projekt speichert seine eigenen Befehle in .agentsroom/commands.json. Projekt wechseln, andere Befehle erhalten. Kein Durcheinander zwischen Repos.

Jeder Server startet mit einem Klick

Jeder gespeicherte Befehl hat seinen eigenen Knopf „Starten“: Backend, Frontend, Mobile-Bundler, Relay-Server, Worker, Datenbank. Jeder öffnet seinen eigenen Terminal-Tab im richtigen Ordner. Schluss mit fünf Tabs, die du von Hand öffnest und in denen du jeweils per cd in den Ordner wechselst.

Remote-Start vom Mobilgerät

Löse Befehle aus der iOS- oder Android-App aus: Terminals werden auf deinem Rechner gestartet, und du siehst die Live-Ausgabe per 4G, 5G oder Wi-Fi auf dein Telefon gestreamt.

Abtrennbares Terminal-Fenster

Trenne den Terminal-Bereich in ein eigenständiges, schwebendes Fenster ab. Lege es auf einen zweiten Monitor, um deine Server im Blick zu behalten, während du im Hauptfenster programmierst.

KI-Befehlsgenerierung

Klicke auf den Zauberstab: Claude scannt dein Repo, erkennt package.json, Dockerfiles und Makefiles und generiert jeden Startbefehl, jeden Pfad und jede Kategorie für dich.

Live-Prozessstatus

Sieh, welcher Service läuft, startet, gestoppt ist oder abgestürzt ist. Exit-Codes werden angezeigt, wenn ein Prozess fehlschlägt. Neustart mit einem Klick, ohne den Scrollback des Terminals zu verlieren.

Einen Agenten auf jede Ausgabe ansetzen

Jedes Terminal hat einen Button Agent aufrufen. Wähle eine Stufe (Schnell, Stark, Teuer) oder Provider, Modell und Aufwand: Der Agent behebt, was das Terminal zeigt, und der Befehl kann danach von selbst erneut laufen.

Prozesse und Snippets

Langlebige Services sind Prozesse. Einmalige Build-Skripte und Deploy-Befehle sind Snippets. Beide leben im selben Dashboard.

Vollständiges Terminal pro Prozess

Jeder Prozess öffnet ein echtes xterm.js-Terminal mit Farben, Scrollback und klickbaren Links. Interagiere direkt mit der Prozessausgabe.

Mit der localhost-Live-Preview verbunden

Starte deine localhost-Website aus einem AgentsRoom-Terminal und erreiche sie dann von außen über den integrierten HTTPS-Tunnel. Teste per 4G/5G auf deinem Telefon, ohne zu deployen.

30+ Framework-Icons

React, Next.js, Vue, Nuxt, Angular, Svelte, Expo, Node.js, NestJS, Django, FastAPI, Rails, Laravel, Spring, Go, Rust, Docker, Redis und viele mehr, jeweils mit eigenem Icon und eigener Farbe.

In Git gespeichert

Befehle liegen in .agentsroom/commands.json, committet in dein Repo. Persönliche Befehle gehen in commands-personal.json, automatisch gitignored.

Terminals und KI-Agenten vereint

Deine Terminals, deine Claude Code-Agenten, deine Prompts, dein Backlog und deine Live-Preview teilen sich dieselbe App. Verlier dich nicht mehr zwischen zehn verschiedenen Tools.

Starte Terminals auf deinem Rechner vom Telefon aus

Das ist vermutlich das einzigartigste Feature von AgentsRoom. Aus der mobilen iOS- oder Android-App durchsuchst du die Befehlsliste jedes Projekts und startest jeden davon mit einem Tipp. Der Befehl läuft nicht auf deinem Telefon: Er läuft auf deinem Rechner, im richtigen Arbeitsverzeichnis, in einem echten PTY-Terminal. Die Ausgabe wird über den Ende-zu-Ende-verschlüsselten Relay live ans Mobilgerät gestreamt.

Konkret: Du bist in der U-Bahn, im Fitnessstudio oder am anderen Ende der Welt. Du willst deine lokale Website starten, um ein Design zu prüfen, oder einen Worker neu starten, der abgestürzt ist, während du unterwegs warst. Du öffnest AgentsRoom mobile, tippst auf 'yarn dev', und der Server fährt auf deinem Rechner zu Hause hoch. Du kannst sogar über die Tastatur des Telefons mit dem Terminal interagieren.

In Kombination mit dem integrierten localhost-Preview-Tunnel kannst du deine lokale Website sogar im mobilen Browser öffnen, per 4G oder 5G, ganz ohne Deploy. Du programmierst, startest, testest und validierst, alles aus deiner Hosentasche. AgentsRoom macht deinen Rechner buchstäblich zu einem aus der Ferne gesteuerten Dev-Server.

Befehlsbenachrichtigungen

Werde benachrichtigt, wenn ein langer Befehl fertig ist

Ein Build, eine Testsuite oder ein Docker-Image kann mehrere Minuten laufen. Du wechselst zu etwas anderem, und das Terminal steht zehn Minuten lang fertig da, bevor du es bemerkst. Aktiviere die Glocke auf einem Terminal-Tab, und AgentsRoom sagt dir in der Sekunde Bescheid, in der der Befehl durch ist, mit dem Namen des Befehls und seiner Laufzeit.

Die Glocke sitzt im kleinen schwebenden Label oben rechts in jedem Terminal-Bereich. Ein Klick aktiviert sie, ein Klick deaktiviert sie, und sie bleibt für dieses Terminal aktiv, sodass jeder Durchlauf desselben Builds zurückmeldet. Ein Klick auf die Benachrichtigung öffnet genau diesen Terminal-Tab.

Eine Glocke pro Terminal

Aktiviere sie nur dort, wo du sie brauchst. Es gibt nichts global zu konfigurieren und keine Benachrichtigung für Terminals, nach denen du nie gefragt hast.

Nur lange Befehle

Alles unter einer Minute gilt als interaktive Nutzung und bleibt stumm, sodass cd, ls und git status dich nie stören. Aktiviere die Glocke, während ein Befehl schon läuft, und genau dieser meldet sich immer zurück, egal wie lange er dauert.

Nie, während du zusiehst

Wenn dieses Terminal bereits auf dem Bildschirm ist und die App den Fokus hat, erscheint nichts. Die Benachrichtigung ist für den Moment gedacht, in dem du weg bist, nicht für den Moment, in dem du die Ausgabe liest.

macOS, Windows und Linux

Die Erkennung liest den Vordergrundprozess des Terminals, es wird also nichts in deine Konfiguration von zsh, bash, fish oder PowerShell geschrieben, und es funktioniert mit der Shell, die du ohnehin verwendest. Benachrichtigungen erreichen auch die iOS- und Android-App, wenn du nicht am Rechner bist.

Deine KI-Agenten bekommen dieselbe Behandlung: Benachrichtigungen für KI-Agenten.

Detach-Modus: Deine Terminals auf einem zweiten Monitor

Das Terminal-Panel lässt sich in ein eigenständiges, schwebendes Fenster abtrennen. Zieh es auf einen zweiten Bildschirm, und deine Logs von Backend, Frontend und Mobile-Bundler bleiben jederzeit sichtbar, während du im Haupt-AgentsRoom-Fenster programmierst. Genau das machen ernsthafte Entwickler mit tmux oder iTerm2 im Tiling-Modus, nur dass es in AgentsRoom nichts zu konfigurieren gibt.

Das abgetrennte Fenster behält jede Funktion: Starten, Stoppen, Neustarten, KI, Kategorien, Multi-Projekt. Du kannst auf dem Zweitbildschirm weiter im Terminal tippen, während ein Claude-Agent im Hauptfenster arbeitet. Kein alt-tab, kein Kontextverlust, keine kryptische Konfiguration.

Eine moderne Alternative zu jedem Terminal, das du je genutzt hast

AgentsRoom Dev Terminals ist für die Projektarbeit die bessere Wahl gegenüber klassischen Terminal-Emulatoren. Hier sind die Tools, die unsere Nutzer bereits dadurch ersetzt haben:

iTerm2 ist seit Jahren der macOS-Goldstandard und Terminal.app ist auf jedem Mac vorinstalliert. Warp hat Befehls-Blöcke und integrierte KI popularisiert. Ghostty ist schnell und nativ. Kitty ist GPU-beschleunigt. Alacritty ist minimalistisch. WezTerm ist Lua-skriptfähig. Hyper basiert auf Web-Technologien. Tabby ist plattformübergreifend. Wave Terminal und Windows Terminal fördern beide moderne Multi-Pane-Workflows. Das sind alles hervorragende Produkte. AgentsRoom versucht nicht, bei der reinen Rendering-Geschwindigkeit zu konkurrieren: es bietet ein anderes Wertversprechen, nämlich ein in deine Entwicklungsumgebung integriertes Terminal, das jedem Projekt zugeordnet ist, mit deinen KI-Agenten synchronisiert wird und von deinem Telefon aus steuerbar ist.

iTerm2Terminal.appWarpGhosttyKittyAlacrittyWezTermHyperTabbyWindows TerminalWave TerminalCore ShellContourTermiustmuxzellij

Alles, was ein modernes Terminal braucht, in einem Fenster

AgentsRoom ist nicht nur ein weiterer Terminal-Emulator. Es vereint alles, was ein moderner Coding-Workflow benötigt, und stellt es hinter einer einzigen Oberfläche bereit:

Erweitertes TerminalKI-Agenten-VerwaltungMulti-Pane-LayoutsAbgetrennte TerminalsZusammenarbeitKontext-VerwaltungArbeitsbereichsorganisation

Wenn du deine Projekte bereits mit mehreren Terminal-Tabs namens 'backend', 'frontend', 'mobile', 'relay' verwaltest, sparst du mit Dev Terminals Zeit. Wenn du tmux oder zellij zum Organisieren von Sessions nutzt, findest du dieselbe Idee wieder, ganz ohne Konfigurationsdatei.

So funktioniert es

01

Projekt öffnen

In der Projektansicht erscheint der Bereich Dev Terminals neben deinen KI-Agenten, deiner Prompt-Bibliothek und deinem Backlog. Wenn noch keine Befehle existieren, wird automatisch ein Standard-Terminal im Projektstammverzeichnis erstellt.

02

Befehle hinzufügen

Klicke auf +, um einen Befehl hinzuzufügen. Lege den Namen, den Shell-Befehl, das Arbeitsverzeichnis (relativ zum Projektstamm) fest und wähle eine Kategorie. Bestimme, ob es ein langlebiger Prozess oder ein einmaliges Snippet ist.

.agentsroom/commands.json
03

Oder lass die KI es machen

Klicke auf das Zauberstab-Icon: Claude liest deine Repo-Struktur (package.json, Dockerfile, Makefile, pyproject.toml, Cargo.toml, go.mod, composer.json) und fügt deine Startbefehle direkt zur Liste hinzu, mit den richtigen Pfaden, Kategorien und Icons. Danach kannst du jeden davon umbenennen, bearbeiten oder löschen.

04

Jeden Server mit einem Klick starten

Drücke bei einem Befehl auf „Starten“, um ihn zu starten, und beim nächsten, damit beide nebeneinander laufen. Jeder Befehl öffnet ein echtes xterm.js-Terminal, in dem du die Ausgabe siehst, auf der Tastatur tippst und genau wie in iTerm2 oder Terminal.app interagierst.

05

Panel abtrennen

Klicke auf das Abtrenn-Icon: Der Terminal-Bereich öffnet sich in einem eigenständigen, schwebenden Fenster, das du auf einen zweiten Monitor legen kannst. Deine Server bleiben sichtbar, während du im Hauptfenster programmierst.

06

Steuere es vom Telefon aus

Öffne AgentsRoom auf iOS oder Android, wähle dein Projekt, tippe auf einen Befehl: Er wird aus der Ferne auf deinem Rechner gestartet, und du siehst seine Ausgabe live von deinem Telefon aus per 4G, 5G oder Wi-Fi über den Ende-zu-Ende-verschlüsselten Relay.

30+ Frameworks

Icons für jeden Stack

Jeder Befehl zeigt das Icon und die Farbe seines Frameworks. Erkenne dein React-Frontend, dein Django-Backend und deine Docker-Services auf einen Blick.

ReactNext.jsVueNuxtAngularSvelteExpoReact NativeElectronNode.jsNestJSExpressDjangoFastAPIRailsLaravelSpringGoRustPythonRubyJava.NETPHPDockerDatabaseRedisWebSocketGatewayWorkerScriptMonorepo

KI-gestützte Befehlseinrichtung

Neues Projekt gestartet? Konfiguriere nicht jeden Befehl manuell. Klicke auf den Zauberstab, und Claude scannt dein Repository, erkennt den Paketmanager (yarn, pnpm, npm, bun), jeden langlaufenden Service, jedes Teilprojekt und jeden Startbefehl. Er fügt sie direkt zu deiner Liste hinzu, mit korrekten Pfaden, Framework-Kategorien, Icons und Ordnern, und du kannst danach jeden davon umbenennen, bearbeiten oder löschen. Die gesamte Einrichtung dauert Sekunden statt Minuten.

Standard-Prompt

"Analysiere meine Projektstruktur und generiere alle Startbefehle für jeden Service, jedes Teilprojekt und jeden Build-Schritt. Gib das korrekte Arbeitsverzeichnis, den Shell-Befehl und die passende Framework-Kategorie für jeden Eintrag an."

Über : AgentsRoom MCP

Sollen deine Agenten den Dev-Server selbst starten ?

AgentsRoom MCP stellt dieselben Terminal Commands, die du hier speicherst, als MCP-Werkzeuge bereit. Deine KI-Agenten rufen commands_list, commands_run und commands_create über den Terminal Commands MCP Server auf und starten Dev-Server, API oder Worker selbst.

Das ist nur einer von vier AgentsRoom MCP Servern. Backlog MCP, Prompt Library MCP und Browser MCP machen den Rest der AgentsRoom ADE zu einem agent-steuerbaren Arbeitsplatz. Manuell, wenn du willst, automatisiert, wenn nicht.

AgentsRoom MCP entdecken
Wie unterscheidet sich das von iTerm2, Warp, Ghostty oder Terminal.app?
iTerm2, Warp, Ghostty, Kitty, Alacritty, WezTerm, Hyper und Terminal.app sind allesamt großartige Terminal-Emulatoren. AgentsRoom Dev Terminals versucht nicht, sie für allgemeine Systemarbeit zu ersetzen: Es ist ein projektbezogener Terminal-Manager. Befehle werden pro Projekt gespeichert, mit einem Klick gestartet, vom Mobilgerät aus steuerbar und leben direkt neben deinen KI-Agenten. Wenn du hauptsächlich an deinen eigenen Projekten arbeitest, verbringst du 90 % deiner Terminal-Zeit in AgentsRoom, ohne iTerm2 zu öffnen.
Nutzen die AgentsRoom-Terminals wirklich xterm.js?
Ja. Jeder Befehl öffnet ein echtes xterm.js-Terminal, das auf der Electron-Seite von einem Pseudo-TTY gestützt wird. Du erhältst ANSI-Farben, Scrollback, klickbare Links, Tastatureingabe, dynamisches Resize und Unicode-Unterstützung, genau wie in einem nativen Terminal-Emulator.
Wie funktioniert der Remote-Befehlsstart vom Mobilgerät?
In der iOS- oder Android-App wählst du ein Projekt und einen Befehl. Die mobile App sendet eine Ende-zu-Ende-verschlüsselte Nachricht über den WebSocket-Relay. Die Desktop-App empfängt den Befehl, startet ein echtes PTY auf deinem Rechner im richtigen Arbeitsverzeichnis und streamt die Ausgabe in Echtzeit zurück ans Mobilgerät. Der Befehl läuft physisch auf deinem Rechner, nicht auf deinem Telefon. Perfekt, um einen Server oder Worker neu zu starten, während du unterwegs bist.
Funktioniert der Detach-Modus auf mehreren Bildschirmen?
Ja. Klicke auf das Abtrenn-Icon: Der Dev Terminals-Bereich öffnet sich in einem eigenständigen, schwebenden Fenster, das du auf einen zweiten Monitor ziehen kannst. Deine Logs und Server bleiben dauerhaft sichtbar, während du im Haupt-AgentsRoom-Fenster programmierst.
Was ist der Unterschied zwischen einem Prozess und einem Snippet?
Ein Prozess ist ein langlebiger Service wie ein Dev-Server, ein Backend, ein Mobile-Bundler, ein File-Watcher oder eine Datenbank. Er läuft, bis du ihn stoppst oder er abstürzt. Ein Snippet ist ein einmaliger Befehl wie ein Build-Skript, eine Migration, ein Deploy oder ein Test. Beide liegen im selben Dashboard, und jeder startet mit seinem eigenen Knopf „Starten“. Der Zauberstab erzeugt nur Prozesse.
Werden Befehle mit meinem Team geteilt?
Ja. Öffentliche Befehle werden in .agentsroom/commands.json in deinem Projektverzeichnis gespeichert. Committe diese Datei, und jeder, der das Repo pullt, erhält die gleichen Befehle. Persönliche Befehle (wie lokale Debug-Skripte) gehen in commands-personal.json, die automatisch zur .agentsroom/.gitignore hinzugefügt wird.
Wie funktioniert die KI-Befehlsgenerierung?
Wenn du auf den Zauberstab klickst, startet AgentsRoom Claude Code im Hintergrund, in deinem Projektordner, mit dem Modell Haiku. Es liest deine Projektstruktur (package.json, Dockerfiles, Makefiles, pyproject.toml, Cargo.toml…), um jeden langlebigen Service und seinen Startbefehl zu erkennen. Die gefundenen Befehle landen direkt in deiner Liste, mit Pfaden, Kategorien, Ordnern und vorgeschlagenen Namen. Es gibt keinen Bestätigungsschritt: Du benennst sie danach um, bearbeitest oder löschst sie wie jeden anderen Befehl. Dafür muss das Claude Code CLI auf diesem Rechner installiert und angemeldet sein.
Kann AgentsRoom mich benachrichtigen, wenn ein Terminal-Befehl fertig ist?
Ja. Jeder Terminal-Tab trägt eine Glocke in seinem schwebenden Label. Aktiviere sie, und AgentsRoom sendet eine Desktop-Benachrichtigung in dem Moment, in dem der laufende Befehl an den Prompt zurückgibt, mit dem Namen des Befehls und seiner Dauer, plus einen Push an die iOS- und Android-App, wenn du nicht am Rechner bist. Ein Klick auf die Benachrichtigung öffnet diesen Terminal-Tab.
Woher weiß AgentsRoom, dass ein Befehl fertig ist, wenn das Terminal offen bleibt?
Ein Terminal-Tab ist eine einzige langlebige Shell, es beendet sich also nichts, wenn ein Befehl endet. AgentsRoom beobachtet stattdessen die Vordergrund-Prozessgruppe des Terminals: Sobald sie wieder bei der Shell selbst liegt, ist der Prompt zurück und der Befehl durch. In deine Shell-Konfiguration wird nichts geschrieben, deshalb verhält es sich mit zsh, bash, fish oder PowerShell gleich und funktioniert für von Hand getippte Befehle genauso wie für gespeicherte.
Bekomme ich eine Benachrichtigung für jeden Befehl, den ich tippe?
Nein. Nur Befehle, die länger als eine Minute liefen, lösen eine Benachrichtigung aus, die alltägliche interaktive Nutzung bleibt also still. Eine bewusste Ausnahme: Wenn du die Glocke aktivierst, während ein Befehl bereits läuft, meldet sich genau dieser Befehl immer zurück, egal wie lange er dauert. Es passiert auch nichts, wenn das Terminal bereits auf dem Bildschirm ist und die App den Fokus hat.
Kann ein Befehl in jedem Projekt verfügbar sein?
Ja. Beim Speichern wählst du, wo er lebt: nur dieses Projekt oder global. Ein globaler Befehl gehört zu deinem Konto und erscheint in jedem Projekt, das du öffnest: genau richtig für einen Tunnel, einen gemeinsamen Docker-Stack oder einen Datenbank-Daemon, den du überall startest. Das Befehle-Fenster hat eine Suchleiste und einen Bereichsfilter (Alle / Dieses Projekt / Global), damit auch eine lange Liste lesbar bleibt.
Können meine KI-Agenten diese Befehle selbst starten?
Ja, über AgentsRoom MCP. Agenten rufen commands_list auf, um alles Verfügbare zu sehen (Projektbefehle und globale, jeweils mit ihrem Geltungsbereich), commands_run, um einen in einem echten Terminal-Tab zu starten, den du siehst und stoppen kannst, und commands_create, um einen neuen zu speichern. Sie dürfen keinen langlaufenden Prozess über eine rohe Shell starten: Was läuft, landet immer in einem Tab, den du kontrollierst. Ein beendeter Befehl wird in seinem bestehenden Tab erneut ausgeführt, statt einen neuen zu öffnen, und mit commands_stop kann ein Agent stoppen, was er gestartet hat, entweder indem er den Tab schließt oder indem er Ctrl-C sendet und ihn behält, um einen Server neu zu starten: So räumt er hinter sich auf, statt dir Tabs zum Schließen zu hinterlassen. Und wenn die eigene Sandbox eines Agenten einen Befehl verweigert, muss er die Zeile nicht mehr ausgeben, damit du sie in ein anderes Terminal einfügst: Er ruft commands_propose auf, der Befehl erscheint in seinem Panel als Karte „Diesen Befehl ausführen?" mit dem Grund, warum er ihn nicht ausführen kann, und ein Klick auf Ausführen startet ihn in einem Terminal-Tab, den der Agent anschließend selbst ausliest. Nichts läuft, bevor du entscheidest, es gibt keine Option „immer erlauben", und der Befehl wird weder gespeichert noch erneut abgespielt.

Mehr zum Thema

Schluss mit dem Jonglieren von Terminal-Tabs

Lade AgentsRoom herunter und starte alle deine Services von einem Dashboard. Kostenlos für bis zu 2 Projekte.

AgentsRoom herunterladenKostenlos

Companion-App: Agenten auch unterwegs im Blick behalten

Nutze Claude, Codex, Antigravity CLI oder einen anderen KI-Anbieter.

Bugs und Wünsche direkt in dein öffentliches Backlog schicken.