world-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@world-mcp propose a recipe edit that makes these tables sturdier"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
thor-world
The live wire between a world generated on the Jetson AGX Thor and the people and agents who use it. Two halves:
Component | What it is | Where | Status |
world-mcp ( | An MCP server over builder-ide's core: the only way agents (Claude Code, zcode, mcode, cloud tile authors) work on a world, through the core's typed doors. Every action is recorded with its author. | Thor or ProArt | 38/38 tests against a live core, per-agent tokens, recipe versions and diffs, plan intentions; the "make these sturdier" demo runs end to end (design) |
world-stream ( | A deterministic recipe-to-glTF compiler (real LOD chains, GPU instancing, quantization + meshopt, provenance, spatially chunked simplification for huge templates), a | Compiler on the Thor; viewer in Chrome on the ProArt | Byte-identical builds across the Thor and an x86 ProArt (chunked and unchunked); a 629 B delta for one moved table; 3.51 M triangles over all LODs in 43.8 MB compiled in 6.7 s — or 4.98 s at jobs 14 with the chunked shell (design, numbers) |
It fills the role of the private companion repo of the maquette Infinigen fork (an MCP server plus a browser viewer). It is our own design, built for the Thor; see builder-ide's docs/research/maquette.md for what we learned from that fork's public half.
Open for the owner:
a source build of
toktx(KTX-Software, Apache-2.0) — or of any BCn encoder, since the round-2 probes found no aarch64 wheel (nvcompressabsent, no BC7 on PyPI); PNG rides the wire today, WebP measured at 5.5× smaller;the five room-shell meshes whose Cycles bake completes without writing (both devices, recorded in
bake_report.json → failures);Warp simplification for total-work reduction (chunking already broke the serial tail: jobs 14 is now 2.1× faster than jobs 1);
a two-minute WebGPU check in desktop Chrome.
Licence: MIT. Part of builder-ide; world engine: infinigen-thor.
world-mcp
An agent's only way into a builder-ide world. The server is a pure client
of the core's HTTP API — it never imports builder-ide, never touches the
ledger, and every write goes through one of the core's typed doors, its
per-agent token putting both the actor and the agent on the audit row
(docs/design.md is the design note).
Six resources, plus one template: world://context (the §1.4 context
packet: selection, recent history, conversation labels, project state, the
budget left tonight, the vocabulary and its gaps), world://vocabulary,
world://recipe, world://recipe/{version}{?against} (a committed
version — the document, hash-verified — and, with ?against=<base>, the
op list that turns the base into it), world://renders (and critic
verdicts), world://ledger (the two tallies), world://dirty (the
{branch, head, seq} cursor).
Nine tools: get_context, list_vocabulary, read_night_plan,
propose_recipe_edit (seals the prediction first), request_render,
propose_plan_intention (a proposal on the night's slate, kind
plan.intention — the band is the proposal's own footprint),
file_work_order (terse request + context → question XOR draft + the
one-line confirm), confirm_work_order / answer_question,
queue_genbatch, subscribe_world_dirty. No tool runs arbitrary code in
the world; a core refusal (a coming-soon word, params outside a schema)
is surfaced verbatim.
Running it (from this directory; the core is builder-ide's, installed read-only into this venv from its own tree):
python -m venv .venv
.venv/bin/pip install -e '.[dev]'
.venv/bin/pip install -e /home/proart/projects/builder-ide # read-only
.venv/bin/world-mcp check # probe the core once
BUILDER_CORE_URL=http://127.0.0.1:8000 \
.venv/bin/world-mcp serve --stdio # local agents (default)
BUILDER_CORE_URL=http://thor-lan:8000 \
.venv/bin/world-mcp serve --http --host 0.0.0.0 --port 8808
# the ProArt's agents reach the ThorEnvironment: BUILDER_CORE_URL and the three token classes
(WORLD_MCP_OWNER_TOKEN / WORLD_MCP_CHARACTER_TOKEN /
WORLD_MCP_PANEL_TOKEN — the owner and character tokens are per-agent
tokens, whose agent claim lands on every audit row they write, so the
log itself answers "which agent acted for whom"; the defaults are a fresh
$BUILDER_HOME's per-agent dev tokens). A standalone seeded
core for trying it: .venv/bin/python demo/core_host.py.
Tests + demo:
.venv/bin/python -m pytest # every tool/resource at a live core
.venv/bin/python demo/agent_session.py # the scripted end-to-end sessionEach test boots a seeded core on a temp $BUILDER_HOME behind a real
uvicorn server and drives the server as a stdio subprocess through the
official MCP client; the HTTP transport and the world.dirty push have
their own tests.
Related MCP server: @skeletiq/mcp
world-stream
See compiler/README.md (recipe → world file → delta) and viewer/README.md (the dev server and the live viewer). Measurements with the box state beside every number are in docs/measurements.md; screenshots are in docs/screenshots/.
Available Tools
11 toolsanswer_questionA
Answer a parked question (the never-guess rule: when the compile found two plausible referent sets it asked, and the answer unblocks the work order). The options are on the question; answer with one of them, in the owner's words.
Inputs: answer (required), question (required).
confirm_work_orderA
Answer a draft work order's confirmation: go (queue it), no (cancel), or edit (cancel and refile with amendments). This is the owner's one word; the call is idempotent by key. Pass the idem_key again if a retry must not double-file.
Inputs: answer (required), work_order (required), idem_key, amendments.
file_work_orderB
File a work order from a terse request plus the context packet: the core captures the packet, resolves the referents through the node registry, and compiles either a draft (with the one-line confirmation and BOTH price lines) or — when two referent sets are both plausible — a one-tap question. It never guesses; answer the question with answer_question. Fill intent.spec_sentence (≤ 25 words), intent.goal, intent.acceptance (≥ 1 machine-checkable check) and intent.estimate {build_verify, generate_test} to shape the compile.
Inputs: request (required), intent, params, region, +2 more.
get_contextB
Read the context packet for a view (§1.4): the selection's resolved referents and current params, the recent history, the conversation labels, the project state, the budget left tonight, and the vocabulary and its gaps. Pass the node ids you are looking at; omit them for the world's own situation.
Inputs: params, region, selection, conversation.
list_vocabularyB
The closed, typed vocabulary: words with their kinds, owners, statuses, param schemas and taste notes. Filter by status to see the coming-soon edges — the gaps that only a work order can close.
Inputs: status.
propose_plan_intentionA
Propose to the night's slate (kind plan.intention): a plan you believe the night should run — read world://context first and aim the proposal at a real gap. It is priced by the cost model like everything else, but the band is the proposal's own footprint: a slate row and the owner's decision on it (zero GPU; the attention estimate, marked [e]). It prices the proposal, not the work it may seed — that work is priced by its own kind when the night runs it. The owner reads the slate before starting the night; starting it is their door, not yours.
Inputs: intention (required), night, cost_estimate.
propose_recipe_editC
Change the world through the typed vocabulary, sealing the prediction FIRST (§5.1: the seal is committed before the render exists). The word's param schema is the contract; anything outside it is refused at the door and the refusal is honest. The render that tests the prediction is requested separately (request_render), so the bet stays sealed before its test exists.
Inputs: word (required), params (required), prediction (required), node, +1 more.
queue_genbatchB
Queue a generative batch (genbatch): a night of props made by the local image model + TRELLIS.2, measured, judged and recorded as assets with provenance and licence. The kind prices it from the measured cost model — prop.512 or prop.1024 per variant; count scales the ask (the p50) and the rail (the p95). The requests themselves ride the intention (what to make, how many seeds); the genbatch seat consumes the queue.
Inputs: intention (required), kind, count, night, +1 more.
read_night_planB
The night's plan and its price: the slated tasks with their asks (the cost model's p50, or the filer's override), the bar (the night's rails), the owner's two lines — what tonight costs and whether it fits — and the budget left if a night is running.
Inputs: no named parameters.
request_renderC
Request a render or preview of entries at a rung of the ladder (1 fast layout · 2 mid with lighting and materials · 3 full). The request is queued at the core's door priced by the measured cost model (kind rung.N); the engine that renders it is the recipe half's seat, so until it lands the queue row is the honest state. Price a sealed prediction against the SAME rung and seed you render.
Inputs: rung (required), entry_paths (required), seed, branch.
subscribe_world_dirtyA
Subscribe to world.dirty: what changed in the world and when. Returns the cursor {branch, head, seq} and the dirty events since since_seq (rewind is free — the feed is the log). Clients that hold a subscription stream receive world://dirty resource-updated notifications the moment the recipe moves; this tool is the polling form for clients that cannot.
Inputs: since_seq.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 11 tools
Each tool targets a distinct action or resource (context, vocabulary, recipe edit, render, work-order flow, night planning, genbatch, dirty feed). A few night-related and answer/confirm tools could be momentarily confused, but the descriptions clearly separate them.
All tools follow a consistent snake_case verb_noun pattern (get_context, list_vocabulary, propose_recipe_edit, confirm_work_order). Compound nouns are used predictably with no style mixing.
The 11 tools are well-scoped for a complex world-editing domain. Each tool covers a distinct capability without obvious redundancy or extreme thinness.
Core flows are covered: reading context/vocabulary/night plan, editing recipes, requesting renders, filing/confirming work orders, answering questions, proposing plans, queuing genbatches, and subscribing to changes. Minor gaps remain around listing or inspecting queued work orders, renders, and genbatches, but agents can likely work around them via context and dirty events.
Maintenance
Related MCP Connectors
Build and run grounded business agents over MCP: agents, knowledge bases, skills, Storylines.
Public MCP for agent verification, work discovery and governed interoperability.
Guarded MCP server for agent-readable business truth, provenance, readiness, and discovery.
Host any HTTP API as MCP tools with a tamper-evident cross-agent settlement ledger.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables MCP-capable agents to author, compile, run, and commit generative music E-- Recipes from a library catalog, completing the full authoring loop.43 PyPIApache 2.0
- AlicenseAqualityBmaintenanceEnables MCP-capable coding agents to access SkeletIQ architecture releases, including reading designs and build orders, generating and critiquing architectures, and reporting build progress and drift.6545 npm1MIT
- FlicenseNot gradedqualityCmaintenanceExposes a version-controlled knowledge base as MCP tools so agents can read merged identity/state summaries and next recommended actions at runtime, plus run deterministic schema validation and cross-reference link checks. This lets agents fetch live state and verify integrity via self-describing calls instead of re-reading raw files.-
- AlicenseNot gradedqualityBmaintenanceExposes a self-hosted shared workspace over MCP where AI agents and their teammates read and write tasks, decisions, docs and results, so each session picks up where the last one left off. It adds hybrid cited search, per-workspace OAuth or scoped tokens, change feeds for cheap re-sync, and an append-only audit trail of every agent or human write.AGPL 3.0