# Spiele in jedem KI-Agenten machen - Summer Engine MCP

> Summer ist die Game Engine für KI. Verbinde kostenlos den Agenten, den du schon nutzt. Er baut, testet und veröffentlicht komplette Multiplayer-Spiele und macht Grafik, Sound und Video dazu.

Füge das in deinen Coding-Agenten ein. Er installiert Summer Engine, meldet dich an und verbindet sich selbst.

```text
Set up Summer Engine for me so I can build games and make game content from here.
First, check that `node --version` prints 20 or newer. On Windows, if Node is missing, ask me, then install it with `winget install -e --id OpenJS.NodeJS.LTS` and remind me to restart you once setup is done. In Windows PowerShell, type `npx.cmd` wherever a command says `npx`.
1. Install the engine app: run `npx -y summer-engine@latest install` (about 1 GB; skip it if Summer Engine is already installed, or if I only want assets and video for a game built in another engine).
2. Sign in: run `npx -y summer-engine@latest login` and let me finish the sign-in in the browser it opens.
3. Connect this agent: run `npx -y summer-engine@latest setup <agent> --yes` with your own installer id (for example claude-code, codex, cursor), then tell me if I need to restart or reload you.
If setup also adds Summer Games (summer-games), tell me the one-time sign-in step it prints.
Let me know when it is ready.
```

## So verbindest du

### Summer mit Claude Desktop verbinden

1. **Terminal öffnen**: Claude Desktop führt keine Befehle für dich aus. Nutze Terminal auf macOS oder PowerShell auf Windows, mit Node.js 20 oder neuer. Fehlt Node unter Windows, führe winget install OpenJS.NodeJS.LTS aus und öffne ein neues PowerShell-Fenster. Gib in PowerShell überall npx.cmd statt npx ein.

2. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

3. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

4. **Claude Desktop verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup claude-desktop --yes
   ```

5. **Neu starten und bauen**: Starte Claude Desktop neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Claude Desktop-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-claude-desktop)

### Summer mit Claude Code verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Claude Code verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup claude-code --yes
   ```

4. **Neu starten und bauen**: Starte Claude Code neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Claude Code-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-claude-code)

### Summer mit Cursor verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Cursor verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup cursor --yes
   ```

4. **Neu starten und bauen**: Starte Cursor neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Cursor-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-cursor)

### Summer mit Codex verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Codex verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup codex --yes
   ```

4. **Neu starten und bauen**: Starte Codex neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Codex-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-codex)

### Summer im Terminal nutzen

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Projekt erstellen und starten**: Legt ein Starter-Spiel im aktuellen Ordner an und öffnet es in der Engine.

   ```bash
   npx -y summer-engine@latest create 3d-basic my-game
   ```

   ```bash
   npx -y summer-engine@latest run my-game
   ```

4. **Beliebigen MCP-Client nutzen**: Richte einen beliebigen MCP-Client auf diesen stdio-Befehl, um ihm die Summer-Engine-Tools zu geben.

   ```bash
   npx -y summer-engine@latest mcp
   ```

### Summer mit Devin Desktop (formerly Windsurf) verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Devin Desktop (formerly Windsurf) verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup windsurf --yes
   ```

4. **Neu starten und bauen**: Starte Devin Desktop (formerly Windsurf) neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Devin Desktop (formerly Windsurf)-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-devin-desktop)

### Summer mit Antigravity verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Antigravity verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup antigravity --yes
   ```

4. **Neu starten und bauen**: Starte Antigravity neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Antigravity-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-gemini-cli)

### Summer mit Cline (VS Code) verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Cline (VS Code) verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup cline --yes
   ```

4. **Neu starten und bauen**: Starte Cline (VS Code) neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Cline (VS Code)-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-cline)

### Summer mit Cline CLI verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Cline CLI verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup cline-cli --yes
   ```

4. **Neu starten und bauen**: Starte Cline CLI neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Kilo Code verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Kilo Code verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup kilo-code --yes
   ```

4. **Neu starten und bauen**: Starte Kilo Code neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Kilo Code-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-kilo-code)

### Summer mit GitHub Copilot CLI verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **GitHub Copilot CLI verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup github-copilot --yes
   ```

4. **Neu starten und bauen**: Starte GitHub Copilot CLI neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit GitHub Copilot in VS Code verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **GitHub Copilot in VS Code verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup vscode-copilot --yes
   ```

4. **Neu starten und bauen**: Starte GitHub Copilot in VS Code neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit GitHub Copilot in Visual Studio verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **GitHub Copilot in Visual Studio verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup visual-studio --yes
   ```

4. **Neu starten und bauen**: Starte GitHub Copilot in Visual Studio neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit GitHub Copilot in JetBrains IDEs verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **GitHub Copilot in JetBrains IDEs verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup copilot-jetbrains --yes
   ```

4. **Neu starten und bauen**: Starte GitHub Copilot in JetBrains IDEs neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit OpenCode verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **OpenCode verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup opencode --yes
   ```

4. **Neu starten und bauen**: Starte OpenCode neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger OpenCode-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-opencode)

### Summer mit Zed verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Zed verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup zed --yes
   ```

4. **Neu starten und bauen**: Starte Zed neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Kiro verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Kiro verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup kiro --yes
   ```

4. **Neu starten und bauen**: Starte Kiro neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Goose verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Goose verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup goose --yes
   ```

4. **Neu starten und bauen**: Starte Goose neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Goose-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-goose)

### Summer mit Hermes Agent verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Hermes Agent verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup hermes --yes
   ```

4. **Neu starten und bauen**: Starte Hermes Agent neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Hermes Agent-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-hermes-agent)

### Summer mit Trae verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Trae verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup trae --yes
   ```

4. **Neu starten und bauen**: Starte Trae neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Qwen Code verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Qwen Code verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup qwen-code --yes
   ```

4. **Neu starten und bauen**: Starte Qwen Code neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Kimi Code CLI verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Kimi Code CLI verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup kimi-code --yes
   ```

4. **Neu starten und bauen**: Starte Kimi Code CLI neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Crush verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Crush verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup crush --yes
   ```

4. **Neu starten und bauen**: Starte Crush neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Amp verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Amp verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup amp --yes
   ```

4. **Neu starten und bauen**: Starte Amp neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Factory Droid verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Factory Droid verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup factory --yes
   ```

4. **Neu starten und bauen**: Starte Factory Droid neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Junie verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Junie verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup junie --yes
   ```

4. **Neu starten und bauen**: Starte Junie neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Warp verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Warp verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup warp --yes
   ```

4. **Neu starten und bauen**: Starte Warp neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Rovo Dev CLI verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Rovo Dev CLI verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup rovo-dev --yes
   ```

4. **Neu starten und bauen**: Starte Rovo Dev CLI neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Qoder CLI verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Qoder CLI verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup qoder --yes
   ```

4. **Neu starten und bauen**: Starte Qoder CLI neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit Grok Build verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Grok Build verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup grok-build --yes
   ```

4. **Neu starten und bauen**: Starte Grok Build neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Grok Build-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-grok-build)

### Summer mit Mistral Vibe verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Mistral Vibe verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup mistral-vibe --yes
   ```

4. **Neu starten und bauen**: Starte Mistral Vibe neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

### Summer mit LM Studio verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **LM Studio verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup lm-studio --yes
   ```

4. **Neu starten und bauen**: Starte LM Studio neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger LM Studio-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-in-lm-studio)

### Summer mit Ollama verbinden

1. **Summer Engine installieren**: Lädt die Desktop-App der Engine herunter, etwa 1 GB. Überspringen, wenn Summer Engine schon installiert ist oder du nur Assets und Video für ein Spiel aus einer anderen Engine brauchst.

   ```bash
   npx -y summer-engine@latest install
   ```

2. **Anmelden**: Öffnet einmal deinen Browser. CLI und Engine teilen sich die Sitzung.

   ```bash
   npx -y summer-engine@latest login
   ```

3. **Ollama verbinden**: Schreibt die summer-engine MCP-Konfiguration und installiert die Summer Game-Dev-Skills.

   ```bash
   npx -y summer-engine@latest setup opencode --yes
   ```

4. **Neu starten und bauen**: Starte Ollama neu, damit der summer-engine Server geladen wird, und bitte ihn dann, ein Spiel zu bauen.

[Vollständiger Ollama-Guide](https://www.summerengine.com/de/mcp/how-to-make-games-with-ollama)

## Per URL verbinden

Ohne Installation. Füge die Summer-Adresse in deiner KI-App hinzu und melde dich einmal im Browser bei Summer an. Dein Agent kann dann Spiel-Assets, Spielpläne und Store-Seiten erstellen, auf Summer Games veröffentlichen, sehen, wie deine Spiele laufen, und Preise ändern. Die Agent-Berechtigungen in den Studio-Einstellungen legen fest, was er ohne Nachfrage tun darf; vorerst fragt er dich noch vor dem Veröffentlichen und vor Änderungen an Preisen, A/B-Tests oder Mitgliederrollen, und bei allem anderen fragt er dich zuerst in Studio. Um Spiele in der Engine auf deinem Computer zu bauen und zu starten, nutze das Setup oben.

Summer-Adresse: https://mcp.summerengine.com/mcp

### Claude Code

Führe das im Terminal aus, tippe dann /mcp in Claude Code und melde dich an.

```bash
claude mcp add --transport http summer https://mcp.summerengine.com/mcp
```

### Codex

Führe diese Befehle im Terminal aus. Der zweite öffnet den Browser zur Anmeldung.

```bash
codex mcp add summer --url https://mcp.summerengine.com/mcp
codex mcp login summer
```

### Cursor

Füge das in ~/.cursor/mcp.json ein und melde dich an, wenn Cursor danach fragt.

```json
{
  "mcpServers": {
    "summer": {
      "url": "https://mcp.summerengine.com/mcp"
    }
  }
}
```

### VS Code

Füge das in .vscode/mcp.json in deinem Projekt ein und melde dich an, wenn VS Code danach fragt.

```json
{
  "servers": {
    "summer": {
      "type": "http",
      "url": "https://mcp.summerengine.com/mcp"
    }
  }
}
```

### Claude

Öffne in Claude Customize, dann Connectors, dann Add custom connector, und füge die Adresse ein.

### ChatGPT

Öffne in ChatGPT Settings, dann Apps, dann Advanced settings, und schalte Developer mode ein. Drücke dann Create app und füge die Adresse ein.

## Bald verfügbar

- Claude.ai: claude.ai, Claude Desktop and the Claude mobile apps connect to Summer's hosted server: in Claude, open Settings, Connectors, Add custom connector, and paste the Summer address from Connect by URL on this page. Plan games, manage your store page and publish from there; the game itself is built in Summer Engine with Claude Code or Claude Desktop. A one-click listing in Claude's connector directory is on the way.
- ChatGPT: ChatGPT connects to Summer's hosted server: in ChatGPT, open Settings, Apps, Advanced settings, turn on Developer mode, then press Create app and paste the Summer address from Connect by URL on this page. Make assets, plan games, manage your store page and publish from there; the game itself is built in Summer Engine with Codex or another coding agent.
- OpenClaw: The Summer installer does not write an OpenClaw config yet. Support is planned.

## Summer API: assets from any agent or code
- [Summer API](https://www.summerengine.com/summer-api): A coding agent (Claude Code, Codex, Cursor, Hermes), a chat app over MCP, or your own code makes game assets: 3D models, images, video, voice, sound effects and music, with Summer's curated models. Same account, credits and library as Summer Studio.
- [Connect an agent](https://docs.summerengine.com/api/agents): `npx -y summer-engine@latest setup <agent> --yes`, then `npx -y summer-engine@latest login`. The browser sign-in asks for a spend limit for that agent; no API keys. Chat apps add https://mcp.summerengine.com/mcp as a custom connector. Signed in to Studio: [From Studio](https://docs.summerengine.com/api/from-studio).
- [Quickstart](https://docs.summerengine.com/api/quickstart): Sign in, price the job for free with `summer api estimate` or POST /v1/estimate, then `summer api run <model> --download .`. HTTP base: https://www.summerengine.com/v1 (OpenAPI: https://www.summerengine.com/v1/openapi.json).
- [Models and prices](https://docs.summerengine.com/api/models): Per-call asset prices are public: each model has one price, the provider's list price, with no markup on assets, listed at GET /v1/models and on the docs models page. Chat and coding model pricing is not public. Jobs use paid credits (plan credits and top-ups); a failed job costs nothing. Machine-readable: https://www.summerengine.com/v1/models (public, no sign-in).
- [Sign-in and limits](https://docs.summerengine.com/api/sign-in): Each connected app has its own spend limit, changed or revoked in Settings > Connected apps (https://www.summerengine.com/studio?tab=settings&section=connected-apps). The only refusals are money: no_credits and over_limit.

- [Desktop-App herunterladen](https://www.summerengine.com/de/download)
- [oder die CLI direkt nutzen](https://www.summerengine.com/de/cli)

---

## Machine-readable resources

- Site index for agents: https://www.summerengine.com/llms.txt
- Full inlined content: https://www.summerengine.com/llms-full.txt
- Porting catalog: https://www.summerengine.com/llms-porting.txt
- Structured catalog: https://www.summerengine.com/agent-catalog.json
- Sitemap: https://www.summerengine.com/sitemap.xml
- Developer resources: https://www.summerengine.com/docs
- Summer API (assets from any agent or code; public per-call model prices): https://docs.summerengine.com/api