io.github.gripforgeai/mcp

Tools

• getAttachmentFrame

  Return the skeleton frame for a limb. Outward = R_Thigh−L_Thigh (never ask the LLM). Up = Knee→Hip / Ankle→Knee. Match getWearableFrame axes — no Euler.

  shallow
• getWearableFrame

  Analyze an armor asset once: up, bodyFacing, outward, anchor. Never returns rotate X = 180°.

  shallow
• gripforge_abilities

  combat.abilities: inspect schema, get an editable Chrono Crab example, validate a pack or export executable Three.js, Godot, Unity and Unreal source adapters. Shared costs, cooldowns, conditions, targeting, windup/active/recovery and presentation cues. Native adapters require the game combat backend and asset bindings. Returns relative path/content files; no rig/animation/VFX generation or automatic installation. Persist through gripforge_gamekit_configure config.pack or project data. 0 credits.

  shallow
• gripforge_abilities_generate

  A hero's abilities ready to play in Character Studio: the kit (role, lane, basic attack, passive + Q/W/E/R with type, range, cooldown, cost, effect, VFX brief, cast animation) from a hero concept or written from one sentence; the basic attack and Q/W/E/R casts animated with NVIDIA Kimodo on the rigged character; and the gripforge.abilities/1 pack (targeting, damage/heal, timings) bound to those clips and stored on the result. Call stage=plan first (free) and show the abilities and price (1 credit per clip, 5 for a kit); then stage=build with the returned kit. Poll gripforge_generation_read with job_id; result.studio_url opens the Abilities tab. Numbers are starting values, not a balance pass; VFX lines are briefs for gripforge_vfx_generate.

  shallow
• gripforge_ability_vfx

  Journey — after the roster; gripforge_game_audit lists it among what a finished MOBA has. Write and bind a cast effect for each ability of a Game Kit project that has none: an area gets a ground shockwave, a line a bolt and its trail, an arc a sweeping crescent, a self cast a rising aura; colour from the ability's words (fire, frost, wind, holy…), size from its range, ultimates larger. The project needs the fx.ability_vfx kit (the moba preset installs it) and an abilities collection (gripforge_moba_roster writes it). Effects are procedural sources saved as VFX items and bound to ability_vfx:<ability id>, immediately. replace: true rewrites the existing ones; abilities limits to some ids. A hand-made or generated VFX bound to the same slot takes over. 0 credits.

  shallow
• gripforge_aim

  Aim-offset poses for a Library character/armed bind (0 credits): per hand, two-bone IK + wrist alignment so the WEAPON AXIS (gf_muzzle locator from loadout, else the seat forward) points at every direction of a yaw×pitch grid. Returns bone-local quaternions per pose + rest, and a Three.js/Godot blend snippet. Dual wield ready (independent hands).

  shallow
• gripforge_animate

  Retarget the Universal Animation Library pack onto a Mixamo-named Library character/enemy/armed bind. Base slots + extras (taunt, stinger, knockback, block, jump_start/loop/land, idle_guns, shoot). archetype remaps the base slots: sword (default), claws, heavy, brawler, puppet. Opt-in slots fire_breath (mouth exhalation) and energy_cast (two-hand azure wave) use the Studio VFX character motions. Saves kind=animation. 0 credits.

  shallow
• gripforge_apply_realism

  Plan or apply render.realism across shared PBR materials, immutable textures, surface shaders, lighting, post-processing, environment and skinned character rendering, with a bounded render quality and render.lod configuration suggestion. Defaults to mode=plan (no save); mode=apply writes one work revision atomically, preserving assets, transforms, animation and validated versions. Explicit nodeIds restrict instance assignments; lighting/post-processing are global. materials/characters rows use {nodeId,material:"*"|exactName,override:{roughness,metalness,map,normalMap,surface,...}}; pinned map references, null removes overrides. Characters require character/enemy/boss/fps-arms role. Does not fabricate missing detail, execute paid generation, add game LOD automatically, or approve realism visually. Request a real scene_review afterwards. WEB only; not DLSS.

  shallow
• gripforge_architecture_schema

  Read the reusable Meshy/Tripo building and district contract, example, limits and plan → build workflow. Separate immutable Library assets, scene instances and shared SceneDocument. No paid generation.

  shallow
• gripforge_armor_generate

  Queue a durable armor-kit job: one shared concept, isolated Imagine references, Meshy PBR models, bounded Blender interior preparation and paired GLB exports, then actual GripForge wearer review. Types: helmet, chest, belt, pauldron, bracer, glove, thigh, greave, boot, upperarm, gorget, tasset, undersuit. coverage=full adds a durable anatomical decomposition of the concept, rejects missing planned roles before mesh generation and records per-instance coverage fits. A piece count alone never proves body coverage. The optional undersuit is a locally manufactured adaptive textile which retains each wearer’s skin weights. Meshy pieces cost 11 credits per canonical type; the textile has no image/mesh charge. A new concept costs 1 credit; mirrors are included. concept_item must be an owned Library image. source_kit + explicit pieces regenerates only those types into a NEW work kit and pins unchanged pieces. Closing the call/page does not cancel. Poll gripforge_generation_read. Success is a work version, never automatic visual approval. The result includes a Grip Studio link, review scene, concepts, source models and Blender source.

  shallow
• gripforge_armor_read

  Read an owned kit manifest, semantic slots and immutable piece revisions. Equipment and instances remain independent. Returns the Grip Studio link. To correct selected types, call gripforge_armor_generate with source_kit and pieces.

  shallow
• gripforge_armor_repair

  Fork a failed/cancelled armor job into a new work kit. Preserve completed pieces and the exact shared concept; recreate only unfinished types by default. Optional pieces chooses types explicitly. Use prompt for targeted corrections. Original checkpoints and artifacts remain intact. Costs 11 credits per regenerated canonical type (plus a concept credit only if none survived). Use generation_retry instead for a transient provider or worker error to reuse the exact same steps without another charge.

  shallow
• gripforge_asset_clone

  Copy a published Community asset into the connected workspace. Assets and armor sets are free by default. Only an explicit creator price is charged, using paid credits. Repeated takes are not billed again but may create another copy: reuse an existing workspace id when possible. Returns the private Library item and signed file URL. Download it with gripforge_library_pull, then import into the actual game.

  shallow
• gripforge_asset_search

  Search actual asset models, materials and animations, independently of Game Kit modules. Returns provenance, import requirements and Library ids. Results are ranked best first by fitness for a GripForge game (score/100, grade A–D, reasons: triangle budget for the target, rigged and clean rig, clips, empty-handed characters, attachable weapons, classified, file size, adoption); `best` is the top pick across sources. Prefer grade A/B; read the reasons before choosing a C/D. Search both sources before manufacturing missing roles. An empty kit search does not mean there are no assets. Search is free; never substitutes proxy geometry for finished models. In a Game Kit project, use it to fill what gripforge_game_audit reports missing (a creature slot gets ranked proposals from gripforge_gamekit_creatures; a character without clips is animated, not left idle).

  shallow
• gripforge_attach

  Attach a prop (sword, shield, gun, staff/scythe…) onto a rigged character. Finds the hand bone across naming schemes, scales the prop to the character, seats the grip, closes the fist, and returns a bind + ready-to-paste Three.js / Unity / Godot snippets. Pass Library ids (character_id / prop_id) or https URLs. attach_id reuses an existing armed bind GLB as the character. prop_id_2 attaches a second held item (off-hand) onto the first result. The bind (+ armed GLB when export_glb) is saved in Library — not a second credit. To write files into an open repo, use the npm MCP package gripforge_library_pull.

  shallow
• gripforge_audio_kit

  Search locker + Community audio. Prompt matches name, description, tags and use (gunshot, ui, magic, footsteps, announcer, dinosaure, magie, pas…). Each hit has id, description, use[], pack, file_url. Community hits: clone with /api/v1/community/{id}/clone (1 credit first take) then pull. Free to search.

  shallow
• gripforge_audit_game

  Inspect project structure and flow, preserve fresh build evidence and report unsupported tests explicitly. 0 credits.

  shallow
• gripforge_blender_fabricate

  Queue a bounded Blender recipe, never arbitrary Python. Saves GLB and .blend in the workspace as an unvalidated work version with a shared Scene Studio link. Read gripforge_scene_schema for recipe fields. Supports original primitive/custom meshes, PBR colors and keyed transforms. Poll gripforge_generation_read; final visual approval must use GripForge rendering, not Blender screenshots.

  shallow
• gripforge_boss

  Create a playable boss for a game look: stats, phases, attacks bound to anim-pack slots, arena, and Three / Godot / Unity / Unreal snippets. Kit is 0 credits. Reuses a locker enemy when one exists. Pass character_id to bind a Library mesh. Pass generate=true to forge a NEW kind=enemy boss mesh (10 credits, 2–8 min) — only if style_kit / locker is empty. Then gripforge_animate(archetype) + gripforge_hitbox. Name stays text.

  shallow
• gripforge_bot_kit

  Navmesh bots as server-owned player scenes so spawner/synchronizer/net-kit damage apply unchanged. 0 credits.

  shallow
• gripforge_build_deploy

  Not implemented. Returns 501 until artifact upload exists.

  shallow
• gripforge_build_get

  Read one game build. Upload/deploy of Linux dedicated artifacts is not implemented yet.

  shallow
• gripforge_build_list

  List game_builds (not Godot kit zips at /api/v1/builds).

  shallow
• gripforge_build_rollback

  Not implemented. Returns 501. Mutating / production-sensitive.

  shallow
• gripforge_cancel_render_preview

  Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

  shallow
• gripforge_cape

  Cape rig v2: generates a 3-column bone grid (gf_cape_c*r*) anchored to the neck/upper-spine bone, skins the cape mesh onto it (vertical blend × gaussian columns), and bakes attached_cape.glb (character + skinned cape). The cape then ANIMATES: run the returned Godot script (spring bones, attach to the Skeleton3D) or the Three.js verlet snippet — the engine simulates, the bind carries structure + suggested spring params. Inputs: Library ids (lib_…) or https URLs of GLBs. CONSUMER RECIPE — (1) call with character_id/cape_id; (2) download the baked glb from library.file_url; (3) drop cape-godot.gd next to it and attach to the Skeleton3D node. 1 credit.

  shallow
• gripforge_character_concepts

  Three LOOK pictures (3/4, Imagine low 1K) of a named character, enemy or boss BEFORE any 3D. Pass weapon to show it on the looks; 3D later is T-pose empty hands. Pick one, then gripforge_generate_character with concept_item. 1 credit per image (default 3).

  shallow
• gripforge_complete_game

  Queue bounded completion using existing kit installers and regression tests. Installs only the provider that fits the game and only kits of its genre, preset or request (never a kit that makes it another game). Preserves exclusions and project revision safety. No paid generation or destructive replacement. Poll status_url; succeeded means the job finished, inspect report.ready. 0 credits.

  shallow
• gripforge_concept_correct

  Turn a character concept image into a strict T-pose sheet (optional: remove flowing cape/train only — sleeved jacket stays; outfit or sport base). Saves PNG to Library. 1 credit. Hosted MCP takes https file_url.

  shallow
• gripforge_configure_render_preview

  Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

  shallow
• gripforge_creature_analyze

  Queue multiview mesh inspection and vision anatomy detection for an OWNED GLB. Detect actual body, legs, arms, claws, wings or tail without imposing a humanoid/eight-leg template. Returns a persistent job_id. Poll gripforge_generation_read with include_preview=true for the annotated views, editable profile and uncertainty flags. No rig mutation. 0 GripForge credits; configured server vision/Blender required.

  shallow
• gripforge_creature_rig

  Create a NEW private draft character/enemy from a completed creature analysis and optional corrected anatomy. Blender builds the skeleton, surface-smoothed skin weights and procedural starting/diagnostic clips. Grounded leg chains get in-place walk/run with IK. Returns job_id; poll gripforge_generation_read for the Character Studio link, skinned GLB, editable .blend, anatomy and deformation report. Never automatically replaces or validates the source. Every anatomy proposal requires explicit review; use generation_cancel/retry to control durable work. Finger/facial authoring and finished combat choreography are outside v1. 0 GripForge credits.

  shallow
• gripforge_creature_rig_schema

  Read the reusable creature anatomy/rig workflow, coordinate contract, limits and export formats. Detect anatomy before authoring; source GLB, asset instances and draft rig stay separate. Blender is the worker, GripForge is the review renderer.

  shallow
• gripforge_define_game

  Journey — right after choosing the genre. The finished game of its genre is the default scope: its definition of done and what every game has (a way to win AND to lose, title / pause / end screens, sound, the genre HUD, touch controls, a loop playable from start to end) are required capabilities; exclude one only when the user explicitly asks (an endless game), and say so. Persist a versioned Game Completion Contract with revision checking. Read get_completion_report for its schema and a proposed contract. Required, optional and excluded capabilities describe the actual intended experience. 0 credits.

  shallow
• gripforge_docs

  The GripForge docs, embedded in this MCP (readable offline, versioned with it), as Markdown. Without topic: the list of topics. With topic: its text, or one section (section = a heading, its number such as "4.2", or words of it); a long topic answers its table of contents first unless a section is given or full=true. Topics: web-export, godot, unity, desktop, c-api, glossary, kit-api, third-party, player, render-budget, scene-optim, porting, game-schema, module-calls, module-calls-native, godot-host, kit-modules, kit-structures, kit-third-party, abi, modding, game-engine-contract, game-engine. Read "third-party" and "porting" + "abi" before writing a presentation module, "modding" before writing a mod, "glossary" for the words. A kit's own API reference is gripforge_gamekit_api. 0 credits.

  shallow
• gripforge_environment_module

  Free parametric 3D masonry, independent of any game: pillar, arch, fountain, stairs, wall, pavement, rock, cliff, ruin, bridge, watchtower, shrine or a stone guardian. inspect (default) returns real generated bounds, triangle count, metric recipe and assembly sockets. build saves a private textured GLB in the Library, with bevelled geometry, baked vertex shading and named stone/recess/trim/water materials. Dimensions are nominal metres; bounds report actual moulding overhang. Ground origin, stairs ascend toward -Z, <=23 cm risers; top/bottom sockets support assembly. Seed and palette are repeatable. Does not place assets, generate arbitrary AI models, publish, or guarantee navigation/collisions in a target game. 0 credits.

  shallow
• gripforge_facial_rig

  Inspect or create mouth controls on an OWNED GLB while preserving its body skeleton and animations. action=schema returns the contract. inspect returns a persistent job with mesh node indices, local bounds, existing facial controls and compatible dialogue.voice mappings. build automatically reuses recognized Oculus/ARKit/Rhubarb controls, or creates eight draft mouth morphs from explicit mouth landmarks (profile). A sealed mouth requires explicit prepare_mouth=true to cut a guided opening on the output copy and add an interior; it interpolates UVs and skin weights, changes face topology and requires visual review. It never guesses landmarks from the body bounds. Poll gripforge_generation_read for the new private GLB, report, voice_rig JSON and Character Studio link. No automatic source replacement or project binding. No TTS/GPU rental; CPU geometry processing, not full facial expression authoring.

  shallow
• gripforge_flexible_chain

  Queue a persistent 240 Hz XPBD simulation using GripForge Scene Engine. Read flexible_chain_schema first. recipe version=1: preset whip|rope|tail, duration<=10s, fps=30|60, physics {length,segments,damping,bendCompliance,gravity,radius,floor,iterations}; choose motion [{time,position,direction,capsules}] OR source {asset:{assetId,revisionId},clip,mount_node,offset,axis,colliders}. Source assets are immutable and workspace-scoped. Returns a job ID; poll generation_read for a new draft skinned-chain GLB, sampled joints, recipe, physics metrics and Character Studio link. This is a neutral physics preview, not a Meshy weapon redesign or automatic rebind of the source weapon. No runtime world collision or seamless loop guarantee. Cancel/retry keeps completed steps. Does not replace or visually validate an existing asset. 0 credits; storage quota applies.

  shallow
• gripforge_flexible_chain_schema

  Read the bounded recipe schema for the shared FlexibleChain solver. Presets: whip, rope, tail. Input can follow an exact named mount in a pinned GLB animation or sampled world-space motion. Includes units, collision capsules, limits and a runnable example.

  shallow
• gripforge_flexible_weapon_schema

  Read the bounded recipe and concept-first workflow for Meshy + Blender flexible weapons, costs, pinned component reuse and source animation requirements.

  shallow
• gripforge_font

  Google-font CSS + exact HUD copy for a game look (DMC: Cinzel D–SSS, kart: Teko, CS: Barlow Condensed). Put letters in HTML/Text nodes. Do NOT rasterize ranks, km/h, or HUD numbers with an image model. 0 credits.

  shallow
• gripforge_formats

  List the mesh formats and grip styles GripForge supports.

  shallow
• gripforge_fp_hands_schema

  Read the native FPS hand template, recipe defaults, limits and reuse workflow. Geometry is manufactured from an articulated FPS template, independently of full-body character generation.

  shallow
• gripforge_fps_animation

  Queue a persistent Blender job for paired FPS arms and an articulated pistol: idle, draw, fire, tactical reload and empty reload. Recipe: {version:1,preset:"pistol",name:"Pistol FPS",tempo:1}; tempo 0.7–1.3. Returns job_id immediately; poll gripforge_generation_read for the private Library asset, .blend source, event markers and Character Studio FPS link. Generated variants are work revisions, never automatically validated. Use gripforge_generation_cancel/retry; completed steps survive closing the page.

  shallow
• gripforge_fps_kit

  Reusable FPS rules, map and runtime exports for Godot and web: weapons, reload markers, viewmodel, camera, bots, grenades and bomb rounds. Offline bots. Persist changes with gripforge_kit. 0 credits.

  shallow
• gripforge_game_art_direction

  Store artistic intent on the existing Game Kit project (game.engine), separately from gameplay: look, world/theme, palette, proportions/materials/lighting notes and device budget. Read first, then set with expected_revision. Unspecified fields are preserved; null clears a field or the profile. Existing assets and rendering are not modified. Use this direction with map wizard.look, VFX look, asset prompts, lighting and UI tools, then inspect gripforge_game_asset_plan and actual-engine captures. 0 credits.

  shallow
• gripforge_game_asset_plan

  Read asset requirements from enabled Game Kits and game.engine archetypes. Without slot: report missing files/bindings, template defaults, metadata style/theme conflicts, unknown classifications and technical ranking concerns. With slot: search accessible Library/Community candidates for that role and the saved art direction; known visual conflicts are excluded. No purchase, generation or binding. Metadata checks do not replace visual/animation/gameplay review in the actual engine. 0 credits.

  shallow
• gripforge_game_audit

  One report of everything that stands between a Game Kit project (gkp_…) and a FINISHED game of its genre — run it before telling the user a game is done, and again after each round of fixes. It aggregates, by severity (blocker / major / minor): creatures (slots drawn as a capsule, models without a skeleton, missing movement or action clips, the animation chain in progress), controls (no control scheme, the suggested one, keys shared by two actions in one mode, playable actions without a key), content (missing capabilities, required slots, the game.engine report), the last headless playtest (failures, warnings, the keys / models / animations probes, capabilities no probe covers) and completeness: what a finished game of the genre has beyond the literal request (MOBA: distinct heroes with Q/W/E/R, minions, towers, jungle monsters, shop, respawn; FPS: weapon, ammo, reload, crosshair, enemies; platformer: checkpoints, collectibles, end of level; racing: laps, ranking, AI opponents… and for every game a way to win AND to lose, title / pause / end screens, sound, a HUD, touch controls), checked against facts of the project, never a declaration. Each defect carries fix { tool, args, note, auto?, credits? }: call it as given. Returns { verdict: complete | playable_with_defects | incomplete, headline, genre, counts, defects, next (ordered calls), sections, text, play_url }. fix=true first applies what is free and safe (the best free Library model on each capsule — rebind at will —, the free standard clips, the suggested control scheme) and reports it in fixes. playtest="run" plays the game headless first (5–20 s); the default reads the last playtest and says when it is stale. Never refuses a write and never spends: paid fixes (a priced model, a rig, a generation) come back with their price to ask the user about. Aim for verdict complete; if you stop before, tell the user exactly what is left. 0 credits.

  shallow
• gripforge_game_broadcast

  Requires the Unity SDK. Currently returns 501. Never runs a shell on the host.

  shallow
• gripforge_game_capabilities

  Start here for an existing project. Report the capabilities a Game Kit project provides, what is still missing for a goal (a preset id from gripforge_gamekit_search or a comma-separated list of capabilities) and which catalogue kits would fill each gap. Call this BEFORE gripforge_gamekit_install to pick the next kit. 0 credits.

  shallow
• gripforge_game_concepts

  Concept art for a whole game, reused before generated. Use it when a user asks for a game "like God of War", "a GTA", "a Zelda": call stage=plan with the game they named. The plan lists concepts that already exist for that game (GripForge community catalog or the workspace) and theme assets already in the library: reuse them first. It then prices the missing concepts: one style bible, heroes and bosses one image each (MOBA and hero games: each hero with its ability kit and ability icons, see hero_kits), enemies, NPCs, weapons, vehicles, buildings, props and VFX in sheets of 6 cut automatically, textures in sheets of 2 turned into seamless 1024 px textures. Maps (counts.maps) are environment paintings, one image each: the level is then built and dressed to match them. Show the plan and price to the user; only call stage=build with a budget after they agree. Concepts are private review images; nothing is sent to 3D. The plan also returns ambient_kits: the kits of the theme's atmosphere (weather, lighting, snow tracks) with their config; install them in the game project next to the blueprint's gameplay kits.

  shallow
• gripforge_game_content

  Journey — the content of the game. Once written, gripforge_game_audit says what a finished game of the genre still lacks (a quest, a way to win and to lose, dialogues…). Read and write the content of a Game Kit project (gkp_…) — what game.engine builds the game from, no engine code needed. kind: archetype (an entity template: kind prop|npc|…, asset { item: lib_… } bound to content:<id> | { slot }, components claimed by kits — see gripforge_game_engine blocks — and gives { quest, offer, progress?, thanks? } for "this NPC gives this quest"), scene (world { kit, config?, doc? }, entries, instances [{ id, archetype, at, yaw?, place?, set? }], zones, layers, ui), script (gripforge.script/1: { id, on: <instance> | archetype:<id> | scene:<id>, rules: [{ when, if?, then, else?, once? }] } with sugars { "interact": "self" }, { "enter": zone }, { "state": { open: false } }, { "quest": id, "is": "completed" }, { "talked": npc }, engine verbs set_state, play_clip, set_solid, show, hide, enable_script, disable_script, load_scene, end_game, call, set_talk and kit verbs as shorthand { "give_item": "key" }), mission (alias quest), dialogue, npc, item, translations, code_module (what game code registers: verbs, components, services, entity kinds), zone, trigger. action=list (kind optional: counts), get (kind, id), put (kind, doc or docs: upsert, validated against the declaring kit schema), remove (kind, id), validate (dry run of a put: the report it would give), place (scene, archetype or asset lib_…, at, yaw?, id?, place ground|none: the placement on the ground is baked once on the server, the same on every engine), bake (re-bake the placements of a scene after its world changed). Writes return the content report after the change; the report never refuses a write — only a document invalid for its schema is. 0 credits.

  shallow
• gripforge_game_creation

  The website and CLI share this saved 3D game creation workflow. Ask which engine (Unity, Godot, Unreal, Three.js) if unspecified; do not choose silently. create saves a brief without spending. quote(operation=plan) estimates AI preparation, accept(quote_token) starts its durable job ONLY after user approval of the shown price. get returns a persistent operation log, slots, studio_url and the same project to resume. Planning can select an appropriate preset OR compose real engine-compatible modules. A missing preset never means the genre needs a native engine. composition.modules pins all module versions; composition.tasks lists the custom logic still to implement. Assembly is a foundation, not a completed custom game: use the coding agent to finish those tasks on the selected engine (including web/Three.js). After a build, get also returns creatures (the models bound so that no unit is a capsule) and audit { verdict: complete | playable_with_defects | incomplete, headline, fixed (the free fixes applied: models, standard clips, control scheme), defects [{ severity, message, fix { tool, args, credits? } }], next }: show the user the verdict and what is left, work through next (gripforge_game_audit reads it again), and never present a verdict other than complete as a finished game. quote refine with message updates the same plan after approval, preserves selected assets and reviewed work, and persists the conversation. use_reference with slot_id and an owned image asset_id supplies an uploaded concept for visual review. assets searches compatible workspace/community items ranked by the brief and role; select chooses one or sets mode=generate with a prompt. For generation: quote concept, obtain approval, accept, poll get, show the concept, approve_concept only after visual user review; quote generate, obtain approval, accept, poll, show the model in its studio, approve_asset only after visual review. Never infer visual approval from technical success. quote build then accept acquires the selected community assets and binds them to a Game Kit prototype, without generating extra assets. With explicit allow_incomplete=true on the build quote, unreviewed models are excluded and missing slots use module defaults where available or remain empty. Show missing_assets before approval; never imply that an incomplete prototype is finished. Native engine projects still need CLI delivery/import; a web project has a play_url. Revision required for edits. Cancel/retry preserve completed steps. 2D unsupported. No automatic spending, invented asset IDs, or unrelated template substitutions.

  shallow
• gripforge_game_engine

  Journey — the build order of the content; its last step is gripforge_game_audit, not "it loads". Read game.engine of a Game Kit project (gkp_…) — a direction, never a gate. action=start (default): the start pack { version, active, structure { engine, kits, content counts, code }, scene, blocks digest, order (scene → playable → assets → archetypes → story → scripts → ui → validate → deliver → code), next [{ step, tool, args, why }], code (where game code goes per engine), rules } and the full content report. action=blocks: the brick catalogue computed from the manifests — entity kinds, archetype components (kit, schema, example), script verbs (conditions / actions with arguments and shorthand), script sugars (interact, enter, leave, scene, talked, quest, state, gives), quest step types, NPC behaviours, worlds, layers, events, variables; scope=catalog adds the bricks of kits not installed (install <kit>). action=report: { ok, errors, warnings, stats } — an error means that piece is left out of the game (the rest plays), a warning that it loads with something missing; each issue may carry a fix { tool, args }. action=next: the next steps only. A game with everything in code is valid: content first, kits second, code for the rest. 0 credits.

  shallow
• gripforge_game_mods

  Journey — while building or after: a packaged way to apply the same extension mechanisms (config, documents, hooks, reactions) as one separable unit — a variant to switch on, content added over the game, a game opened to its players' mods (an option of the developer). gripforge_game_audit then plays the modded game. The mods of a Game Kit project (gkp_…), docs/mods-engine.md: a mod (gripforge.mod/1) is data applied over the project before the kits mount — config keys and collection documents the kits declare moddable (configPatch by dotted path, data.<collection> { remove, patch, add, order }, hooks documents that tap decisions, scripts whose rules react to events) — whole or not at all, never code. The kits are built to be adapted without recoding them — interceptable (hooks), registrable (registries), modifiable (config, documents, patches) and reactive (rules on events that change data): that is the normal, recommended way to build a game, written in the project (see gripforge_game_engine points) or packaged as a mod. A mod packages those changes as one separable unit: a variant to switch on or off (a hard mode, a season event) without copying the project, content added over the game, and — an option of the developer — a game opened to its players' mods. action=list (default): the game policy (config.mods of game.engine: enabled, disabled, order, deny), every mod with its status (applied | disabled | refused) and issues ({ level, code, path, message }), the documents each added, the fingerprint the network handshake compares. action=validate { mod }: a dry run — the project with this mod added (or replacing the one with its id), applied as the host would: its status and issues, nothing written. action=install { mod }: writes it to the mods collection (validated against the mod schema). action=remove { id }. action=enable / disable { id }: the policy list mods.disabled. action=order { ids }: these mods first, in this order (a mod always comes after those it depends on). 0 credits.

  shallow
• gripforge_game_play_url

  Get the browser play URL of a Game Kit project so a human (or a screenshot step) can run its current revision in the web runtime. Reads the project bundle and returns { url, absolute }; absolute is built on the GripForge origin of this key. Call it AFTER gripforge_gamekit_install or gripforge_game_project bind to check the result live. 0 credits.

  shallow
• gripforge_game_project

  Manage Game Kit projects (gkp_…): the container holding installed kits, their lockfile, asset bindings and data collections. action=list lists the workspace projects; create needs name and takes a preset (see gripforge_gamekit_search) or an explicit kits map; get returns the full ProjectDetail (installed kits, bindings, capabilities, missing, playUrl); bind maps asset slots to Library items (lib_…, null to clear); data reads a collection or upserts / removes documents validated against the kits’ schemas (replace=true swaps the whole collection); delete needs confirm=true. Call this first to create or pick the project, then gripforge_gamekit_install. 0 credits.

  shallow
• gripforge_game_test

  Journey — after each change. A playtest that passes is not a finished game: gripforge_game_audit (playtest="run" runs this test) gives the verdict and everything the tester cannot see. Play the project headless and report what works and what is broken. Run it after building or changing a game, before telling the user it is done. An automatic player spawns, walks, follows the mission waypoints, uses what offers a prompt, picks things up and attacks enemies. Probes check each capability the game provides (character control, combat, XP and levels, inventory, interactions, missions, needs, gathering, crafting, building, machines, world counters). Detectors flag a stuck player, unreachable goals, kit exceptions, NaN positions, a player under the ground, enemies that never reach the player, and step time. Returns { summary, text, report, next }: text has one line per result, ✓ pass, ⚠ warning, ✕ failure, · not checked, each with its time, position, entity or kit; "provoked" means the tester set the condition up through the kit service. Fix the ✕ lines first, then run it again. report.notCovered lists the capabilities no probe looks at. report.replay replays the same inputs; pass it back as replay to check a fix against the same run. Deterministic: same project, seed and budget, same report. Runs in the compute service, about 5–20 s. 0 credits.

  shallow
• gripforge_game_theme_from_concept

  Generic concept → theme pipeline for a Game Kit project: the saved art direction (gripforge_game_art_direction: look, theme, palette, notes, device) becomes ONE interface concept image (title, main menu, HUD with health, a weapon card, key prompts), a vision pass reads its design tokens (colour roles, radius, border width, button shape, padding, letter case, weight, the closest open-licence font, glyph style, closest preset) and they are written as the ui.theme config (contrast repaired). The concept is kept in the Library (kind concept, category ui). action=quote prices it: 1 credit per run (quote it and ask the user before run). Without regenerate the latest concept of the project is reused with the tokens already read from it (0 credits), so a run after a dry run applies exactly what the dry run showed; reread=true reads the concept again (1 credit). dry_run=true writes nothing. run returns a generation job: poll it with gripforge_generation_read; its result carries config, tokens, fixes, previous_config and revision_before for a rollback (gripforge_gamekit_configure ui.theme with previous_config).

  shallow
• gripforge_game_web_export

  Journey — last. Run gripforge_game_audit first: export a game whose verdict is complete, or tell the user what is left. Prepare a download manifest for an existing web Game Kit project in the current workspace. Reuses the same player and HUD as hosted play, compiles only installed enabled kit runtimes, and lists the game configuration, static resources and Library assets to download. Does not publish the project or change its visibility. The hosted MCP cannot write local files: use gripforge game-export <project_id> <folder> locally, then npm run dev. The CLI verifies downloads and preserves local edits on updates (--check previews conflicts; --force backs up and replaces edits only when authorized). The delivered versions remain fixed until an explicit export update. Legacy kits and unpublished source overlays cannot be exported. net.* kits still need their online services. 0 credits.

  shallow
• gripforge_game_world

  Read source-linked plans (get), author one (plan), construct actual kit content atomically (build, with plan_id, options and expected_revision; dry_run previews; activate explicitly sets the entry scene), save an input journey (journey), inspect without a run (inspect), or queue a real Bevy input/capture test (test). get section:builder with kit returns the provider options; section:journey returns its schema. Builders belong to kits, never genres. 0 credits. test returns a durable job; AI visual review uses a separately quoted Develop and test pass. Generated content remains unverified. Preserve requirements and existing authored content.

  shallow
• gripforge_game_world_scope

  Read every spatial obligation in the saved game contract (get), or save region/location classifications, hierarchy, entries and intended connections (put). No genre counts. Old contracts need explicit classifications; declared spatial roles cannot be weakened. Regions require real child locations. Construction and verification remain separate. 0 credits; scope writes use project revision checking. Continue with gripforge_game_world build/journey/test.

  shallow
• gripforge_gamekit_api

  The API reference of one Game Kit, as compact Markdown: what it does and when to use it, every config key (type, default, unit, limits; mod = a mod may set it, live = read again while the game runs, scene = a scene may override it), hooks (payload, mutable fields, cancellable), events emitted and listened to (when, payload), web views and HUD vars, services and their methods, script verbs, asset slots, data collections, input actions, mod points, its Bevy presentation module (needs, ABI families, web UI), target parity, changelog, and an example config and an example mod (gripforge.mod/1). Read it BEFORE gripforge_gamekit_configure, before writing a mod (gripforge_game_mods) or hooks / scripts for the kit, and before writing its presentation module. sections narrows the answer (e.g. ["config","hooks"]); full=true adds nested keys, examples of every hook and verb, and the README. 0 credits.

  shallow
• gripforge_gamekit_configure

  Tune an installed kit: merge config values validated against the kit configSchema (read it with gripforge_gamekit_get), or toggle enabled to switch the kit off without uninstalling it. Returns { kit, project } with the new project revision. Call this AFTER gripforge_gamekit_install. 0 credits.

  shallow
• gripforge_gamekit_creatures

  Journey — right after creating or binding: no unit stays a capsule, every model gets its movement and action clips. gripforge_game_audit folds this report with the rest and applies the free steps with fix=true. The living units of a Game Kit project (gkp_…) — player, heroes, enemies, bosses, minions, monsters, NPCs: the creature slots its kits declare. Two rules: NO creature ships as a capsule, and a model ships WITH its animations (movement AND action). action=report (default): every creature slot with its status (bound | fallback = a capsule in game), the model bound, the clips the slot plays (locomotion, action), the ones the model lacks, and its chain (steps: clone | rig | animate | more_clips, each done / running / proposed with its tool, free or its credits). action=propose: ranked Library models for each unbound slot — the workspace first, then the Community — with the reasons of the rank (source, slot and role words, game theme, size, rigged, animated, triangle budget). YOU judge: read the reasons, pick the model that fits the game (any monster beats a capsule), bind it with gripforge_game_project { action: "bind" }; nothing is final, rebind any time. A slot with no proposal at all carries defect creature_no_model: generate a model (paid — quote and ask first), never leave the capsule. action=animate: run the free steps of the chain now for the bound models (a free Community model is copied into the workspace and bound in place of the original; the standard clip pack is retargeted, 0 credits; wait=true waits for the result, else it runs in the background — read report again). action=fill: bind the best free proposal to every unbound creature slot, then animate (what the hosted creation does). Nothing here spends credits: the automatic rig, a priced Community asset and generated motions always come back as proposed steps for you to quote and ask about. Binding a model through gripforge_game_project already starts its chain. 0 credits.

  shallow
• gripforge_gamekit_deliver

  Turn catalogue kits, or the enabled kits of a Game Kit project, into engine files: Godot gets GDScript, scenes and config under gripforge/kits/<kit>/, Unity and Unreal get recipes, web needs nothing. Call with dry_run=true FIRST: it returns the plan (files to add / keep / modify / delete, conflicts, dependencies, post-install steps) and never charges. Pass project_state (the current gripforge/gamekits.lock.json, path → sha256 of the files under gripforge/, engineVersion) so updates keep your edits and detect conflicts. Then call without dry_run to get the bundle. The hosted endpoint cannot write into your project: write bundle.files following plan.actions in order (backup, write, writeBin from bundle.binaries, delete with .uid / .import siblings, writeLock with bundle.lock), or use the npm client with project_dir (gripforge_gamekit_deliver_local), or the editor bridge. A blocked plan answers 409 with the plan: force backs up then overwrites edited files, accept_breaking allows a major update. Credits: the first delivery of a kit major version to an engine costs 1 credit per workspace; re-deliveries, updates within a major, dry runs and the web target are free.

  shallow
• gripforge_gamekit_dependencies

  Dependency graph of a Game Kit project: nodes (installed kits with version, provides, requires), edges labelled by capability, conflicts and unresolved requirements. Pass project_id for the installed graph; pass a kit id instead to read the declared requires / provides tree of a catalogue kit before installing it. Call this BEFORE gripforge_gamekit_remove with force. 0 credits.

  shallow
• gripforge_gamekit_get

  Read one Game Kit: its manifest (provides / requires capabilities, asset slots, data collections, events), README docs, config JSON schema with defaults, and published versions. Pass with_usage=true to also list the workspace projects that have it installed. Call this BEFORE gripforge_gamekit_configure to know which config keys exist. 0 credits.

  shallow
• gripforge_gamekit_install

  Add a modular gameplay kit to a Game Kit project (gkp_…). Dependencies declared in the kit manifest are resolved and added automatically; the response returns the plan (add / upgrade / keep) and the updated capabilities. Pass dry_run=true to preview without writing. Call gripforge_game_capabilities first to see what the project is missing, gripforge_gamekit_search to find the kit, then gripforge_gamekit_configure to tune it. Legacy genre kits (legacy.*) are not installable here — use gripforge_kit. 0 credits.

  shallow
• gripforge_gamekit_installed

  Journey — first on an existing project; gripforge_game_audit then says what stands between it and a finished game. Start here for an existing project. Lists the kits installed in a Game Kit project (gkp_…), first and marked priority: id, name, enabled, addedBy (user / agent / auto / preset / default — the interface kits every new game gets), provides, requires and config, plus the rule that goes with them. Versions are for your information (projects always follow the latest): each kit also has version (in the project), latest, delivered { godot | unity | unreal } (the version the last engine delivery carries — a delivered game can run an older one) and pendingMigrations (manual migrations left to you). Installed kits are choices already made for this game: build on them for what they cover and configure them as needed; search the catalogue only for what they do not cover. 0 credits.

  shallow
• gripforge_gamekit_remove

  Uninstall a kit from a Game Kit project (gkp_…). Refused with 409 kit_in_use while other installed kits still require one of its capabilities; pass force=true to remove it anyway and prune=true to also drop the dependencies nothing else needs. Returns { removed[], project }. Call gripforge_gamekit_dependencies BEFORE forcing to see who depends on it. 0 credits.

  shallow
• gripforge_gamekit_search

  Start here. Search the modular Game Kit catalogue (vehicle.driveable, mission.objectives, npc.wanted, …) by free text, capability, tag or engine target. Pass project_id to score kits against that project: each hit then carries state { installed, updateAvailable, compatible, conflicts, reason } and kits that fill one of its missing capabilities rank first. Returns { kits, presets }; legacy genre kits appear as legacy.* and are installed with gripforge_kit, not here. Kart Racing is native: compose world.racetrack + vehicle.driveable + race.kart; edit race_tracks through project data. world.lighting adds shared sun/fill, point lights and spots, presets, bounded light budgets and bloom; edit world_lights through project data. Call this BEFORE gripforge_gamekit_install. 0 credits.

  shallow
• gripforge_gamekit_update

  Check or apply kit updates in a Game Kit project. Dry-run by default: returns the plan (from / to version, breaking changes, migrations to run) without writing. Pass apply=true to write the new lockfile and run the migrations; range narrows the target version (e.g. ^1.2.0). Omit id to check every installed kit in one call. Call gripforge_gamekit_get on the target version to read its manifest first. 0 credits.

  shallow
• gripforge_generate

  CREATE any mesh asset and save it to Library — the canonical generation door. kind decides the pipeline: character/enemy/boss are auto-rigged (pass concept_item or file_url for image-to-3D; otherwise text-to-3D), weapon and prop are direct text-to-model (no rig, no concept step). The workspace Style DNA is applied to the prompt. If the look may already exist, call gripforge_style_kit FIRST. Costs 10 credits. Returns a persistent job_id immediately; poll gripforge_generation_read for progress and the Library/Studio result. Closing this call does not cancel it.

  shallow
• gripforge_generate_building

  Reusable plan → artistic concept → isolated reference views → review → Meshy or explicitly selected Tripo build workflow. Generate 1–4 images through OpenAI or Imagine; alternate views reference one master but must be checked for actually different viewpoints. If edits repeat the front, use one good concept instead of a false multiview set. Separate explicit budgets for concepts and 3D. Accepts text, owned concept views or a static GLB. Optional delivery preserves the source master and prepares reusable LOD GLBs with PBR and a common metric fit. Durable jobs return workspace links; poll generation_read, cancel/retry preserves finished steps. Review the actual render before publishing. No guaranteed interiors, collisions or runtime LOD switching; no automatic game replacement.

  shallow
• gripforge_generate_character

  CREATE a Mixamo T-pose auto-rigged character, enemy or boss and save it to Library. NEVER describe a handheld weapon, staff or shield in the prompt: characters and enemies are forged empty-handed (the forge enforces it); make the weapon apart with gripforge_generate (kind=weapon) and put it in the hand with gripforge_attach. polycount is honoured (default 8000; keep it at or under 10000 for a mobile game).To sculpt from a picture (image-to-3D): pass concept_item (lib_… from gripforge_concept_correct / character_concepts) or file_url. Without an image this is text-to-3D. If the look may already be in the locker, call gripforge_style_kit FIRST. For knives/guns use gripforge_generate_weapon. Alias of gripforge_generate (the canonical door). Costs 10 credits. Returns a persistent job_id immediately; poll gripforge_generation_read. Closing this call does not cancel it.

  shallow
• gripforge_generate_creature

  Generic animal/alien creature factory, one to eight original creatures per batch. stage=plan quotes concept + Meshy 3D + anatomy vision without paid calls. stage=build requires explicit budget and stable idempotency_key, then generates private meshes and inspectable skeleton overlays. Poll gripforge_generation_read; inspect each preview/profile before stage=rig with generation_job, creature_id, reviewed_anatomy=true and optional corrected profile. Reuses the anatomy-aware Blender rig, never humanoid autorig. Exports GLB, Blender source and diagnostics. Procedural starting clips are drafts; missing fly/swim/action clips are reported. No automatic game-ready approval. Existing owned immutable source/concept revisions can be reused. Use generation_cancel/retry for durable work.

  shallow
• gripforge_generate_district

  Plan then build a straight-street district from 1–8 distinct Meshy/Tripo buildings, each manufactured once and reused as separate editable instances. Includes road, pavements, spawn, daylight and camera in the shared Map SceneDocument. Optional owned PBR road/pavement maps; otherwise simple solid surfaces. Plan returns layout, provider-credit count and account quote without spending. Build requires a budget and returns a persistent job, then Map Studio link. Private work version requiring visual review; no automatic Community publication or game replacement.

  shallow
• gripforge_generate_flexible_weapon

  Persistent concept → isolated handle/segment references → Meshy PBR components → FlexibleChain XPBD → Blender assembly/rig → actual GripForge renderer review. Read flexible_weapon_schema first. recipe stage=concept returns an image before 3D; build can reuse that concept and owned pinned components. Up to 12 existing source clips or sampled motions; character choreography is not generated by this tool. Returns job_id immediately; poll generation_read for weapon GLB, Blender source, physics reports, separate character/weapon review scene and Studio links. Max 23 credits when all art is new; reused components are free. Cancel/retry retains successful provider and fabrication steps. Always private work: no automatic replacement, promotion or Community publication.

  shallow
• gripforge_generate_fp_hands

  Manufacture a NEW fps-arms work asset using the native FPS template: curved hand surface refinement, fitted skinned long sleeves/cuff, optional tactical glove reinforcement and embedded PBR. recipe={version:1,name,quality:high|standard,gloves:tactical|light,sleeves:long|none,colors?:{fabric:#RRGGBB,sleeve:#RRGGBB,trim:#RRGGBB},source?:{assetId,revisionId,fileRole?}}. No source gives standalone hands with native finger rig, hand_item_r/l sockets and existing starting clips. Optional owned immutable native paired source keeps weapon, camera and animation tracks; source must contain FPS_Hands or FPS_Arms_Mesh, all ten native fingers, embedded GLB <=32 MiB. This is template geometry/garment manufacture, not prompt-to-new-anatomy or arbitrary rigging. Returns job_id; poll generation_read. Inspect fingers, seams and weapon/garment contact in the actual renderer before binding. No external provider charge; never auto-promotes or overwrites.

  shallow
• gripforge_generate_prop

  CREATE a game-ready prop GLB (kart, crate, barrel, banana…) and save it to Library as kind=prop. Default Meshy, no T-pose, no biped rig. polycount defaults to 4000. 10 credits.

  shallow
• gripforge_generate_vehicle

  Read vehicle_schema first. Recommended recipe.workflow=body_wheels follows concept → references (five wheel-less body views + wheel) → geometry (stop/review) → topology (stop/review) → build (PBR + wheel + rig). Each geometry review uses scene_review with the returned assetRef and must be approved before the next paid step. Rigging preserves UVs and corner normals, GLB/FBX/Blend and measured Chaos setup. Top view is review-only. parts.body.geometry accepts unfinished Hunyuan/Blender GLB; parts.body.topology pins the reviewed reduced GLB; parts.<role>.source reuses finished meshes. Legacy modular_doors remains available for articulated doors. stage=plan quotes each stage without spending; paid stages require its budget. Durable job; poll generation_read. Work draft, real-render review and target-engine driving test required; no automatic publication/replacement.

  shallow
• gripforge_generate_weapon

  CREATE a game-ready weapon GLB (knife, gun, sword…) and save it to Library as kind=weapon. Default provider Meshy, no T-pose, no biped rig. polycount defaults to 4000. style=melee|gun is written to meta.style for gripforge_attach. 10 credits. Do NOT write one-off Meshy scripts.

  shallow
• gripforge_generate_weapon_catalog

  Plan then manufacture 1–64 original static weapon models using the existing Meshy PBR pipeline. plan is free and returns an exact aggregate quote and plan_hash. build requires that hash, an explicit budget covering the quote and a stable idempotency_key. One durable job, two bounded fabrication lanes, per-weapon checkpoints and billing; cancellation/retry preserves finished work and provider task IDs. Results remain private work assets. Inspect geometry, textures and actual renderer output before publishing. Does not create attack/reload animations, grip bindings, or flexible-chain physics. Poll gripforge_generation_read; result.items contains Library IDs and Studio links.

  shallow
• gripforge_generation_cancel

  Request worker cancellation while retaining completed steps and artifacts. Closing a page alone does not cancel a job.

  shallow
• gripforge_generation_list

  List workspace jobs. Jobs and completed steps survive closing the studio or restarting the web server and worker.

  shallow
• gripforge_generation_quote

  Free quote for a model, concept, texture, rig or animation. Reports the account funding mode, available balance and estimated operation cost. A subscription combines AI and paid asset generation in one monthly limit without also charging generation credits. Quote every missing role, propose the plan, and obtain a generation budget before submitting paid jobs. Estimates cover one operation, not the full concept/rig/review pipeline.

  shallow
• gripforge_generation_read

  Poll a job returned by a generation tool. Includes durable steps, progress, failure/retry state and the resulting work revision with a Studio link. include_preview returns the saved image or all map concept views (at most 4). Set preview_view to return one chosen concept view. Concepts are generated illustrations, not implemented-map renders. Success does not mean visual approval or promotion.

  shallow
• gripforge_generation_retry

  Retry a failed or cancelled job, reusing completed steps. An unconfirmed interrupted provider call may be executed again when explicitly retried.

  shallow
• gripforge_get_completion_report

  Journey — while building: what the contract still misses, leaves unverified, fails or blocks. The genre defects come from gripforge_game_audit. Read the contract, requirements, implementation status, build-specific evidence, blockers and remediation. Without a contract returns the schema and a proposal. 0 credits.

  shallow
• gripforge_get_render_capabilities

  Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

  shallow
• gripforge_hitbox

  Body capsules (head/torso/limbs) plus weapons[] — one reach capsule per gf_prop_ wrapper on a loadout/armed bind. Pass id of a loadout GLB (or character_id / attach_id). 0 credits. Use weapons[] not the single weapon field for dual-wield.

  shallow
• gripforge_hud

  Generate a ready-to-drop survivor HUD: hud.json (layout/anchors, no pixels), original GripForge cartoon PNGs (hearts full/half/empty, portrait frame, currency chips, empty hex slot), a Godot 4 .tscn (Control with named nodes Health/XP/Portrait/Currencies/Minimap), and Three.js / Unity / Unreal snippets. 1 credit per successful generate. CONSUMER RECIPE — (1) call gripforge_hud; (2) write the PNGs (download the asset URLs) + hud.json (+ hud.tscn) into the game repo, same folder; (3) Godot: instance the tscn, add_child, then get_node("Health").set_health(current, max) and set XP.value; (4) Unreal: the GripForgeHUD plugin must already be in the project (unreal_plugin_url) — point UGFHudWidget::CreateFromFolder at the folder and call BindHealth on your health component. DO NOT redraw the hearts. DO NOT open a UI editor. This hosted endpoint returns file CONTENTS + URLs; pass out_dir only with the npm MCP package, which writes the files for you.

  shallow
• gripforge_hud_bar

  Forge an ORIGINAL themed health-bar style: an image model draws the ornate empty frame (transparent background), the inner trough is located pixel-precisely, and a thematic gradient fill is composed to match — returns an aligned frame+fill PNG pair, same contract as the built-in gripforge_hud bar styles. Describe a THEME (e.g. "gothic demon-hunter, baroque metal, horn ornaments"), never a specific game — styles of a genre, not copies. 2 credits. RECIPE: download frame_url + fill_url next to your hud.json ; Godot: TextureProgressBar (texture_under=frame, texture_progress=fill, custom_minimum_size=size) ; Three/Unity: frame behind, fill cropped horizontally to the health percent. Generation has model variance — if the trough is not found, retry with a clearer theme.

  shallow
• gripforge_hud_import

  Not the survivor generator (that is gripforge_hud): this one READS an existing HUD. action=import {text, filename?, name?} → reads the HUD of the project and saves it as a HUD document of the workspace; Pass screenshot (a capture of the screen while the game runs) so My HUDs shows the real thing; action shot attaches one to a HUD imported earlier.returns the studio URL to open it. `text` is the engine file as-is: a Godot .tscn scene, a Unity .uxml (UI Toolkit) or a .unity / .prefab (RectTransforms), the Unreal UMG designer clipboard (select the widgets, Ctrl+C — .uasset files are binary), or a GripForge hud.json / hud.v2.json. Read the file yourself and pass its content; `filename` helps detect the format. Controls are recognised by name (health, mana, minimap, ammo, quest…) and type, placed on nine anchors; the report lists what was created and skipped. action=list → HUDs of the workspace. action=get {id} → one HUD document (hud_… id).

  shallow
• gripforge_input_kit

  Godot InputMap for an FPS: move_forward/back/left/right bound to WASD AND arrow keys, plus jump/crouch/fire/reload/buy. Write res://gripforge/input.json and autoload GfInput (snippet_godot). Player still uses Input.is_action_pressed("move_*"). Optional third_person=true adds portable character-facing JavaScript and a Three.js adapter: movement-facing, independent camera, aim/fire/build facing. Orientation only, not a physics controller. 0 credits.

  shallow
• gripforge_inspect

  THE FEEDBACK LOOP: call this after every generate/attach/rig to SEE and VERIFY what you made, before building on top of it. Deterministic, free, repeatable. Returns (1) a structured report — kind guess, triangles/vertices, materials+textures, skeleton (bones, finger bones per hand, cape grid), animations, size in metres — and (2) QA checks with ok/warn/fail + why: plausible scale, poly budget, normals/UVs, rig skinned, strict T-pose arms, five-finger bones, feet on ground. Also returns a multi-angle render sheet (front/right/back/left by default) so you can look at the asset. Fix warns/fails (regenerate, rest_pose, retarget…) then inspect again.

  shallow
• gripforge_joystick_kit

  Generate input.joystick source files and installation instructions: touch + mouse, independent dual sticks, radial deadzone, continuous holding and release/focus reset. Unreal runtime Pawn component, Godot CanvasLayer scene, Unity UI component, Three.js DOM controls + GripForge input.actions bridge. Feeds the existing movement controller rather than replacing physics, collision or networking. Returns files with relative path/content; the agent writes them into the target project and compiles/tests there. Does not install automatically, modify project settings or claim runtime validation. 0 credits.

  shallow
• gripforge_kit

  A game kit IS an engine: its manifest carries asset slots AND GameRules — the genre as a document (movement, camera, world, objective, entities, pickups, ai, hud, audio). action=list → kits of the workspace. action=get {id} → manifest + rules (lib_… id). action=create {style?, name?, rules?, slots?} → new kit, rules default to the style then merge yours. action=patch {id, rules?, slots?, prompts?, name?} → partial update; rules merge section by section, a section set to null resets it. Slot refs inside rules must point at slot ids of the kit (unknown refs are dropped, the renderer falls back to procedural). Compose a NEW genre by writing rules: e.g. movement vehicle-boost + world arena-ring + objective knockout = sumo cars, no code.

  shallow
• gripforge_level

  Plan a playable level from a prompt (0 credits): rooms placed in metres (entrance, combat rooms, key/lock, boss room, treasure, secret), connections, critical path, shortcuts, and gameplay spawns (player/packs/boss/rewards). Same seed → same level. Pair with gripforge_scene_kit for dressing props.

  shallow
• gripforge_library_get

  Get one Library item (metadata + signed file_url). VFX items also return studio_url to open the editable effect in GripForge, and workspace_id. Pull bytes into a repo with the npm package.

  shallow
• gripforge_library_list

  List items in the GripForge Library locker (characters, enemies, weapons, props, textures, HUD, binds, vfx). Filter by kind and/or game style id (devil-may-cry, genshin…). Same origin as Studio — not a marketplace.

  shallow
• gripforge_library_optimize

  Derive a lighter version of a static model (prop, weapon, equipment, vehicle) for a target: decimated to `triangles`, textures bounded to `texture` px, saved as a NEW Library item linked to its master (meta.lod_of). The master is never changed — generate high once, derive mobile/desktop versions. Wheel pivots and nodes are kept. 0 credits.

  shallow
• gripforge_library_pull

  Return a signed same-origin file URL for a Library item you own (free). This hosted endpoint cannot write into your agent's working tree — use npx @gripforgeai/mcp gripforge_library_pull for that (that is the sync). First clone of a community asset into your locker costs 1 credit.

  shallow
• gripforge_library_push

  Upload a file into the Library locker from a URL (or small base64). Local paths need the npm MCP package.

  shallow
• gripforge_library_tag

  Add a game look (devil-may-cry, genshin…) to tags so gripforge_style_kit can find the item. Does NOT overwrite grip style melee/gun/shield/staff — that stays on meta.style.

  shallow
• gripforge_light_kit

  Moon / sun / candle point lights + fog + environment intensity for a game look, plus a Three.js snippet. 0 credits. Does not generate meshes. Pair with scene_kit placements (candle tags match candelabra xyz).

  shallow
• gripforge_loading_page

  Loading overlay for a game look. Returns html/css/js (Three/web) plus engines.three | godot | unity | unreal. Title is text — do not rasterize. Overlay alone is 0 credits. Pass character_id (lib_… character/enemy/bind) to generate a cinematic 16:9 background still of that character (1 credit). No letters in the still.

  shallow
• gripforge_loadout

  Build a multi-weapon character in ONE call: attaches every prop of every set onto the same rig, names each prop node gf_prop_<slug>_<l|r>, stamps glTF extras { gripforge: { prop, set, hand } } and a scene manifest { default, sets }, then retargets the standard clip pack (animate: false to skip). The engine switches weapons by toggling node visibility — the returned Three.js snippet does it. Example sets: { "sword": [{"prop_id":"lib_sword"}], "guns": [{"prop_id":"lib_gun","hand":"left","style":"gun"}, {"prop_id":"lib_gun","hand":"right","style":"gun"}] }. Credits: one attach per prop.

  shallow
• gripforge_make_seamless

  Turn an image into a seamless (tileable) texture: 50% wrap offset, then the seams are cross-faded in a narrow band — the pattern is PRESERVED, nothing is generated or invented. Pass image_url (https) or texture_id (Library id, lib_…). Optional size forces a power of two (512/1024/2048), resampled before the seam fix. The result is saved in your Library as a texture and its download URL is returned. No credit consumed.

  shallow
• gripforge_map_concept

  gpt-image-2 draws a top-down plan schematic (solid white walls on pure black) + a 3/4 aerial greybox concept render, auto-traces the plan into MapPlan wall boxes and saves both images to the Library. Reuse the traced plan with gripforge_map_plan { item } or https://gripforge.ai/map-plan?item=lib_…&greybox=1. Use when the layout should come from an image instead of the code presets. ~2 images of generation cost.

  shallow
• gripforge_map_generate

  Queue a persistent map job. stage=concept creates a private master overview plus optional views and stops. views: overview,top_down,entrance,objective. All additional views are conditioned on the SAME pinned master; they are illustrations, not exact 3D renders. reference is an environment screenshot for a NEW layout. To add views to an existing concept, pass source_concept instead; the master is kept unchanged and is free. One credit per new image (full new 4-view set = 4); default is overview only. Poll generation_read with include_preview=true to see the views. After the user selects the concept, submit stage=build with the returned concept and a new idempotency key. Build costs 1 credit and is the default for existing callers; legacy concept_item accepts a Library image ID, while concept pins its exact version. wizard: style realistic|stylized|lowpoly|handpainted; world open_world|closed_arena|dungeon|linear|battle_map; terrain auto|plains|desert_canyon|forest|snow|island|volcanic; size small|medium|large; boundary fixed|infinite (open edge, finite terrain); spawn single|teams; teams 2|4; boss,safeZone,extraction booleans. sources selects catalog/workspace/community props. Build uses the common Scene Engine with independent terrain, regions, paths, zones and asset instances. Cancel/retry keeps successful images and billing. No automatic visual validation, promotion or Unreal import.

  shallow
• gripforge_map_import

  Queue a one-time materialization of an owned legacy terrain map into the shared Scene Engine. Preserve the saved spec, seed, resolution, family replacements, placed assets and removed props. Completed jobs return a canonical Studio link; source edits during migration cause a conflict rather than data loss.

  shallow
• gripforge_map_import_unreal

  Queue a persistent import of schema gripforge.unreal-studio-import.v1. Upload files via local gripforge_map_unreal_upload_local or POST /api/v1/maps/import/unreal/assets first. document is a common SceneDocument with workspace-owned immutable assets, separate props, static foliage patches and editable terrain. source={engine:unreal,level:/Game/...,sha256,warnings:[]}. Returns job_id; poll generation_read for studio_url. Always a NEW private work scene; no overwrite, automatic validation or Community publication. 0 credits; storage quota applies.

  shallow
• gripforge_map_import_unreal_schema

  Read the native export → binary upload → persistent map import workflow, limits and explicit conversion caveats. Native extraction requires the local MCP and an installed Unreal editor. Hosted MCP/API consume the resulting portable SceneDocument; they cannot read your local .umap/.uasset files.

  shallow
• gripforge_map_look

  Reproduce a Dust II still WITHOUT copying pixels. Returns camera (pos/target/fov) + volume/prop/wire ids for that shot. shot=shot21a (A site), shot1a (T yard), shot5a (cat). Official URL is a LINK only — never rehost, never Meshy image-to-3d. Pair with gripforge_map_plan + map_props + map_wires. 0 credits.

  shallow
• gripforge_map_plan

  FPS/bomb map in metres. Interprets the overhead as a 3D compound: hollow rooms, corniche/catwalk, A plat + pit, arches/windows, vaulted tunnels, T/CT, sidewalks. Preview: https://gripforge.ai/map-plan?prompt=dust2. Pair gripforge_map_props (crates/cars) + gripforge_map_wires (cables). 0 credits. Not a dungeon — use gripforge_level.

  shallow
• gripforge_map_props

  Dressing for an FPS map in metres: crates (xbox, A default, goose, B big box), doors (mid, long, B), palms at T spawn, barrels, cars. Matches locker props when tagged. Empty slot → generate that prop. Pair with gripforge_map_plan. 0 credits. Preview https://gripforge.ai/map-plan?prompt=dust2

  shallow
• gripforge_map_reconstruct

  Reconstruct an FPS map: collect official stills (HTTPS LINKS, classified by folder) → MapGraph (callouts/chokes) → footprint greybox (no props) → zone parts → camera match → dress. prompt e.g. "Reconstruct map: Counter-Strike 2 Dust II". stage=collect|graph|greybox|zone|validate|capture|dress|all. zone=LONG_A|A_SITE|…. stage=dress keeps greybox volumes and adds original tileable materials + map_props + map_wires (never Valve pixels). Preview /map-plan?prompt=dust2. Dust II is Valve IP — internal greybox benchmark, not a commercial clone. Never Meshy a screenshot, never ingest BSP/VPK. 0 credits. Greybox preview https://gripforge.ai/map-plan?prompt=dust2&greybox=1

  shallow
• gripforge_map_refs

  Look up official in-game stills for a map (Dust II: A, B, mid, cat, tunnels, T yard). Returns HTTPS URLs (Valve CDN). Reference only — do not rehost, do not send to Meshy image-to-3d. Read materials then generate ORIGINAL locker props. live=true HEAD-checks links. 0 credits. Preview https://gripforge.ai/map-plan?prompt=dust2

  shallow
• gripforge_map_schema

  Read the concept-first map workflow, immutable image reference format, costs and an example. Concepts, map work scenes and external engine delivery are separate steps.

  shallow
• gripforge_map_wires

  Sagging electrical cables for an FPS map: spans with two anchors (metres) + sag + strands. Not a generated mesh — GfMap tessellates cylinders (role=wire). Dust II: T yard, cat (shot5a), mid, A. Pair with gripforge_map_plan. 0 credits. Preview https://gripforge.ai/map-plan?prompt=dust2

  shallow
• gripforge_match_create

  Records match.started. Does not spawn a new process. Mutating.

  shallow
• gripforge_match_get

  Read one match record.

  shallow
• gripforge_match_kit

  Party size, teams, maps, ranked flag, join-by-IP. Write res://gripforge/match.json and autoload GfMatch on top of GfNet. GripForge does not host a matchmaking queue. 0 credits.

  shallow
• gripforge_match_list

  Matches recorded for a server (SDK or API).

  shallow
• gripforge_match_stop

  Marks the match ended. Mutating.

  shallow
• gripforge_menu_kit

  Main menu (host/join/quit), lobby listing connected peers where only the host starts, in-game HUD reading replicated state. Pairs with gripforge_net_kit. 0 credits.

  shallow
• gripforge_moba_map

  The map of a moba project as a gameplay plan: bounds, team bases and spawns, 1 to 5 lanes (the minions' paths), structure slots (towers, inhibitors, nexus), jungle zones and camp slots, objective zones, the divider (river: walkable; chasm, lava, void: crossed only at bridges), crossings, bush zones, walls, camera limits and symmetry. action "generate" builds a fair map (mirrored through the centre) from lanes, divider, size, team_size, camps_per_jungle, objectives, bushes, walls and returns it with a playability report; apply: true puts it in the project (moba_maps, the match's map and team size, the camera turn). action "validate" checks a map you pass, or the project's: every lane open end to end, spawns, structures and camps reachable, nothing out of bounds, the declared symmetry respected. action "set" stores an edited map document (refused while it has errors, unless force). action "get" returns the current map and its report. New maps default to style {theme: "sanctum", detail: "high", seed: 11, relief: "landscape"}. action "dress" previews a reusable procedural finish for the current map: jungle plateaus, river banks and paved fords, terraced bases, walkable staircases, carved structures, clustered forests, stone guardians and lilies; apply: true saves only the map document, keeping its lane layout and camera configuration; relief updates the shared terrain mesh, ground queries and stair collisions; landscape is the default, terraced keeps base terraces only, flat keeps a level arena. Themes: sanctum, wildwood, ashen; detail: low, medium, high; seed makes the finish repeatable. Bound Library models and textures take precedence. The scenery kit dresses walls and bushes with the bound models. 0 credits.

  shallow
• gripforge_moba_roster

  Journey — a MOBA needs distinct heroes; then gripforge_game_audit for the minions, towers, jungle monsters and the rest of a finished MOBA. Turn champions into the playable roster of a moba project (preset "moba"). Pass the Library ids of 1 to 10 champions that carry an ability pack (the items made by gripforge_abilities_generate: rigged model + basic_attack and ability_q…r clips). Writes the moba_heroes and abilities collections (ids <hero>__ability_q), binds each champion to moba_hero_<n> and the player's champion (player, else the first) to player_character. Bots play the other champions. Returns the heroes with their attack and Q/W/E/R. Then gripforge_game_play_url to play. 0 credits.

  shallow
• gripforge_motion_generate

  Custom animations generated from text with NVIDIA Kimodo on GripForge's GPU, retargeted onto a rigged Library character (or the UAL mannequin): spell casts, signature attacks, emotes, anything the standard clip pack (gripforge_animate) lacks. Kit mode turns a MOBA hero concept's basic attack and Q/W/E/R into clips in one call. Call stage=plan first (free) and show the prompts and price (1 credit per clip); stage=build queues a durable job — poll gripforge_generation_read with job_id (a cold GPU takes a few minutes). The result is a kind=animation Library item, one clip per prompt.

  shallow
• gripforge_navmesh

  Walkable XZ AABB + circular holes (pillars) for a scene_kit room. JSON the engine clamps against — not a baked .navmesh. 0 credits.

  shallow
• gripforge_net_kit

  GfNet autoload host/join/spawn with server-side hit validation, gf_round.gd for the round + bomb, MultiplayerSpawner/Synchronizer wiring. 0 credits.

  shallow
• gripforge_performance

  Analyze a supplied game performance report, or read the latest instrumented kit capture in your authenticated workspace. Separates frame pacing, measured CPU/GPU work, render counters and stale network snapshots; returns evidence, recommendations and explicit measurement limits. Captures expire after 10 minutes or server restart. Explicit reports are not stored. Does not edit, deploy or automatically fix a game. 0 credits.

  shallow
• gripforge_player_ban

  HIGH IMPACT. Requires the Unity SDK. Currently returns 501. Owner only.

  shallow
• gripforge_player_get

  Read one player session on a server.

  shallow
• gripforge_player_kick

  Requires the Unity SDK. Currently returns 501. Mutating.

  shallow
• gripforge_players_list

  Sessions reported by the Unity SDK. Empty until the SDK calls player.joined.

  shallow
• gripforge_prepare_vehicle

  Durable Blender preparation of an owned static segmented GLB. Map each Door_FL/FR/RL/RR or Wheel_FL/FR/RL/RR to exact mesh node names from the segmentation report. Keeps geometry placement, UVs and PBR; normalizes +Z forward/metres using yaw and length; adds hinge origins, seat/entry sockets and portable GLB open/close/preview clips. Optional hinge coordinates are in normalized vehicle metres. thickness adds an inward door shell, not a full cabin. Optional cuts provide strictly convex door outlines [forwardZ,heightY] and depth [near,far] measured from the centre on that side, in normalized metres. cuts[].meshes restricts each cut to exact exterior/glazing meshes so seats and dashboard cannot be cut. removeMeshes discards explicitly named obsolete trim in the work copy only. Optional clearanceDepthM clears scoped inner walls behind the door skin; trim adds measured body frames, seals and moulded cards below cardTopY. framePoints follows outline in normalized [x,y,z]. Optional trim.fitToSurface projects frames, seals and the inner card onto only the explicitly selected opaque door skin, preserving the supplied outline. attachments adds scoped [min,max] [x,y,z] volumes for mirrors extending beyond the door profile. Blender cuts those explicit profiles while interpolating UVs. Does not infer outlines or guarantee clearance. Returns job_id, new private work GLB, Blender source and animated Studio review link. 0 credits; storage applies. Inspect before replacement.

  shallow
• gripforge_project_get

  Read a dedicated-server project (gpj_…) in the authenticated workspace. Not a Library asset.

  shallow
• gripforge_projectile_create

  ADMIN ONLY. Create an editable 3D projectile: ignition, elemental volume, world-space trail, embers, contact flash, oriented ring and soot. 20 named variants: darts, short bolts, orbs, wisps, carrot rocket, spinning disc, spears, comets, coils and lightning. config.variant selects the geometry, trail and impact; style/color optionally override its palette. Omit variant to retain the original elemental recipe. To save several catalogue entries, pass variants=[IDs] without config/name: one persistent job renders/reviews each item sequentially, preserves completed items on retry and returns result.items. Publication remains explicit. Uses the shared trail and Scene Engine modules. save=true (default) queues persistent rendering/review/workspace save; poll gripforge_generation_read for Library ID and Studio link. save=false returns an unsaved recipe. Bind the resulting VFX to combat.projectiles/projectile_vfx using the Game Kit tools; gameplay speed/gravity/damage stay in the module. Web/Three.js only in v1. Does not install a kit or modify a game automatically. Recipe compilation needs no AI; saved previews use the existing review pipeline. No automatic visual validation.

  shallow
• gripforge_realism_schema

  Read render.realism systems, modes, bounds and immutable-source workflow for an accessible scene.

  shallow
• gripforge_render

  Server-side software preview (PNG) of a Library GLB so the agent can see pose/attach without a browser. Not a path-traced studio shot.

  shallow
• gripforge_render_preview

  Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

  shallow
• gripforge_resolve_requirements

  Resolve the saved contract, transitive capabilities and rules into an inspectable requirement graph. Does not run tests. 0 credits.

  shallow
• gripforge_rest_pose

  Lower the character's arms from T-pose until they would clip THIS mesh (cape/chest/hips), then save an arms-down rest GLB (clip "idle"). Armed binds keep attached weapons in the hands. 0 credits. Attach first, then rest_pose on the bind id.

  shallow
• gripforge_retarget

  Convert animation clips from skeleton A (source_id GLB) onto skeleton B (target_id). Bone-name heuristic (Mixamo / UAL / Tripo). Saves kind=animation.

  shallow
• gripforge_runtime_command

  Queue a versioned GripForge runtime command for the exact browser session. Use inspect, apply_patch, set_relief (off/pom/spom on configured relief surfaces), step (paused only), run_test, play, pause, reset, load_game, unload_game or get_stats. Returns received; fetch the applied receipt with gripforge_runtime_receipt. Preview changes do not persist the project. Unknown kits/components and invalid fields are refused by the Rust core. 0 credits.

  shallow
• gripforge_runtime_receipt

  Read received/applied/rejected status for a Rust preview request, including simulation boundary and revisions. 0 credits.

  shallow
• gripforge_runtime_sessions

  List live Rust/Bevy previews for an authorized Game Kit project. Open the project Rust player in GripForge first. No server-side solo simulation. 0 credits.

  shallow
• gripforge_scene_asset_pin

  Archive the owned Library resource bytes and metadata for use in scenes. Returns assetId/revisionId, capabilities, material/animation names and sockets. Repeating for identical content reuses the archive; it consumes workspace storage only once. Prefers the validated version for insertion; choose version=work to test the draft. Does not approve the asset visually.

  shallow
• gripforge_scene_asset_promote

  Promote only when the exact work revision has a matching trusted review for the current renderer. Existing scene instances keep their pinned revision.

  shallow
• gripforge_scene_asset_review

  Create a shared test scene and queue an independent review of real GripForge captures. Supports meshes, textures and effects. Never promotes automatically.

  shallow
• gripforge_scene_asset_versions

  Read immutable asset work/current pointers and the trusted review of work. Does not create a version.

  shallow
• gripforge_scene_create

  Create a draft scene. Pin Library assets first and use returned assetId/revisionId references. The response contains a GripForge Studio link. Exporting a VFX definition must not include this test scene.

  shallow
• gripforge_scene_kit

  Return locker props for a game look plus a suggested layout (metres, Y-up). Call after style_kit. Empty slots mean generate that dressing prop, tag it, retry. Does not generate meshes.

  shallow
• gripforge_scene_list

  List scenes, work/validated revision pointers and links in the authenticated workspace.

  shallow
• gripforge_scene_modify

  Queue a scoped edit of saved scene nodes or a region. The server derives the allowed scope and preserves locks, gameplay zones, outside geometry and the last validated revision. Blender may fabricate missing assets. The result is a proposal requiring explicit application, never a silently replaced map.

  shallow
• gripforge_scene_optimize

  Queue resumable browser texture variants for a saved scene. Preserve original GLBs, geometry, transforms, PBR, animations and Library heads. Color textures up to 1024px, data maps up to 512px and terrain color up to 4096px; WebP encoding. Saves a new work revision only if expectedRevision still matches. Does not promote validated. Poll generation_read for byte savings and studio_url. 0 credits; storage quota applies. New Unreal imports do this automatically.

  shallow
• gripforge_scene_patch

  Apply insert/remove/transform/replace/update commands atomically. Environment updates can configure shared 3D cloud layers (density, altitude, wind, colour and quality); see gripforge_scene_schema. Replace preserves id, transform, role, materials and attachments, and rejects incompatible named slots. Locked objects cannot be changed. Scope constrains regional edits; read the schema first.

  shallow
• gripforge_scene_promote

  Explicitly promote the latest work revision only if its trusted visual review matches the exact content, dependencies and current renderer. expectedCurrent must match the existing validated pointer or null. No client-supplied approval report is accepted.

  shallow
• gripforge_scene_proposal_apply

  Explicitly accept or discard a proposal after inspecting it. Accept requires expectedRevision to match the exact base and current work revision. Atomic: concurrent changes or discard abort the save. Creates work, never promotes validated.

  shallow
• gripforge_scene_proposal_read

  Read the original scene, proposed document and scoped commands. Use the Studio link to inspect actual rendering before applying.

  shallow
• gripforge_scene_proposals

  List persistent proposals and their base revision, status and descriptions.

  shallow
• gripforge_scene_read

  Read the editable SceneDocument at work, validated, or a numbered revision. Keep work_revision for optimistic writes. Validated can be absent.

  shallow
• gripforge_scene_realism

  Apply reusable architectural surface profiles and GTAO to a saved work scene. Read gripforge_scene_schema.realism first. assignments [{nodeId,material:"*" or a named slot,surface:{preset:preserve|brick|stone|metal|glass,detail:0..1,weathering:0..1,regions:[]}}]; surface:null removes only this local profile. Optional glass regions use explicit normalized mesh-local min/max bounds and interior parallax settings. Never guess masks from colours. ambientOcclusion {enabled,radius:0.02..3 metres,intensity:0..1,quality:low|medium|high}, or null to remove. Preserves transforms, source PBR maps, other instances and validated revisions. Returns Studio link for visual comparison. Optional quality {preset:performance|balanced|quality,resolutionScale:0.5..1,sharpness:0..0.5}, or null to restore the original presentation. Quality supports viewport resolution up to a bounded 4K budget. Optional automotive {look:studio|daylight,quality,lengthM,depthOfField:false,focusDistanceM} explicitly applies a whole-scene look: HDR strip reflections, contact AO, quality and restrained post-processing. Studio replaces an existing HDRI; daylight keeps it. Optional colorGrading/depthOfField overrides or null. DOF is perspective/capture only, disabled with volumetric passes. No generation charge, DLSS or automatic approval.

  shallow
• gripforge_scene_review

  Queue a persistent render and independent visual review of the exact saved work revision. Poll generation_read. This does not promote or replace the validated version.

  shallow
• gripforge_scene_schema

  Start here. Read the shared scene model, kinds, commands, limits and an editable example. Assets are immutable revisions; placed objects are independent instances. Scene saves create work revisions, never automatic visual approval.

  shallow
• gripforge_scene_versions

  Read work/current pointers, immutable revision history and trusted visual review evidence. A rejected or unavailable review does not change the validated version.

  shallow
• gripforge_scene_write

  Save a complete SceneDocument. expectedRevision must equal the latest work revision. A 409 is a real conflict: reread before changing it. Does not change the validated revision or source Library assets.

  shallow
• gripforge_server_create

  Create a dedicated server record. Implemented: Unity+FishNet (Docker demo) and Godot+ENet (real Godot Linux headless in Docker). Unreal returns unsupported. Does not start the process until deploy.

  shallow
• gripforge_server_delete

  HIGH IMPACT. Stops the instance and deletes the server. Requires confirm=true. Owner only.

  shallow
• gripforge_server_deploy

  Create a Docker instance for this server and start it. Local demo uses a real container (python heartbeat unless a custom image is set). Mutating.

  shallow
• gripforge_server_events

  Activity feed: server.created, server.ready, player.joined, match.started, …

  shallow
• gripforge_server_get

  Read one dedicated server, its instance, engine/networking detection and integration status.

  shallow
• gripforge_server_list

  List dedicated game servers in the workspace with current status and latest instance.

  shallow
• gripforge_server_logs

  Stdout/stderr from the runtime provider (Docker logs). Not stored in SQL.

  shallow
• gripforge_server_metrics

  CPU, memory, network counters and player count from the metrics provider.

  shallow
• gripforge_server_restart

  Restart the running instance. Mutating.

  shallow
• gripforge_server_scale

  Update desired max players. Does not resize cloud hardware (Docker provider has no node pool). Mutating.

  shallow
• gripforge_server_start

  Start the existing instance. Mutating.

  shallow
• gripforge_server_stop

  Stop the running instance. Mutating.

  shallow
• gripforge_settings

  The workspace IS the game: genre (cs, mario-kart, arena-car, dmc…), remappable controls (same InputKit as the Godot input.json AND the web players), match rules (rounds/laps/score/timers/ports) and menu options (title, HUD toggles). Once set, every *-kit route called WITHOUT ?prompt= reads them (explicit prompt always wins), and the web players use the same bindings. Call with no args to READ (settings + resolved defaults). Pass fields to MERGE-SET. Pass a section as null to reset it to the genre preset. Set genre at project start, right after gripforge_style.

  shallow
• gripforge_shader_pull

  Pull a catalog shader (id or alias like slash_reveal) for godot | unity | three. Returns file contents + assignment snippet (Godot ShaderMaterial / Unity Material / Three ShaderMaterial). This hosted endpoint cannot write into the working tree — use npx @gripforgeai/mcp gripforge_shader_pull with out_dir for that. v1 pull is free (no credit).

  shallow
• gripforge_shaders

  List shaders from the GripForge catalog (authorized GodotShaders.com mirror). Returns { id, name, engines }. Search q=slash_reveal. Then pull with gripforge_shader_pull. Free.

  shallow
• gripforge_shield_export

  ADMIN ONLY. Compile a shield recipe into reusable native source files for Three.js, Godot 4, Unity or Unreal 5, using the same geometry and shader functions. Returns files keyed by relative path plus install instructions. Write ALL files into a dedicated directory; never overwrite an existing modified package without checking. Includes enable/hit/shatter runtime; no mannequin or preview environment. Native builds require target-engine verification; source export is not visual certification.

  shallow
• gripforge_shield_vfx

  ADMIN ONLY. Create an original editable 3D elemental shield using the shared shield-vfx module: 17 styles, radius/stretch, colours, intensity, quality and seed. Same shaders used in Studio and native exports. save=true by default queues persistent rendering/review/workspace save; poll generation_read for Studio URL. save=false returns an unsaved project. No commercial reference assets, collision or damage. Recipe compilation needs no AI; saving uses the normal VFX review pipeline. Work is not visually validated automatically.

  shallow
• gripforge_style

  The visual identity of the workspace: palette (hex colors), written art direction, and sliders (realism/saturation/edges). Once set, it is AUTOMATICALLY appended to every generation prompt (characters, enemies, props, HUD bars…) so ten assets come out as ONE game — and gripforge_inspect gains a style check flagging assets whose dominant colors drift from the palette. Call with no args to READ the current DNA (+ the compiled prompt block). Pass fields to SET it. Pass extract_from (image lib ids) to auto-build the palette from reference art. clear:true removes it. Set the DNA at the START of a game project, before generating.

  shallow
• gripforge_style_kit

  Resolve a prompt like "Devil May Cry like" / "genshin" to a game-style id, then return the locker kit already tagged with that look: characters, enemies, weapons, props. Call this BEFORE generating when the user wants that game. Reuse the returned Library ids (attach / pull). Only generate if a bucket is empty.

  shallow
• gripforge_terrain_map_use

  Make a map of the terrain studio the world of a game that has the world.terrain kit. Pass map (a terrain studio map id, lvl_…) or scene (a scene id, with terrain when the scene has several terrain nodes). The map is baked once into a file (heights, ground roles, lakes and rivers, vegetation, roads, spawn and objective points) stored in the Library and bound to the terrain_map slot; the project data keeps its reference in terrain_maps. The same file is delivered to Godot, Unity and Unreal with the kit. Buildings and other non-vegetation props, and terrain holes, are not carried yet (counted in map.notCarried). Without a bound map world.terrain keeps generating its world from the seed. 0 credits.

  shallow
• gripforge_test_game

  Journey — after each change, with gripforge_game_test (the headless playtest). Passing tests are not a finished game: gripforge_game_audit, then gripforge_validate_release. Queue validation on the existing durable job worker. Plays the game with its own controls: the suites each kit declares (several clients joining, leaving and coming back, click orders on the ground, an enemy, a door, a chest, a downed ally, held buttons, a player that plays to an ending) and the headless playtest; endings (victory, defeat, boss defeated) come back as events. A real page that reached an ending, its hardware frame rate and the default screens it opened count for this revision. Returns job and status_url; poll that URL with the existing job tools. Simulation is not end-to-end gameplay proof. 0 credits.

  shallow
• gripforge_texture_prep

  Prep a game texture (terrain / props): optional 50% wrap + seam blend, then a faithful lanczos upscale (1× / 2× / 4×, capped at 1024 or 2048). The pattern is PRESERVED — nothing is generated (not Magnific, not an image model). Pass texture_id (Library) or image_url (https). Result is saved as kind=texture and the albedo URL is returned. To write the PNG into an open repo, use the npm package with out_dir. No credit consumed.

  shallow
• gripforge_ui_screen

  Reusable death/victory screen concepts backed by the existing ui.endscreen Game Kit. List four visual templates, validate or export screen.json + a standalone web/Bevy presenter + runnable preview. No credits, no AI image generation. Connect authoritative game events and acknowledge multiplayer retries; a downed player is not a party defeat. Get health PNGs from gripforge_hud.

  shallow
• gripforge_urban_building

  Free, deterministic parametric architecture. plan validates a metric recipe; build queues a durable common-compute job and returns job_id to poll with gripforge_generation_read. Real window reveals, balconies, shopfronts, rooftop HVAC, photographic PBR and optional arid shutters/canopies/water tanks. Private immutable GLB plus recipe/report; reuse via Library bindings or scene instances. Nominal width/depth exclude protrusions: use returned actual bounds and preserve proportions. A solid envelope with storefront depth, not traversable interiors, a complete city or an AI replacement for gripforge_generate_building. Review in the actual game. 0 credits.

  shallow
• gripforge_validate_release

  Journey — last, after gripforge_game_audit says complete. The game is finished only when report.ready=true on a contract that holds the genre requirements; otherwise tell the user what is left and why. Evaluate explicit release blockers for the current build. Only report.ready=true proves all mandatory acceptance checks passed; coverage ratios never override blockers. 0 credits.

  shallow
• gripforge_vehicle_doors

  Save an independent door pose on one prepared vehicle instance in a saved scene. doors maps Door_FL/FR/RL/RR to 0 (closed)..1 (open). Unspecified doors retain their state; null clears the manual pose. Requires exact expectedRevision and named hinges/portable clips from prepare_vehicle. Pauses the global animation for manual control. Preserves the source asset, transforms, other instances and validated versions. Returns the actual Studio link. No generation charge.

  shallow
• gripforge_vehicle_finish

  Repair generated automotive surfaces. Preferred: source (immutable static GLB with Body/Wheel_* groups) + repair recipe queues a persistent Blender job; guided glazing/panel regions, paint cleanup, coloured caliper extraction, measured replacement panels/curves with PBR and fitted boundaries, optional rebuilt wheels and rigid wheel rig. features.marks adds surface-fitted pinned PNG logos, relief badges and mesh lettering; wheel markings follow their wheel, named authored marks are replaced in the new work copy. For grilles or trim on a reconstructed recess, set curves.fitSurface.panel to its non-structural panel name to follow the final part. Returns a NEW private work version with GLB/Blend/optional FBX and GripForge review link. Does not promote or overwrite the source. Regions use +Y up/+Z forward metres, bounded displacement; region-only glass stays opaque, authored transmissive panes need an authored cabin. Poll/cancel/retry generation-jobs. 0 provider credits. Legacy id without repair uses one-time material/wheel finish and rewrites its Library file.

  shallow
• gripforge_vehicle_orient

  Yaw so a kart/vehicle GLB nose is local +Z (Meshy often faces +X). Then heading = yawToward(track tangent) = atan2(fx, fz). Pass Library id of the kart prop. Returns meshYaw + Three.js / Godot snippets. 0 credits.

  shallow
• gripforge_vehicle_schema

  Read the concept-first vehicle recipe, canonical parts, hinge convention, limits, quotes and revision workflow.

  shallow
• gripforge_vehicle_segment

  Quote then queue one durable Tripo v2 semantic segmentation of an owned immutable GLB, including Meshy or Blender sources. stage=plan is free; stage=build requires quoted budget. 40 Tripo provider credits, distinct from the GripForge quote. Returns job_id; inspect parts and texture preservation in generation_read. No automatic completion, retexture, articulation, publication or replacement. A segmented output still needs hinge preparation.

  shallow
• gripforge_vfx

  ADMIN ONLY. Generate + export a 3D slash/thrust/spin VFX parented to an existing attach bind, or a world-space fire meteor (head + ribbon trail + impact). Pass prompt to fill type/style/color/emitters. Returns studio_url (open this link to edit the saved effect in GripForge), workspace_id, GLB, PNG and vfx.json. Refused for non-admin API keys.

  shallow
• gripforge_vfx_generate

  ADMIN ONLY. Text-to-VFX or image-to-VFX: interpret a prompt or reference into an editable animated effect specification. No Library save or credit charge. Pass the resulting type, style, look, color, duration, width, name, emitters and generation to gripforge_vfx to save/export (1 credit). Image mode requires a configured vision provider.

  shallow
• gripforge_vfx_preview

  ADMIN ONLY. Play/scrub pose of a strike VFX at time t (seconds). t=0 is empty. No credits. Arc reveal / trail length / burst particles. Refused for non-admin keys.

  shallow
• gripforge_vfx_project_generate

  ADMIN ONLY. Text/image -> durable generation job -> original geometry/shaders -> actual GripForge rendering -> visual critique/correction -> workspace work revision. Returns immediately with job_id, status_url and studio_url. Poll gripforge_generation_read, then open its source_url to inspect the saved source and review. Closing the request does not cancel the job. Completed steps survive worker restart. Pass id + expected_revision to refine; image_id must belong to this workspace. A visually rejected candidate never replaces the validated version.

  shallow
• gripforge_vfx_project_promote

  ADMIN ONLY. Explicitly promote work after a trusted positive review matching this source, dependencies and renderer. expectedCurrent is the existing validated revision, or null.

  shallow
• gripforge_vfx_project_read

  ADMIN ONLY. Read a project in the authenticated workspace. Returns project.json, per-layer .vert/.frag source, current revision, recent revision history and a Studio link. Read an older revision to restore it through write with the CURRENT expected_revision. Does not grant access to the server repository or arbitrary user files.

  shallow
• gripforge_vfx_project_render

  ADMIN ONLY. Queue a durable render of an owned id OR an unsaved project at 1–4 timestamps. Returns job_id immediately. Poll gripforge_generation_read with include_preview for the actual rendered image, coverage, clipping and shader diagnostics. Uses the shared GripForge SceneViewport. Saves preview evidence only, no project revision. Requires workspace write access because the job and preview consume storage. Render timings are not browser FPS.

  shallow
• gripforge_vfx_project_review

  ADMIN ONLY. Queue a fresh GripForge capture and independent visual review without writing another source revision. Poll gripforge_generation_read; inspect its preview, then explicitly promote if approved.

  shallow
• gripforge_vfx_project_schema

  ADMIN ONLY. Start here to create original VFX beyond presets. Returns the editable source format, shader helpers, geometry budgets and a working example. Workflow: write custom source -> render -> inspect the returned image -> revise -> save. Blender or another modeling tool may supply custom mesh vertices/UVs/indices; no Blender instance is required for procedural effects.

  shallow
• gripforge_vfx_project_write

  ADMIN ONLY. Create with project, or update id with project OR edits:[{path,content}]. Updates require expected_revision. Returns HTTP 202 job_id and studio_url immediately. Poll gripforge_generation_read; the worker compiles, renders and saves a work revision, then reviews it visually. Completed result includes source_url, preview_url and review. Use generation_read with include_preview to see the actual image. A source conflict fails the job and preserves current work; reread before writing. Validated versions remain unchanged. Editable files are project.json and layers/{id}.vert/.frag.

  shallow
• gripforge_viewmodel_kit

  CS-style first-person arms + gun under Camera3D/Hold. Returns viewmodel.json, gf_viewmodel.gd, clip shader. Pull Mixamo T-pose characters (palms down) into bodies paths. Gun is a sibling under Hold, not the world-body hand bone. Pair with gripforge_input_kit. 0 credits.

  shallow
• gripforge_voice_profile

  Reusable voice identities in Community > Audio > Voices and the workspace. list/get return provider, model, voice, tested languages, acting instructions and timed sample ranges in file_url. schema describes the contract. characters reads speakers and revision from an OWNED Game Kit project. To assign, first clone a community voice into the workspace, then supply voice_id, project_id, speaker, language and expected_revision from characters. Optional instructions describe the character acting style. Saves a per-speaker/language snapshot in dialogue.voice voice_cast, preserving other voices and dialogue content. Assignment performs no TTS: bake recordings with tools/dialogue-voice/build.mjs and a matching worker. Per-line emotions use dialogue_voice_directions. Free reads; no GPU rental or automatic generation.

  shallow
• gripforge_weapon_motion

  Queue a persistent weapon-aware motion draft from an owned armed GLB. Axe/hammer get distinct procedural cleave, backhand and overhead attacks; sword uses the explicit UAL sword pack. Staff attacks fail with compatible_motion_missing; no silent sword fallback. Holds Grip finger poses, supports a second-hand anchor with IK. Poll gripforge_generation_read, cancel/retry with generation tools. Returns a NEW work asset and Character Studio URL; never replaces the game/source or visually validates a result. 0 generation credits.

  shallow
• gripforge_weapon_motion_review

  Independently sample the saved weapon-motion GLB at 60 Hz: grip drift, finger pose, wrist rotation, joint discontinuities, second-hand reach and torso overlaps. Reports technicalPassed separately from visualStatus=not_reviewed. Inspect idle, wind-up, impact, recovery and locomotion in GripForge before using the draft. No promotion or mutation.

  shallow
• gripforge_weapon_profile

  Measure an owned armed GLB instance and return its editable weapon/motion profile: explicit family, holding hand, dimensions, grip anchors, handle and cutting-edge axes. Use gripforge_attach first. Default axes are +Y handle and +Z edge; inspect/correct them. Does not mutate the Library source or certify the initial seating.

  shallow
• gripforge_world_backup

  Not implemented. Returns 501. Mutating.

  shallow
• gripforge_world_deploy

  Not implemented. Returns 501.

  shallow
• gripforge_world_list

  Worlds stored for the workspace or a server’s project. Empty until worlds are implemented.

  shallow
• gripforge_world_restore

  HIGH IMPACT. Not implemented. Returns 501.

  shallow

Embed this server’s score

Tool count and median score across every tool in this server’s corpus — honest in a way a single cherry-picked tool’s badge wouldn’t be.

[![Vouch score](https://vouch.tools/api/servers/7a25dbc6-95ad-4c61-af36-af6a5cde99ae/badge.svg)](https://vouch.tools/servers/7a25dbc6-95ad-4c61-af36-af6a5cde99ae)