# Summer Engine now comes as an MCP and a CLI

> Summer Engine now comes as an MCP and a CLI. Add one link to your AI agent, or let it run Summer as commands in its terminal. Here is how both work.

- URL: https://www.summerengine.com/blog/summer-mcp-and-cli
- Published: 2026-10-16T00:00:00.000Z
- Author: Summer Team
- Tags: MCP, CLI, AI Agents, Summer Engine, AI Game Dev

Summer Engine now comes as an MCP and a CLI. Your AI agent can plug into Summer through the MCP, or run Summer as plain commands in its terminal. Both reach the same things: assets, your games, the store and analytics. The local MCP and the CLI also drive the engine on your computer. Pick the one that fits how your agent works.

The CLI, the local MCP and the skills live in one open source package, [summer-engine](https://www.npmjs.com/package/summer-engine), with the code and setup lines at [github.com/summerengine/summer](https://github.com/summerengine/summer). This post shows how each one works, with the lines to copy.

## What is new in the MCP and CLI

- **The hosted MCP.** One link, nothing to install. Add `https://mcp.summerengine.com/mcp` to your agent and sign in once.
- **The local MCP.** `summer mcp` runs on your computer and drives the Summer Engine app. After you sign in, it also does everything the hosted MCP does.
- **The CLI.** Every Summer job is a command: `summer <area> <action>`. Find one with `summer ops search`, try it with `--dry-run`, read it with `--json`.
- **CLI only.** Set up an agent with no MCP at all. It gets the Summer skills and runs Summer from its shell.

Your agent does not need to know every tool or command. On the MCP, it tells `summer_search` what it wants in words and gets back the right operation and its exact input, then runs it with `summer_call`. On the CLI, `summer ops search` does the same job.

## Why both an MCP and a CLI?

Agents work in different ways. Claude Code, Codex and Cursor all speak MCP, so a link is the fastest way in. But every coding agent also has a terminal, and many are at their best there. A command is easy to read, easy to retry and easy to put in a script. You can run it yourself to see exactly what your agent sees.

So Summer gives you both, over the same jobs. A sound effect made through the MCP and one made with `summer assets generate-sfx-choices` land in the same Summer library. Your agent can switch between them in the middle of a task.

## How do you connect the hosted MCP?

The hosted MCP is for cloud work. It makes assets (images, 3D models, motion, sound effects, music, voices and video), searches your Summer asset library, plans games, and runs your projects, store pages, publishing and analytics. It has no engine tools. For those, use the local MCP below.

Add the link to your agent with the line for your app:

| Agent | Add the hosted MCP |
|---|---|
| Claude Code | `claude mcp add --transport http summer-cloud https://mcp.summerengine.com/mcp`, then type `/mcp` to sign in |
| Codex | `codex mcp add summer-cloud --url https://mcp.summerengine.com/mcp`, then `codex mcp login summer-cloud` |
| Cursor | add `"summer-cloud": {"url": "https://mcp.summerengine.com/mcp"}` under `mcpServers` in `~/.cursor/mcp.json` |
| VS Code | `code --add-mcp '{"name":"summer-cloud","type":"http","url":"https://mcp.summerengine.com/mcp"}'` |
| Claude | add a custom connector and paste `https://mcp.summerengine.com/mcp` |

Signing in opens a Summer page in your browser. Sign in once and your agent is connected. Then ask it for something real, like "Make three sword clash sound effects and let me pick one."

The [MCP setup page](/mcp) shows the steps for each app, and the [MCP setup guide](https://docs.summerengine.com/mcp/setup) covers every path.

## How does the local MCP work?

The local MCP is for building the game itself. It runs on your computer next to the Summer Engine app. Your agent uses it to build scenes, write scripts, play the game, take screenshots and read errors. After `summer login`, it also runs every cloud job, so your agent needs only this one server.

Set it up with one line. Swap `claude-code` for your agent, like `codex` or `cursor`:

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

Setup writes the MCP entry into your agent's config, installs the Summer game-dev skills and checks that everything works. It needs Node 20 or newer.

You can also skip the steps and paste one prompt into your agent. It reads the repo, checks what you already have, installs only what is missing and signs you in:

```text
Install Summer Engine and let's make a game. Read github.com/summerengine/summer, check what I already have installed, install whatever is missing, log me in, and scaffold a starter project so we can start building.
```

## How does the Summer CLI work?

The CLI is the `summer` command. Run it with `npx -y summer-engine@latest`, or install it once and type `summer`:

```bash
npm i -g summer-engine
# or, on a Mac or Linux with Homebrew
brew install summerengine/tap/summer
```

Sign in first:

```bash
summer login
summer whoami
```

Every Summer job is a command with an area and an action. Fields are flags:

```bash
summer assets generate-image --prompt "a cozy pixel art tavern at night" --aspect-ratio 16:9
summer assets generate-sfx-choices --text "sword clash"
summer games list
summer analytics summary --game-id <id> --days 28
summer engine play
```

Don't know the command? Search for it in plain words:

```bash
summer ops search "make a sound effect"
summer ops describe assets.generate_sfx_choices
```

`ops search` lists the matching operations. `ops describe` shows one in full, with every field it takes.

Three flags make the CLI safe for agents and scripts:

- `--dry-run` checks the input and shows what would happen. Nothing runs and nothing changes.
- `--json` prints only the answer, as one line of JSON. The exit code is 0 when it worked and 1 when it did not.
- `--wait` follows a long job, like a 3D model, until it is done.

Files your agent makes, like images and sounds, land in your Summer library. When the CLI makes an image, audio, 3D model or video inside a game project, it also saves a copy in the project's asset folder. Add `--out <folder>` to save it somewhere else. The [operations reference](https://docs.summerengine.com/mcp/operations) lists every area with example commands, and the [CLI page](/cli) lists the main commands.

## Can your agent use Summer without the MCP?

Yes. Some agents work best in a terminal. Set up CLI only:

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

This needs summer-engine 4.2.0 or newer, which `@latest` gets you. It installs the Summer skills for your agent, including `summer-cli`, the guide to the commands. It writes no MCP entry. Your agent signs you in with `summer login`, finds what it needs with `summer ops search` and runs it as a command. Each skill that names a Summer tool ends with a table of the command for each one.

## Which one should you pick?

- **You only want cloud work** like assets, store pages or analytics: the hosted MCP. Nothing to install.
- **You are building a game in Summer Engine:** the local MCP, through the setup line or the one prompt above.
- **Your agent lives in a terminal,** or you want to script Summer: the CLI, with or without the MCP.

You can mix them. The same Summer account works in all three, and so do your games, assets and credits.

## What should you know before you start?

- **Sign in once.** Cloud jobs need your Summer account. Signed out, `summer ops search` still finds every job and marks the ones that need sign-in.
- **Engine commands need the app.** `summer engine` commands and the engine tools work when the Summer Engine app is open with a project.
- **Making assets uses your credits.** Generating images, 3D models, sound and video spends Summer credits. Use `--dry-run` to check a command first.
- **Publishing asks the owner first.** When your agent publishes a game to Summer Games, the game's owner approves it. See [publishing from your agent](https://docs.summerengine.com/publishing/connect-your-agent).
- **The hosted MCP has no engine tools.** For building scenes and playing the game, use the local MCP or `summer engine` commands.

## What can your agent do with it?

The MCP and the CLI are the doors. For the whole picture, read [Summer 4.0](/blog/game-engine-for-ai-agents). Here is what is behind them:

- [Make game audio](/blog/make-game-audio-with-your-ai-agent): sound effects, music and voices, wired into the game.
- [Add multiplayer](/blog/add-multiplayer-to-your-game) and [matchmaking](/blog/add-matchmaking-to-your-game), with Summer running the servers on Summer Games.
- [Make store art](/blog/introducing-store-art-from-your-agent) from real gameplay screenshots.
- [Add analytics](/blog/game-analytics-and-events) and track any moment in your game.

Each one works the same way through the MCP or the CLI.

Tell your agent "Install Summer Engine and let's make a game."

---

## 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