GripForge MCP Server

by gripforgeai Your server? Claim it

answering

GripForge is answering right now. Last checked 10 min ago. 371 installs a week from npm. It exposes 142 tools. Last commit 20 Sep 2026.

Turn prompts into production-ready game assets: animated characters, textures, terrain, VFX, HUD.

Installs per day peak 200 · avg 24 · +1180% w/w

a month agotoday

Uptime history 29 hours of history · worst hour 50%

29 hours agonow

97.8%

Uptime 24h

88 of 90 checks

142

Tools

read from the server

460 ms

Response time

average over 24h

371

Installs / week

npm and PyPI

What changed 2

Every tool that appeared, vanished or quietly changed what it asks for. Recorded since 21 September 2026. No other catalogue keeps this.

21 Sep 2 tools appeared gripforge_flexible_weapon_schema, gripforge_generate_flexible_weapon

What the code does

We read the source, 6 h ago · tools taken from the live server · rules 3dff92dd89df

A tool parameter reaches a dangerous call

A value the model can set ends up inside a file or shell call. That is not a flaw by itself — for a terminal server it is the job — but it is where things go wrong when it is not.

A tool parameter reaches a file or shell call gripforge_map_plan.item → src/server.ts:1138

      if (r.ok) { const f = path.join(out_dir, team ? `${team}_arms.glb` : (data.item.filename ?? 'arms.glb')); await fs.writeFile(f, Buffer.from(await r.arrayBuffer())); wrote.push(f); }

Capabilities

What this server is able to do. For an MCP server this is often the job itself — a terminal server runs commands because that is what it is for. Listed so you know what you are plugging in, not as an accusation.

Runs an external command src/gamekit-deliver-local.ts:258, src/server.ts:2128

    const child = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] });

Builds a file path from a variable src/server.ts:2171

    const outDir = path.join(proj, 'builds', v, preset);

Reads files and sends them to the network src/gamekit-deliver-local.ts:176, src/server.ts:2156

      entries = await readdir(under(dir, rel), { withFileTypes: true });

Is this your server and something here is wrong? Tell us — corrections are free and do not require a plan.

A tool parameter here reaches a dangerous call

That is not a flaw by itself — but it is where things go wrong when it is not the job. We re-read this code on every release. Watch it and you hear from us the day another one appears.

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 10 min ago.

Claude Code Claude Desktop Codex Cursor VS Code

run in your terminal

claude mcp add mcp --transport http https://gripforge.ai/mcp

~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "mcp": {
      "url": "https://gripforge.ai/mcp"
    }
  }
}

~/.codex/config.toml

[mcp_servers.mcp]
url = "https://gripforge.ai/mcp"

.cursor/mcp.json

{
  "mcpServers": {
    "mcp": {
      "url": "https://gripforge.ai/mcp"
    }
  }
}

.vscode/mcp.json

{
  "mcpServers": {
    "mcp": {
      "url": "https://gripforge.ai/mcp"
    }
  }
}

This one needs environment variables set before it will start: GRIPFORGE_API_KEY (GripForge API key (gf_...) — create one at https://gripforge.ai/account). The author declared them in the registry entry; get the values from the project itself.

Available tools 142

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

gripforge

gripforge_aim

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

gripforge_animate

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

gripforge_armor_generate

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

gripforge_armor_read

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

gripforge_armor_repair

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

gripforge_attach

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

gripforge_audio_kit

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

gripforge_blender_fabricate

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

gripforge_boss

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

gripforge_bot_kit

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

gripforge_build_deploy

Not implemented. Returns 501 until artifact upload exists.

gripforge_build_get

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

gripforge_build_list

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

gripforge_build_rollback

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

gripforge_cape

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

gripforge_character_concepts

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

gripforge_concept_correct

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

gripforge_flexible_chain

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

gripforge_flexible_chain_schema

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

gripforge_flexible_weapon_schema

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

gripforge_font

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

gripforge_formats

List the mesh formats and grip styles GripForge supports.

gripforge_fps_animation

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

gripforge_fps_kit

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

gripforge_game_broadcast

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

gripforge_game_capabilities

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

gripforge_game_play_url

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

gripforge_game_project

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

gripforge_gamekit_configure

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

gripforge_gamekit_deliver

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

gripforge_gamekit_dependencies

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

gripforge_gamekit_get

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

gripforge_gamekit_install

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

gripforge_gamekit_remove

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

gripforge_gamekit_search

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

gripforge_gamekit_update

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

gripforge_generate

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

gripforge_generate_character

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

gripforge_generate_flexible_weapon

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

gripforge_generate_prop

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

gripforge_generate_weapon

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

gripforge_generation_cancel

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

gripforge_generation_list

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

gripforge_generation_read

Poll a job returned by a generation tool. Includes durable steps, progress, failure/retry state and the resulting work revision with a Studio link. include_preview returns an actual rendered VFX image when available. Success does not mean visual approval or promotion.

gripforge_generation_retry

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

gripforge_hitbox

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

gripforge_hud

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

gripforge_hud_bar

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

gripforge_hud_import

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

gripforge_input_kit

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

gripforge_inspect

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

gripforge_kit

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

gripforge_level

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

gripforge_library_get

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

gripforge_library_list

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

gripforge_library_pull

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

gripforge_library_push

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

gripforge_library_tag

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

gripforge_light_kit

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

gripforge_loading_page

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

gripforge_loadout

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

gripforge_make_seamless

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

gripforge_map_concept

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

gripforge_map_generate

gripforge_map_import

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

gripforge_map_look

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

gripforge_map_plan

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

gripforge_map_props

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

gripforge_map_reconstruct

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

gripforge_map_refs

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

gripforge_map_wires

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

gripforge_match_create

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

gripforge_match_get

Read one match record.

gripforge_match_kit

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

gripforge_match_list

Matches recorded for a server (SDK or API).

gripforge_match_stop

Marks the match ended. Mutating.

gripforge_menu_kit

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

gripforge_navmesh

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

gripforge_net_kit

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

gripforge_performance

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

gripforge_player_ban

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

gripforge_player_get

Read one player session on a server.

gripforge_player_kick

Requires the Unity SDK. Currently returns 501. Mutating.

gripforge_players_list

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

gripforge_project_get

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

gripforge_render

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

gripforge_rest_pose

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

gripforge_retarget

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

gripforge_scene_asset_pin

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

gripforge_scene_asset_promote

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

gripforge_scene_asset_review

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

gripforge_scene_asset_versions

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

gripforge_scene_create

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

gripforge_scene_kit

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

gripforge_scene_list

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

gripforge_scene_modify

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

gripforge_scene_patch

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

gripforge_scene_promote

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

gripforge_scene_proposal_apply

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

gripforge_scene_proposal_read

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

gripforge_scene_proposals

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

gripforge_scene_read

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

gripforge_scene_review

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

gripforge_scene_schema

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

gripforge_scene_versions

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

gripforge_scene_write

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

gripforge_server_create

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

gripforge_server_delete

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

gripforge_server_deploy

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

gripforge_server_events

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

gripforge_server_get

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

gripforge_server_list

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

gripforge_server_logs

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

gripforge_server_metrics

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

gripforge_server_restart

Restart the running instance. Mutating.

gripforge_server_scale

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

gripforge_server_start

Start the existing instance. Mutating.

gripforge_server_stop

Stop the running instance. Mutating.

gripforge_settings

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

gripforge_shader_pull

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

gripforge_shaders

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

gripforge_style

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

gripforge_style_kit

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

gripforge_texture_prep

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

gripforge_vehicle_orient

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

gripforge_vfx

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

gripforge_vfx_generate

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

gripforge_vfx_preview

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

gripforge_vfx_project_generate

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

gripforge_vfx_project_promote

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

gripforge_vfx_project_read

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

gripforge_vfx_project_render

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

gripforge_vfx_project_review

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

gripforge_vfx_project_schema

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

gripforge_vfx_project_write

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

gripforge_viewmodel_kit

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

gripforge_world_backup

Not implemented. Returns 501. Mutating.

gripforge_world_deploy

Not implemented. Returns 501.

gripforge_world_list

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

gripforge_world_restore

HIGH IMPACT. Not implemented. Returns 501.

getattachmentframe

getAttachmentFrame

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

getwearableframe

getWearableFrame

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

Endpoints

URL	Transport	State	Latency	Checked
https://gripforge.ai/mcp	streamable-http	answering	452 ms	10 min ago

Alternatives to GripForge

same job, measured the same way

mcpify

by furkan708

Focused, production-ready CLI: turn any OpenAPI REST API into an MCP server.

5 440 installs/wk local only

three.ws 3D Studio

by nirholas

Turn text or an image into an animation-ready 3D model (GLB): generate, rig, animate, retexture.

answering

Furlen MCP

by amitsha86

Turn a CSV or a named public dataset into an animated chart video, figures re-checked first.

29 installs/wk local only

FAQai

by faqai

Turn any document into a production-ready RAG dataset from Claude, Cursor, or any MCP host.

35 installs/wk local only

Chartwire

by outturndev

Generate production-ready chart code (Recharts, Chart.js, ECharts, Plotly) from a prompt.

answering

AgentForge

by sciscale

Turn rough requests into rigorously structured prompts, for any coding agent.

29 installs/wk local only

PicoBerry

by umodeler

An AI 3D workspace for games, VR, and beyond. Generate, remesh, texture, and animate 3D assets.

43 installs/wk local only

The Scribble Thing

by boringstuff

Turn one line-art image into a prompt-directed, hand-drawn scribe animation MP4.

6 tools answering

GripForge — questions

Answers built from our own checks of this server.

What can GripForge do?

It exposes 142 tools, read directly from the server on our last check. Among them: getAttachmentFrame, getWearableFrame, gripforge_aim, gripforge_animate, gripforge_armor_generate, gripforge_armor_read and 136 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →

Is GripForge working right now?

We send a real MCP handshake every 15 minutes. Over the last 24 hours 88 of 90 checks got a reply (97.8%), average response time 460 ms. The bar chart above shows every period we have measured.

How do I connect GripForge?

Copy the ready config from this page — we generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each with the file path that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.

Does GripForge need an API key?

No. GripForge completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 142 of them are readable on this page. This is what we observed, not what the docs claim.

How fast is GripForge?

It answers our handshake in 460 ms on average, which is faster than 34% of all working MCP servers we measure. The comparison comes from our own checks across the whole registry, every 15 minutes.

How many people use GripForge?

The npm package @gripforgeai/mcp was installed 371 times in the last week. Week over week that is +1180%. We show installs rather than GitHub stars on purpose: a star is a bookmark, an install is someone actually running it.

Is GripForge open source?

Yes — it is published under the MIT licence, written in TypeScript and 1 stars on GitHub. The source link is on this page, so you can read exactly what it does with your data before you connect it.