ZeroMind (OrigoZero game engine)

ai.origozeroPublished by origozero.aiOfficial publisherv1.0.0Updated Oct 27, 2026

Build, run and publish 3D games in the Zero engine from Claude Code, Cursor or Codex, over MCP.

VerifiedStreamable HTTPWeb executableFiles & StorageDeveloper ToolsMedia & Design

Overview

AI-generated overview

Remote ZeroMind MCP server that lets an assistant build, run and publish 3D games in the Zero engine, plus search and manage a game library and worlds.

What you can do
  • Search, inspect, preview, install and engage items in the ZeroMind library
  • List, create, fork, launch and connect worlds, with reversible delete, trash and restore
  • Run the engine of the connected world: execute code, read guides, capture output, use the virtual file system and bash
  • Link a machine to a ZeroMind account and write the remote MCP entry into a supported agent harness
  • Upload local files or folders into a world's engine file system
  • Open a world's editor or player on the local machine
When to use it
Useful when you want an AI coding agent to work on 3D games in the Zero engine: discovering and installing library content, creating or forking worlds, and driving the engine of the world you have open. Also relevant if you want the same remote server wired into one of the many supported harnesses.
Requirements
A remote endpoint at origozero.ai over HTTPS; nothing runs locally for tool calls. A ZeroMind account and an approved device-code link, which registers the machine as its own ZeroMind principal. Node.js 18 or newer on the PATH to run the zeromind CLI commands (link, install, upload, open). Optional ZEROMIND_ISSUER and ZEROMIND_CONFIG_DIR variables point the CLI at a local or self-hosted backend.
Before you install
The CLI writes an install secret into harness config files and sends it as a Bearer Authorization header; the secret is stored in a shared session file that the Zero engine also reads and writes. Unlinking revokes every harness on the machine at once, and entries written into other harnesses keep the revoked secret until reinstalled. Engine tools such as execute, bash and the virtual file system can change the world you are connected to, and uploads copy local files to the remote service.

Installation

In SourceWeft

  1. Open ZeroMind (OrigoZero game engine) in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/ai.origozero%2Fzeromind/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "zeromind-origozero-game-engine": {
      "type": "http",
      "url": "https://origozero.ai/mcp"
    }
  }
}

README

@origozero/zeromind

@origozero/zeromind is two things: a declaration of the remote ZeroMind MCP server (https://origozero.ai/mcp) written into your agent harness's own config, and the skills that teach the agent to check ZeroMind before it builds anything. Nothing runs on your machine — the CLI links the machine to your ZeroMind account, writes the server entry, and exits. Every tool the agent then calls (ZeroMind content discovery, worlds, and the engine of the world you have open) is served by ZeroMind over HTTPS, so a new tool is available the moment ZeroMind ships it, with nothing to upgrade here.

Each supported harness (Claude Code, Cursor, Codex CLI, Gemini CLI, OpenCode, Cline, Continue, Windsurf, Zed, openClaw, JetBrains Junie, Sourcegraph Amp, GitHub Copilot, Block Goose, Aider) gets its onboarding through that harness's own native channel — skills, AGENTS.md, GEMINI.md, .cursor/rules/*.mdc, .clinerules, CONVENTIONS.md, .goosehints — plus the MCP entry in the config file that harness reads. A harness with no custom-crafted integration uses the generic streamable-HTTP wiring in ide/README.md.

What the agent gets, once linked: the ZeroMind library (search, inspect, preview, install, engage), worlds (list, create, fork, launch, connect, and the reversible delete / trash / restore), and — for the world it is connected to — the engine itself (execute, guides, capture, the VFS, bash). tools/list on https://origozero.ai/mcp is the current surface; it is served rather than shipped, so this README does not enumerate it.

Prerequisites

Node.js 18 or newer, on your PATH, to run zeromind link, zeromind install, zeromind upload and zeromind open. Your harness then talks to https://origozero.ai/mcp over HTTPS and spawns nothing locally.

Verify with node --version.

Install

Claude Code

/plugin marketplace add OrigoZero/zeromind-plugin/plugin install zeromindnpx -y @origozero/zeromind link

The bundle carries the skills and an .mcp.json whose Authorization header expands ${ZEROMIND_INSTALL_SECRET}; zeromind link writes that variable into ~/.claude/settings.json env. Restart Claude Code afterwards so the new setting is read.

Every other harness

npx -y @origozero/zeromind install <harness>

One command per harness — it links the machine first if it isn't linked yet, writes the harness's native instruction file, and writes the /mcp entry into that harness's own MCP config:

npx -y @origozero/zeromind install claude       # .claude/skills/zeromind-{getting-started,library}/SKILL.mdnpx -y @origozero/zeromind install cursor       # .cursor/rules/zeromind.mdcnpx -y @origozero/zeromind install codex        # ~/.codex/AGENTS.md (or ./AGENTS.md)npx -y @origozero/zeromind install gemini       # ~/.gemini/GEMINI.md (or ./GEMINI.md)npx -y @origozero/zeromind install opencode     # .opencode/skills/zeromind/SKILL.mdnpx -y @origozero/zeromind install cline        # .clinerules/zeromind.mdnpx -y @origozero/zeromind install continue     # .continue/rules/zeromind.mdnpx -y @origozero/zeromind install windsurf     # ./AGENTS.mdnpx -y @origozero/zeromind install zed          # .claude/skills/zeromind/SKILL.mdnpx -y @origozero/zeromind install openclaw     # skills/zeromind/SKILL.mdnpx -y @origozero/zeromind install junie        # ./AGENTS.mdnpx -y @origozero/zeromind install amp          # ./AGENT.mdnpx -y @origozero/zeromind install copilot      # .github/copilot-instructions.mdnpx -y @origozero/zeromind install goose        # ~/.config/goose/.goosehintsnpx -y @origozero/zeromind install aider        # ./CONVENTIONS.mdnpx -y @origozero/zeromind install hermes       # ~/.hermes/config.yaml + plugin bundle
npx -y @origozero/zeromind install --list       # enumerate

Every command is idempotent: shared files (AGENTS.md, GEMINI.md, CONVENTIONS.md, .goosehints, copilot-instructions.md) carry a delimited <!-- BEGIN ZEROMIND --> block that is replaced in place; owned files (skills, rule files) need --force to overwrite. Two harnesses have no MCP config path to write into — openClaw's is unconfirmed, and Aider takes servers on the command line — so the install prints their entry for you to paste. ide/README.md has the full table, with a README per harness.

Linking

A machine links once, and the link is the same one the Zero engine uses: both read and write session.json in the OS config dir (~/.config/zero/session.json; %APPDATA%\zero\session.json on Windows; mode 0600 off Windows). Linking from either side links both, and unlinking revokes every harness on the machine at once.

npx -y @origozero/zeromind link                       # device code, approved in the browsernpx -y @origozero/zeromind link --username <handle>   # pre-fill the approval page's agent namenpx -y @origozero/zeromind status                     # what this machine is linked asnpx -y @origozero/zeromind unlink                     # revoke it

link registers this machine as its own ZeroMind principal, prints a URL and a code, and waits for you to approve it on that page. The approved account is the agent's identity — its own ZeroMind account, distinct from yours.

On a machine that already holds an approved install — linked by an earlier run, or by the Zero engine, which writes the same file — link prints who the machine acts as, asks for no new code, and still hands the secret to Claude Code. One linked install per machine is the whole rule; unlink, then link, is how a machine changes which account it acts as.

unlink revokes the install at ZeroMind and removes it from this machine's cache — the install fields only, so a session the Zero engine signed in with, and the issuer it signed in against, stay where they are. If ZeroMind answers that it holds no such install, the local clear happens anyway; if the revoke cannot be made at all, nothing is cleared and the command tells you to run it again once ZeroMind is reachable.

unlink also takes ZEROMIND_INSTALL_SECRET back out of ~/.claude/settings.json when it holds the secret being revoked — before it revokes anything, so a settings file it cannot read is reported and the unlink still completes. (That one line is then yours to delete.) The entries install <harness> wrote into other harnesses keep the revoked secret and answer 401 until you link again and re-run the install for that harness — the command says so when it runs.

The credential a harness presents is that install's secret, sent as Authorization: Bearer ins_sec_…. A 401 / invalid_token from any tool means the machine is not linked (or the entry holds a stale secret): run link, re-run install <harness> so the entry is rewritten, and restart the harness.

Uploading local files into a world

npx -y @origozero/zeromind upload <path> --world <name-or-guid> [--to <vfs dir>]

Copies a file — or a folder, its relative layout preserved — from this machine into the world's engine VFS, under /source unless --to says otherwise. The bytes go from disk to the world's write_file as base64, so an asset pack never passes through an agent's context window. Ceilings of 256 MiB and 10 000 files are checked before anything is written (--max-bytes / --max-files raise them), and a world with no engine running is reported rather than half-written.

Opening a world on this machine

npx -y @origozero/zeromind open <world guid | name | https url | zero:// url> [--play | --edit] [--native | --browser] [--dry-run]

Every tool an agent calls is served by ZeroMind, which has no browser tab and no engine process on your machine: world.open and world.launch answer where a world opens, and this command is what opens it here. It opens the world's editor by default and the player's face with --play; it hands the URL to the desktop engine when this machine has a zero:// handler registered and to a browser tab when it does not. --native / --browser decide it outright and are remembered in open.json beside session.json, so later calls with neither flag follow what you chose. --dry-run prints the target and the URL and changes nothing.

A guid or a URL is opened without a single network call. A name is resolved against your own worlds over /mcp, with this machine's install secret — which is never printed. No engine is contacted at all.

Pointing at a local / self-hosted ZeroMind

Two environment variables move the whole CLI to another backend:

VariableDefaultWhat it controls
ZEROMIND_ISSUERhttps://origozero.aiBase for every REST call (/v1/installs/*, /v1/worlds, …) and the /mcp URL written into a harness's config. Also the origin of the /link approval page.
ZEROMIND_CONFIG_DIR~/.config/zero (XDG; %APPDATA%\zero on Windows)Where session.json — the install_id / install_secret this machine shares with the Zero engine — lives. Point it elsewhere (e.g. ~/.config/zero-local) so a local backend gets a fresh install identity instead of replaying credentials registered against production.

For the local ZeroMind dev stack, point the issuer at the front door (http://127.0.0.1:3003), not the bare API on :3001 — the front door serves the /v1 REST surface, /mcp, and the web app (including /link and the /edit/<guid> engine pages) on one origin, which is what the CLI assumes.

bash
ZEROMIND_ISSUER=http://127.0.0.1:3003 \ZEROMIND_CONFIG_DIR=$HOME/.config/zero-local \  npx -y @origozero/zeromind link
ZEROMIND_ISSUER=http://127.0.0.1:3003 \ZEROMIND_CONFIG_DIR=$HOME/.config/zero-local \  npx -y @origozero/zeromind install claude

The entry that lands is the production shape at the local address:

jsonc
// .mcp.json{  "mcpServers": {    "zeromind": {      "type": "http",      "url": "http://127.0.0.1:3003/mcp",      "headers": {        "Authorization": "Bearer ins_sec_...",        "X-ZM-Harness": "claude-code"      }    }  }}

Or with the Claude Code CLI:

bash
claude mcp add --transport http zeromind http://127.0.0.1:3003/mcp \  --header "Authorization: Bearer ins_sec_..." \  --header "X-ZM-Harness: claude-code"

Plain http:// issuers work end to end: auth is a Bearer header on every request, with no cookies and no TLS-only assumption.

Updating

  • The tools are served from https://origozero.ai/mcp. Every harness reaches the running version; there is nothing to upgrade on your machine.
  • The artifacts zeromind install <harness> wrote — instruction blocks, skills, the MCP entry — refresh by re-running the install command.
  • The Claude Code bundle (skills + .mcp.json) updates through /plugin.

Maintainers: package.json version is the source of truth. tests/directory-manifests.test.ts fails when a manifest it names carries a different one.

Status

0.7.1 — the plugin runs no MCP server of its own. It links a machine, writes the remote /mcp entry into sixteen harnesses, uploads local files into a world, opens a world on this machine, and ships the two skills. The tool surface is ZeroMind's, served live at https://origozero.ai/mcp; the tests drive the CLI end to end against the bundled mock ZeroMind server in tools/mock-zeromind/.

This release needs a Zero engine that keeps install_secret in the shared session.json it writes: an engine whose cached-session struct has no such field re-serialises the file without it, and the machine reads as unlinked the next time the CLI runs. 0.7.1 therefore ships after that engine release.

Development

bash
npm installnpm test          # builds, then runs the suite against the bundled mock ZeroMind servernpm run build     # compile TypeScriptnpm run lint

The canonical agent operating manual lives in templates/manual.md; every per-harness installer wraps that one file with the harness's expected frontmatter. Adding a harness is one entry in src/cli-install.ts plus an ide/<harness>/README.md.

Directory manifests

Four plugin directories read a manifest from the root of this repository:

DirectoryRoot fileWhat it loads
Claude Code marketplace.claude-plugin/marketplace.json, .claude-plugin/plugin.jsonskills/, .mcp.json
Gemini CLI extensions gallerygemini-extension.jsonskills/, templates/manual.md as the context file
Codex plugins.codex-plugin/plugin.jsonskills/, dist-publishing/codex-plugin/.mcp.json
Cursor Marketplace.cursor-plugin/marketplace.jsonthe bundle in dist-publishing/cursor-plugin/

Nothing generates these files or the bundles under dist-publishing/. tests/directory-manifests.test.ts runs in CI and fails when a root manifest and its bundle disagree, when a path one of them names does not resolve, or when a bundle's copy of skills/ differs from the original.

Releasing

  1. Bump version in package.json and in every manifest tests/directory-manifests.test.ts checks against it.
  2. git tag vX.Y.Z && git push --tags — the publish workflow runs.

Requires the NPM_TOKEN secret in repo settings, scoped to the @origozero npm org.

Security

SECURITY.md says how to report a vulnerability.

License

MIT. See LICENSE.

Source: README.md at commit c57fb6a

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

1
  1. v1.0.0LatestSep 20, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts