Skip to main content
Glama

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 (src/, tests/, demo/)

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 (compiler/, viewer/)

A deterministic recipe-to-glTF compiler (real LOD chains, GPU instancing, quantization + meshopt, provenance, spatially chunked simplification for huge templates), a since_version delta channel over SSE, and a three.js viewer (WebGPU, with a WebGL2 fallback) that now renders colour — flat material constants (deterministic, byte-identical rebuilds) or baked base-colour textures (content-hashed).

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 (nvcompress absent, 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 Thor

Environment: 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 session

Each 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 tools
answer_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

    B3.3/5.0

    Scored across 11 tools

    Disambiguation4/5

    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.

    Naming Consistency5/5

    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.

    Tool Count5/5

    The 11 tools are well-scoped for a complex world-editing domain. Each tool covers a distinct capability without obvious redundancy or extreme thinness.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Enables 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.
      6
      545 npm
      1
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Exposes 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.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Exposes 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