GripForge

The 241 tools it listed

"Read only" and "Changes data" are the server's own marks. Underlined parameters are required.

1. getAttachmentFrameRead only

   Skeleton attachment frame

   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.

   character_url bodyPart

2. getWearableFrameRead only

   Wearable asset frame

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

   asset_url type side

3. gripforge_abilitiesRead only

   Abilities / skills · three engines

   combat.abilities: inspect schema, get an editable Chrono Crab example, validate a pack or export executable 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.

   action target pack model_asset

4. gripforge_abilities_generate

   Generate hero abilities

   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.

   stage prompt hero_concept_id kit name character_id workspace_id idempotency_key

5. gripforge_ability_vfx

   Give every ability of a game its cast effect

   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.

   project_id replace abilities workspace_id

6. gripforge_admin_assetsRead only

   Platform assets (admin)

   ADMIN ONLY. Every asset of the platform, all workspaces: filter by kind, owner, tag, pack, style, team rating (rating=none is the review queue) or curation (featured, hidden), sort by rating or size. Each row has its team rating (1–5), featured / hidden flags and its mobile rank (0–100). Pass id for one asset in full. Refused for non-admin keys. Change them with gripforge_admin_assets_update.

   id q kind workspace owner published pack tag style rating curation sort dir page size

7. gripforge_admin_assets_update

   Rate, tag and curate assets (admin)

   ADMIN ONLY. Curate platform assets in bulk (up to 200 ids): rate 1–5 (moves the community rank), add or remove a tag, replace the tags of one asset, feature (first in the rank sort), hide (out of listings and search, still served by id), publish / unpublish, file into a pack. Every change is audited with the admin who made it. Find ids with gripforge_admin_assets. Deleting stays in the /admin/assets screen. Refused for non-admin keys.

   action ids rating tag tags pack

8. gripforge_aimRead only

   Aim-offset poses (two-bone IK per hand)

   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 Godot blend snippet. Dual wield ready (independent hands).

   attach_id character_id hands yaws pitches extension

9. gripforge_animate

   Apply standard animation pack

   Retarget the Universal Animation Library pack onto a Mixamo-named Library character/enemy/armed bind. In a Game Kit project gripforge_gamekit_creatures runs it for free on every bound creature, and gripforge_game_audit lists the models still lacking movement or action clips. 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. For captured two-hand saber guards/parries use actions with pack=touche and TC_Saber_* clips from GET /api/v1/animate-pack; retains CC BY 4.0 attribution. Explicit actions replace the preset selection. Saves kind=animation. 0 credits.

   actions character_id archetype slots name

10. gripforge_apply_realism

    Orchestrate scene 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.

    id expectedRevision mode quality lighting nodeIds materials characters environment postProcess workspace_id

11. gripforge_architecture_schemaRead only

    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.

12. gripforge_armor_generate

    Generate a modular armor kit

    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 w

    prompt name pieces coverage textile_color concept_item source_kit character_items polycount idempotency_key workspace_id

13. gripforge_armor_readRead only

    Read a modular armor kit

    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.

    id workspace_id

14. gripforge_armor_repair

    Repair unfinished armor pieces

    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.

    source_job prompt pieces idempotency_key workspace_id

15. gripforge_asset_clone

    Copy a Community asset to the workspace

    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.

    id workspace_id

16. gripforge_asset_searchRead only

    Search workspace and Community assets

    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).

    q kind subtype source limit offset target sort workspace_id

17. gripforge_attach

    Attach weapon to character

    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 Unity / Godot snippets. For melee, provide prop_grip.edgeAxis (signed cutting direction, distinct from the flat normal) and handleSpan (usable handle length). Read bind.orientation and bind.contact; missing or ambiguous measurements remain needs_review. 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.

    character_url prop_url character_id attach_id prop_id prop_id_2 prop_url_2 style hand height_ratio prop_grip style_2 height_ratio_2 prop_grip_2 fist ai_refine export_glb

18. gripforge_audio_generate

    Generate game sounds · Stable Audio 3 Medium

    Generate SFX and ambience with self-hosted Stable Audio 3 Medium, the default sound model. No downgrade to Small. Call action=quote first (no generation/charge), then action=generate with the returned quote_hash and identical inputs. Cost is disclosed in the quote; generation may spend the selected AI allowance or GripForge credits. Returns a durable job_id immediately; poll gripforge_generation_read. Successful takes survive retries as Library audio with prompt, seed, revision and WAV measurements. Optional role assignment uses expected_revision; a conflicting edit keeps takes in Library without overwriting the project. Listen to results: quality and seamless loops are unreviewed. Max SFX 30s, ambience 60s, 1–4 variants, seed increments per take. Music uses its own pipeline; voices use Drama 3 via audio.speech.

    action prompt name subtype duration variants seed loop project_id role weapon expected_revision quote_hash idempotency_key workspace_id

19. gripforge_audio_kitRead only

    Audio kit for a game style

    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 (free unless the creator sets a price in credits) then pull. Free to search.

    prompt

20. gripforge_audit_game

    Game completeness: audit game

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

    project_id workspace_id

21. gripforge_blender_fabricate

    Fabricate editable assets with Blender

    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.

    recipe idempotency_key workspace_id

22. gripforge_boss

    Boss kit (stats + phases + optional mesh)

    Create a playable boss for a game look: stats, phases, attacks bound to anim-pack slots, arena, and 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.

    prompt role character_id generate name provider

23. gripforge_bot_kitRead only

    Server-owned navmesh bots

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

    prompt

24. gripforge_build_deploy

    Deploy a build

    Not implemented. Returns 501 until artifact upload exists.

    id workspace_id

25. gripforge_build_getRead only

    Get a dedicated build

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

    id workspace_id

26. gripforge_build_listRead only

    List dedicated builds

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

    workspace_id

27. gripforge_build_rollbackChanges data

    Rollback a build

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

    id workspace_id

28. gripforge_cancel_render_preview

    Bevy neural preview: 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.

    project_id session_id request_id expected_revision workspace_id

29. gripforge_cape

    Rig a cape onto a character (bones + skinning + spring params)

    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) — 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.

    character_id character_url cape_id cape_url columns rows save

30. gripforge_character_concepts

    Three character / enemy / boss concept pictures

    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).

    name prompt kind weapon n

31. gripforge_complete_game

    Game completeness: 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.

    project_id workspace_id max_attempts idempotency_key

32. gripforge_compute_assetsRead only

    Compute · list assets (deprecated alias)

    DEPRECATED alias of gripforge_library_list with engine=compute (each item carries the same `compute` block) and of gripforge_library_get (its `compute` block: family and edit link). List recent GripForge Compute assets of the workspace (manufactures and variants), newest first, each with asset_id, kind, type, category, tags (engine, recipe, budget, near/scene, materials, style, licence…), needs_rig, level (scene/detail), edit_url and file_url. With asset_id: that asset's family (original + colour/material versions) and its edit link. Free.

    asset_id limit workspace_id

33. gripforge_compute_downloadRead only

    Compute · download a GLB (deprecated alias)

    DEPRECATED alias of gripforge_library_get (same signed library file). Signed-in download link of one Compute GLB (file_url, needs the API key header) and its edit page. Free.

    asset_id workspace_id

34. gripforge_compute_generate

    Compute · generate 3D assets (deprecated alias)

    DEPRECATED alias of gripforge_generate_prop with provider=compute (same request through the single generation door POST /api/v1/generate-asset, same answer); prefer that tool. ON DEMAND ONLY: use when the user asks for GripForge Compute; the default 3D generator stays gripforge_generate_prop without provider. Make textured 3D prop/furniture assets with GripForge Compute from images or text descriptions: one asset (name + prompt or image) or several at once (items, up to 5; each item is one asset, from its prompt or its image). Two steps: stage=quote (free) returns each quote.token and the total price; show it to the user, then stage=generate with the tokens (quote_token, or quote_tokens in item order) and confirm=true launches one durable job per asset, each debited once after success with its own idempotency key. Text assets stop after four reference images (billed on their own): show them to the user, then gripforge_compute_validate with the chosen image (the 3D is quoted then, and b

    stage source name prompt image_base64 items type object_type quality triangles options description auto_pick quote_token quote_tokens confirm idempotency_key workspace_id

35. gripforge_compute_jobRead only

    Compute · follow jobs (deprecated alias)

    DEPRECATED alias of gripforge_generation_read (same GET /api/v1/generation-jobs/:id; that tool returns the same studio_url, attente, validation and result.assets edit_url / file_url). Read GripForge Compute jobs (generations or variants): job_id, or job_ids for several at once. Status (queued, running, succeeded, failed), current stage and stage counts. While the router waits, `attente` = {raison: demarrage_machine | aucune_machine | file | machine_occupee, position, depuis, estimation_s} (a machine start takes about 10 min the first time). On success, result.assets lists the GLBs (scene, detail) with asset_id, triangles, edit_url (open it to edit in the studio) and file_url. Free.

    job_id job_ids workspace_id

36. gripforge_compute_statusRead only

    Compute · router status

    GripForge Compute readiness (free, read-only): whether generation is open, which actions the router can run now (image, text, couleur, matiere) and a machine summary (ready / busy / starting). The router rents and stops its own machines; nothing is started by this call.

37. gripforge_compute_validate

    Compute · validate or regenerate text images

    A text generation of GripForge Compute stops after its four reference images (gripforge_generation_read shows validation.etat en_attente and images[{stage, url}]). Show them to the user, then: image=1..4 to turn that image into 3D (stage=quote returns the 3D price; stage=generate with quote_token and confirm=true launches the 3D job, billed when finished), or regenerate=true (optionally with a new prompt) for four new images, billed again on their own, or abandon=true (only the images were billed).

    job_id image regenerate prompt abandon stage quote_token confirm idempotency_key workspace_id

38. gripforge_compute_variant

    Compute · colour, material or polygon variant

    New version of a Compute asset, on demand: kind=couleur (value #RRGGBB, recolours the main material), kind=matiere (value: a few words, e.g. "green velvet"; the texture is redone) kind=retexture (value: a style for the whole asset, same mesh and UVs, e.g. "painted blue wood, worn") or kind=budget (change the polygon count: value bas | moyen | haut relative to the current one, or an exact « near » triangle count 500–200000; the « scene » GLB gets half; refused as coming soon until the router supports it). stage=quote (free) returns quote.token; after the user accepts, stage=generate with quote_token and confirm=true launches one billed job. Poll gripforge_compute_job; new assets come back with edit_url. Painted-area edits need the studio brush: give the user the edit_url.

    asset_id kind value stage quote_token confirm idempotency_key workspace_id

39. gripforge_concept_correct

    Correct a character concept

    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.

    file_url clothes cape notes name

40. gripforge_configure_render_preview

    Bevy neural preview: 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.

    project_id session_id request_id expected_revision mode workspace_id

41. gripforge_creature_analyze

    Creature rig · detect anatomy

    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.

    workspace_id name idempotency_key source_id kind

42. gripforge_creature_rig

    Creature rig · manufacture

    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.

    workspace_id name idempotency_key analysis_job profile reviewed_anatomy allow_rerig

43. gripforge_creature_rig_schemaRead only

    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.

44. gripforge_debug_sessionsRead only

    Live game tabs for the debug inspector

    List the play tabs of a game that a member of the workspace has open right now (heartbeat within 30 s; closed tabs are gone): session id, last seen, viewer role, engine, backend (webgpu/webgl2) and render thread (worker/main). The first is the default target of gripforge_debug_snapshot / gripforge_debug_set. Empty: no tab is open, and the debug tools answer at once that no game tab is open. 0 credits.

    project_id workspace_id

45. gripforge_debug_set

    Drive the debug inspector of a running game

    Send ops of gripforge.debug/1 to the debug inspector of a game open in a browser by a member of its workspace, then read the snapshot: { op: "mode", wireframe?, colliders?, bounds? } (wireframe, collision boxes, mesh bounds), { op: "tree", root?, depth?, maxNodes? }, { op: "select", ids }, { op: "hide", id, hidden }, { op: "outline", id, on }, { op: "reset" } (show everything, no outline), { op: "extension", id, on } (a debug mode of a kit, e.g. ai.navigation.paths), { op: "open" } / { op: "close" } (the panel on screen). Ids are those of the snapshot tree. Nothing is saved in the project. Same rights as the panel: members of the workspace. 0 credits.

    project_id session_id ops wait_seconds workspace_id

46. gripforge_debug_snapshotRead only

    Debug snapshot of a running game

    Read the debug inspector of a game open in a browser by a member of its workspace (the play page, Bevy player): frame rate and frame time (p50/p95/p99, worst, slow frames, stages of a frame), GPU and backend (webgpu, webgl2, vulkan, dx12, metal…, software rasteriser or not), draws, meshes, triangles, materials, lights, textures and their memory, entities, memory; the modes (wireframe, colliders, bounds), the selection, hidden and outlined nodes, the debug modes the kits registered and their data; with tree=true the scene tree (scenes, nodes, meshes with vertices / triangles / material, world boxes) within depth and max_nodes. JSON contract gripforge.debug/1, identical on every engine. The inspector is open to everyone by default; a game where the developer turned it off (kit debug.inspector config enabled: false, set with gripforge_gamekit_configure) answers "not open to this viewer". Use it to find why a game is slow or wrong before changing it. Same rights as the panel: members of th

    project_id session_id tree depth max_nodes wait_seconds workspace_id

47. gripforge_define_game

    Game completeness: define game

    Journey — once the user's game is understood (any game: no character, enemy, level, ending or known genre is required). Record what the game contains; for a known genre, its definition of done and the common frame (title / pause / end screens, sound, HUD, touch controls, a way to win or lose when the game has an end) are proposals to offer, recorded when the user takes them. Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. 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.

    project_id workspace_id contract expected_revision

48. gripforge_docsRead only

    GripForge docs (offline)

    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, unreal, desktop, rooms-server, central-server, c-api, lod, shadows, collision, render-lod, render-optimize, core-loop, local-project, game-plan, warnings, physics-async, structs, net, web-multiplayer, scenes, input, combat, character, enemies, npcs, quests, inventory, economy, vehicles, puzzles, sport, ui-webui, ui-screens, world-terrain, minion-waves, game-cinematic, debug-inspector, world-environment, hud, audio-core, i18n-text, save-persistence, settings-graphics, asset-preload, ai-navigation, fx-kits, glossary, kit-api, third-party, player, render-budget, scene-optim, porting, game-schema, module-calls, module-calls-native, godot-host,

    topic section full workspace_id

49. gripforge_environment_module

    Create a reusable 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.

    stage recipe name workspace_id

50. gripforge_facial_rig

    Facial rig · inspect and prepare dialogue

    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.

    action source_id node prepare_mouth profile name idempotency_key workspace_id

51. gripforge_flexible_chain

    Simulate and bake a 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.

    recipe idempotency_key workspace_id

52. gripforge_flexible_chain_schemaRead only

    Flexible chain recipes and examples

    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.

    workspace_id

53. gripforge_flexible_weapon_schemaRead only

    Flexible weapon manufacturing recipes

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

    workspace_id

54. gripforge_fontRead only

    HUD webfont + rank copy

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

    prompt

55. gripforge_formatsRead only

    Supported formats

    List the mesh formats and grip styles GripForge supports.

56. gripforge_fp_hands_schemaRead only

    First-person hand manufacturing contract

    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.

    workspace_id

57. gripforge_fps_animation

    Author first-person weapon rigs and materials

    Queue a persistent FPS work asset. Pistol recipe: {version:1,preset:"pistol",name:"Pistol FPS",tempo:1}, tempo 0.7–1.3; manufactures paired arms and articulated pistol clips plus .blend in Blender. Materials recipe: {version:1,preset:"materials",name:"Tactical gloves",source:{assetId,revisionId},node:"FPS_Hands",materials:{map:{assetId,revisionId},normalMap?:{assetId,revisionId},roughnessMap?:{assetId,revisionId},normalScale:0.35,roughness:1,metalness:0}}. Upload and pin owned textures first; they must match source UVs. Select one exact skinned node; other nodes, geometry, fingers and clips stay intact. Normal is OpenGL +Y; grayscale roughness reads G and requires metalness=0 (skin/fabric). Sources <=32 MB, images PNG/JPEG/WebP <=16 MB and 4096 pixels per side. Materials authors a reusable GLB variant, not new hand anatomy or a new .blend; no provider charge. Returns job_id: poll gripforge_generation_read for private Library ref, report and FPS Studio link. Never automatically validate

    recipe idempotency_key workspace_id

58. gripforge_fps_kitRead only

    Tactical FPS engine

    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.

    action target kit_id rules map asset_slots

59. gripforge_game_app_icon

    Generate or reuse the app icon of a game

    One original square icon from the saved game art direction, delivered as PNG, macOS ICNS and Windows ICO in the Library. get returns the latest complete pack. quote prices generation; run queues it after the quoted cost is accepted. Existing icons are reused for free unless regenerate=true. Poll the returned job with gripforge_generation_read. Use files for direct and Steam builds; Steam store artwork is separate.

    project_id action expected_revision regenerate idempotency_key workspace_id

60. gripforge_game_art_direction

    Read or update the shared art direction of a game

    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.

    project_id action expected_revision art_direction workspace_id

61. gripforge_game_asset_planRead only

    Audit project asset roles or search compatible candidates

    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.

    project_id slot q source limit workspace_id

62. gripforge_game_audio

    Game audio · effects, weapons, music and ambience

    Read and configure the existing audio.core of an owned Game Kit project. get returns revision, role catalogue, sources, procedural/silent roles, weapon shot overrides, bus defaults, music states/playlists, event cues and broken references. It is a configuration audit; playback stays unverified until heard in the player. configure merges only supplied roles/weapons/volumes/fade and requires expected_revision from get. dry_run previews the same validated result without saving. Preserves other sounds, custom cues, spatial areas and Rust acoustic geometry. Search Library audio first; never use a sound effect as music. No generation, GPU rental, asset purchase or credit charge. Voice identities use gripforge_voice_profile and dialogue.voice; bake audio.speech through Drama 3, English by default.

    project_id action roles weapons volumes fade expected_revision dry_run workspace_id

63. gripforge_game_audit

    Audit a game: what is left before it is finished

    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 core loop rule: an explicit game tick by genre — content.core_loop:tick, fixed for free by fix=true; the source checks are gripforge_core_loop_check), the last headless playtest (failures, warnings, the keys / models / animations probes, the checks of what the game chose — promised gestures, fullscreen, right button, pointer capture, texts —, capabilities no probe covers), the frame rate measured in a real page (sections.fr

    project_id fix playtest brief workspace_id

64. gripforge_game_broadcast

    Broadcast to a match

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

    id message workspace_id

65. gripforge_game_capabilitiesRead only

    Capabilities report of a project

    Journey — while composing; gripforge_game_audit includes this report, with the creatures, the controls, the playtest and the definition of done of the genre. 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. The installed kits (gripforge_gamekit_installed) come first; call this BEFORE gripforge_gamekit_install to pick the next kit. 0 credits.

    project_id goal workspace_id

66. gripforge_game_concepts

    Game concepts

    Concept art for a whole game, reused before generated. Use it when a user asks for a game like a title they name: call stage=plan with the game as they wrote it. When the user describes specific items (heroes, weapons, props…), pass them in wishes: they are drawn exactly as asked. 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

    stage game custom counts wishes hero_kits provider budget workspace_id idempotency_key

67. gripforge_game_content

    Drop content into a game: scenes, archetypes, scripts, quests…

    Journey — the content of the game, as data (documents, config), never as code. Once written, gripforge_game_audit lists what a game of its genre usually has, as proposals (a quest, a way to win or lose, dialogues…) Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. 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,

    project_id action kind id doc docs scene archetype asset at yaw place set dry_run workspace_id

68. gripforge_game_creation

    Prepare and resume a game

    The hosted orchestration for creating and continuing GripForge games from the web or terminal, one way among others (a Game Kit project made directly, the user's local project with gripforge game-attach, parts written by the user's AI: all welcome and mixable). Any game is accepted: no character, enemy, level, ending or known genre is required. The server owns planning, fabrication, development, checkpoints, budgets and verification of its own tasks; while one runs, do not run a second copy of it locally. If an existing creation id is supplied, get it and resume that exact project, never create a replacement. Ask which engine (Bevy (the GripForge player), Godot, Unity or Unreal) if unspecified and no engine project is in the folder of the user (project.godot, Unity ProjectSettings, an Unreal .uproject, a Bevy crate: then that engine); do not choose silently. A local project is never exported: once built, gripforge game-attach <gc_id|gkp_id> <folder> brings the game into it, whatever th

    action id expected_revision first_game prompt engine platforms slot_id mode asset_id operation quote_token geometry_mode geometry_sources production_source resume_token message allow_incomplete player_accounts plan_document suggestions workspace_id other_styles source q

69. gripforge_game_engineRead only

    The engine of a game: structure, bricks, report, next steps

    Journey — the build order of the content; its last step is gripforge_game_audit, not "it loads". Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. 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, sce

    project_id action scope kit scene workspace_id

70. gripforge_game_host_provides

    Capabilities the game serves itself

    Declare that the GAME serves a capability itself instead of a kit (GameProjectDoc.hostProvides), as the engine host serves physics.character: the user's own Godot / Unity / Unreal / Bevy terrain answers world.ground, its own camera camera.*… With the declaration the kits that require it keep working without a provider kit (none is added, none is removed with its dependents) and remove_kit removes that provider kit ALONE in the same revision. The game must then serve it at run time (GDScript host.provide_service("world.ground", obj), Unity Provide, Unreal ProvideService, C gfk_provide, Rust Host::provide — gripforge_docs topic engine-interop); a kit that asks it before it is served logs a warning naming it. Without add/remove it lists { hostProvides, hostable: { <kit>: capabilities the game could serve in its place } }. remove withdraws a declaration: the default provider kit comes back. dry_run=true previews. Then re-run game-attach in the engine project. 0 credits.

    project_id add remove remove_kit prune dry_run reason workspace_id

71. gripforge_game_mods

    Mods of a game: list, validate, install, enable, order

    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_

    project_id action mod id ids workspace_id

72. gripforge_game_play_urlRead only

    Play URL of a Game Kit project

    Journey — to look at the running game. Share it as finished only when gripforge_game_audit says complete and gripforge_validate_release says ready; otherwise say what is left. 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.

    project_id workspace_id

73. gripforge_game_project

    List, create, read, bind, feed, set the controls of or delete Game Kit projects

    Journey — create (or reuse the user's project), then bind a model to each creature slot the game has (get carries the creatures report) and set the controls: action=controls applies the control scheme of the gameplay, a proposal to adapt. Before telling the user the game is done: gripforge_game_audit Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. 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; adventure is the reference game of game.engine) or an explicit kits map — every new project gets game.engine first (the engine of the game: scenes, archetypes, scripts, life cycle; its answer carries the engi

    action project_id name preset kits target bindings collection documents remove replace scheme dry_run force reset controls logic confirm workspace_id

74. gripforge_game_publish

    Publish a game (preview or release) or take it offline

    Publish the Game Kit project so its play link opens without an account, and start its online server if the game is online (same API as the Publish button and `gripforge game-publish`). mode=preview shares a TEST build: no release checks (completion, animation proof), the project is marked preview; use it to let testers join an online game before it is release-ready. mode=release (default) runs the release checks and refuses with the blockers if the build is not ready. unpublish=true takes the game and its online server offline (mode is ignored). Needs an editor role on the owning workspace. Returns published, publicationMode and playUrl. 0 credits.

    project_id mode unpublish workspace_id

75. gripforge_game_releases

    Game releases · desktop updates and Steam

    Read immutable game release history and stable/beta channel revisions; obtain a snapshot fingerprint for an exact saved project revision; register a prepared signed release; or promote its build ID with expected_revision from history. Direct Windows/macOS updates use the signed launcher feed. Steam builds use SteamPipe and are promoted in Steamworks separately. Registering never promotes. Use gripforge game-release prepare/finalize/publish locally for packaging, signatures and binary uploads; game-release steam-upload uses an already authorized local SteamCMD account. Never send a signing private key or Steam password to this tool. A missing artifact returns warnings and preserves the current channel.

    project_id action revision build_id channel expected_revision manifest public_key workspace_id

76. gripforge_game_scenes

    Scenes and levels of a game: list, create, order, link, assets, load plan

    The scenes and levels of a Game Kit project (gkp_…), game.engine 1.7 — use this tool, never code a scene manager. A scene has a kind: interface (no world: title, main menu, credits — kits build nothing, the renderers draw no world), 2d, 3d (default), loading (shown while the next scene loads), cinematic; a role: menu (entered first, Play leads on), level (levels follow the order), credits, other; next (the scene that follows: Play from the menu, the end of a level, the script verb next_scene); loading (how it shows when its files are not ready — on demand: preloaded or cached files go straight in, a screen comes up only after sceneFlow.showAfterMs; overlay = ui.menu's loading screen with the real asset.preload progress, none, background = the scene left stays until this one is ready, or a scene id: a loading scene or an interface scene of the game); loadingScreen { image, tips, background, title } (several screens per game: one per scene, or flow.loadingScreen); background { image, vid

    project_id action id scene kind role title next loading background world at set ids files dry_run workspace_id

77. gripforge_game_testRead only

    Playtest a Game Kit project

    Journey — after each change: it also checks what the game chose (its scheme's gestures, fullscreen, right button, pointer capture, texts against the bindings). 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. Then it checks the game on what it CHOSE, on a fresh run (

    project_id budget_seconds seed replay lang workspace_id

78. gripforge_game_theme_from_concept

    Fill the game interface theme from a generated UI 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,

    project_id action expected_revision regenerate dry_run reread workspace_id

79. gripforge_game_web_export

    Prepare a standalone local web game

    Journey — last, and never for a local engine project (gripforge game-attach works in it). Run gripforge_game_audit then gripforge_validate_release first: export a game whose verdict is complete and whose release is ready, or tell the user what is left. Not for a local engine project: when the game's Godot project already exists on the user's machine, do not export it — attach GripForge to it with the CLI, gripforge game-attach <project_id> <project folder> (addon gripforge_kits + game under gripforge/, never its project.godot, scenes or scripts); Unity / Unreal: gripforge_gamekit_deliver in place. A native project's answer carries notices [{ code: export_not_needed, howToFix }]: follow it. If game-attach reports manual_setup_found, follow its howToFix before any --force. Prepare a download manifest for an existing 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, stat

    project_id workspace_id

80. gripforge_game_world

    Level plan and world review

    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. 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. 0 credits.

    project_id action plan_id section kit options journey dry_run activate idempotency_key plan expected_revision offset workspace_id

81. gripforge_game_world_scope

    Spatial production queue

    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. Scope writes use project revision checking. Continue with gripforge_game_world build/journey/test. 0 credits.

    project_id action scope expected_revision offset workspace_id

82. gripforge_gamekit_anim_layers

    Animation layers: what an action keeps or blends of the body, and of the movement

    The animation layers of the characters of a Game Kit project (gkp_…), part of the generic animation layer of the kits (module-kits packages/gamekits/src/runtime/anim-layers.ts, mixed in Rust by the players: Bevy on the web and natively, libgfkits for Godot / Unity / Unreal). An action (attack, heavy_attack, punch, kick, ability, shoot, reload, throw, block, emote, interact, hit, body) plays on the parts of the body its layer takes over the locomotion, which keeps the rest: attacking while running keeps the legs running and the player moving. Defaults: a one-hand attack while moving = upper body (legs and hips to the locomotion, waist blended), standing still = whole body; movement free. NEVER recode a blend of animations, a bone mask or a movement lock in game code: set the layer here. action=table (default): the masks (full, upper, torso, lower, legs, arms, arm_right, arm_left, head, upper_right, upper_left; regions hips, spine, chest, head, arm_l, arm_r, leg_l, leg_r), the action fam

    project_id action kit key layer reason workspace_id

83. gripforge_gamekit_apiRead only

    API reference of a Game Kit

    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.

    id sections full workspace_id

84. gripforge_gamekit_configure

    Configure an installed Game Kit

    Journey — while composing, and to fix what gripforge_game_audit reports (its defects carry the exact config to write). Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Tune an installed kit: merge config values validated against the kit configSchema (read it with gripforge_gamekit_get), or patch the config as a document (patch: set a nested key, add / change / remove one element of a list without rewriting it), or toggle enabled to switch the kit off without uninstalling it. Configure installed kits freely rather than recoding what they do (game.engine: startScene, startEntry, flow.title, story flags). The interface look of a game is ui.theme: set preset (scifi-lowpoly, military, fantasy-medieval, cyberpunk-neon, cartoon-bright, horror-dark, minimal-clean, retro-pixel) for a complete

    project_id id config patch enabled confirm reason workspace_id

85. gripforge_gamekit_creatures

    Creatures of a project: a model and its animations for every unit

    Journey — when the game has creatures, right after creating or binding: no unit stays a capsule, every model gets its movement and action clips (read from its passport, never named in code). 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

    project_id action slot slots limit wait brief workspace_id

86. gripforge_gamekit_deliver

    Deliver Game Kits into an engine project

    Journey — kits into a local engine project, in place (with the CLI: gripforge game-attach <gkp_id> <folder>, Bevy, Godot, Unity or Unreal; never an export); a final delivery is last. Run gripforge_game_audit then gripforge_validate_release first: deliver a game whose verdict is complete and whose release is ready, or tell the user what is left. Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. 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 gets an embedded UPM package plus C# files and Unreal a Blueprint-first plugin for every kit with an engine delivery (gameplay and net.* kits; recipes otherwise), web needs nothing. Kits always deliver at their latest version; a kit the proj

    target kits project_id mode project_state dry_run force workspace_id

87. gripforge_gamekit_dependenciesRead only

    Dependency graph of a project or kit

    Dependency graph of a Game Kit project: nodes (installed kits with version, provides, requires), edges labelled by capability, same-scene overlaps (conflicts: several enabled providers of one exclusive capability) 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.

    project_id id workspace_id

88. gripforge_gamekit_getRead only

    Read one Game Kit

    Read one Game Kit: its manifest (provides / requires capabilities, asset slots, data collections, events), README docs, config JSON schema with defaults, version and changelog (information only: projects always run the latest version), and summary { tagline, tags, targets, status, cover, coverUrl } with the featured image URL. 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.

    id version with_usage section workspace_id

89. gripforge_gamekit_install

    Install a Game Kit into a project

    Journey — while composing. A kit installed and left empty is not done (audio.core without a sound, ui.endscreen without an end condition): gripforge_game_audit names them. Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Add a gameplay kit (a brick) to a Game Kit project (gkp_…); installing marks that the game uses it. Decide it yourself, no confirmation needed. Always the latest version; dependencies are added automatically and listed in added [{ kit, version, requiredBy, capability }] (e.g. game.engine for a kit that requires it). A kit that looks with the mouse (first person, third person, shooters, vehicles, mounts) also brings its companion input.pointer_lock (mouse capture) the first time it is added — listed in added with reason "companion of …"; keep it unless the user wants

    project_id id pack existing config dry_run allow_planned reason workspace_id

90. gripforge_gamekit_installedRead only

    Installed kits of a project (use these first)

    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.

    project_id workspace_id

91. gripforge_gamekit_removeChanges data

    Uninstall a Game Kit from a project

    Uninstall a kit from a Game Kit project (gkp_…). Remove a kit the user installed (addedBy user in gripforge_gamekit_installed) only when the user asks. game.engine (the engine of the game) and the default kits (ui.menu, input.remap, settings.graphics, ui.prompts, ui.endscreen, save.persistence, audio.core, i18n.text, ui.theme, input.virtualpad, display.fullscreen, asset.preload, asset.cache, ai.navigation on web, addedBy default) are removed only when the user explicitly asks — never to "clean up". A kit other kits depend on, and game.engine always, is not removed by a first call: it answers 409 (kit_in_use, or confirm_required) with details { dependents, confirm } — nothing applied; show the user the dependents, then call again with with_dependents=true and confirm=<token> to remove the kit and its dependents together (the token is bound to the project revision). dry_run=true returns the plan, the dependents and the token without writing. force=true (legacy) removes it and disables it

    project_id id dry_run with_dependents confirm force prune host_provides reason workspace_id

92. gripforge_gamekit_searchRead only

    Search the Game Kit catalogue

    Journey — first: analyse the project or the plan, then recommend the kits that fit, each with what it brings, and offer to plug them in ("these kits would help: shall I plug them in?"); never impose them. A preset of a known genre has a `done` list: proposals of what a finished game of that genre usually has, recorded in the contract (gripforge_define_game) when the user takes them; gripforge_game_audit checks what was chosen at the end Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. 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, enabled, fills, reason } and kits that fill one of its mis

    q capability tag target project_id limit workspace_id

93. gripforge_gamekit_update

    Bring Game Kits to their latest version

    Projects always follow the latest version of their kits: the studio updates them automatically when a project is opened. Use this to do it now. Dry-run by default: returns the plan (from / to version, migrations). Pass apply=true to apply it. A migration with auto=false is never applied by itself: it is your task — apply its note (config, data) then call again. Omit id to check every installed kit. 0 credits.

    project_id id apply workspace_id

94. gripforge_generate

    Generate a game asset — one door for every mesh kind

    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.

    idempotency_key prompt kind provider engine rig name polycount underwear concept_item file_url

95. gripforge_generate_building

    Generate a 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.

    stage budget workspace_id idempotency_key recipe concept_provider concept_presentation concept_reference concept_views

96. gripforge_generate_character

    Generate a ready-to-use 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.

    idempotency_key prompt provider engine rig name kind polycount underwear concept_item file_url

97. gripforge_generate_creature

    Creatures · plan, generate and rig

    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.

    stage recipes concept_provider budget idempotency_key generation_job creature_id profile reviewed_anatomy allow_rerig workspace_id

98. gripforge_generate_district

    Generate a 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.

    stage budget workspace_id idempotency_key recipe

99. gripforge_generate_flexible_weapon

    Generate an articulated 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.

    recipe idempotency_key workspace_id

100. gripforge_generate_fp_hands

     Generate dedicated first-person 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.

     recipe idempotency_key workspace_id

101. gripforge_generate_prop

     Generate a prop (Meshy)

     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. Quoted against the shared subscription, or 10 GripForge credits if it cannot cover the complete operation. Returns a persistent job_id immediately; poll gripforge_generation_read, then download and import the completed model. provider=compute (GripForge Compute, only when asked): stage=quote (free) then stage=generate with quote_token + confirm=true; router type, size, several assets (items), text → four images to validate (gripforge_compute_validate) unless auto_pick; returns studio_url.

     idempotency_key prompt name polycount provider engine concept_item concept_items meshQuality optimize stage source image_base64 items type object_type quality triangles options description auto_pick quote_token quote_tokens confirm workspace_id subtype

102. gripforge_generate_vehicle

     Generate a vehicle from reviewed multi-view references

     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.

     stage recipe budget idempotency_key workspace_id

103. gripforge_generate_weapon

     Generate a weapon (Meshy)

     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. Returns a persistent job_id; poll gripforge_generation_read. Do NOT write one-off Meshy scripts.

     idempotency_key prompt name polycount style provider engine

104. gripforge_generate_weapon_catalog

     Generate a weapon catalogue

     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.

     stage workspace_id entries plan_hash budget idempotency_key

105. gripforge_generation_cancel

     Cancel generation

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

     id workspace_id

106. gripforge_generation_listRead only

     List persistent generation jobs

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

     workspace_id

107. gripforge_generation_quoteRead only

     Estimate generation usage before spending

     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.

     kind provider count source auto_pick workspace_id

108. gripforge_generation_readRead only

     Read generation progress and result

     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 saved HUD/map/building concept images (at most 4). Set preview_view to return one chosen view. Concepts are generated illustrations, not verified 3D renders. Success does not mean visual approval or promotion.

     id include_preview preview_view workspace_id

109. gripforge_generation_retry

     Retry interrupted generation

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

     id workspace_id

110. gripforge_get_completion_reportRead only

     Game completeness: 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.

     project_id workspace_id

111. gripforge_get_render_capabilitiesRead only

     Bevy neural preview: 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.

     project_id session_id request_id expected_revision workspace_id

112. gripforge_hitboxRead only

     Gameplay hitboxes

     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.

     character_id attach_id id

113. gripforge_hud

     Design, apply and visually review a game HUD

     Required completion gate: action=workflow stays ready=false until a current runtime capture passes all artistic criteria. After screen_assets/assembly, submit screen_item (or design/project), renderer_version, capture_item, capture and the authorized review_budget; workflow schedules the reviewer automatically. Poll workflow; correct and recapture if changes_requested. No paid retry loop. Genre-independent workflow: pass design (from plan, edited) WITHOUT project to get/quote/concept/review_quote/review. get returns the normalized design hash; quote then concept returns reference_item. For review supply design, reference_item, renderer_version (fingerprint of actual presenter/build including styles/assets/dependencies), capture_item and capture. Forward exact quote.next and poll the generation job. This reviews an immutable snapshot; compare returned identity with current files before reusing the result. No installed kit or per-genre adapter is needed for concept/review. Project mode r

     action project expected_revision title brief template theme document bindings design screen_item review_budget reference_item renderer_version capture_item capture reference_region review_provider quote_hash hud_id provider idempotency_key preset health_type health_max health_style currencies minimap portrait out_dir

114. gripforge_hud_bar

     Forge a custom health bar style

     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) ; 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.

     theme colors name

115. gripforge_hud_import

     HUD Studio — import a game HUD from the project, list and read the workspace HUDs

     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).

     action text filename name project level role textures pictures embeds screenshot id

116. gripforge_input_kitRead only

     Input maps and optional third-person character facing

     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: movement-facing, independent camera, aim/fire/build facing. Orientation only, not a physics controller. 0 credits.

     prompt third_person

117. gripforge_inspectRead only

     Inspect an asset: metrics, QA checks, multi-angle sheet

     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.

     id angles sheet

118. gripforge_joystick_kitRead only

     Ready-to-use joystick · Unreal / Godot / Unity

     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. 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.

     target layout deadzone radius accent

119. gripforge_kit

     Game Kits — read and compose game engines (manifest + rules)

     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.

     action id style name rules slots prompts

120. gripforge_levelRead only

     Plan a playable level from a prompt

     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.

     prompt seed combat_rooms floors optional_branches

121. gripforge_library_getRead only

     Get Library item

     Get one Library item (metadata + signed file_url). A forged mesh shows its game-ready verdict first (meta.gameReady: ready, missing checks; meta.collider). VFX items also return studio_url to open the editable effect in GripForge, and workspace_id. A GripForge Compute asset also returns `compute` {edit_url, family: original + colour / material / polygon versions}. Pull bytes into a repo with the npm package.

     id workspace_id

122. gripforge_library_listRead only

     List Library

     List items in the GripForge Library locker (characters, enemies, weapons, props, textures, HUD, binds, vfx). Filter by kind and/or game style id (e.g. souls-like, open-world-adventure). Every item carries `rank` {score/100, grade A–D, reasons}: fitness for a GripForge game on the target platform. sort=rank lists the best fit first — use it to choose between candidates. engine filters on the generator: engine=compute lists GripForge Compute assets (manufactures and variants), each with a `compute` block {level scene/detail, family, triangles, edit_url, file_url}. Same origin as Studio — not a marketplace.

     kind q subtype style sort target engine limit workspace_id

123. gripforge_library_optimize

     Derive a lighter version

     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.

     id triangles texture error name

124. gripforge_library_pullRead only

     Pull from Library

     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). Community assets are free to clone into your locker unless their creator sets a price in credits.

     id

125. gripforge_library_push

     Push to Library

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

     kind name file_url filename base64

126. gripforge_library_tag

     Tag a Library item

     Add a game look (e.g. souls-like, open-world-adventure) to tags so gripforge_style_kit can find the item. Does NOT overwrite grip style melee/gun/shield/staff — that stays on meta.style.

     id style tags kind subtypes also_kinds

127. gripforge_light_kitRead only

     Scene lights + fog

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

     prompt

128. gripforge_loading_page

     Game loading overlay

     Loading overlay for a game look. Returns html/css/js (web) plus engines.godot | unity | unreal. With project_id, action quote → accept → get → apply generates reviewed artwork via a persistent job and binds it to the game; creation_id and quote_token resume it. 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.

     project_id action creation_id quote_token prompt character_id

129. gripforge_loadout

     Multi-weapon loadout (attach + manifest + clips)

     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. 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.

     character_id sets default archetype name animate

130. gripforge_make_seamless

     Make a texture tileable

     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.

     image_url texture_id size band name

131. gripforge_map_concept

     AI-drawn map layout

     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.

     prompt extent_m threshold

132. gripforge_map_generate

     Create map concept views or an editable map

     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: look stylized|painted|toon|anime|realistic|lowpoly|pixel (rendering, separate from style; omit for the theme default); style realistic|stylized|lowpoly|handpainted (l

     prompt wizard stage reference source_concept views concept concept_item structure sources seed idempotency_key workspace_id

133. gripforge_map_import

     Migrate a saved terrain map

     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.

     id workspace_id

134. gripforge_map_import_unreal

     Import a portable Unreal scene

     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.

     schema document source idempotency_key workspace_id

135. gripforge_map_import_unreal_schemaRead only

     Unreal to Studio import contract

     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.

     workspace_id

136. gripforge_map_lookRead only

     Map still → camera + dressing

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

     prompt shot

137. gripforge_map_planRead only

     Top-down FPS map plan

     For original competitive 5v5 maps use target=tactical: deterministic modular greybox, real controller/bot paths, standing/crouched sightlines, timings and diagnostic links. Optional art_profile applies reusable PBR harbor facades without changing gameplay collision. Human playtests required. Legacy 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=bomb%20defusal. Pair gripforge_map_props (crates/cars) + gripforge_map_wires (cables). 0 credits. Not a dungeon — use gripforge_level.

     prompt target seed variant art_profile item windows window_density

138. gripforge_map_propsRead only

     FPS map callout props

     Dressing for an FPS map in metres: crates (A default, B big box, cover boxes), doors (mid, long, B), palms at a 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=bomb%20defusal

     prompt

139. gripforge_map_reconstructRead only

     Hierarchical FPS map reconstruction

     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: desert bomb-defusal map with two sites". 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 the owner's pixels). Preview /map-plan?prompt=bomb%20defusal. A known map stays its owner's 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=bomb%20defusal&greybox=1

     prompt stage zone

140. gripforge_map_refsRead only

     Map in-game screenshot refs

     Look up reference stills of a known map the user names (A, B, mid, catwalk, tunnels, spawn). Returns HTTPS URLs of their owner. 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=bomb%20defusal

     prompt live

141. gripforge_map_schemaRead only

     Map concept and generation workflow

     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.

     workspace_id

142. gripforge_map_wiresRead only

     FPS map overhead electricals

     Sagging electrical cables for an FPS map: spans with two anchors (metres) + sag + strands. Not a generated mesh — GfMap tessellates cylinders (role=wire). Typical spans: spawn yard, catwalk, mid, A site. Pair with gripforge_map_plan. 0 credits. Preview https://gripforge.ai/map-plan?prompt=bomb%20defusal

     prompt

143. gripforge_match_create

     Create a match record

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

     id map workspace_id

144. gripforge_match_getRead only

     Get a match

     Read one match record.

     id match_id workspace_id

145. gripforge_match_kitRead only

     Listen-server match contract

     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.

     prompt

146. gripforge_match_listRead only

     List matches

     Matches recorded for a server (SDK or API).

     id workspace_id

147. gripforge_match_stopChanges data

     Stop a match

     Marks the match ended. Mutating.

     id match_id workspace_id

148. gripforge_menu_kitRead only

     Menu + lobby + HUD

     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.

     prompt

149. gripforge_moba_map

     Generate, dress, check and set the map of a MOBA project

     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: "

     project_id action style lanes divider size team_size camps_per_jungle objectives bushes walls id name apply map force workspace_id

150. gripforge_moba_roster

     Set the champions of a MOBA project

     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.

     project_id heroes player workspace_id

151. gripforge_motion_generate

     Generate motions from text

     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.

     stage prompts hero_concept_id character_id name workspace_id idempotency_key

152. gripforge_navmeshRead only

     Walkable floor JSON

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

     prompt

153. gripforge_net_kitRead only

     Godot ENet listen-server (Godot only)

     GfNet autoload host/join/spawn with server-side hit validation, gf_round.gd for the round + bomb, MultiplayerSpawner/Synchronizer wiring. 0 credits. Godot only: for a web game built on the Game Kits the network model is the installed sync kit (net.claim = claim, net.authoritative, net.rollback, net.state; room config.net {model, sync, physics} is read from the project): use gripforge_gamekit_install / gripforge_gamekit_configure, then gripforge_docs topics net and web-multiplayer (rooms at /play/online/host/<project_id>?players=N).

     prompt

154. gripforge_performanceRead only

     Diagnose game stutter from measured frames and network delivery

     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.

     kit_id report

155. gripforge_player_banChanges data

     Ban a player

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

     id player_id workspace_id

156. gripforge_player_getRead only

     Get a player session

     Read one player session on a server.

     id player_id workspace_id

157. gripforge_player_kickChanges data

     Kick a player

     Requires the Unity SDK. Currently returns 501. Mutating.

     id player_id workspace_id

158. gripforge_players_listRead only

     List connected players

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

     id workspace_id

159. gripforge_prepare_vehicle

     Prepare segmented vehicle hinges in Blender

     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.fitTo

     source parts cuts removeMeshes yaw length openAngle thickness hinges idempotency_key workspace_id

160. gripforge_project_getRead only

     Get a game project

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

     id workspace_id

161. gripforge_projectile_create

     Create projectile VFX

     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 p

     variants workspace_id name save idempotency_key config

162. gripforge_realism_schemaRead only

     Read realism orchestration contract

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

     id workspace_id

163. gripforge_renderRead only

     Render a Library mesh to PNG

     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.

     id width height

164. gripforge_render_preview

     Bevy neural preview: 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.

     project_id session_id request_id expected_revision workspace_id

165. gripforge_resolve_requirementsRead only

     Game completeness: resolve requirements

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

     project_id workspace_id

166. gripforge_rest_pose

     Idle rest pose (arms down)

     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.

     character_id name

167. gripforge_retarget

     Retarget a clip onto another skeleton

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

     source_id target_id clip name

168. gripforge_room_closeChanges data

     Close an online room

     Close and delete one online room (frees the room quota). Invitations to it stop working. Mutating.

     room_id workspace_id

169. gripforge_room_listRead only

     List online rooms

     List the online (multiplayer) rooms of the workspace with their live state. A closed page can leave a room open until its lifetime ends; each workspace holds at most 8 live rooms, so list and close the stale ones when "Room capacity reached" appears.

     workspace_id

170. gripforge_runtime_command

     Command Rust preview

     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.

     project_id command workspace_id

171. gripforge_runtime_receiptRead only

     Read Rust command receipt

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

     project_id session_id request_id workspace_id

172. gripforge_runtime_sessionsRead only

     Rust 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.

     project_id workspace_id

173. gripforge_scene_asset_pin

     Pin an immutable Library revision

     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.

     assetId version workspace_id

174. gripforge_scene_asset_promote

     Set the visually approved asset version

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

     assetId revisionId expectedCurrent workspace_id

175. gripforge_scene_asset_review

     Review an immutable asset

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

     assetId revisionId idempotency_key workspace_id

176. gripforge_scene_asset_versionsRead only

     Read asset version and review

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

     assetId workspace_id

177. gripforge_scene_create

     Create a workspace scene

     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.

     document workspace_id

178. gripforge_scene_kitRead only

     Scene dressing 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.

     prompt

179. gripforge_scene_listRead only

     List workspace scenes

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

     workspace_id

180. gripforge_scene_modify

     Modify a selection with AI

     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.

     id expectedRevision nodeIds prompt blendDistance idempotency_key workspace_id

181. gripforge_scene_optimize

     Prepare a scene for fast browser loading

     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.

     id expectedRevision idempotency_key workspace_id

182. gripforge_scene_patch

     Edit selected scene instances

     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.

     id baseRevision commands scope workspace_id

183. gripforge_scene_promote

     Set the visually approved scene version

     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.

     id revision expectedCurrent workspace_id

184. gripforge_scene_proposal_apply

     Apply a reviewed proposal to work

     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.

     id proposal action expectedRevision workspace_id

185. gripforge_scene_proposal_readRead only

     Read a proposed scene edit

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

     id proposal workspace_id

186. gripforge_scene_proposalsRead only

     List proposed scene edits

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

     id workspace_id

187. gripforge_scene_readRead only

     Read scene source

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

     id version workspace_id

188. gripforge_scene_realism

     Shared materials, automotive lighting and post-processing

     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 who

     id expectedRevision assignments ambientOcclusion quality automotive colorGrading depthOfField workspace_id

189. gripforge_scene_review

     Request an actual GripForge visual review

     Queue a persistent render and independent visual review of the exact saved work revision. Poll generation_read. Optional assetRef records the review on the exact isolated asset revision as well; required for vehicle geometry/topology gates. This does not promote or replace the validated version.

     id expectedRevision assetRef prompt idempotency_key workspace_id

190. gripforge_scene_schemaRead only

     Shared scene engine format

     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.

     workspace_id

191. gripforge_scene_versionsRead only

     Scene versions and visual reviews

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

     id workspace_id

192. gripforge_scene_write

     Save scene work revision

     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.

     id document expectedRevision workspace_id

193. gripforge_server_create

     Create a game server

     Create a dedicated server record. Godot supports ENet and gfnet; gfnet requires a game server Docker image that boots its simulation and validation hooks. Does not start the process until deploy.

     name engine networking environment region maxPlayers gamePort sourceKind image hints launchTemplate command privateNetwork demo workspace_id

194. gripforge_server_deleteChanges data

     Delete a game server

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

     id confirm workspace_id

195. gripforge_server_deploy

     Deploy a game server

     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.

     id workspace_id

196. gripforge_server_eventsRead only

     Read server events

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

     id workspace_id

197. gripforge_server_getRead only

     Get a game server

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

     id workspace_id

198. gripforge_server_listRead only

     List game servers

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

     workspace_id

199. gripforge_server_logsRead only

     Read server logs

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

     id tail workspace_id

200. gripforge_server_metricsRead only

     Read server metrics

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

     id workspace_id

201. gripforge_server_restart

     Restart a game server

     Restart the running instance. Mutating.

     id workspace_id

202. gripforge_server_scale

     Scale max players

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

     id maxPlayers workspace_id

203. gripforge_server_start

     Start a game server

     Start the existing instance. Mutating.

     id workspace_id

204. gripforge_server_stopChanges data

     Stop a game server

     Stop the running instance. Mutating.

     id workspace_id

205. gripforge_settings

     Game Settings of the workspace — genre, controls, match, menu

     The workspace IS the game: genre (a game kit style id, e.g. arena-car), 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.

     genre controls match menu

206. gripforge_shader_pullRead only

     Pull a shader

     Pull a catalog shader (id or alias like slash_reveal) for godot | unity. Three.js is no longer a supported target. Returns file contents + assignment snippet (Godot ShaderMaterial / Unity Material). 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).

     id engine out_dir

207. gripforge_shadersRead only

     List 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.

     q type limit offset

208. gripforge_shield_exportRead only

     gripforge_shield_export

     ADMIN ONLY. Compile a shield recipe into reusable native source files for 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.

     workspace_id config engine

209. gripforge_shield_vfx

     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.

     workspace_id config save idempotency_key

210. gripforge_style

     Workspace Style DNA — set once, applied to every generation

     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.

     palette direction realism saturation edges refs extract_from clear

211. gripforge_style_kitRead only

     Game-style kit from Library

     Resolve a game look the user names ("stylish gothic action", "anime open-world adventure") 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.

     prompt

212. gripforge_terrain_map_use

     Play a terrain studio map in a game

     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.

     project_id map scene terrain workspace_id

213. gripforge_test_game

     Game completeness: 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.

     project_id workspace_id max_attempts idempotency_key

214. gripforge_texture_prep

     Prep a game texture

     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.

     image_url texture_id seamless scale size name save

215. gripforge_ui_screenRead only

     Game screen templates

     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.

     action template language screen

216. gripforge_urban_building

     Manufacture a reusable 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.

     stage workspace_id idempotency_key recipe

217. gripforge_validate_release

     Game completeness: validate release

     Journey — last, after gripforge_game_audit says complete. The game is finished only when report.ready=true on a contract that holds what the user chose for the game (genre proposals taken included); 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.

     project_id workspace_id

218. gripforge_vehicle_doors

     Open or close vehicle doors in the Studio

     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.

     id expectedRevision nodeId doors workspace_id

219. gripforge_vehicle_finish

     Finish a vehicle

     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 r

     id source repair name idempotency_key smooth wheels segments

220. gripforge_vehicle_orientRead only

     Vehicle / kart mesh yaw

     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 + Godot snippets. 0 credits.

     id prop_id

221. gripforge_vehicle_schemaRead only

     Modular vehicle manufacturing contract

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

     workspace_id

222. gripforge_vehicle_segment

     Separate an existing vehicle with Tripo

     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.

     stage source granularity budget idempotency_key workspace_id

223. gripforge_vfx

     Strike VFX on an attach (admin)

     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.

     name emitters generation attach_id prompt type style look color duration width core

224. gripforge_vfx_generateRead only

     Text / image to editable VFX (admin)

     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.

     preset prompt visual_style image_data image_id

225. gripforge_vfx_previewRead only

     VFX timeline sample (admin)

     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.

     bind t type style duration

226. gripforge_vfx_project_generate

     Create, render and refine a custom VFX

     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.

     idempotency_key prompt visual_style look image_mode image_id image_data id expected_revision workspace_id

227. gripforge_vfx_project_promote

     Set the visually approved VFX version

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

     id revision expectedCurrent workspace_id

228. gripforge_vfx_project_readRead only

     Read VFX project files and revisions

     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.

     id revision workspace_id

229. gripforge_vfx_project_render

     Render actual VFX frames for inspection

     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.

     idempotency_key id project times workspace_id

230. gripforge_vfx_project_review

     Review an existing work revision

     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.

     id expected_revision idempotency_key workspace_id

231. gripforge_vfx_project_schemaRead only

     VFX authoring language and example

     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.

     workspace_id

232. gripforge_vfx_project_write

     Create or edit a VFX project

     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.

     idempotency_key id expected_revision project edits times note workspace_id

233. gripforge_viewmodel_kitRead only

     FPS viewmodel (CS hands)

     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.

     prompt

234. gripforge_voice_profile

     Voice profiles · listen and cast characters

     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.

     action q language scope voice_id project_id speaker instructions expected_revision workspace_id

235. gripforge_weapon_motion

     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.

     source_id workspace_id family hand hands weaponNode primaryAnchor secondaryAnchor handleAxis edgeAxis slots name idempotency_key

236. gripforge_weapon_motion_reviewRead only

     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.

     source_id workspace_id

237. gripforge_weapon_profileRead only

     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.

     source_id workspace_id family hand hands weaponNode primaryAnchor secondaryAnchor handleAxis edgeAxis

238. gripforge_world_backup

     Backup a world

     Not implemented. Returns 501. Mutating.

     id workspace_id

239. gripforge_world_deploy

     Deploy a world

     Not implemented. Returns 501.

     id workspace_id

240. gripforge_world_listRead only

     List worlds

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

     id workspace_id

241. gripforge_world_restoreChanges data

     Restore a backup

     HIGH IMPACT. Not implemented. Returns 501.

     id workspace_id