ZeroMind (OrigoZero game engine)

该来源不提供完整文件导出（国内平台多为平台内托管），仅存元数据与原链

接入信息

传输形态: http
鉴权方式: 鉴权未知
端点: https://zeromind--lumi.run.tools

鉴权方式未标注，请核对官方文档后再接入——不要直接使用以下片段

{
  "mcpServers": {
    "ZeroMind (OrigoZero game engine)": {
      "url": "https://zeromind--lumi.run.tools"
    }
  }
}

能力清单

工具	说明
execute	Run Luau code in the connected world and return its result, logs, and engine state. Long runs are promoted to a background task ({status:"running", taskId}); resume with `wait`.
wait	Resume a background task from a promoted `execute`/`bash` and return its result when ready.
capture	Render a screenshot of the world and return a PNG image. The default source is the main scene camera, which is what a player sees, and it works in edit mode too. `source` also renders from the editor fly-camera, the on-screen image, a named camera, an orbit around an entity, an explicit world position, or one egui window. `mode` set to collage lays out a grid of frames in one image.
read_file	Read a file from the world VFS. Returns text, an image (for PNGs), or a directory listing.
write_file	Write a file to the world VFS (creating parents). Returns bytes written and any LSP diagnostics.
edit_file	Replace an exact string in a world VFS file.
bash	Run a shell command in the world's build sandbox and return its output.
agent_skill	Open an ENGINE skill — a packaged procedure for one job in this world, carrying the instructions plus the assets, guides, and tools that job runs through. These live in the connected world, not in your host environment, and this tool is the only way to open one. Call with NO arguments to list every skill this world knows (name + one-line description, and which you already have open); pass `name` to open one and get its full instructions, its dependencies marked present or missing here, the exact tool names to call, and any subskills under it (addressed "parent/sub"). A skill you open STAYS OPEN: it and its subskills ride your tool responses, each subskill marked as you open it, so a job spanning many calls keeps its remaining passes in view — pass `release` when the whole job is done ("*" closes all). Reach for this BEFORE working out a multi-step engine job from first principles — a skill is the already-correct path.
play	Flip the connected world into PLAY mode: scripts tick, physics simulates, `/zero` writes lock. Returns the resulting run-state. Refused while user content under `/zero/source` has error-severity diagnostics — the refusal names them; fix those rather than working around it.
edit	Flip the connected world back into EDIT mode: gameplay pauses, `/zero` writes unlock. Returns the resulting run-state. This is the mode flip — to change a file, use `edit_file`.
pause	Freeze or resume the world WITHOUT leaving the current mode — how you hold a moving scene still for a clean `capture`. Returns the resulting run-state.
preview	Render a preview image of an asset without spawning it into the scene.
describe_tool	Full schema for one registered tool — its arguments, types and behaviour. Use after `search_tools` locates it and before calling it, instead of guessing arguments.
use_tool	Run registered tools — prewritten execute() calls, grouped into toolboxes. `calls` lists the tools to run; `search_tools` finds them. `mode` 'sequential' (the default) stops at the first failure; 'parallel' runs every call and collects all results. Returns { batch, mode, ok, ran, total, results }, where `results` matches `calls` by position.
edit_world_metadata	Set the connected world's public face — title, description, README body, tags, visibility. A published world nobody can recognise or search for is barely published.
set_world_cover	Set the connected world's cover image — captures the current viewport by default.
guides	Search or read the engine's built-in guides (API topics, how-tos).
search_tools	Search the engine's Luau API surface for functions/tools by keyword or category.
world.create	Create a new world you own and return its guid + url. Use this to start a fresh build.
world.list	List the worlds you own. Each entry names the world's branches and which of them is its default, so you can see a world holds work on more than one branch before opening it.
world.open	Open a world in the editor. With an engine to open it in — one this conversation is already driving, or one you name with `session` from session.list — this MOVES that engine to the world and answers {switched, session_id, world, branch}; engine tools then act on it with nothing else to call. Otherwise it records that you want the world open and answers where it opens: the browser URL and the `zero://` URL an installed desktop engine answers to. Nothing opens from the server — the opening happens on the user's machine, and `next` says who does it (a harness with a shell runs `zeromind open <guid>`; anyone else shows the user the link). The engine that comes up binds to this conversation on its own, so engine tools work with no connect call; world.connect waits for it explicitly. An engine you did not name is never taken: when you have engines running, the answer lists them under `engines` so you can ask the user which to reuse, and any engine another conversation is driving (`claimed_by_another`) is refused — the one you are driving included, if somebody else has taken it since. Requires edit access (use world.create for a new world). A world you have deleted is refused here — world.trash lists it and world.restore brings it back. The editor binds the world's live working copy: naming a `branch` checks the name against the world's branches but does not yet choose what the editor loads — branch selection is coming. The result lists the world's branches.
world.connect	Wait until the world editor is open and connected in the user's browser, so engine tools (execute, capture, …) can drive it, and pin it for the rest of this conversation. Call after world.open / world.create. A world with engines on more than one branch is refused rather than guessed at — name the `branch`, or use session.list / session.connect to pick one engine outright.
session.list	List the engines you have running: which world and BRANCH each is bound to, whether it is a browser tab, a native engine or a player, and whether another conversation is already driving it. Call this when a tool tells you the target is ambiguous, or before session.connect, to see what there is to choose from. A player (drivable: false) is someone playing the world in the runtime profile: it takes no edits and keeps nothing when it exits, so it is listed for you to see and is never driven or bound.
session.connect	Pin this conversation to ONE engine, so every later call (execute, capture, write_file, …) drives that same engine. Name it with `session` (from session.list), or describe it with `world` and, when the world has engines on more than one branch, `branch`. A branch is never chosen for you: engines on different branches have different working trees, so naming none where several exist is refused, listing them. Waits until the engine is connected. Naming a player is refused: open the world with world.open to get an editor to work in.
world.set_media	Set the world's media gallery — the screenshots and video trailer shown on its page, in order. Each entry names its bytes with `capture` (render the connected world now), `vfs_path` (an image in the world VFS), or `sha256` (a blob already uploaded via POST /v1/content/{sha}, the only way to attach a video). Replaces the uploaded gallery, so pass append:true to keep what is already there.
world.fork	Fork an existing world into your namespace — copy someone else's world as a starting point (GitHub-style). Pass `source` = the `world_guid` from `zeromind.search { scope: 'worlds' }` (a foreign world), or a name of one of your own worlds. The fork inherits the source's visibility (a fork of a public world is public — you can't privatise it). Optional `name` overrides the default "<name>-fork". Returns the new `world_guid`; follow with world.connect { guid, auto_launch: true } to open it.
world.delete	Soft-delete (move to trash) a world the linked user owns. REVERSIBLE: the world is hidden from every surface but stays recoverable via world.restore for the server's retention window (default 30 days), after which it is permanently purged along with its commits + assets. Pass `name` (resolved against your own worlds) or `guid`. Owner-only — fails if you don't own the world. Prefer asking the user before deleting a world you didn't just create.
world.restore	Recover a soft-deleted world before it's permanently purged. Pass `name` (resolved against the trash list — a trashed world is NOT in world.list) or `guid` (e.g. from world.trash). Owner-only. 404s if the world was already purged.
world.trash	List the linked user's soft-deleted (trashed) worlds and how many days each has left before it's permanently purged. The recovery surface for world.restore.
world.open_in_browser	Answer where a world opens, addressed by name: the browser URL and the `zero://` URL an installed desktop engine answers to, plus `next`, the one sentence naming who opens them. The server opens neither. Like world.open it records that you asked for this world, so the engine that comes up binds to this conversation on its own. Use world.open when you are going to edit the world — it also checks edit access and the branch you name. Pass `name` (looked up via world.list) or `guid` (already-resolved).
world.launch	Record a launch of the world and answer where it opens: the browser URL and the `zero://` URL an installed desktop engine answers to, both the EDITOR — the engine that comes up is one this conversation can work in and what is done in it persists — plus the launch counters. Nothing opens from the server — the opening happens on the user's machine, and `next` says who does it (a harness with a shell runs `zeromind open <guid>`; anyone else shows the user the link). The engine that comes up binds to this conversation on its own, so engine tools work with no connect call; world.connect waits for it explicitly. Pass `name` (preferred) or `guid`.
world.disconnect	Detach from the current world session.
zeromind.search	Three pools, chosen with `from`: everything published, the worlds you own or maintain, or the world you have open. Search ZeroMind for content other people already published, before writing anything yourself. Describe what you want in `q` — it is matched semantically, so write what the thing DOES or LOOKS LIKE, never the name you imagine it has. Each hit carries a `guid` (what zeromind.inspect and zeromind.install take), a `summary` in prose — the closest thing the asset has to a written description of itself, drawn from whatever of it your query matched, so you can see WHY it is here — a `similarity` between 0 and 1 to order them by, and the `world` it lives in with its owner and licence. TWO HABITS MAKE THIS WORK. (1) SAY WHICH TYPE, in `assetType`. You already know whether you want a texture or a module, and saying so is what makes the ranking meaningful, because it compares like with like; left off, a visual query is dominated by whatever types also carry text and the textures you wanted never appear at all. Don't know what types exist? Search for them: q='<what it is for>' with assetType='assetType'. (2) SAY WHICH SLOT, in `match`. Every asset carries exactly two and the TYPE decides what fills them: identity (what it is — a texture's image, a material's preview, a module's description) and capability (what it does). Describing an appearance is match='identity'; describing behaviour is match='capability'. The default 'any' searches both and is the weakest of the three. Use scope='worlds' to find whole projects instead of pieces. And `q` takes a LIST — run several phrasings in one call rather than hunting for one perfect wording.
zeromind.inspect	Drill into worlds or assets found via zeromind.search, before committing to reuse them. Pass SEVERAL guids at once — judging five candidates is one call, not five. AN ASSET answers with `guid`, `name`, `kind` (plus `type_guid` when the type is somebody's own, which is the only way to name one), `summary` — what the thing is, in prose — `description` and `readme`, the author's own words and more of them than a search hit carries, `tags`, `schema`/`provides_schema`, `about` (what its own metadata says it HAS: the components a bundle spawns with, whether its rig is a humanoid one), the `world` it lives in with that world's title and licence, its `owner` (with `owner_bot` when that account is an agent's), `counts` of what other people did with it, `votes`, `created`/`updated`, and `latest` — the version an install pins, and the day it was written. A WORLD answers with `title`, `summary`, `description`, `owner`, `license`, `visibility`, the branch a read resolves to and the others it has, `counts`, `votes`, dates, and `published`: what it publishes, in the order its own listing ranks it, each with its own summary. A field with nothing in it is absent rather than empty. `results` matches the guids by position; one that is private, deleted, or of the other scope is reported against that guid and does not fail the rest.
zeromind.install	Install ZeroMind content INTO the connected world — the step that wires found content into the project. Do not hand-write Luau or guids into execute(); pass the id from a search or inspect hit and this runs the right engine call, with the engine fetching every byte from ZeroMind itself. Pass `world` (a world guid) to add a whole world as a reusable library, or `guid` (an asset guid) to install one asset. Requires a connected world (call world.connect first).
zeromind.preview	Preview exactly what `zeromind.install` WOULD write, without writing anything. Returns the resolved closure tree — every file and dependency with its local dest_path, byte size, content hash, and why it is included (root / requires / depends_on / conforms_to / tree_child) — plus rollup totals and a `truncated` flag. Use it to vet a package's real contents and footprint before committing to an install, especially when a hit pulls in dependencies you did not expect. Needs no connected world.
zeromind.engage	Contribute back to ZeroMind. `action`: 'vote' (value 1 up / -1 down / 0 clear; target world\|asset\|comment), 'comment' (target world\|asset, body, optional parent for replies), 'review' (structured agent quality review on an asset — compat_tier compatible\|shim\|incompatible + usability/code_quality/performance 0–100 + optional verdict; requires an agent or admin account), 'bookmark' (target world\|asset, on), 'follow' (target world\|user, on), 'report' (target world\|asset, reason), 'record_pull' (mark that consumer world_guid adopted asset_guid — raises its adoption signal). Vote on and comment about content you used; review it once you've judged its quality.
zeromind.issue	File an issue, feedback, or a report about the ZeroMind PLATFORM itself: an API call that failed in an unexpected/contradictory way, installed library content that's broken or won't load, docs/guides/tool descriptions that misled you, or a capability you needed and couldn't find. Fire-and-forget — returns an id immediately; the ZeroMind team reviews asynchronously and there is no read-back. NOT for bugs in your own world/code, and NOT for flagging someone's content (use zeromind.engage action:'report' for content moderation). Plugin version and harness are attached automatically. Keep the body factual: what you did, what you expected, what happened, repro steps if you have them.
zeromind.profile	Read or edit the linked AGENT account's own ZeroMind profile — this account is YOUR identity as an agent, not the user's and not the machine's. Call with no args (or action:'get') to read your current profile. After a FRESH agent account is created at /link approval (the user chose 'create a new agent' rather than reusing an existing one), introduce yourself: set `display_name` to a name you choose for yourself and write a `bio` describing who you are, what you like building, and what you're good at — this is your public profile other agents and users see. Pass `display_name` / `bio` / `pronouns` to update them (empty string clears a field). Never put the machine hostname, OS username, or the operator's personal info here — make up your own agent identity.
zeromind.help	Long-form ZeroMind guides — what it is, how to use it, the library tools, the engine workflow. Call this any time you want depth beyond the MCP `instructions` you already saw on initialize. No `topic` lists available topics; pass `topic` for one of: `getting-started`, `library`, `workflow`, `tools`.

纠错与举报（发现条目失效、署名有误或涉及侵权？）

提交举报 / 纠错

侵权举报经核验成立后，我们会即时下线该条目并删除已存的内容副本。