GripForge

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.

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.

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

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 co

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.

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

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 r

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 valid

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

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

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 measur

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 segm

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.

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 generati

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

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 generate

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.

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 ar

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

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.

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 i

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.

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.

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 k

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.

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

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

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.

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.

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 paral

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

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

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; st

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

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

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.

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.

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.

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

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.

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.

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.

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

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

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

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.

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 han

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?:{a

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

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.

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

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

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.

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

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

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

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

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.

Start the existing instance. Mutating.

Stop the running instance. Mutating.

Restart the running instance. Mutating.

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

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

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

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

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

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

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

Not implemented. Returns 501 until artifact upload exists.

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

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

Read one player session on a server.

Requires the Unity SDK. Currently returns 501. Mutating.

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

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

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

Not implemented. Returns 501.

Not implemented. Returns 501. Mutating.

HIGH IMPACT. Not implemented. Returns 501.

Matches recorded for a server (SDK or API).

Read one match record.

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

Marks the match ended. Mutating.

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 return

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

Journey — right after choosing the genre. The finished game of its genre is the default scope: its definition of done and what every game has (a way to win AND to lose, title / pause / end screens, sound, the genre HUD, touch controls, a loop playable from start to end) are required capabilities; exclude one only when the user explicitly asks (an endless game), and say so. Persist a versioned Ga

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

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

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.

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,

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.

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

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.

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

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

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,

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,

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,

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,

Journey — last. 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. Prepare a download manifest for an existing web Game Kit project in the current workspace. Reuses the same player and HUD as hosted play, compiles only installed enabled kit runtimes, and lists the game configuration, s

Journey — first: find the preset of the genre. Its `done` says what a finished game of that genre has beyond the request: write it into the contract (gripforge_define_game) as required, and gripforge_game_audit checks it at the end. Start here. Search the modular Game Kit catalogue (vehicle.driveable, mission.objectives, npc.wanted, …) by free text, capability, tag or engine target. Pass proje

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 i

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 s

The GripForge docs, embedded in this MCP (readable offline, versioned with it), as Markdown. Without topic: the list of topics. With topic: its text, or one section (section = a heading, its number such as "4.2", or words of it); a long topic answers its table of contents first unless a section is given or full=true. Topics: web-export, godot, unity, desktop, c-api, glossary, kit-api, third-party,

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

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

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.

Journey — while composing, and to fix what gripforge_game_audit reports (its defects carry the exact config to write). 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

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 th

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 k

Journey — 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. 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 Bluep

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 (gr

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

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

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.

Journey — create, then bind a model to every creature slot (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. Manage Game Kit projects (gkp_…): the container holding installed kits, their lockfile, asset bindings and data collections. action=lis

Journey — right after creating or binding: no unit stays a capsule, every model gets its movement and action clips. gripforge_game_audit folds this report with the rest and applies the free steps with fix=true. The living units of a Game Kit project (gkp_…) — player, heroes, enemies, bosses, minions, monsters, NPCs: the creature slots its kits declare. Two rules: NO creature ships as a capsu

Journey — the build order of the content; its last step is gripforge_game_audit, not "it loads". Read game.engine of a Game Kit project (gkp_…) — a direction, never a gate. action=start (default): the start pack { version, active, structure { engine, kits, content counts, code }, scene, blocks digest, order (scene → playable → assets → archetypes → story → scripts → ui → valida

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 (gripforg

Journey — the content of the game. Once written, gripforge_game_audit says what a finished game of the genre still lacks (a quest, a way to win and to lose, dialogues…). Read and write the content of a Game Kit project (gkp_…) — what game.engine builds the game from, no engine code needed. kind: archetype (an entity template: kind prop|npc|…, asset { item: lib_… } bound to content:<id>

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 o

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 b

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 contro

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

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 pro

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

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 d

Generate input.joystick source files and installation instructions: touch + mouse, independent dual sticks, radial deadzone, continuous holding and release/focus reset. Unreal runtime Pawn component, Godot CanvasLayer scene, Unity UI component, Three.js DOM controls + GripForge input.actions bridge. Feeds the existing movement controller rather than replacing physics, collision or networking. Retu

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

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.

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.

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/Blende

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

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, re

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 lan

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, lang

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.

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

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.

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 o

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

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 eleme

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.

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.

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 requi

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 m

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 w

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 as

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 p

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 cl

The website and CLI share this saved 3D game creation workflow. Ask which engine (Unity, Godot, Unreal, Three.js) if unspecified; do not choose silently. create saves a brief without spending. quote(operation=plan) estimates AI preparation, accept(quote_token) starts its durable job ONLY after user approval of the shown price. get returns a persistent operation log, slots, studio_url and the same

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 tas

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

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

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 actu

Attach a prop (sword, shield, gun, staff/scythe…) onto a rigged character. Finds the hand bone across naming schemes, scales the prop to the character, seats the grip, closes the fist, and returns a bind + ready-to-paste Three.js / Unity / Godot snippets. Pass Library ids (character_id / prop_id) or https URLs. attach_id reuses an existing armed bind GLB as the character. prop_id_2 attaches a se

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

Cape rig v2: generates a 3-column bone grid (gf_cape_c*r*) anchored to the neck/upper-spine bone, skins the cape mesh onto it (vertical blend × gaussian columns), and bakes attached_cape.glb (character + skinned cape). The cape then ANIMATES: run the returned Godot script (spring bones, attach to the Skeleton3D) or the Three.js verlet snippet — the engine simulates, the bind carries structure +

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 specif

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

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

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 mob

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.

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.

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

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.

List the mesh formats and grip styles GripForge supports.

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 retu

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.

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

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

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.

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. Same origin as Studio â€

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.

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 b

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. Pull bytes into a repo with the npm package.

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

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.

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.

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 sl

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.

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

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.

Build a multi-weapon character in ONE call: attaches every prop of every set onto the same rig, names each prop node gf_prop_<slug>_<l|r>, stamps glTF extras { gripforge: { prop, set, hand } } and a scene manifest { default, sets }, then retargets the standard clip pack (animate: false to skip). The engine switches weapons by toggling node visibility — the returned Three.js snippet does it. Exam

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

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.

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.

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?,

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

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

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

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.

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.

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.

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

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

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

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

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