
GripForge MCP ServerVerifiedFeatured
@gripforgeai
Basic information
About GripForge MCP Server
The tools your AI needs to make your games. Turn prompts into production-ready game assets — animated characters with their weapons attached, seamless textures, terrain, VFX, HUDs — and playable game kits Unity, Godot, U






GripForge MCP Server config
Add this server to your MCP-compatible client using the configuration below.
{
"mcpServers": {
"gripforge": {
"command": "npx",
"args": [
"-y",
"@gripforgeai/mcp"
],
"env": {
"GRIPFORGE_API_KEY": "gf_..."
}
}
}
}GripForge MCP Server tools
200ADMIN 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 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.
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.
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 restart. Pass id + expected_revision to refine; image_id must belong to this workspace. A visually rejected candidate never replaces the validated version.
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.
Durable Blender preparation of an owned static segmented GLB. Map each Door_FL/FR/RL/RR or Wheel_FL/FR/RL/RR to exact mesh node names from the segmentation report. Keeps geometry placement, UVs and PBR; normalizes +Z forward/metres using yaw and length; adds hinge origins, seat/entry sockets and portable GLB open/close/preview clips. Optional hinge coordinates are in normalized vehicle metres. thickness adds an inward door shell, not a full cabin. Optional cuts provide strictly convex door outlines [forwardZ,heightY] and depth [near,far] measured from the centre on that side, in normalized metres. cuts[].meshes restricts each cut to exact exterior/glazing meshes so seats and dashboard cannot be cut. removeMeshes discards explicitly named obsolete trim in the work copy only. Optional clearanceDepthM clears scoped inner walls behind the door skin; trim adds measured body frames, seals and moulded cards below cardTopY. framePoints follows outline in normalized [x,y,z]. Optional trim.fitToSurface projects frames, seals and the inner card onto only the explicitly selected opaque door skin, preserving the supplied outline. attachments adds scoped [min,max] [x,y,z] volumes for mirrors extending beyond the door profile. Blender cuts those explicit profiles while interpolating UVs. Does not infer outlines or guarantee clearance. Returns job_id, new private work GLB, Blender source and animated Studio review link. 0 credits; storage applies. Inspect before replacement.
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 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.
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.
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 generation_read for studio_url. Always a NEW private work scene; no overwrite, automatic validation or Community publication. 0 credits; storage quota applies.
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 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.
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 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.
Queue a durable armor-kit job: one shared concept, isolated Imagine references, Meshy PBR models, bounded Blender interior preparation and paired GLB exports, then actual GripForge wearer review. Types: helmet, chest, belt, pauldron, bracer, glove, thigh, greave, boot, upperarm, gorget, tasset, undersuit. coverage=full adds a durable anatomical decomposition of the concept, rejects missing planned roles before mesh generation and records per-instance coverage fits. A piece count alone never proves body coverage. The optional undersuit is a locally manufactured adaptive textile which retains each wearer’s skin weights. Meshy pieces cost 11 credits per canonical type; the textile has no image/mesh charge. A new concept costs 1 credit; mirrors are included. concept_item must be an owned Library image. source_kit + explicit pieces regenerates only those types into a NEW work kit and pins unchanged pieces. Closing the call/page does not cancel. Poll gripforge_generation_read. Success is a work version, never automatic visual approval. The result includes a Grip Studio link, review scene, concepts, source models and Blender source.
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 instead for a transient provider or worker error to reuse the exact same steps without another charge.
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 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 (legacy wording); world open_world|closed_arena|dungeon|linear|battle_map; terrain auto|plains|desert_canyon|forest|snow|island|volcanic; size small|medium|large; boundary fixed|infinite (open edge, finite terrain); spawn single|teams; teams 2|4; boss,safeZone,extraction booleans. sources selects catalog/workspace/community props. Build uses the common Scene Engine with independent terrain, regions, paths, zones and asset instances. Cancel/retry keeps successful images and billing. No automatic visual validation, promotion or Unreal import.
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 parallax settings. Never guess masks from colours. ambientOcclusion {enabled,radius:0.02..3 metres,intensity:0..1,quality:low|medium|high}, or null to remove. Preserves transforms, source PBR maps, other instances and validated revisions. Returns Studio link for visual comparison. Optional quality {preset:performance|balanced|quality,resolutionScale:0.5..1,sharpness:0..0.5}, or null to restore the original presentation. Quality supports viewport resolution up to a bounded 4K budget. Optional automotive {look:studio|daylight,quality,lengthM,depthOfField:false,focusDistanceM} explicitly applies a whole-scene look: HDR strip reflections, contact AO, quality and restrained post-processing. Studio replaces an existing HDRI; daylight keeps it. Optional colorGrading/depthOfField overrides or null. DOF is perspective/capture only, disabled with volumetric passes. No generation charge, DLSS or automatic approval.
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.
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; storage quota applies. New Unreal imports do this automatically.
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 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.
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 validates or promotes. Cancel/retry supported; completed steps survive closing the page.
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.
Replace a registered game’s marketplace description and photo gallery without uploading its executables again. First image is the cover. Requires the game-specific GRIPFORGE_PUBLICATION_TOKEN environment variable. Send all desired images; an empty array removes the gallery. Images must be local PNG/JPEG/WebP files, at most 5 MiB each. Returns the public page URL.
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. 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.
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.
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.
Close and delete one online room (frees the room quota). Invitations to it stop working. 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 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.
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.
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.
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, 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.
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 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.
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 fields are refused by the Rust core. 0 credits.
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, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 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, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 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, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 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, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.
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.
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 the workspace. 0 credits.
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.
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, static resources and Library assets to download. Does not publish the project or change its visibility. The hosted MCP cannot write local files: use gripforge game-export <project_id> <folder> locally, then npm run dev. The CLI verifies downloads and preserves local edits on updates (--check previews conflicts; --force backs up and replaces edits only when authorized). The delivered versions remain fixed until an explicit export update. Legacy kits and unpublished source overlays cannot be exported. net.* kits still need their online services. 0 credits.
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 missing capabilities rank first. Kits are bricks that go together: a kit handling the same thing as an installed one is a same-scene overlap (only one active in a scene), never a reason to skip it. Returns { kits, presets }; each kit carries its presentation: name, tagline (one-line hook), tags, targets and status per engine (web / godot / unity / unreal), and cover / coverUrl, the featured landscape image (WebP) to show the user when proposing kits. legacy.* kits play through their existing client. Kart Racing is native: compose world.racetrack + vehicle.driveable + race.kart; edit race_tracks through project data. world.lighting adds shared sun/fill, point lights and spots, presets, bounded light budgets and bloom; edit world_lights through project data. world.fluids adds interactive mud / blood surfaces, displaced 3D wheel ruts and footprints; edit fluid_surfaces through project data (web renderer). world.terrain adds a seeded large landscape (terrain_edits data), movement.traversal climbing / swimming / gliding with stamina, world.elements data-driven fire, water, ice, electricity and poison (element_rules, element_materials, element_climates data). Also returns packs: content packs (ready-made game content — documents and kit configs, e.g. a realistic atmosphere, a tree of life, a star system) that gripforge_gamekit_install { pack } installs into a project. Call this BEFORE gripforge_gamekit_install. 0 credits.
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.
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.
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, kit-modules, kit-structures, kit-third-party, abi, modding, game-engine-contract, game-engine, animal-behavior, animal-breeding, animal-taming, asset-cache, asset-meta, automation-logistics, bots-skirmish, build-modular, build-placement, camera-strategy, cards-deck, central-client, character-first-person, character-forms, character-platformer, character-roster, character-top-down, checkpoint-rest, collect-tokens, collection-packs, combat-abilities, combat-attacks, combat-defense, combat-duel, combat-grabs, combat-hit-reactions, combat-lockon, combat-melee, combat-moveset, combat-projectiles, combat-ranged, combat-stamina, combat-threat, combat-turns, combat-weakpoints, companion-control, coop-session, craft-recipes, custom-paint, defense-towers, defense-waves, desktop-launcher, dialogue-voice, display-fullscreen, drop-parachute, encounters-waves, enemy-boss, enemy-horde, enemy-stalker, engine-interop, faction-system, farming-crops, fishing-rod, fps-abilities, fps-armory, fps-deathmatch, fps-network, fps-tactical, fx-ability-vfx, game-endings, hazard-traps, horror-sanity, hud-minimap, hud-mmo, hud-moba, hud-nameplates, hud-open-world, hud-tactical, input-actions, input-pointer-lock, input-remap, input-virtualpad, interaction-feedback, interaction-system, interaction-telekinesis, inventory-equipment, launch-pad, life-ecosystem, life-genetics, light-flashlight, loot-ground, lore-journal, machines-production, match-knockout, mission-system, moba-hero, moba-lanes, mount-ride, movement-boost, movement-dash, movement-flight, movement-grapple, movement-grind, movement-modes, movement-traversal, net-async, net-authoritative, net-claim, net-lobby, net-physics, net-rollback, net-rooms, net-state, net-transport, net-zones, npc-dialogue, npc-pedestrian, party-rounds, photo-mode, present-native, progression-levels, puzzle-circuits, race-kart, render-raytrace, render-realism, research-samples, resource-extraction, resource-nodes, rts-ai, rts-production, run-map, save-online, shared-memory, social-party, spawn-system, sport-golf, stealth-detection, stealth-takedown, storage-containers, survival-needs, tactics-grid, time-rewind, trade-shop, traffic-system, travel-worlds, ui-cursor, ui-endscreen, ui-prompts, ui-theme, units-command, upgrades-boons, vehicle-boostpads, vehicle-damage, vehicle-doors, vehicle-enter-exit, vehicle-rivals, vehicle-spaceship, vehicle-upgrades, wanted-police, weapons-arsenal, weapons-loadout, weapons-mastery, world-access, world-arena, world-atmosphere, world-bindings, world-biomes, world-daynight, world-destructibles, world-district, world-elements, world-fluids, world-grass, world-gravity-zones, world-instances, world-interiors, world-magnetism, world-platforms, world-portals, world-racetrack, world-rooms, world-scene-ground, world-scenery, world-sky-bodies, world-stages, world-streaming, world-tracks, world-vision, world-water, world-weather, wrappers-demo, zone-shrink. Read "third-party" and "porting" + "abi" before writing a presenta…
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.
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 the cursor visible (remove it alone with gripforge_gamekit_remove), and never code requestPointerLock by hand. Kits are bricks that go together: two kits handling the same thing (e.g. two lightings) are a same-scene overlap, never a game-level conflict — only one is active in a scene. Returns { plan, applied, added, project }; dry_run=true previews without writing. Check gripforge_gamekit_installed first, then gripforge_gamekit_search; tune with gripforge_gamekit_configure. To adapt a kit to the game, go through its extension points first — its configuration, its overridable collections, rules and scripts on its events, hooks documents on the hooks it declares (engine.hooks) — and recode or copy a kit only as a last resort, saying why: a copy is no longer updated. Legacy genre kits (legacy.*) use gripforge_kit. 0 credits.
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 its dependents instead; prune=true also drops the dependencies nothing else needs (never game.engine nor a default kit). When the GAME serves what the kit provided (its own terrain for world.ground, its own camera…: a Godot, Unity, Unreal or Bevy project attached with game-attach), pass host_provides=["world.ground"] (or [] for every capability the dependents need from it, listed in details.hostable of the 409): the kit goes ALONE, its dependents stay, and the project declares those capabilities served by the game (hostProvides) — offer this to the user before removing dependents. Returns { applied, removed[], dependents, project }. 0 credits.
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.
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 look, and only the colours, typography, shapes or glyphs that must differ (they win over the preset); gripforge_game_theme_from_concept fills it from the art direction. No key on screen in game outside a tutorial: never write a legend of the controls into a HUD text (hud.action hint, captions, labels) and leave ui.prompts bar off (its default); a tutorial step pushes its prompt with ui.prompts show(), and ui.prompts context: true / interaction.feedback worldPrompt: true are set only when the gameplay needs contextual prompts (the key is then the live binding, never written) — the controls live in Options › Controls (input.remap). Switching game.engine off follows the confirmation of a removal: the first call answers 409 confirm_required with details.confirm; send it back with enabled=false after the user agreed — never on your own. Returns { kit, project } with the new project revision. Call this AFTER gripforge_gamekit_install. 0 credits.
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.
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.
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 project copied locally is delivered from its copy. Call with dry_run=true FIRST: it returns the plan (files to add / keep / modify / delete, conflicts, dependencies, post-install steps) and never charges. Pass project_state (the current gripforge/gamekits.lock.json, path → sha256 of the files under gripforge/, engineVersion) so updates keep your edits and detect conflicts. Then call without dry_run to get the bundle. The hosted endpoint cannot write into your project: write bundle.files following plan.actions in order (backup, write, writeBin from bundle.binaries, delete with .uid / .import siblings, writeLock with bundle.lock), or use the npm client with project_dir (gripforge_gamekit_deliver_local), or the editor bridge. A blocked plan answers 409 with the plan: a file edited in the engine project is reported (modified_file), never overwritten silently; force backs it up then overwrites it. Credits: the first delivery of a kit major version to an engine costs 1 credit per workspace; re-deliveries, updates within a major, dry runs and the web target are free.
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.
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.
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.
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.
Generic concept → theme pipeline for a Game Kit project: the saved art direction (gripforge_game_art_direction: look, theme, palette, notes, device) becomes ONE interface concept image (title, main menu, HUD with health, a weapon card, key prompts), a vision pass reads its design tokens (colour roles, radius, border width, button shape, padding, letter case, weight, the closest open-licence font, glyph style, closest preset) and they are written as the ui.theme config (contrast repaired). The concept is kept in the Library (kind concept, category ui). action=quote prices it: 1 credit per run (quote it and ask the user before run). Without regenerate the latest concept of the project is reused with the tokens already read from it (0 credits), so a run after a dry run applies exactly what the dry run showed; reread=true reads the concept again (1 credit). dry_run=true writes nothing. run returns a generation job: poll it with gripforge_generation_read; its result carries config, tokens, fixes, previous_config and revision_before for a rollback (gripforge_gamekit_configure ui.theme with previous_config).
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.
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 engine start pack { structure, scene, blocks, order, next, rules } and added, the kits installed for dependencies), then the default kits ui.menu (title / pause / options / load and save screen), input.remap (key remapping), settings.graphics (graphics options), ui.prompts (on-screen key prompts that follow remapping and the gamepad), ui.endscreen (end screen and credits), save.persistence (save slots, quick save, autosave), audio.core (game audio: mixer, music, effects, event → sound table), i18n.text (game texts in the player’s language: translation tables in the translations collection, ICU plurals) ui.theme (the design of every interface as kit config: colours, font, shapes, key glyphs; unset = built-in look) and input.virtualpad (the on-screen gamepad of touch screens, mode auto: shown on a touch screen without a gamepad, Touch controls tab) and display.fullscreen (the game in fullscreen: F11, the Options entry, start in fullscreen with atStart, the player’s choice saved), asset.preload (the files of the game loaded in phases — first playable frame, background, next scene ahead — each file once, checked; progress as state and events shown by ui.menu, ui.endscreen and hud.action) and asset.cache (the files kept on the device between visits: IndexedDB, then Cache Storage with a service worker, then the HTTP cache; quota and eviction) and, on web, ai.navigation (the paths of the game over its real collision geometry: route and steer for NPCs, enemies and click-to-move), addedBy default: keep and configure them (never recode a pathfinding: ask ai.navigation and adapt its config, the hook navigation.plan and the event navigation.blocked; never recode an asset loader, a download queue or a cache: adapt their rules, asset_preload documents, scenes ahead and cache quota instead), leave one out ({ "ui.menu": false }) or remove it only if the user asks. They hold for EVERY game, a compiled module with its own page or a custom page included: that page mounts the menu, Options › Controls and Video, fullscreen and the prompts from the bindings through the kits’ web views (gripforge-ui.mjs, GET /api/v1/hud) or their adapter, never its own copy; get returns the full ProjectDetail (installed kits, bindings, capabilities, missing, playUrl); bind maps asset slots to Library items (lib_…, null to clear); data reads a collection or upserts / removes documents validated against the kits’ schemas (replace=true swaps the whole collection); collection asset_passports = the game’s own passport of a Library model, over the global GripForge one (what it leaves out is inherited): { id: <slot>, item: lib_…, passport: { kits: { lod: { ratios, minTriangles, fit, maxError… } } } } changes the mesh levels of that model for this game only (its own game copy; ratios: [] = no level; characters keep their bone weights); controls reads or sets the controls: without scheme it returns the control schemes of the catalogue (fps, third_person, moba_click, top_down, platformer, fighting, …
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 role words, game theme, size, rigged, animated, triangle budget). YOU judge: read the reasons, pick the model that fits the game (any monster beats a capsule), bind it with gripforge_game_project { action: "bind" }; nothing is final, rebind any time. A slot with no proposal at all carries defect creature_no_model: generate a model (paid — quote and ask first), never leave the capsule. action=animate: run the free steps of the chain now for the bound models (a free Community model is copied into the workspace and bound in place of the original; the standard clip pack is retargeted, 0 credits; wait=true waits for the result, else it runs in the background — read report again). action=fill: bind the best free proposal to every unbound creature slot, then animate (what the hosted creation does). Nothing here spends credits: the automatic rig, a priced Community asset and generated motions always come back as proposed steps for you to quote and ask about. Binding a model through gripforge_game_project already starts its chain. 0 credits.
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 families with their states and their default layer. action=get: the layers the project sets — actionLayers of its character kits (character.third_person, character.first_person, character.top_down: by family or by state such as attack3) and weaponLayers of weapons.loadout (by weapon id). action=set { kit, key, layer }: one entry, layer = { mask, still, weight, mode: replace | additive, fadeIn, fadeOut, movement: free | slow | lock | root, moveScale } (mask / still: a mask name or { regions: { <region>: 0..1 }, bones: { <bone>: 0..1 } }); the kit validates it, mods may override it (the keys are moddable), the hook character.action decides the movement once per action and player.action reports it. action=clear { kit, key }: back to the defaults. Existing games get the defaults without any change; nothing is recompiled. 0 credits.
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, scene, talked, quest, state, gives), quest step types, NPC behaviours, worlds, layers, events, variables; scope=catalog adds the bricks of kits not installed (install <kit>). action=points (game.engine 1.3): what can be plugged into the kits without recoding them — without kit, the compact view of every installed kit (hooks with their mutable fields and whether they cancel, events emitted and listened to, registries, collections and config keys with what is moddable or live, settings, verbs, components, services, completeness counters); with kit, the full extension points of that kit with schemas. Look here before writing anything new: the kit or tool that already does it is the proven way, above all for what makes a game complete (input, camera, combat, saving, HUD, menus, sound). The kits are built to be adapted, nothing in them is fixed: adapt one as deep as the game needs through its extension points — its config (gripforge_gamekit_configure), its documents and registries (gripforge_game_content, gripforge_game_project data), taps on its hooks (documents of the hooks collection), scripts whose rules react to its events and change data — in the project, or packaged as a mod (gripforge_game_mods); write something new only when no kit does it, and then as a kit following the extension contract; a local copy of a kit last, saying why. action=report: { ok, errors, warnings, stats } — an error means that piece is left out of the game (the rest plays), a warning that it loads with something missing; each issue may carry a fix { tool, args }. action=next: the next steps only. A game with everything in code is valid: content first, kits second, code for the rest. 0 credits.
Journey — while building or after: a packaged way to apply the same extension mechanisms (config, documents, hooks, reactions) as one separable unit — a variant to switch on, content added over the game, a game opened to its players' mods (an option of the developer). gripforge_game_audit then plays the modded game. The mods of a Game Kit project (gkp_…), docs/mods-engine.md: a mod (gripforge.mod/1) is data applied over the project before the kits mount — config keys and collection documents the kits declare moddable (configPatch by dotted path, data.<collection> { remove, patch, add, order }, hooks documents that tap decisions, scripts whose rules react to events) — whole or not at all, never code. The kits are built to be adapted without recoding them — interceptable (hooks), registrable (registries), modifiable (config, documents, patches) and reactive (rules on events that change data): that is the normal, recommended way to build a game, written in the project (see gripforge_game_engine points) or packaged as a mod. A mod packages those changes as one separable unit: a variant to switch on or off (a hard mode, a season event) without copying the project, content added over the game, and — an option of the developer — a game opened to its players' mods. action=list (default): the game policy (config.mods of game.engine: enabled, disabled, order, deny), every mod with its status (applied | disabled | refused) and issues ({ level, code, path, message }), the documents each added, the fingerprint the network handshake compares. action=validate { mod }: a dry run — the project with this mod added (or replacing the one with its id), applied as the host would: its status and issues, nothing written. action=install { mod }: writes it to the mods collection (validated against the mod schema). action=remove { id }. action=enable / disable { id }: the policy list mods.disabled. action=order { ids }: these mods first, in this order (a mod always comes after those it depends on). 0 credits.
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, video, color, scene } of an interface scene; unload (release | keep); transition (replace: the scene left is unloaded | add: it stays loaded under this one) and below (what the scenes under an added scene do: run, pause = drawn but frozen, hide = not drawn). Scenes stack and keep their states at run time — the game changes scene by program (engine.scenes.enter(scene, entry, { unload: false, previous: { visible, paused } }), push / pop / unload / activate / set(scene, { visible, paused }); script verbs load_scene { unload: false }, push_scene, pop_scene, set_scene): a scene kept loaded is frozen in memory and resumed at once; nothing a loaded scene uses is freed. The flow (game.engine config sceneFlow): transition replace | add, menu scene | overlay (scene: the title of ui.menu is a scene of its own, entered first with no world behind it — synthesised as menu when the project writes none; every new game and every opened game has it), menuScene, loading overlay | scene | none | background, loadingScene, showAfterMs, minLoadingMs, loadTimeout (s), onFail retry | enter | wait, retries, loadingScreen, unload. Each scene loads its files before it is entered (asset.preload, progress on the loading screen) and leaving it frees its instances and the memory of the files only it used (never the disk cache); hooks engine.scene.change (redirect or refuse a change) and engine.scene.release, events engine.scene.loading / loaded / unloaded / refused for mods. The asset list of a scene (scene_assets: files with role, phase, size, shared) is generated from its content (instances → archetype models, the global slots a played scene needs, world, HUD, music, menu art) — retouch it by hand or with assets_put; asset.preload uses it as one more source, never a restriction. action=list (default; scene: one scene with its files and plan): the flow (menu, start, levels, loading), each scene (kind, role, next, instances, world kit, files, written or generated list), the scene issues of the report, the check of the asset lists and the load plan (per scene in play order: what entering it loads, what leaving it frees, what is shared, and the loading screen of that transition). action=create { id, kind?, role?, title?, next?, loading?, background?, world?, at? (index) } | update { id, set: {…} } (null clears a key) | remove { id } | order { ids } (these first, in this order) | link { id, next } (next null: unlink) | flow { set: { menu, menuScene, transition, loading, loadingScene, showAfterMs, minLoadingMs, loadTimeout, onFail, retries, loadingScreen, unload } } | menu { id?, title?, background? } (writes the menu scene as a document, first, role menu) | assets { scene? } (generate or refresh the lists; files written by hand are kept) | assets_put { scene, files } | assets_check (missing file, file used by nothing, duplicate, list out of date). dry_run answers the new state without writing. Every write answers the new state. Scene content (instances, entries, zones, scripts) stays…
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, on: <instance> | archetype:<id> | scene:<id>, rules: [{ when, if?, then, else?, once? }] } with sugars { "interact": "self" }, { "enter": zone }, { "state": { open: false } }, { "quest": id, "is": "completed" }, { "talked": npc }, engine verbs set_state, play_clip, set_solid, show, hide, enable_script, disable_script, load_scene, end_game, call, set_talk and kit verbs as shorthand { "give_item": "key" }), mission (alias quest), dialogue, npc, item, translations, code_module (what game code registers: verbs, components, services, entity kinds), zone, trigger. action=list (kind optional: counts), get (kind, id), put (kind, doc or docs: upsert, validated against the declaring kit schema), remove (kind, id), validate (dry run of a put: the report it would give), place (scene, archetype or asset lib_…, at, yaw?, id?, place ground|none: the placement on the ground is baked once on the server, the same on every engine), bake (re-bake the placements of a scene after its world changed). Writes return the content report after the change; the report never refuses a write — only a document invalid for its schema is. 0 credits.
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.
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 (lines game.*): the gestures its control scheme promises (a click game: click to walk, held to follow the cursor, click an enemy to strike, held to keep striking), fullscreen when the game offers it, the right button when the game gives it a role (no browser menu), the pointer captured exactly when the scheme looks with the mouse, and its texts (title, help, tutorial, dialogue) against the real bindings — never a fixed W A S D in a click game; nothing is imposed on a game that did not choose it. The frame rate is · not verified here: only a real page measures it (the play page reports it to the audit). Returns { summary, text, report, next }: text has one line per result, ✓ pass, ⚠ warning, ✕ failure, · not checked, each with its time, position, entity or kit; "provoked" means the tester set the condition up through the kit service. Fix the ✕ lines first, then run it again. report.notCovered lists the capabilities no probe looks at. report.replay replays the same inputs; pass it back as replay to check a fix against the same run. Deterministic: same project, seed and budget, same report. Runs in the compute service, about 5–20 s. 0 credits.
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.framerate: measured, or unverified — never call the game smooth while it is unverified; under 30 fps it is a major defect), keys shown in game (completeness common.no_key_hints, major: a ui.prompts help bar, build.placement keyHints or ui.menu keyHints turned on, a HUD text that lists keys or mouse buttons — no key on screen outside a tutorial), the default screens (sections.screens: on the KitHost page the host mounts them; a compiled module or a custom page must mount the menu, Options › Controls and Video, fullscreen when offered and the prompts from the bindings through the kits’ web views or adapter — a missing kit or a failing screen is a major defect, and a screen no real page has opened is screens.unverified, a major defect: say "not verified", never done) and completeness: what a finished game of the genre has beyond the literal request (MOBA: distinct heroes with Q/W/E/R, minions, towers, jungle monsters, shop, respawn; FPS: weapon, ammo, reload, crosshair, enemies; platformer: checkpoints, collectibles, end of level; racing: laps, ranking, AI opponents… and for every game a way to win AND to lose, title / pause / end screens, sound, a HUD, touch controls), checked against facts of the project, never a declaration. Each defect carries fix { tool, args, note, auto?, credits? }: call it as given. Returns { verdict: complete | playable_with_defects | incomplete, headline, genre, counts, defects, next (ordered calls), sections, text, play_url }. fix=true first applies what is free and safe (the best free Library model on each capsule — rebind at will —, the free standard clips, the suggested control scheme) and reports it in fixes. playtest="run" plays the game headless first (5–20 s); the default reads the last playtest and says when it is stale. Never refuses a write and never spends: paid fixes (a priced model, a rig, a generation) come back with their price to ask the user about. Aim for verdict complete; if you stop before, tell the user exactly what is left. 0 credits.
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.
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.
The map of a moba project as a gameplay plan: bounds, team bases and spawns, 1 to 5 lanes (the minions' paths), structure slots (towers, inhibitors, nexus), jungle zones and camp slots, objective zones, the divider (river: walkable; chasm, lava, void: crossed only at bridges), crossings, bush zones, walls, camera limits and symmetry. action "generate" builds a fair map (mirrored through the centre) from lanes, divider, size, team_size, camps_per_jungle, objectives, bushes, walls and returns it with a playability report; apply: true puts it in the project (moba_maps, the match's map and team size, the camera turn). action "validate" checks a map you pass, or the project's: every lane open end to end, spawns, structures and camps reachable, nothing out of bounds, the declared symmetry respected. action "set" stores an edited map document (refused while it has errors, unless force). action "get" returns the current map and its report. New maps default to style {theme: "sanctum", detail: "high", seed: 11, relief: "landscape"}. action "dress" previews a reusable procedural finish for the current map: jungle plateaus, river banks and paved fords, terraced bases, walkable staircases, carved structures, clustered forests, stone guardians and lilies; apply: true saves only the map document, keeping its lane layout and camera configuration; relief updates the shared terrain mesh, ground queries and stair collisions; landscape is the default, terraced keeps base terraces only, flat keeps a level arena. Themes: sanctum, wildwood, ashen; detail: low, medium, high; seed makes the finish repeatable. Bound Library models and textures take precedence. The scenery kit dresses walls and bushes with the bound models. 0 credits.
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.
npm client only. Deliver Game Kits straight into an engine project folder on this machine: hashes project_dir/gripforge/**, reads gripforge/gamekits.lock.json, asks the GripForge API for the plan, then executes plan.actions with fs — every overwritten or deleted file is copied to gripforge/.backup/<plan id>/ first and the lock is written last. Paths are checked inside project_dir (Godot: gripforge/, assets/gripforge/ and addons/gripforge_gameplay|gripforge_net only) and every hash is verified before anything is written. Run dry_run=true first. A blocked plan (files edited in the project) returns the conflicts without touching files: re-run with force to back them up and overwrite. Kits always deliver at their latest version. verify=true runs Godot headless (import, then each kit smoke.gd) when GODOT_BIN is set. Undo with gripforge_gamekit_rollback_local. Credits: the first delivery of a kit major version to an engine costs 1 credit per workspace; re-deliveries, updates within a major and dry runs are free.
npm client only. Undo the last gripforge_gamekit_deliver_local in project_dir: restores every file saved in gripforge/.backup/<lock id>/, removes the files that delivery added when you did not edit them (edited ones are kept and listed), and puts gripforge/gamekits.lock.prev.json back as gripforge/gamekits.lock.json (or removes the lock after a first install). Pass backup_id (a plan id) to restore the backups of a delivery that failed before writing its lock. Backups are never deleted. 0 credits.
Read-only local project inventory for concept-first map creation. Returns reusable /Game asset paths, map files and inferred mesh/material/texture kinds from one selected pack. No Unreal editor or API key required; no upload or conversion. It cannot recover geometry, material bindings or actor transforms from .uasset files. Use an actual viewport image as the map concept reference, then inspect assets in the editor before native scene delivery. Available in the npm MCP client only; the hosted MCP cannot read your local disk.
The common build tool of the kit logic modules (refused before compiling when the kit breaks the core loop rule — logic only on the tick, frame/physics hooks read only, no tick path waits; gripforge_core_loop_check lists each problem with its fix): compiles the source of a kit of your own (a folder with kit.json — { "schema": "gripforge.kit-module/1", "id", "version", "services"?, "requires"?, "optional"? } — and src/lib.rs giving "pub fn module() -> Rc<dyn KitModule>"; no Cargo.toml, no export macro) on the base GripForge fixes: the pinned Rust toolchain with its components, the locked crates, the options of each mode. Writes, per mode, <id>-<version>.<mode>.wasm and its manifest .kit.json (provides/consumes read from the binary, sha256), plus build.json; checks each binary against the base (its mode, its structures table, the links it takes). Both modes by default: "isolated" (a memory of its own) and "common" (relocatable, for a game that trusts the kit). Runs cargo locally: the first build of the common mode rebuilds the standard library (a minute or two). When the toolchain is missing the error gives the one rustup command to run (install: true runs it; it adds a toolchain beside the others and never changes the default one). Then declare a build with gripforge_third_party_kit_add. Guide: gripforge_docs { topic: "kit-third-party" }.
The build base a kit is compiled on (what gripforge_third_party_kit_build uses): the contract and the structures version, the pinned Rust toolchain with its components and target, the profile, the options of each mode, the locked crate versions, the links an isolated kit may take — and whether this machine is ready for it (toolchain.ok, toolchain.missing, toolchain.install: the one rustup command). Guide: gripforge_docs { topic: "kit-third-party" }.
Verify one build of a third-party kit — no game needed — against the core it is meant for (modules: a folder of kit modules, e.g. <exported game>/runtime-rust/kit-modules): the version of the contract and of every interface it consumes, then the structures of the contract, each compared with the core's. Answers ok, mode (isolated or common), contract { expected, found }, structs { expected, found } and the issues, each naming what was expected and what was found. Guide: gripforge_docs { topic: "kit-third-party" }.
Declare a third-party kit — a kit of game logic compiled alone into one .wasm (a kit module), not one of GripForge's — in a local game, in the COMMON memory of the game by default (not isolated) or, with trust "isolated", with a memory of its own. Reads one build of gripforge_third_party_kit_build (kit: its output folder; or wasm + manifest, file or http(s) URL), checks it (the binary against the manifest; against the core and the kits of the game's kit modules when the game has them; the kits it requires against the game), then writes: project.thirdPartyKits (source, sha256, manifest), its entry in project.installed (config), its place at the end of lock.order, and lock.thirdParty (version and sha256 frozen). A module given as a file is copied beside the game (third-party-kits/). A third-party module is loaded only when the game declares it; the page then plays the kit modules by itself. Use GripForge's kits first (gripforge_gamekit_search): a third-party kit is for a rule no kit has. check=true writes nothing. Calling it again with a new build replaces the kit. Guide: gripforge_docs { topic: "kit-third-party" }.
Verify the third-party kits a local game declares (one with id): each module is read again from its source and must have the sha256 the game declares and its lock froze; its manifest must be what the binary says; the declaration, project.installed, the lock and the kit modules of the game must agree on the version. Answers ok and, per kit, the issues (each says what differs). Run it before an export and after fetching a game. Guide: gripforge_docs { topic: "kit-third-party" }.
The third-party kits a local game declares: id, version, source, sha256, whether each is installed, enabled and frozen by the lock, the kits it requires and the services it serves. Guide: gripforge_docs { topic: "kit-third-party" }.
Remove a declared third-party kit from a local game: its declaration, its entry in project.installed, its lock lines, the copy of its module beside the game and its kit module. GripForge's kits are not removed by this tool (gripforge_gamekit_remove). Guide: gripforge_docs { topic: "kit-third-party" }.
Make the mesh levels (LOD) and the optimised textures of a model on this machine, with the SAME code as the GripForge service (same Rust simplifier meshoptimizer, same file, same cache key). From the passport of the model (kits.lod: defaults of the usage, the global passport, then the game's override). Use it when an asset arrives and before delivery; with project_id it reads what each bound model needs, makes only the missing copies and gives them to the server. A copy already current is not made again. Guide: gripforge_docs { topic: "lod" }. 0 credits.
Make the collision of a model on this machine with the SAME code as the GripForge service (same Rust tool, same description gripforge.collision/1, same cache key). The tool analyses the model (concavity, proportions, size, usage, static or mobile) and CHOOSES the method (none, box, compound, convex, convex_decomposition, trimesh) unless the passport imposes one; the answer carries the method, the score and the reason. From the passport of the model (kits.collision, then the game's override). With game it reads what each bound model needs, makes only the missing ones and gives them to the server; it also returns the level check (warnings). Never add a collision by hand to a game: fix the passport. Guide: gripforge_docs { topic: "collision" }. 0 credits.
The level check of a game: fixed decor larger than 1.5 m that collides with nothing (its passport or the tool said none, or no collision was made yet) — a character would walk through it. Returns the warnings with the model, its size, the method and the reason; builds nothing. Fix by gripforge_collision_build, or by kits.collision.shape in the passport (never by hand in the game). Run it before delivering a level. 0 credits.
The actions of the collision studio (/collision-studio) for one bound model of a game: compare every method with its score and reason, save the method and budgets the game wants in its passport (deviations only, never a copy of the passport), or remove them. Then run gripforge_collision_build with game (and server: true) to make the collision again. 0 credits.
Check a game or kit folder on this machine against the core loop rule every GripForge game follows (docs/game-engine-contract.md §12): game logic only on the game tick (game.engine tick.hz set explicitly), frame/present hooks and physics callbacks read only, the GripForge tick stepped from the frame callback and never from _physics_process / FixedUpdate, the engine physics step not retuned, no tick path waiting on another thread, and the render/physics Workers and shared memory not turned off without a stated reason. Rules: tick_missing, frame_mutates_state, physics_runs_gameplay, engine_physics_retuned, worker_disabled, shared_memory_disabled, physics_main_thread, sync_worker_call. Each problem comes with its file, line and fix. ok=false fails the game or kit; same check as gripforge game-check --loop (CLI), refused by gripforge kit build. Free, local, reads only.
Validate a common GripForge map SceneDocument and native/GLB asset bindings, pin source revisions and package the bounded UE Python worker into a persistent local job. Preserves PBR and separate instances. No source package changes. A new target under /Game/GripForge/Maps is required; work versions are never automatically visually validated. Local npm MCP only.
Launch the installed Unreal editor to materialize a prepared job as a separate native work level. Writes generated assets and that level only; original native meshes/materials remain shared. Continues after the MCP call ends. Closing and relaunching the same job resumes saved checkpoints without duplicate actors. Returns status location, never claims visual acceptance.
Read stages, saved progress, failures, collision/scale checks and actual viewport captures for a prepared native map import.
Request cancellation at the next safe checkpoint. Completed generated assets and saved actors remain available for a later resume; the current validated map is not replaced.
Generic local UE 5.7 exporter. Pins the selected saved map and runs a separate Unreal Python commandlet without saving source assets. Exports PBR GLBs, all supported static placements, compact foliage patches, Landscape height/holes and baked albedo. Durable per-file checkpoints survive closed MCP calls. Native shader graphs, animated water/sky, Niagara and gameplay Blueprints are reported, not silently recreated. Work version requires visual review in GripForge. Local MCP only; Unreal/Python/GLTFExporter must be installed.
Read durable stages, failures, completed assets and final GripForge Studio link. Does not equate technical export success with visual validation.
Request cancellation at the next safe asset checkpoint. Keeps completed files and uploaded private assets; resume with export_local or upload_local using the same directory. Never kills an unrelated Unreal editor.
Assemble a completed native export as a common SceneDocument, upload immutable assets to the authenticated workspace and queue a persistent API import. Detached upload resumes per-file checkpoints. Poll export_status_local for studio_url. Private work only, never auto-promotes or publishes. 0 generation credits; workspace storage quota applies.
Local signatures, source hash and known-format-first recommendation. Unknown remains unknown. Does not execute or alter the source.
Imports a copy into a dedicated installed Ghidra analysis project, without running the binary. Requires a finished local import job, native file signature and rights basis. Records hash and explicit program selector, so later reads never depend on the shared current program. No extraction or visual approval is implied.
Configured local Ghidra MCP bridge only. Verifies source hash and installed tool schema. Bounded output and persisted evidence; no unsupported converter is invented. List native functions with an explicit program selector
Configured local Ghidra MCP bridge only. Verifies source hash and installed tool schema. Bounded output and persisted evidence; no unsupported converter is invented. Search native strings for asset loading/format clues; results are evidence, not inferred assets
Configured local Ghidra MCP bridge only. Verifies source hash and installed tool schema. Bounded output and persisted evidence; no unsupported converter is invented. Read one native function to investigate an asset loader; never changes executable code
Write the studio's central server into a new local folder: a NestJS starter the studio runs as is and changes (accounts and sign in, sessions, short signed tickets, directory of rooms servers, launch, match results; later payments or chat as modules). SQLite by default (db=postgres for Postgres), tickets of 60 s. Returns { dir, secret, next }: `secret` is GF_CENTRAL_SECRET, give it to gripforge_rooms_server_create. Run `npm install && npm start` in dir. Same as `gripforge create central-server`.
Only for an online multiplayer game. Write a rooms server (NestJS starter: rooms, challenges, one match server per match) into a new local folder, linked to the central server: players enter it with central's ticket. Declared match servers are the studio's only (a studio token is generated with placement declared or both). Returns { dir, studioToken?, next }; run `npm install && npm start` in dir after central. Same as `gripforge create rooms-server --central <url> --central-secret <secret>`.
Optional for any game (solo too); never apply it unless the game needs accounts or the studio's central server, or the user asks. action=add installs central.client with its ready-made account view (ui.webui, menu) and sets central's address (url, else GF_CENTRAL_URL); multiplayer=true also installs net.rooms + net.transport with the rooms view (only for an online multiplayer game; app = the GF_APP of the rooms server). action=remove takes the preset's kits and views out again (net.transport stays only if another kit needs it). action=status reads { applied, url, multiplayer, app, kits }. Named errors: central_url_missing, central_url_invalid, central_app_invalid, central_not_applied. Same as `gripforge central add|remove|status <gkp_id>`.
LOCAL MCP ONLY. Analyze → discover → classify → normalize → private Library import. Starts a detached durable local job; returns immediately. Known portable formats first, Unity GUID relations carry evidence, unsupported formats stay blocked with an explicit toolchain. Does not launch the game, bypass encryption, guess sockets or claim behavior/visual validation. Read the inventory and select before uploading. Closing the MCP or Studio does not delete progress; read/resume by job_id. Analysis is free and local. Source files remain unchanged.
Read persistent local state with paginated assets, role confidence, extraction blockers and verified relationship edges. The report_path can be opened in Library → Add asset → From Game. Unknown/bundled files are not counted as successfully imported assets.
LOCAL ONLY. Dedicated AssetRipper loopback HTTP adapter for assets; installed Cpp2IL/ILSpy adapters for local code/metadata only. The agent chooses AssetRipper first unless tool is explicit. Uses durable output/checkpoints and rescans exported assets; never executes game code. Requires installed tools configured in the MCP environment, compatible OpenAPI routes and an authorization basis. No Ghidra fallback is silently invoked. Tools/version and errors remain visible. Cancellation is checked between external operations, each bounded to 20 minutes.
Requires an analyzed local job, explicit source ids, workspace id and rights basis. Self-contained GLB and standard images/audio import directly; glTF packs its local resources into GLB. Engine-native formats require extraction first. Durable per-file checkpoints and server idempotency preserve completed imports across retries. Saved as work revisions, never published/promoted. Storage quotas apply; no paid AI call. Relations remain a knowledge graph and Game Kit suggestions require actual gameplay integration.
LOCAL durable worker. Installed GRIPFORGE_BLENDER_BIN converts FBX/OBJ to GLB and DDS/TGA to PNG. Keeps available PBR, rig and animations; does not fabricate missing materials or validate appearance. Sources remain unchanged; checksummed outputs persist for resume. OBJ with external MTL and missing FBX textures fail explicitly; export embedded materials first. Run before registration/import. Source engine scenes still require their known exporter.
Cancel between files; an already committed upload remains imported. Resume preserves successful receipts and checkpoints. After a worker crash, resume with the same job_id. Credentials are supplied by the current MCP session, never saved in the job report.
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.
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.
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/Blender required.
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.
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.
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.
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.
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.
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.
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.
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 a NEW work asset and Character Studio URL; never replaces the game/source or visually validates a result. 0 generation credits.
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 or damage. Recipe compilation needs no AI; saving uses the normal VFX review pipeline. Work is not visually validated automatically.
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.
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 player only in v1. Does not install a kit or modify a game automatically. Recipe compilation needs no AI; saved previews use the existing review pipeline. No automatic visual validation.
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. 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.
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.
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.
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.
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 review images; nothing is sent to 3D. The plan also returns ambient_kits: the kits of the theme's atmosphere (weather, lighting, snow tracks) with their config; install them in the game project next to the blueprint's gameplay kits.
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.
Overview
What is GripForge MCP?
The tools your AI needs to make your games. Turn prompts into production-ready game assets — animated characters with their weapons attached, seamless textures, terrain, VFX, HUDs — and playable game kits Unity, Godot, Unreal or Three.js can load.
How to use
Hosted — nothing to install. Point any remote-capable MCP client at https://gripforge.ai/mcp
with your API key (create one at https://gripforge.ai/account):
{
"mcpServers": {
"gripforge": {
"url": "https://gripforge.ai/mcp",
"headers": { "x-api-key": "gf_..." }
}
}
}
Claude Code, in one line:
claude mcp add --transport http gripforge https://gripforge.ai/mcp --header "x-api-key: gf_..."
Local, via npm — when the agent must write files into your repository:
{
"mcpServers": {
"gripforge": {
"command": "npx",
"args": ["-y", "@gripforgeai/mcp"],
"env": { "GRIPFORGE_API_KEY": "gf_..." }
}
}
}
Key features
- Characters that move. Describe one, get a rigged T-pose with an animation set — idle, run, attack — re
- Weapons in hand. GripForge finds the hand bone on any rig, scales the prop, closes the fist around thed plus Three.js, Unity and Godot snippets.
- Seamless textures. Tileable material sets from a prompt or from your own image, upscaled without inven
- Terrain and maps. Playable room graphs, top-down shooter layouts with spawns and lanes, greybox recons
- VFX and HUD. Animated effects and interface kits exported for your engine.
- Playable game kits. Assemble modular capabilities — movement, combat, enemies, worlds — into a game that runs in the browser, then bind your own assets to it.
- One Library. Everything generated lands in a locker your engine can pull from, and that your agent can search by look ("Devil May Cry like", "genshin").
Use cases
- "Attach this sword to my knight, right hand, then export the armed GLB." — the agent handles the bone, t get a file that loads.
- "Make me a boss for an ashen underworld, with three phases and an arena." — stats, attacks and engine snippets come back together.
- "Give this floor a mossy cobblestone texture that tiles." — a seamless set, saved to the Library.
- "Build a playable roguelike slice I can try in the browser." — a game kit project with its assets bound, playable from a link.
FAQ
Do I need to install anything? No. The hosted endpoint works from any MCP client that speaks streamable HTTP. The npm package exists for one reason: letting the agent write files directly into your repository.
Which engines are supported? Unity, Godot, Unreal and Three.js — assets come with the binds and snippets each one expects.
How is it billed? Credits, per generation. Reading the Library, animating an existing character, level and map kits cost nothing; generating a character or a weapon costs 10.
Where do my assets live? In your workspace Library. You can pull them into your repository, push your ow community catalog.
Can I use my own concept art? Yes — pass an image and GripForge builds the T-pose sheet from it rather t
More Developer Tools MCP servers

Yocoolab
YocoolabMCP server for AI Agents — exposes Yocoolab feedback threads and design selections as tools

SSH MCP Server
hypnosisSSH MCP server for AI agents: remote commands, file transfer, log search and server audits through OpenSSH.
OSIR Domain Name MCP Server
OsirRemote MCP server from OSIR, an ICANN-accredited registrar: 105 tools and 11 prompts to search, register, renew, transfer, and manage domains, DNS, VPS, email, and websites from Claude, ChatGPT, Cursor, or any MCP client

Crawl Readiness
GrubbomaticAI SEO tools for MCP clients — audit whether AI crawlers can read a website, validate JSON-LD and robots.txt, and generate llms.txt, AI-crawler-aware robots.txt, and JSON-LD schema without leaving the conversation.
Cronwatch
cronwatchdevCronWatch records every run of your scheduled jobs in your own database, and speaks up when one is missed, fails, gets stuck, runs slow or costs too much. CronWatch is free and open-source.
Comments