MCP App Store
by KeenEthics
Exekite icon

Exekite MCP Server for ChatGPT

By Exepad LLC

Overview

Create, improve and test games through your assistant. Exekite stores your projects, runs automated checks and playtests, and saves verified versions you can preview, restore or export. Manage game assets and prepare release builds and store settings. Visual tools help you inspect gameplay, models, images and sounds where supported. Connect your Exekite account and choose which games your assistant may access. Optional generated art, sound, music and 3D models are created only when requested for an Exekite game project. Store submission, signing, agreements and account deletion stay with you in Exekite Studio.

How to connect

  1. ChatGPT: Open the Exekite listing in the ChatGPT app directory and choose Connect. ChatGPT listing Exekite exposes 104 tools here.

Tools

abort_turn

ChatGPT
Cancels or pauses a change that has not been saved. It waits for any operation already running on the turn, stops the turn's Game Test and Blender sessions, unlocks the game and returns its files to the turn's base revision. retain_draft false (default) discards the draft; true keeps it parked for 24 hours, and resume_turn can continue it while the game stays at that revision. A saved (landed) change cannot be cancelled; restore_revision returns the game to an earlier verified revision. Runs as a job in the game's workspace.

acquire_control

ChatGPT
Acquire a fenced human controller for this existing Game Test viewer. Refuses another controller, stale runtime, expired lease or readonly grant. No new test is started.

act_in_game

ChatGPT
Plays the running Game Test with the keyboard, then returns a screenshot and the new log lines, to see what an input does. timeline: 1–16 steps of {keys, duration_ms}, each holding up to 8 distinct keys together for 0–10000 ms, 30000 ms in all; keys [] waits. Keys repeated in the next step stay held; all are released at the end. Keys: letters, digits, ArrowLeft, ArrowRight, ArrowUp, ArrowDown, Space, Enter, Escape, Tab, Shift, Control, Backspace; no mouse. A paused game resumes 0.15 s before the input, runs during it, then pauses again; otherwise it keeps running between calls. The screenshot is an image in the job result (get_job or wait_for_job), not a file view_images or read_files can open. Edits no game files. Its workspace minutes count as build time. Refused while a person is controlling the game from the live view. Its identity names the revision, draft sequence and source_digest the running game started from; later edits do not change it.

add_game_asset

ChatGPT
Generates and registers a new game asset with Exekite's paid asset service when the person asks: an image, a side-view sprite sheet, a sound effect or music, or a static 3D model. element.asset_id must be new; subject_kind is audio for sounds and character for sprite sheets; description is at most 600 characters. It is checked with Godot and saved as a new revision; an edit turn wires it into gameplay. Needs the current revision as expected_revision and the estimate_id of an estimate_cost quote for the same arguments (on ESTIMATE_EXPIRED, quote again). The charge comes off the account's existing Exekite balance: at most the quote's maximum_charge_micros, nothing if it fails. Refused if the plan no longer includes it (PLAN_NOT_INCLUDED or DIMENSION_NOT_INCLUDED), while another change or paid generation in the account runs, or if the balance less held and pending charges is below that maximum. Other changes wait while it runs, and after a failure until settlement releases its hold. Its maximum stays held until the charge settles (usually 5–10 minutes), then list_charges shows it.

apply_changes

ChatGPT
Writes code and scene edits into a turn's draft. Up to 32 operations, one per path: write (whole text), literal_replace (find occurs exactly once), unified_patch (exact-context hunks), move or delete. Each path needs its expected_sha256 (null for a new file); a move also needs expected_destination_sha256 and, for a file with a .uid, both .uid hashes. expected_sequence is the latest sequence (this call's result or get_turn); checks, plans, Game Test and Blender steps also advance it. The batch applies fully or not at all. In a build turn, a write, delete or move onto a file of the starter waiting screen (scenes/Main.tscn and main.gd) also accepts the hash it had before the turn opened (null if absent) while it still holds the starter bytes and the turn has not changed it. Writable: .gd, .tscn, .tres, .gdshader, .gdshaderinc, .json and .md files outside addons/, assets/, marketing/ and .exekite/, except platform-owned ones like scripts/art_bank.gd. A call over 1 MiB is refused (REQUEST_TOO_LARGE): split big changes. The first call locks the game; submit_turn alone makes a revision.

attach_game_asset

ChatGPT
Adds a file the person uploaded (begin_file_upload, purpose game_asset) as a new registered asset that Godot can load: an image up to 8192 px per side and 16 megapixels, a sound up to 600 seconds, or a self-contained GLB model. It is checked with Godot and saved as a new revision; wiring it into gameplay takes an edit turn. element.asset_id must be a new lowercase id; existing assets are never replaced. An animated GLB may have up to 6 MiB, 64 clips, 256 channels, 100,000 keyframes and 600 seconds of non-skinned node translation, rotation and scale (LINEAR, STEP or CUBICSPLINE). Requires the current revision as expected_revision. A file the game's storage cannot hold (each saved file counts about twice, saved versions included) is refused with PROJECT_STORAGE_FULL before any check. Its workspace minutes count as build time. It needs a plan with editing and a positive balance after funds held for paid generations. Refused while a turn or another change holds the workspace. Runs as a job.

begin_file_upload

ChatGPT
Prepares an upload of the person's own art, sound, 3D model or store image (up to 16 MiB). Declare purpose, filename, mime_type, byte_size and the bytes' lowercase hex sha256. The result gives upload_id and a presigned upload_url: PUT exactly those bytes there with the returned Content-Type, then within 15 minutes pass upload_id to attach_game_asset (purpose game_asset: PNG, JPEG, WebP, WAV, OGG, MP3 or GLB), import_3d_model (blender_source: GLB) or upload_store_asset (store_asset: PNG or JPEG; it refuses WebP). Anyone holding upload_url can upload until it expires, but only bytes matching the declared size and checksum are used, and upload_id works only for this connection and project. After it expires the job's result no longer shows upload_url (link_expired is true); begin a new upload with a new operation key. No tool uses a .blend or a project_attachment upload. Changes no game; runs as a job.

cancel_job

ChatGPT
Asks to stop one job. A queued job is cancelled at once and any amount reserved for it is released without charge. A running operation that belongs to a turn (a write, check, Game Test or Blender step) stops the whole turn: its draft is kept parked, the game's files return to the turn's base revision, and cancellation completes only once that rollback is confirmed; resume_turn continues the draft. Other running operations, such as paid generation, previews, exports and release builds, cannot be cancelled; their result and any charge stay visible through get_job. operation_id identifies this cancellation request. Runs as a job whose result says cancelled, already_terminal or completed_before_cancel.

check_scripts

ChatGPT
Parses chosen GDScript files with the game's Godot 4.6 engine and reports syntax and type errors by file and line, without running the game. Use it after editing scripts, for quick feedback before a full start_check. paths takes 1–50 project .gd files; the project's other scripts still count as known types. It belongs to a turn: it locks the game for the turn if needed, stops a running Game Test first and uses one of the turn's 30 parse runs (shared with start_check's parse profile and apply_changes' check parse). It changes no source files. Runs as a job; parse errors are reported in its result, not as a failed job.

check_store_listing

ChatGPT
Checks what one store's saved listing still needs before it can be submitted. workspace must be a store (a destination: value); a platform is refused (STORE_REQUIRED). Returns listing_review (checked, language_required or not_applicable), ready, listings[] (each: scope, label, primary, issues[{field,code,message,fix}], reviewed, reviewed_at) and blockers[] ({field,code,message,expected?,received?,fix}); fix is {with:"update_ship_settings",patch_path,values?,ask_person?} or {with:"studio",where}: values lists the only values accepted there, and ask_person marks a fact to ask the person for, such as the App Store release type. CrazyGames and Poki have no listing; their release settings are checked. Store images are not checked. A stale manifest_revision returns REVISION_CONFLICT with expected and received. ready is never store approval. It records no review and changes no settings; it starts the project's workspace if needed, and its workspace minutes count as build time. Returns a job.

close_viewer_session

ChatGPT
Release only this app viewer. Does not abort an authoring turn or cancel a job. Existing stream authority becomes invalid.

create_3d_model

ChatGPT
Builds a new 3D model, such as a prop, from simple shapes in the project's Blender and saves it into the turn's draft. element.asset_id optionally links an existing game element from list_game_assets; omit it for a standalone model. The server generates model_id. recipe.operations: 1–32 steps as in edit_3d_model; no code. Starts Blender if needed, activates a turn that is not active yet, and leaves the new model open in place of any other. A failed step saves nothing and closes Blender. Limits: 512 objects, 100,000 vertices, 128 models per project. operation_id: 8–100 letters, digits, underscores or hyphens. Returns model_id, checkpoint and object names. It joins the game when the turn lands and shows only where game code loads it (ArtBank.scene(model_id)). A turn's draft holds at most 15 MiB: an operation whose output would exceed it is refused (DRAFT_LIMIT, with details.headroom_bytes) and undone, closing Blender, while the turn stays active. Its workspace minutes count as build time.

create_project

ChatGPT
Creates a new game project in the person's account for the assistant to build; Exekite never builds it automatically, and a start_turn build turn writes the game. Pass a title (1–80 characters, unique among the account's projects, including deleted ones) and optionally dimension 2d or 3d, or a graphics style (pixel, vector or painterly for 2D, lowpoly3d for 3D), which decides the dimension. Without design the project is empty and nothing is charged. design takes set_game_design's pitch, expanded_brief, concept and key_art_decision: the same job starts the new game's workspace and saves it, its minutes count as build time, and it needs what set_game_design needs. The concept's 2D or 3D must match dimension or graphics, and decides the dimension when neither is given. result.design.status is saved (with the new revision), refused or unknown; a refused design leaves the project for set_game_design. Needs a connection with access to the whole account and a plan that allows creating games; 3D needs a plan that includes 3D. Runs as a job; the result's id is the new project_id.

create_share

ChatGPT
Publishes the game's current verified revision on its public exekite.games page, where anyone with the address can play it and search engines may list it. Use it only when the person asks to publish publicly; create_preview_link makes a temporary unlisted link instead. Pass get_play_link's share_request (the current verified_revision and its confirmation_digest) with an operation_id. It starts the project's workspace and rebuilds the web export if needed. The address stays the same: publishing again replaces the public version, and the replaced version's player notes are deleted at the next daily cleanup. Needs the connection's permission to publish; without it nothing starts, and the host asks the person to reconnect Exekite with it or the call returns INSUFFICIENT_SCOPE. Refused after a moderation takedown, at the account's limit of published games, after too many publishes a minute, or while another change is in progress. Returns a job.

create_viewer_session

ChatGPT
Create an expiring app-only view of an existing Game Test, Blender desktop or verified preview job. No new test, export, author call or paid work. Stream credentials are delivered only to the component.

discard_3d_model_changes

ChatGPT
Discards the open 3D model's unsaved changes and closes it; edits already saved stay in the draft. It ends the turn's Blender session, for example when model work is finished. create_3d_model, edit_3d_model and import_3d_model save every accepted change into the turn's draft as it happens, so usually nothing is left unsaved (the result's unsaved_discarded says whether anything was). Undoing saved changes means discarding the whole turn with abort_turn (retain_draft false, the default), which also drops its other changes. Needs the open model's model_id and latest expected_checkpoint (MODEL_NOT_OPEN or MODEL_CHECKPOINT_CONFLICT otherwise). open_3d_model opens it again. No charge.

edit_3d_model

ChatGPT
Changes the model open in this turn's Blender with 1–32 modelling steps and saves it to the turn's draft. primitive adds a new named cube, sphere, cylinder, cone, torus or plane; transform sets (not adds) position, rotation in XYZ degrees or scale; material gives a mesh one RGBA colour (0–1), roughness and metallic; duplicate copies an object under a new name; delete removes one; bevel permanently rounds a mesh's edges. Use exact names from the latest object list. A step that fails in Blender undoes the whole batch, keeps the last save and closes Blender until the model is reopened. Needs model_id and the latest expected_checkpoint; operation_id: 8–100 letters, digits, underscores or hyphens. Limits: 512 objects, 100,000 vertices. A turn's draft holds at most 15 MiB: an edit whose output would exceed it is refused (DRAFT_LIMIT, with details.headroom_bytes) and undone, closing Blender, while the turn stays active. Returns the new checkpoint and object list. Its workspace minutes count as build time.

edit_game_asset_image

ChatGPT
Edits a registered PNG image or one sprite sheet animation in place with Exekite's paid asset service when the person asks. edit.operation is instruct, variation or inpaint (with mask_base64, a PNG the image's size); edit.animation picks the animation, keeping its size and frames. expected_take is the PNG's current SHA-256 (list_files reports it). Saved as a new revision; restore_asset_take can undo it. Needs the current revision as expected_revision and the estimate_id of an estimate_cost quote for the same arguments (on ESTIMATE_EXPIRED, quote again). The charge comes off the account's existing Exekite balance: at most the quote's maximum_charge_micros, nothing if it fails. Refused if the plan no longer includes it (PLAN_NOT_INCLUDED or DIMENSION_NOT_INCLUDED), while another change or paid generation in the account runs, or if the balance less held and pending charges is below that maximum. Other changes wait while it runs, and after a failure until settlement releases its hold. Its maximum stays held until the charge settles (usually 5–10 minutes), then list_charges shows it.

estimate_cost

ChatGPT
Prices one paid media generation before it runs. Set operation to generate_key_art, add_game_asset, edit_game_asset_image or generate_store_art, and parameters to exactly that tool's arguments without operation_id and estimate_id; they are checked now. Returns estimate_id, expires_at and maximum_charge_micros: the most that tool can take with this estimate_id from the account's existing Exekite balance (the charge can be lower; the rest is released). A quote lasts 15 minutes, is used once, covers only these arguments on this connection, and must be renewed if the project or the provider's price changes. Before the workspace starts it refuses: PLAN_NOT_INCLUDED on a plan without editing games; DIMENSION_NOT_INCLUDED on a plan without generated media (details.capability generated_media) or for a 3D game on a plan without 3D (details.alternative 2d). It and the paid tools need asset generation permission; without it nothing starts (the host asks to reconnect, or INSUFFICIENT_SCOPE). Runs as a job, starting the project's workspace if needed; its workspace minutes count as build time.

export_source

ChatGPT
Packages a game's saved project as a .zip the person can keep or open in Godot: scenes, scripts, assets and settings, without git history, Godot's import cache, chat history or private platform state. revision must be the game's current revision, with no unsaved change in progress. Runs as a job in the game's workspace (starting it if needed); the result gives an artifact_id and the zip's size and SHA-256. get_download_link with that artifact_id returns a link that expires after 5 minutes and works for anyone who has it; the archive is kept 30 days. It does not change or publish the game.

generate_key_art

ChatGPT
Generates the game's key art (its poster) from the saved design with Exekite's paid asset service when the person asks. The image becomes the game's library card picture and, unless the game has a banner, its loading screen; it is saved as a new revision and changes no game code. Needs a saved design, the current revision as expected_revision and the estimate_id of an estimate_cost quote for the same arguments (on ESTIMATE_EXPIRED, quote again). The charge comes off the account's existing Exekite balance: at most the quote's maximum_charge_micros, nothing if it fails. Refused if the plan no longer includes it (PLAN_NOT_INCLUDED or DIMENSION_NOT_INCLUDED), while another change or paid generation in the account runs, including an active turn, or if the balance less held and pending charges is below that maximum. Other changes wait while it runs, and after a failure until settlement releases its hold. Its maximum stays held until the charge settles (usually 5–10 minutes), then list_charges shows it. Runs as a job.

generate_store_art

ChatGPT
Generates store art with Exekite's paid asset service when the person asks: a square icon for any platform or store, or a 1024x500 Google Play feature graphic. Without recipe.prompt, the prompt is built from the game's saved design. The image is saved into that workspace's release settings as a new revision, never into game files; a new icon clears that workspace's review confirmation. Needs the saved manifest_revision as expected_manifest_revision and the estimate_id of an estimate_cost quote for the same arguments (on ESTIMATE_EXPIRED, quote again). The charge comes off the account's existing Exekite balance: at most the quote's maximum_charge_micros, nothing if it fails. Refused if the plan no longer includes it (PLAN_NOT_INCLUDED or DIMENSION_NOT_INCLUDED), while another change or paid generation in the account runs, or if the balance less held and pending charges is below that maximum. Other changes wait while it runs, and after a failure until settlement releases its hold. Its maximum stays held until the charge settles (usually 5–10 minutes), then list_charges shows it.

get_3d_model

ChatGPT
Returns what is known about one 3D model without opening it: its saved entry (name, linked game element, file paths, revision), whether it is open in Blender now, and the checkpoint of its open session. Use it to check a model before editing it. The object list (up to 512 objects and 100,000 vertices: exact names, types, local transforms in XYZ degrees, vertex counts) is included only while the model is open, saved and unchanged; otherwise description is null with description_status unavailable, and open_3d_model returns a fresh one. It changes no file and does not start Blender or re-read the model, though it starts the project's workspace if that is stopped. An unknown model_id returns MODEL_NOT_FOUND. With turn_id, which must be a turn of this connection on this game (otherwise TURN_NOT_FOUND), the read is also recorded in that turn's activity, which the visual companion follows; the answer is the same. Its workspace minutes count as build time.

get_account

ChatGPT
Returns the connected Exekite account's opaque id (id), which stays the same across reconnections, token refreshes and permission changes and is never reused, and what its plan includes: whether it includes creating and editing games, 3D games, generated media, store release kits, and desktop and mobile (Android and iOS) releases, and its live project limit, plus the balance in micro-dollars (1,000,000 = 1 USD). Use it to check what the account can do before starting work. It returns no personal name, and an email address only when the connection was granted email access; no plan name, prices or offers. Read-only; starts nothing.

get_balance

ChatGPT
Returns the account's Exekite balance in micro-dollars (1,000,000 = 1 USD): balance_micros; held_micros, reserved by paid work still running or settling, such as paid generations and open build sessions; pending_settlement_micros, charges for finished or running changes not yet deducted (null, with pending_status unavailable, when they cannot be read); available_before_pending_micros, the balance minus holds, from which pending charges still come off; and build_time: open_sessions (games whose workspace minutes count now), minutes_today and charged_today_micros. Use it to explain a quote or a balance refusal. The figures cover the whole account; project_id only checks access. Plan limits are in get_account. Read-only; starts nothing.

get_deletion_handoff

ChatGPT
Returns a link to Exekite Studio's home page, where the signed-in person can delete a project themselves; use it when the person wants a project deleted, which no tool here can do. The assistant cannot approve the deletion for them. It deletes nothing and does not report whether deletion happened: afterwards the project no longer appears in list_projects and get_project refuses it. Read-only; starts nothing.

get_diff

ChatGPT
Shows changes as a unified diff. Use turn_id to review a turn's draft against its base revision before checking or submitting it (new files included; large or binary ones summarized), or from_revision and to_revision (full commit hashes) to compare two saved revisions. paths narrows it to up to 64 files. The patch stops at 100,000 characters (truncated: true) and is not paged, so narrow it with paths. A build turn's draft can be diffed once its first apply_changes, start_check or start_game_test has run, and a parked draft after resume_turn. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time.

get_failed_attempt

ChatGPT
Reads one change attempt (a turn) and its saved draft, to inspect or reapply failed or paused work. Identify it by turn_id, or by iteration_id (a list_history row's id); only this connection's turns are found, and an iteration_id with no matching turn returns draft_available false. Returns the state, base revision, request, check counts, last validation verdict, plan, draft_available (false once the draft was discarded or landed), draft files with base64 content and deleted paths. Files come in pages of up to limit files (default 20, max 100) and 128 KiB via next_cursor; a larger file is listed without content. It reads saved records only and does not reopen the draft (resume_turn does).

get_game_asset

ChatGPT
Shows one asset in detail: where it came from (generated, uploaded, made with the Blender tools or made by code, with its generation prompt when recorded), its files and animation names, and the code lines and other scripts that use it. Use it before editing, replacing or wiring an asset. Pass asset_id for a registered asset or fingerprint for something made by code, both from list_game_assets. It does not list earlier versions. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time. With turn_id it reads that turn's draft; TURN_NOT_ACTIVE refuses a parked draft, or a build turn before its writer lease opens. Without turn_id it is refused with WORKSPACE_BUSY while a turn or another change holds the workspace (details.holder says which; retry after retry_after_s).

get_game_design

ChatGPT
Reads the game's saved design; use it before setting or changing the design or starting a first build. It returns the person's original pitch and expanded brief, the concept, concept_input (the editable copy to start a concept update from), the key-art decision, whether the game has been built and the current revision to pass as expected_revision, plus authoring_contract: the exact input schemas, with a valid example, for set_game_design and for the build manifest submit_turn needs, even on an empty project. It changes no game file; it starts the game's workspace if needed, and its workspace minutes count as build time. Runs as a job: read the result with wait_for_job or get_job.

get_game_test_status

ChatGPT
Reports the state of the turn's Game Test: available (none running), starting, running, stopping, stopped or unavailable, with a short detail. Use it to see whether a started game is ready or has stopped; if the game exited on its own, the detail ends with its last log lines. It never starts, restarts or advances the game, though it starts the project's workspace if that is stopped. Its workspace minutes count as build time. game_test_id is the one start_game_test returned (equal to turn_id). A turn that is not active is refused with GAME_TEST_NOT_ACTIVE, naming the call that helps. New logs come from observe_game with capture false. Its identity names the revision, draft sequence and source_digest the game started from (sequence and source_digest are null if none was started).

get_godot_guide

ChatGPT
Returns one of Exekite's guides as Markdown, the whole guide in one result. It needs no project and starts no workspace: project_id is accepted and ignored. guide_id is exekite-studio, the workflow for building, checking, playing and handing off a game; one of its parts: exekite-studio-authoring (designs, source turns and recovery), exekite-studio-failures (the next step after each refusal code), exekite-studio-game-craft (gameplay, playtests and assets) or exekite-studio-visual-companion (watching, playing and inspecting); or a Godot craft guide: autoload-discipline, collisions-and-areas, debugging-godot, entity-lifecycle, gdscript-style, generated-media-wiring, godot-4-syntax-vs-3, hud-and-overlay-layout, moving-things-that-collide, resource-pattern, scene-organization, signals-and-events, startability-and-input-gates or tilemap. A link to another guide names its id. An unknown id returns GUIDE_NOT_FOUND with details.valid_ids. Read-only.

get_iteration_report

ChatGPT
Returns the saved validation report of one change (iteration_id is a list_history row's id): whether it passed, a summary, the check that stopped it, failed check ids, errors, warnings and each check's result, such as parse, scene, boot and playtest_probe. Use it to see why a change failed or what it verified. report_kind gate and summary return this report. Playtest results are among its checks; report_kind playtest looks for a separate playtest report that changes no longer save, so it returns report_available false, as does a change with no saved report. A change that ran no game checks reports only ok. Process logs are never returned; a report over 1 MiB is refused (REPORT_TOO_LARGE). It reads saved records only.

get_job

ChatGPT
Reads one job, the record of an operation started through this connection, to see whether it finished and what it returned. It starts nothing. The job has a state (queued, running, succeeded, failed, cancel_requested, cancelled or interrupted) and, once finished, a result or error. Images or audio the job produced, such as Game Test screenshots or viewed images, come back as content. retry_after_s says when to look again; cursor is the job's change counter for wait_for_job. A link in a finished result (a preview, upload or download link) is left out once it has expired, with link_expired true. A job is final for its operation key: repeating a call with the same key returns the same job, even one that failed or was interrupted. A connection that calls too often is refused with RATE_LIMITED; retry after its retry_after_s.

get_notarization_handoff

ChatGPT
Returns the Exekite Studio link (the project's Ship page) for macOS notarization: the person signs and notarizes a Mac release on their own Mac, with the script in its download and their Apple account, then uploads the resulting receipt in Studio. Use it when a Mac release needs notarization. It only returns that link and step: it does not look up the release (release_id is echoed back unchecked) or read whether a receipt was recorded, and neither it nor the assistant can record one. It starts nothing and changes nothing.

get_project

ChatGPT
Returns one project's basic facts: title, 2D or 3D, its latest verified revision (verified_head: iteration id and revision hash, or null before the first verified change; a saved design or concept counts here, so list_projects' has_verified_version says whether the game has been built), a Studio link, metadata_revision (the value rename_project checks) and whether it was created for assistant authoring, which Exekite never builds automatically. Use it to confirm the target game. It reads only stored records and starts nothing; get_project_status and get_game_design report build and design state.

get_project_activity

ChatGPT
Reads the recorded activity of one turn or root job of this connection, with a snapshot of its latest job, so the companion can follow it: up to 50 events (default 30) from the last 24 hours, after after_sequence. Pass the returned next_sequence as after_sequence to continue; snapshot_required true means the cursor is past or before the kept events, so rely on the snapshot. It never selects a whole project's latest activity, starts a workspace or job, or changes anything.

get_project_context

ChatGPT
Summarizes a game for authoring in one read: its design (brief, concept, editable concept_input, and the authoring contract: field schemas and an example for set_game_design and birth_manifest), whether it is built, declared tunables with current values, the current revision and up to 300 files with sizes and SHA-256 hashes. Without turn_id, an unbuilt game's files omit those its build turn replaces; starter_files_replaced_at_build counts them. storage gives the game's storage use against its limit, saved versions included: used_bytes, cap_bytes, left_bytes and a summary line (null until first measured). Use it before a build or edit; list_files lists more files. With turn_id it reflects that turn's draft (a build turn only after its first write, check or Game Test; a parked one after resume_turn); revision, if given, must be the current one. While another writer holds the workspace, a call without turn_id is refused with WORKSPACE_BUSY. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time.

get_project_status

ChatGPT
Summarizes one game without starting anything: its title, dimension, current verified revision, Studio link, a page of up to 20 of the jobs this connection ran for it (newest first, with a next_cursor that list_jobs accepts as cursor), active_jobs (its jobs still queued, running or being cancelled) and open_turns (its turns not yet landed, aborted, failed or expired). Each job row carries its state, cursor and any error but not its result, which get_job or wait_for_job reads. Use it to pick up work after an interruption.

get_release

ChatGPT
Returns one release build by release_id (a build_id from list_releases): its workspace, profile, status and settings revision, and its still-available downloads (artifact_id, filename, bytes, sha256, expires_at; get_download_link takes the artifact_id). For a complete release it adds kit_refresh: a preview of repackaging it with the current saved settings, carrying the expected_manifest_revision and preview confirmation_digest that refresh_kit takes, or unavailable with a reason. Preparing that preview starts the project's workspace if needed, and its workspace minutes count as build time; nothing is changed. Returns a job; read it with get_job or wait_for_job.

get_runtime_scene

ChatGPT
Returns the node tree recorded from a short run of the game's current landed version without a screen, to find which node and script make a character or object. Up to 400 nodes with a script, group or visual: path, class, groups, script and whether it draws itself. The run lasts about 3 seconds and presses ui_accept; later spawns, collision shapes, timers, cameras, audio and plain UI are absent. This call returns the stored recording and makes none itself: cached false means no recording exists for this revision yet (made after each landed change and at workspace start); a failed one has ok false and a reason. revision, if given, must be current; with an active turn's turn_id, stale_for_draft is true, as the recording ignores the draft. Starts the project's workspace if stopped. Its workspace minutes count as build time. Its identity names the landed revision, with null turn_id and sequence; its source_digest is null while a draft holds the workspace.

get_share_feedback

ChatGPT
Lists the notes players have sent about the game's public page. Use it to read what players reported. Each note is anonymous player-written text of up to 500 characters, returned as written, with its share_id and created_at; notes are not in date order. share_id narrows the list to one publication. Pages of up to limit notes (default 20, max 100) continue with next_cursor. Notes on an unpublished or replaced version are deleted at the next daily cleanup. It reads saved records only. Returns a job; read it with get_job or wait_for_job.

get_ship_settings

ChatGPT
Returns the saved release settings of one platform or store (the workspace argument): manifest_revision, that workspace's listing copy and listing languages, title and description overrides, version, release notes, pricing, ads, setup and Google Play images, the project-wide release information, and what update_ship_settings can change there: editable_fields, editable_values (the only values accepted, such as the Poki ad mode) and, for Google Play, App Store and Steam, listing_languages (that store's language ids). Use it before editing listing copy or adding store art; their revision checks take this manifest_revision. It changes no settings; it starts the project's workspace if needed, and its workspace minutes count as build time. Returns a job; read it with get_job or wait_for_job.

get_ship_status

ChatGPT
Reports release readiness on one platform or store (the workspace argument): whether a verified revision exists, which release targets Exekite can build for this account (plan-excluded ones read not_included_in_plan), the latest release build for the saved profile and whether the game has a public page. readiness.blockers names saved CrazyGames or Poki settings Exekite would refuse, each with its fix, as check_store_listing does, such as Poki saved with ad mode none (no Poki release package builds from it; update_ship_settings can choose Test ads); other targets are checked when start_release runs. Use it before start_release: with a verified revision, release_request holds the arguments start_release takes apart from an operation_id. It never claims store approval. It changes no settings, files or releases; it starts the project's workspace if needed, and its workspace minutes count as build time. Returns a job.

get_submission_handoff

ChatGPT
Returns the Exekite Studio link (the project's Ship page) where the person takes a release through store submission; for App Store releases they also report there the build number they actually submitted. Use it when a release is ready for a store. It only returns that link and step: it does not look up the release (release_id is echoed back unchecked), uploads nothing to any store, and cannot record or confirm a submission; only the signed-in person can, in Studio. It starts nothing and changes nothing.

get_tunables

ChatGPT
Reads the game's declared tuning knobs: named numbers in its code, such as speed or jump height, that set_tunables can change. Each has name, file, constant, min, max, step and the value currently in the code; a knob that cannot be adjusted has value null and blocked says why (missing, out_of_range, or clobbered when the code reassigns it at runtime). declared is false when there are none. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time. revision, if given, must be the current one. With turn_id it reads that turn's draft; TURN_NOT_ACTIVE refuses a parked draft, or a build turn before its writer lease opens. Without turn_id it is refused with WORKSPACE_BUSY while a turn or another change holds the workspace (details.holder says which; retry after retry_after_s).

get_turn

ChatGPT
Reads the saved state of one change (turn) without starting anything: its state (such as ready, active, parked, landed, aborted or expired), sequence, base revision, purpose and request, deadlines, check and failed-submit counts, to-do plan, last check verdict, whether its draft is still available, and the draft's size (draft_bytes) against its 15 MiB limit (draft_limit_bytes). Use it to get the expected_sequence that apply_changes and submit_turn need, or to decide whether to call resume_turn after an interruption: the state is as last saved, so after a workspace restart an unfinished turn can still read active, and resume_turn restores its draft. Only turns started through this connection are visible. File contents are not included.

import_3d_model

ChatGPT
Adds a static 3D model from an uploaded .glb file as a new Blender model, saved into the turn's draft like create_3d_model. Upload it first with begin_file_upload (purpose blender_source, model/gltf-binary, at most 16 MiB) and import within 15 minutes. The file must embed its textures and hold only meshes: no animations, skins, rigs, cameras or lights (animated models go through attach_game_asset); at most 512 nodes, 32 textures and 100,000 vertices. element works as in create_3d_model. It always makes a new model with a server-generated model_id, never replacing one, and leaves it open in Blender. Starts Blender if needed and activates a turn that is not active yet. operation_id: 8–100 letters, digits, underscores or hyphens. A turn's draft holds at most 15 MiB: an import whose output would exceed it is refused (DRAFT_LIMIT, with details.headroom_bytes) and undone, closing Blender, while the turn stays active. A model the game's storage cannot hold is refused (PROJECT_STORAGE_FULL). Returns model_id, checkpoint and object names. Its workspace minutes count as build time.

inspect_game_state

ChatGPT
Reads the live node tree of the running native Game Test and, if asked, current property values, to check facts such as a player's position or health. Select nodes by exact node_paths (such as /root/Main/Player, up to 16), by subtree (that node and everything under it) or neither (the whole tree); at most 200 nodes are returned. properties names up to 16 properties to read, script variables included; with properties, at most 16 nodes are returned. Paths and names: at most 256 characters; each value is cut at 4000 characters. Returns nodes with path, name, type, the values read and missing_properties (requested names a node cannot show), plus total_nodes, truncated and paused. It sets nothing, calls no method and does not advance the game, though reading a property runs its getter. A web test is refused, and a result over 192 KB fails. Starts the project's workspace if it is stopped. Its workspace minutes count as build time. Its identity names the revision, draft sequence and source_digest the running game started from; later edits do not change it.

install_ads_helper

ChatGPT
Adds Exekite's ads helper script (scripts/ads.gd, class Ads) to the game as a new verified revision, so a later edit turn can call it at the person's saved ad placements; by itself it shows no ads (previews and ad-free builds report ads as unavailable). configuration is {revision, workspace?}: the saved settings' manifest_revision, and a {kind,id} for Web, App Store, CrazyGames or Poki (omit it for Google Play) whose Test or Live ads, adult audience and placements the person saved in Studio. expected_revision is the project's current revision (from get_project_context). Refused while another change is in progress or when the game's own code has scripts/ads.gd or class Ads. Needs a plan with editing and a positive balance after funds held for paid generations. Its workspace minutes count as build time. Returns a job with a wiring guide.

install_privacy_helper

ChatGPT
Adds or updates Exekite's privacy policy helper script (scripts/privacy_policy.gd, class PrivacyPolicy, whose open() opens the policy page) as a new verified revision, so a later edit turn can add a privacy policy button to the game's menu; Google Play requires the policy inside the app. privacy_url must be an https URL with no user name or password, at most 2048 characters. expected_revision is the project's current revision (from get_project_context). Refused while another change is in progress or when the game's own code uses that path or class name. Needs a plan with editing and a positive balance after funds held for paid generations. Its workspace minutes count as build time. Returns a job with a wiring guide.

list_3d_models

ChatGPT
Lists the game's Blender models, to choose one to open. Each entry gives assetId (the model_id the other 3D model tools take: blender_ plus 32 hex characters), name, linked game element (logicalAssetId), revision (open_3d_model's expected_source_digest), file paths and digests. activeAsset is the model open in Blender now; legacy is an older combined scene these tools cannot open. It shows the workspace as it is: landed models plus any saved by the active turn. A project holds at most 128 models, all returned at once. It changes no file and does not start Blender, though it starts the project's workspace if that is stopped. Its workspace minutes count as build time.

list_charges

ChatGPT
Lists the account's balance entries: charges for game changes and paid generations (kind debit; amount_micros negative, or 0 for a change that cost nothing), credits when funds are added or refunded (positive), and adjustments such as expired credit or a reversed payment (negative). Each entry has kind, amount_micros, project_id, iteration_id, operation and created_at. A connection limited to some games lists only those games' entries and entries that belong to no game; get_balance gives the totals. Optional project_id keeps only that project's entries; since and until (Unix seconds) bound the period. Newest first; cursor and limit (default 20, at most 100) page the list, with next_cursor passed back unchanged. Read-only; starts nothing.

list_files

ChatGPT
Lists a game's files with their sizes and SHA-256 hashes. Use it to find files to read or edit and to get the expected_sha256 values apply_changes needs. Narrow with prefix; up to 100 rows per page, then pass next_cursor as cursor. Private platform state, such as Godot's import cache and chat history, is never listed. On a game not yet built, a listing without turn_id or revision also leaves out the starter files a build turn replaces, and starter_files_replaced_at_build gives how many the project holds. turn_id reads that turn's draft (for a build turn, once its first apply_changes, start_check or start_game_test has run; when parked, after resume_turn); revision reads a committed revision (not both). Rows for a revision carry git blob ids instead of SHA-256. Reads of current files are refused (WORKSPACE_BUSY) while another writer holds the workspace. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time.

list_game_assets

ChatGPT
Lists the game's art, sound and 3D models in one result: registered asset files (generated, uploaded or made with the Blender tools, with path, kind and whether code uses them) and the visuals and sounds made by code, each with a fingerprint and the code line that makes it. Use it to find the asset_id or fingerprint for get_game_asset, preview_game_asset or an asset edit. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time. With turn_id it reads that turn's draft; TURN_NOT_ACTIVE refuses a parked draft, or a build turn before its writer lease opens. Without turn_id it is refused with WORKSPACE_BUSY while a turn or another change holds the workspace (details.holder says which; retry after retry_after_s).

list_history

ChatGPT
Lists the project's changes, newest first: assistant turns, Studio edits, design saves, asset generation and helper installs. Each row has id (its iteration_id), status (running, verifying, verified, rolled_back or failed), git_commit_sha (its revision) and created_at, but not the request text. current_revision is the current verified revision, and each verified row carries restore_request, the arguments restore_revision takes apart from an operation_id. Use it to find a change for get_iteration_report or a version to restore. Pages of up to limit rows (default 20, max 100) continue with next_cursor. It reads saved records only. Returns a job; read it with get_job or wait_for_job.

list_jobs

ChatGPT
Lists the jobs started through this connection, each with its state and, once finished, its result or error. Use it to recover a job_id or to find work still running. Filter by project_id, state (queued, running, succeeded, failed, cancel_requested, cancelled or interrupted) or kind, the tool that created the job (for example submit_turn). Newest first, up to 100 per page (default 20); pass next_cursor back unchanged as cursor for more (any other cursor is refused with INVALID_CURSOR). Reads saved records only and starts nothing.

list_projects

ChatGPT
Lists the account's games that this connection can access, excluding deleted ones: each with project_id, title, 2D or 3D, whether it has been built and has a verified version (has_verified_version; a saved design alone is not one), latest_status (the status of its latest change attempt, a saved design included; a rolled_back attempt, which is also how a cancelled one reads, or a failed one leaves the verified version unchanged), metadata_revision (the value rename_project checks, as get_project gives it) and a Studio link. Use it to find the project the person means. Sorted by project id; cursor and limit (default 20, at most 100) page the list. Read-only; starts nothing.

list_recoverable_assets

ChatGPT
Lists this project's paid asset generations that finished but never made it into the game, for example because the change that requested them failed or was rolled back. Each entry gives the recovery_id for recover_game_asset, the asset_id it was made for and when it completed; key art and store art are not listed. cursor and limit (default 25, at most 100) page the list. It changes no game file and generates nothing; it starts the game's workspace if needed, and its workspace minutes count as build time. Refused with WORKSPACE_BUSY while any change holds the workspace, including your own turn once its writer lease is open. Runs as a job.

list_releases

ChatGPT
Lists the project's release builds for every platform and store. Each row has build_id (the release_id get_release takes), workspace_key, profile_id, status (queued, running, complete, failed or cancelled), filename, bytes, created_at and failure_code. Use it to find a release, then get_release for its downloads. Rows are ordered by build_id, not by date; pages of up to limit rows (default 20, max 100) continue with next_cursor. Repackages made by refresh_kit are not listed. It reads saved records only and starts nothing.

list_turns

ChatGPT
Lists the changes (turns) started on one game through this connection, with each turn's state and sequence. Use it to recover a turn_id after an interruption, or pass state (for example active or parked) to find unfinished work. Latest update first, up to 100 per page (default 20); pass next_cursor back unchanged as cursor for more (any other cursor is refused with INVALID_CURSOR). Reads saved records only and starts nothing.

lookup_godot_api

ChatGPT
Looks up a class, method, property, signal, constant, annotation or global function in the Godot 4.6 reference Exekite runs games with, so code uses real engine names. class_name takes a class (CharacterBody2D), a dotted member (Environment.BG_SKY) or a global (lerp, @export); member optionally narrows a class. Names are case-exact, and a miss says so and suggests close names. Returns up to 40,000 characters of reference text. project_id is required unless the connection covers exactly one game. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time.

observe_game

ChatGPT
Takes a screenshot of the running Game Test, to see its current state, and returns it with the log lines written since the last look, whether the game is paused and whether the running build matches the current draft. capture false returns only the new logs, which also works after the game stopped or crashed. It sends no input and does not unpause a paused game; an unpaused game keeps running between calls. A blank screenshot is retried once, then returned with a blankFrame flag marking it as not showing the game. The screenshot is an image in the job result (get_job or wait_for_job), not a file view_images or read_files can open. Edits no game files and starts the project's workspace if it is stopped. Its workspace minutes count as build time. Its identity names the revision, draft sequence and source_digest the running game started from; later edits do not change it.

open_3d_model

ChatGPT
Opens a saved 3D model in the project's Blender so it can be edited, previewed or saved, and returns its current object list. asset_id is the model's id (assetId in list_3d_models) and expected_source_digest its revision from the same list; a stale digest is refused. Returns model_id, checkpoint (the expected_checkpoint for edit_3d_model, save_3d_model and discard_3d_model_changes), source_revision and each object's exact name, type, local position, rotation (XYZ degrees), scale and vertex count; edit_3d_model needs these exact names. Starts Blender if needed, activates a turn that is not active yet, and closes any other open model (its saved edits stay in the draft). Opening changes and saves nothing. Its workspace minutes count as build time.

open_companion

ChatGPT
Open an empty focused companion. Ask the assistant to show an existing game/test/model/asset to select a workflow. Does not choose the latest project, list account data, start work or spend money.

pause_game

ChatGPT
Pauses or resumes the running native Game Test, or steps a paused game frame by frame, to examine an exact moment. Give exactly one of paused (true freezes processing and physics with the frame left on screen, false resumes) or advance_frames (1–10 frames of an already paused game). Stepping returns a screenshot of the last frame (an image in the job result, read with get_job or wait_for_job, not a file view_images or read_files can open) and only the final step's log lines. Pausing and resuming return only the state. While paused, act_in_game runs the game only for its input plus a 0.15 s resume before it, so its first press is not lost. A web test cannot pause. Edits no game files. Its workspace minutes count as build time. Refused while a person is controlling the game from the live view. Its identity names the revision, draft sequence and source_digest the running game started from; later edits do not change it.

preview_game_asset

ChatGPT
Shows what one asset looks or sounds like, without changing the game. Supply exactly one of preview_ref (a registered asset's asset_id or preview path: its stored image or sound, or for a 3D model the thumbnail saved with the Blender tools) or fingerprint (something made by code: renders its sound, or runs the game in an isolated copy and screenshots the whole game just after startup, where the item may be off screen). Previews are images or sounds under 2 MiB. Repeating operation_id with the same arguments returns the same job. Without turn_id it is refused while a turn or another change holds the workspace; with turn_id it runs inside that turn, opening its writer lease if needed. Starts the project's workspace if needed; the image or sound comes with the job result.

read_asset_animation

ChatGPT
Read actual registered model clips or sprite frame regions/timing at an exact verified revision, or active turn/base revision/expected sequence. Returns content hashes and bounded media metadata; never wakes a runtime or generates assets. The returned asset_sha256 fingerprints this exact read; pass it back here only to pin the same read. It is not a show_project_view selector. A GLB model over 6 MiB is read from its reduced-texture preview, whose animation data is unchanged; the derivative field labels it, and while that preview is prepared the read answers ASSET_PREVIEW_UNAVAILABLE with details.reason preview_preparing, so read again after details.retry_after_s. Other media over 6 MiB or eight files is refused with ASSET_READ_LIMIT (details.byte_size and details.limit_bytes, or details.file_count and details.file_limit). A sleeping runtime returns ASSET_PREVIEW_UNAVAILABLE with details.reason runtime_not_running; when the person asks to inspect the asset now, one get_game_asset call without turn_id starts the workspace, then read again.

read_asset_preview

ChatGPT
Reads a registered GLB model, SpriteFrames atlas, image sequence, image or sound at an exact revision, so the companion can show or play it. Its bytes go only to the companion, at most 6 MiB, eight files and sixteen megapixels. A registered GLB model over 6 MiB (generated models are often 8 to 11 MB) is shown as a reduced-texture preview: textures at most 1024 px, the rest of the model unchanged. The result's derivative field labels it, and the game keeps using the full model. While that preview is being prepared, the read answers ASSET_PREVIEW_UNAVAILABLE with details.reason preview_preparing; read again after details.retry_after_s. Other media over 6 MiB or eight files, or a model no preview can be made from (details.reduced_preview unavailable), is refused with ASSET_READ_LIMIT; an image over sixteen megapixels with ASSET_DECODE_LIMIT. It generates and imports nothing and never starts the workspace: a stopped one returns ASSET_PREVIEW_UNAVAILABLE with details.reason runtime_not_running.

read_files

ChatGPT
Reads a game's text files with their SHA-256 hashes. Use it before an edit; apply_changes needs those hashes. paths (1–16, always required) returns each file's first 400 lines; when line_ranges (1–16 {path, start_line, end_line}, up to 2,000 lines each) is given, it is read instead. Files must be text under 2 MiB, and a result over 192 KB fails. Images use view_images; Game Test captures come only with the Game Test call's result. turn_id reads that turn's draft (for a build turn, once its first apply_changes, start_check or start_game_test has run; when parked, after resume_turn); revision reads a committed revision (not both). Reads of current files are refused (WORKSPACE_BUSY) while another writer holds the workspace. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time.

read_model_preview

ChatGPT
Reads the GLB of an owned Blender model at the exact 64-character checkpoint its job returned, so the companion can show it, from a workspace that is already running. It never starts the workspace, edits the model or calls a provider. The model bytes (at most 8 MiB) go only to the companion; a stopped workspace, a missing or stale checkpoint or a larger file is refused with MODEL_PREVIEW_UNAVAILABLE.

recover_game_asset

ChatGPT
Brings a paid generation found by list_recoverable_assets into the game without paying for it again. An image edit replaces that asset's image in place; other output replaces or adds that asset id's files, or is added as a separate asset when it cannot replace the current one. available_only true means the game does not use it yet; an edit turn can wire it in. It is checked with Godot and saved as a new revision; output already in the project's history returns already_imported and changes nothing. Key art and store art cannot be recovered. Requires recovery_id and the current revision as expected_revision. Its workspace minutes count as build time. Needs a plan that includes generated media and editing, and a positive balance after funds held for paid generations; refused on plans without generated media. Refused while a turn or another change holds the workspace. Starts the project's workspace if needed; runs as a job.

refresh_kit

ChatGPT
Repackages a completed release with the current saved release settings, such as listing text and release guides, reusing its built game files instead of rebuilding them. Use it when the person asks to apply the kit_refresh preview from get_release. Pass release_id, expected_manifest_revision and that preview's confirmation_digest; a changed preview is refused with CONFIRMATION_STALE and the current preview in details. Not available for ad-enabled web, CrazyGames, Poki, or ad-enabled Google Play and App Store releases, after the original download expired, or when a new build is needed. It starts the project's workspace and runs in the background; the job ends with the new package's status, filename and size (get_release does not list its download). Needs a positive balance after funds held for paid generations. Its workspace minutes count as build time.

release_control

ChatGPT
Release this viewer generation and controller fence; held keys are released. Does not close the viewer or abort the turn.

rename_project

ChatGPT
Renames a project in the person's Exekite library and Studio. Only the project name changes, not the game's files or its concept title. Pass the new title (1–80 characters, unique among the account's projects, including deleted ones) and expected_metadata_revision from a fresh get_project: it changes whenever the name or the game's latest version changes, and a stale value is refused with REVISION_CONFLICT. Charges nothing and starts nothing. Runs as a job.

render_3d_model_preview

ChatGPT
Renders a still image of the model open in this turn's Blender, to check how it looks: a fixed isometric camera framing the whole model, showing its material colours and base-colour textures on a transparent background. camera_preset must be isometric, the only option. The PNG (at most 2 MiB) is in the job result (get_job or wait_for_job). It does not change or save the model. model_id must be the open model (MODEL_NOT_OPEN otherwise). Its workspace minutes count as build time.

renew_viewer_session

ChatGPT
Renew an eligible visible viewer using its current generation. Rechecks live connection, project and turn authority; a stale generation or expired lease is refused.

restore_asset_take

ChatGPT
Puts one asset back to an earlier saved version (a take), for example to undo a regeneration or image edit the person did not like. take_id is the full revision hash of an earlier change to that asset, such as the revision a generation, edit, attachment or recovery returned, or the git_commit_sha of a list_history row that changed it; only its 25 most recent versions qualify. The asset's files and registration are restored, checked with Godot and saved as a new revision; gameplay code is not edited and nothing is generated or charged, though the account needs a plan that includes editing and a positive balance after funds held for paid generations. Requires the current revision as expected_revision. Refused while a turn or another change holds the workspace. Starts the project's workspace if needed; runs as a job.

restore_revision

ChatGPT
Rewinds the game's files to an earlier verified version from the project's history. Use it when the person asks to go back to a previous version. Pass a list_history row's restore_request exactly (verified_revision, expected_current_revision and confirmation_digest) with an operation_id. Only game files rewind: release settings, store images and the saved design are kept, and later versions stay in the history. It stops any running Game Test or Blender session and is refused while another change is in progress or with unsaved source changes. The restore is not a new verified revision: previews, publishing, release builds and another restore are refused until a turn lands on the restored files. Its workspace minutes count as build time. Returns a job whose result revision is the next turn's base_revision.

resume_turn

ChatGPT
Continues a paused change: locks the game for the turn again and restores the draft into the game's files. Use it after abort_turn with retain_draft true, after the turn went idle (10 minutes without a write, check, Game Test or Blender step) or reached its 45-minute lock limit, or after an interruption. expected_base_revision must equal both the game's current revision and the turn's base; a draft is never merged onto a newer revision, so after another change a new turn must reapply the files. A parked draft is kept 24 hours, and no turn resumes after its 6-hour limit. Check and submit counts are not reset. Locking can be refused like a first write; the draft then stays parked. Runs as a job.

revoke_share

ChatGPT
Takes the game off its public exekite.games page, which then says the game is no longer available. Use it when the person asks to unpublish. Pass share_id and expected_share_revision from get_play_link (its share_id and share_revision); a share that changed since then is refused with SHARE_CHANGED. The project keeps its page address: a later create_share reuses it for the then-current verified revision. The unpublished version's files and player notes are deleted at the next daily cleanup. The game itself is unchanged. Needs the connection's permission to publish; without it nothing starts, and the host asks the person to reconnect Exekite with it or the call returns INSUFFICIENT_SCOPE. Returns a job.

run_scripted_playtest

ChatGPT
Runs the turn's current draft without a screen at a fixed 60 frames per second for 1–1200 frames, pressing the game's input actions on exact frames and sampling chosen node properties about 16 times, to check game logic repeatably. timeline (required, may be []): up to 128 {frame, action, pressed, strength?}; frame below frames, action an InputMap action name, strength 0–1; unknown actions are listed in missing_actions. selectors: up to 16 {node_path under /root/, up to 16 properties}. Returns the samples and recent logs. Stops a running Game Test and activates a turn that is not active yet; edits no files and checks no visuals. At most 12 runs per turn; a failed run returns PLAYTEST_INCOMPLETE with logs. Not the check that lets a change land. Its workspace minutes count as build time. Its identity names the revision, draft sequence and source_digest it ran.

save_3d_model

ChatGPT
Saves the model open in Blender, as it stands, into the turn's draft: its Blender source, GLB file, preview image and entry in the game's asset list, then returns the new checkpoint and a refreshed object list. create_3d_model, edit_3d_model and import_3d_model already save every accepted change, so this only saves the open model again. Needs model_id and the latest expected_checkpoint; operation_id: 8–100 letters, digits, underscores or hyphens. A refused save (no visible geometry, a file over 32 MiB, more than 64 MiB of Blender files in the project, or more than the game's storage can hold) leaves the previous save in place. A turn's draft holds at most 15 MiB: a save whose output would exceed it is refused (DRAFT_LIMIT, with details.headroom_bytes) and undone, closing Blender, while the turn stays active. It joins the game when the turn lands (submit_turn) and shows only where game code loads it (ArtBank.scene(model_id)). Its workspace minutes count as build time.

search_files

ChatGPT
Finds where literal text occurs in a game's files, to locate code; each match gives its path, line number and text. query is up to 500 characters of plain text (no regular expressions), case-insensitive unless case_sensitive is true; glob filters paths with , * and ?. Each call searches about 2 seconds for up to 100 matches (default 50); if truncated, continue with next_cursor. Binary files and files over 256 KB are skipped. On a game not yet built, a search without turn_id or revision also skips the starter files a build turn replaces, and starter_files_replaced_at_build gives how many the project holds. turn_id reads that turn's draft (for a build turn, once its first apply_changes, start_check or start_game_test has run; when parked, after resume_turn); revision reads a committed revision (not both). Reads of current files are refused (WORKSPACE_BUSY) while another writer holds the workspace. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time.

send_feedback

ChatGPT
Sends the person's own message to the Exekite team: a bug report, question, feature idea or billing question (category bug, question, feature or billing; message 1–4000 characters). Use it when the person asks to contact Exekite. Exekite stores it, alerts its support staff and emails an acknowledgement to the account's email address, where any reply goes; with project_id, a Studio link to that project is attached. It changes no game. Too many messages in a short time are refused (RATE_LIMITED). Runs as a job.

set_game_design

ChatGPT
Saves an unbuilt game's design before its first build: the person's original request (pitch), an expanded brief (title, genre, 1–4 mood words), the complete concept, and key_art_decision (declined, or requested, which only records the wish; generate_key_art is a separate paid step). It is saved as supplied as a new revision, with no AI model call or charge, building nothing; it still needs a plan with editing (3D for a 3D game) and a positive balance after funds held for paid generations. Refused once the game is built (use update_game_concept), if expected_revision is not current, if an existing concept's 2D/3D dimension would change, or while a turn, Studio edit or export holds the workspace. get_game_design's authoring_contract gives the schemas and an example. Runs as a job, starting the project's workspace if needed.

set_tunables

ChatGPT
Changes the values of the game's declared tuning knobs (see get_tunables) without an authoring turn. Send 1–32 {file, constant, value} entries: each value is clamped to the knob's min and max and rounded to its step, and an entry that is not a declared, adjustable knob refuses the whole batch. The values are written, checked with Godot and saved as a new revision only if the game passes; otherwise nothing changes. Requires the current revision as expected_revision. Its workspace minutes count as build time. It needs a plan with editing and a positive balance after funds held for paid generations. Refused while a turn or another change holds the workspace; inside your own open turn, edit the constants with apply_changes instead. Once it lands, a parked turn from the older revision cannot resume. Starts the project's workspace if needed; runs as a job.

show_project_view

ChatGPT
Shows a job of this connection, or its result, in the companion. Targets: {kind:"job", job_id} for any job, even queued or running; {kind:"preview", job_id, revision} for a create_preview_link job and its verified_revision; {kind:"model", job_id, model_id, revision} for a Blender model at the 64-character checkpoint its job returned; {kind:"asset", job_id, asset_id, revision} at the 40-character verified game revision a succeeded job returned for that asset_id. After a Ship settings save, a get_game_asset job without turn_id returns an unverified revision, which an asset target refuses (revision_not_verified). Each mismatch names details.reason and a details.accepted_target to show instead. Any asset_sha256 must be a hash the job returned. Inline previews read at most 6 MiB; a larger generated model shows as a labelled reduced-texture preview while the game keeps the full model. Hosts without apps get a status snapshot. It starts no work, workspace or viewer and changes no game files.

start_check

ChatGPT
Runs the same full verification as submit_turn (profile full_gate) on a turn's draft without saving it: Godot imports the project and checks its scripts, scenes and node references, images, a test boot and a short automated play. Use it when a candidate is complete, to find failures before submitting. profile parse instead only parses every script (at most 50; otherwise use check_scripts). Either profile locks the game for the turn if needed and stops a running Game Test first. The full check runs the game's code; if that code changes source files, the turn is closed and rolled back. A turn has 9 full checks: start_check can use 8, keeping the last for submit_turn; parse runs count toward check_scripts' 30. Runs as a job whose result holds the verdict, failed checks and errors.

start_game_test

ChatGPT
Runs the game on a private test desktop, to play and inspect it before the change lands, starting the project's workspace if needed. target native runs the turn's current draft in Godot (imported first; this can take a minute); only native supports pause_game and inspect_game_state. target web plays the last verified web build (made when a turn lands, or by create_preview_link) in a browser, not the draft; without one it is refused with WEB_EXPORT_MISSING and nothing starts. It uses the main scene in a fixed-size window. With timeline, it then plays that input as act_in_game does; act reports the outcome. Activates a ready turn, like a first apply_changes; calling again restarts the game. The test stops when the turn lands, parks or is aborted, and before checks and scripted playtests. Its workspace minutes count as build time. Its game_test_id equals turn_id; identity names the revision, sequence and source_digest it runs. There is no sound output (results say audio.output none); to check a sound, read its AudioStreamPlayer's playing and stream properties with inspect_game_state.

start_release

ChatGPT
Builds a downloadable release package of the game's verified revision for one platform or store, such as a Windows build or the Google Play files, from its saved release settings. Use it when the person asks to prepare a release. Pass get_ship_status's release_request exactly (workspace, target, expected_manifest_revision, expected_revision, confirmation_digest) with an operation_id; a changed game or settings is refused. It starts the project's workspace and can run for minutes; the job completes with the build, then get_release lists its downloads, kept for 30 days. The plan decides which targets build, one build runs at a time, a positive balance after funds held for paid generations is required, and settings such as a 1.0.0-style version are checked first. Its workspace minutes count as build time. Nothing is submitted to a store.

start_turn

ChatGPT
Starts a change (a turn) to one game: edits collect in a draft that submit_turn saves as a new revision. Use purpose build for a game's first playable version, edit for every later change. Its workspace minutes count as build time. Its first write, check or Game Test locks the game, blocking Studio edits, other changes and paid generation until the turn is saved, cancelled or paused (after 10 idle or 45 locked minutes); locking needs a plan with editing (3D for a 3D game), no paid generation in progress, and a positive balance after what paid generations hold until they settle. A build turn opens with a starter project once it locks the game: project.godot, which the platform keeps, and a waiting screen (scenes/Main.tscn and main.gd) that the first writes replace; apply_changes says which hashes those writes accept. Turns last at most 6 hours. request (the user's words or a faithful summary) shows in Studio chat. base_revision must be current; the same idempotency_key returns the same turn. Runs as a job, starting the game's workspace if needed; its result holds turn_id. When get_account shows entitlements.allowEdits false, each game is built once: finish and check its first version before submit_turn, because a turn on a game after its first accepted build is refused with DIMENSION_NOT_INCLUDED (details.capability game_edits).

stop_game_test

ChatGPT
Stops the running game and closes the turn's Game Test desktop, for example when testing is finished. It does not end or land the turn or change its files, and start_game_test can start a fresh test later. Stopping when nothing runs just reports the status. It also works while a person is controlling the game from the live view, and releases that control. The test stops by itself when the turn lands, parks or is aborted, and before checks and scripted playtests. No charge. When the turn holds no live writer (ready, parked or ended), nothing can be running: it answers stopped true and already_stopped true with the turn's state, without touching a desktop. A game_test_id from another turn is refused (GAME_TEST_NOT_FOUND). The job result is the test's new status. Its identity names the revision, draft sequence and source_digest of the game it stopped (sequence and source_digest are null if none was started).

submit_turn

ChatGPT
Finishes a change once it is complete: runs the final full check on the draft and, if it passes, saves it as the game's new verified revision. expected_sequence must be the turn's current sequence; a build turn also needs birth_manifest describing the game actually built. It first stops the turn's Game Test and Blender session, and uses one of the turn's 9 full checks. On success the job result has accepted true and the new revision, and the game's web build is refreshed. With preview, an accepted submit also starts create_preview_link, a temporary unlisted link to that revision anyone holding it can open until it expires; its workspace minutes count as build time. result.preview names its job_id; get_job and wait_for_job add its state, then its preview_url and expires_at or error. A failed preview leaves the submit accepted. Nothing is published. On failure it returns accepted false and the verdict; on_fail keep_open (default) keeps the draft open to repair, while rollback, a repeated identical failure or a third failure parks it; after three failures the turn cannot be submitted.

update_game_concept

ChatGPT
Replaces the game's saved concept, the design document shown in Studio, before or after the game is built. It is a complete replacement, not a merge: start from get_game_design's concept_input and send the whole edited concept, because omitted optional blocks become empty. Keep the uppercase 2D or 3D dimension, which cannot change, and at least two filled design blocks. Saved as a new revision with no AI model call or charge; it changes no game code and builds nothing, and still needs a plan with editing (3D for a 3D game) and a positive balance after funds held for paid generations. Refused when expected_revision is not current, when the project has no design yet (use set_game_design), or while a turn, Studio edit or export holds the workspace. Starts the project's workspace if needed; runs as a job.

update_plan

ChatGPT
Saves the to-do list for a change with its turn, replacing the previous list, so the plan survives an interrupted conversation; get_turn returns it. Use it to track multi-step work. items holds up to 40 entries, each with text (up to 1,000 characters) and status pending, in_progress or completed, about 16,000 characters in all. It changes no game files, does not lock the game and starts no work, but advances the turn's sequence; the turn must still be open. Runs as a job in the game's workspace, starting it if needed.

update_ship_settings

ChatGPT
Saves listing copy and descriptive release settings for one platform or store: listing fields (listing.<field>), the title and description overrides, version and release_notes; for Google Play, App Store and Steam, the primary and extra listing languages from that store's list (get_ship_settings returns listing_languages), each with its copy and the declared language of its text; the itch.io page language; the App Store release type (first_release or update), saved only as the person answered it; and the ad mode, none for CrazyGames or test for Poki. check_store_listing names the patch_path for each problem this tool can fix. Supplied fields replace their saved values; others are kept. Live ads, audience, pricing, signing, agreements, privacy declarations and review confirmations are refused with OWNER_CONFIGURATION_REQUIRED, naming where the person sets them in Studio. expected_manifest_revision must match the saved revision. Saving clears the workspace's review confirmation and changes no game files. Starts the project's workspace if needed; returns a job.

upload_store_asset

ChatGPT
Adds an image the person uploaded to one platform's or store's release settings. Use it after begin_file_upload with purpose store_asset, within 15 minutes of starting that upload; only PNG or JPEG is accepted, not WebP. media_role icon sets that platform's or store's icon and clears its review confirmation; store_icon, feature_graphic and screenshot are for Google Play only, with up to 8 screenshots and no duplicates. Images may be up to 16 megapixels and 8192 pixels per side and are re-encoded as PNG; Google Play's size rules are not checked here. expected_manifest_revision must match the saved revision. Game files are unchanged. Starts the project's workspace if needed; returns a job.

view_images

ChatGPT
Shows a game's PNG, JPEG or WebP images at full size, so their art can be seen: 1–4 project paths (strings or {path}), each under 2 MiB and 4 MiB together. They arrive as image content, in request order, in the job's result. Game Test screenshots are not project files; each comes with the result of the Game Test call that took it (observe_game, act_in_game or pause_game), read with get_job or wait_for_job. turn_id reads that turn's draft (for a build turn, once its first apply_changes, start_check or start_game_test has run; when parked, after resume_turn); revision reads a committed revision (not both). Reads of current files are refused (WORKSPACE_BUSY) while another writer holds the workspace. It changes no game file; it runs as a job in the game's workspace, starting it if needed, and its workspace minutes count as build time.

wait_for_job

ChatGPT
Waits for one job to change, then returns the same view as get_job. Use it instead of repeated get_job calls while an operation runs. It re-reads about once a second and returns as soon as the job finishes or its cursor passes the cursor you give (by default its cursor when the wait began), or after max_wait_seconds (0–20, default 20). Waiting never starts, repeats or speeds up the work. Only jobs started through this connection are visible. A submit_turn job whose result names a preview job counts as finished once that preview job has finished too.

Capabilities

WritesInteractive

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/exekite"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/exekite)