- Brand
- Exekite
- Category
- Consumer & Lifestyle
- Primary Subcategory
- AI Agent Builders & Deployment Platforms
Integration details
Description
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.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- AI Agent Builders & Deployment Platforms
- Secondary Subcategories
- None listed
- Brand
- Exekite
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 104
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Exekite suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Exekite
Get updates when Exekite’s Discoverability Score or category rank changes.
Competing in ChatGPT AI Agent Builders & Deployment Platforms
View Category104 tools agents can invoke
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.
upload_store_asset
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.
attach_game_asset
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.
cancel_job
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.
abort_turn
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.
set_tunables
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_scripts
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.
check_store_listing
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. That play presses ui_accept at its start and again until a player exists, takes the player from the "player" group, else a CharacterBody2D/3D or RigidBody2D/3D, and counts as motion only Node2D and Node3D position changes, not what _draw, Controls or shaders animate; by default its warnings fail nothing. 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_check
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_game_test_status
Release only this app viewer. Does not abort an authoring turn or cancel a job. Existing stream authority becomes invalid.
close_viewer_session
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.
resume_turn
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_project
Creates a temporary unlisted link to play the game's current verified revision, to try or show the game without publishing it: anyone holding the link can open it until it expires, and disconnecting this connection ends it early. It starts the project's workspace, rebuilds that revision's web export if needed and copies it to a frozen preview. verified_revision must be the current verified revision (a refusal names details.current_revision); expiry_seconds is 60-3600, default 3600. Refused while another change is in progress. The same operation_id and arguments return the existing job instead of exporting again. The job's result has preview_url and expires_at; after expires_at the job no longer shows preview_url and says link_expired, so a new preview needs a new operation_id. show_project_view can display the job while it prepares. It publishes nothing. Its workspace minutes count as build time.
create_preview_link
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.
discard_3d_model_changes
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.
edit_game_asset_image
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_3d_model
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.
open_companion
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.
export_source
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_recoverable_assets
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.
generate_store_art
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.
add_game_asset
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_key_art
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_godot_guide
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_deletion_handoff
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.
get_turn
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_iteration_report
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_project_status
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_job
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_release
Creates a download URL for a finished file: a release download (artifact_id from get_release) or a source export (artifact_id from export_source). The URL is signed: anyone who holds it can download the file for 5 minutes (expires_in_seconds 300), and a new call returns a fresh one. Once the 5 minutes pass, reading the job again shows no url and says link_expired; call again for a fresh one. Files are kept for 30 days after they are made; after that this returns ARTIFACT_NOT_FOUND. It also returns filename, bytes and sha256. It reads saved records only and starts nothing. Returns a job; read it with get_job or wait_for_job.
get_download_link
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_share_feedback
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
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_context
Reports release readiness on one platform or store (the workspace argument): whether a verified revision exists, which release targets Exekite can build (a platform the plan excludes reads not_included_in_plan), the latest release build for the saved profile and whether the game has a public page. For a target Exekite can build, 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 and a target Exekite can build, 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_ship_status
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_balance
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_notarization_handoff
Returns the Exekite Studio link (the project's Ship page) for release settings, guides and creator-reported submission records; for App Store releases the person reports there the build number they actually submitted. The person submits through the store's own developer console or upload tools. A Studio link does not make an unavailable release kit available. 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), upload to any store, or record or confirm a submission. It starts nothing and changes nothing.
get_submission_handoff
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_account
Returns where a game can be played: its Exekite Studio link (for the signed-in owner) and, if it is published, its public exekite.games page (null otherwise). Use it to open or share the game, or before publishing or unpublishing it: it also returns share_id and share_revision for revoke_share and, when the game has a verified revision, share_request with the project_id, verified_revision and confirmation_digest create_share takes (add an operation_id). It reads saved records only; it starts nothing, publishes nothing and makes no new link. Returns a job; read it with get_job or wait_for_job.
get_play_link
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.
import_3d_model
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_asset
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_ads_helper
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.
install_privacy_helper
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.
list_turns
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_charges
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_jobs
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_files
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_projects
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_releases
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_3d_models
Exekite ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Exekite's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Exekite alternatives on ChatGPT?
As of 2026-11-20, Exekite competes with Abracadabrax Stickers, Agent Swarm, Agentic Atlas, Agentplace, Agora, AI Teacher, Amfion, Anam AI Avatars and 59 more in ChatGPT AI Agent Builders & Deployment Platforms, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.