Build with your agent.

Remote connection — no desktop installation

Add a remote Streamable HTTP MCP server using this URL:

https://modeljlabs.com/aether/workspace/mcp

1. Choose OAuth authentication in your client. Aether supports automatic client registration, authorization-code flow and PKCE S256 for public clients.
2. Sign in with your Model J Labs account and approve the client’s access to your Aether projects. The existing email sign-in is open to customers.
3. Ask the agent to call aether_get_capabilities and aether_document_schema, then create or list projects. Open Game Engine → MCP projects → Refresh in the browser editor to edit them. Save writes back to the same project with revision conflict protection.

If your client supports bearer headers instead of OAuth, create an Aether token on the connection page and send Authorization: Bearer YOUR_TOKEN. Treat this token as a password. Personal tokens expire in 90 days; OAuth connections expire in 24 hours and can reconnect. Revoke either from the connection page.

A remote MCP server does not automatically appear in every client’s app catalog. Add the URL in a client that supports custom remote MCP servers. This is a public service with private account projects; it is separate from the owner’s private ChatGPT connector.

Author → test → export

The public endpoint exposes 110 shared-engine tools. For 2D, use aether_2d_project_apply, aether_2d_project_test, and aether_2d_project_export. Save the returned result.html as a self-contained playable HTML file.

For supported 3D adventure, squad and rigid-body games, use the scene, terrain, actor, asset, gameplay and physics tools. Author executable squad mission Blueprints with aether_blueprint_apply. For adventure/squad sessions, test with aether_play_start and aether_play_step. Those adventure/squad tools do not test native physics. For combined rule/physics projects, use aether_gameplay_test, which runs the actual native WASM solver; still playtest rendering and audio in the browser. Call aether_game_export with your target and renderer to package the game; aether_3d_project_export remains available for 3D web export. The result includes an authenticated download URL. Open it while signed into the same account, or fetch it using your bearer header. Extract the ZIP and upload all files to a static web host. Playing the exported game needs no Aether account or desktop application.

The browser’s Export game button produces the same portable player package, using the same viewport and selected executable-rule, adventure, squad or configured native WASM physics runtime as browser Play. Project JSON remains the editable backup, separate from the playable game.

Cloud requests are limited to 8 MB, saved state including history to 20 MB, 100 projects per account, and 120 API requests per minute. Use local MCP for larger projects. Runtime tests are headless; visually playtest your release before sharing it.

General 3D authoring through MCP

Use aether_gameplay_catalog for the complete program schema and expression semantics. aether_gameplay_apply installs a program (or accepts null to remove it), aether_gameplay_read retrieves it, and aether_gameplay_test executes the actual fixed-step runtime with scheduled input and menu selections. Programs define variables, ordered conditions and assignments, actor transforms/attachments, camera behavior, start menus, HUD and end conditions.

1. Call aether_project_create with a unique project_id.
2. Call aether_gameplay_examples without arguments to discover example recipes, or with {"id":"platform"}, {"id":"puzzle"} or {"id":"runner"}. Execute the returned result.calls in order, adding your project_id to each call’s arguments. These are ordinary scene, model and program authoring calls; example IDs are not runtime modes.
3. Modify the saved actors or program using the same tools. aether_model_compose builds editable box, convex polygon and lathe recipes; aether_model_recipe_read retrieves them. The engine generates the geometry.
4. For the platform example, call aether_gameplay_test with the arguments below. It reports one collected item and a completed run. Tests use 1/120-second frames and do not perform GPU rendering.
5. Call aether_game_export with {"project_id":"your-project-id","target":"web","renderer":"webgl2"}. Download the returned URL with the same account, extract the package and serve it over HTTP(S). Open the saved project in the browser’s MCP projects panel for direct editing and a visual playtest.

{"project_id":"your-project-id","frames":300,"events":[{"frame":0,"code":"KeyD","pressed":true},{"frame":85,"code":"Space","pressed":true},{"frame":86,"code":"Space","pressed":false}]}

Combine rules with native physics and media

Configure bodies with aether_3d_physics_apply, then apply a program containing sensors, prefab definitions and rule actions. Rules support physics, spawn, despawn, sound_play, sound_stop, animation_play and animation_stop. Obtain their exact schemas from aether_gameplay_catalog. Targets use {"actorId":"scene-id"} or {"instance":"handleVariable"}. Spawn actions can write a new numeric handle into their result variable, so subsequent actions in the same rule can address the clone.

{"name":"Launch","event":"key","key":"Space","when":1,"set":[],"actions":[{"type":"spawn","prefab":"projectile","position":[0,3,0],"velocity":[0,4,-12],"lifetime":5,"result":"shot"},{"type":"physics","target":{"instance":"shot"},"operation":"ApplyImpulse","vector":[0,2,0]},{"type":"sound_play","sound":"launch","voice":"launch","target":{"instance":"shot"},"volume":0.7}]}

This rule assumes a declared numeric variable shot, a physics-enabled prefab named projectile referencing a configured dynamic body, and an embedded sound ID launch. aether_sound_upsert adds or replaces a sound: {"sound":{"id":"launch","name":"Launch","data":"data:audio/wav;base64,..."}}. WAV, MP3 (audio/mpeg) and OGG are supported; arbitrary audio URLs are not fetched.

Import rigged GLB assets with aether_assets_import. Call aether_animation_clips with an actor_id to inspect embedded clip names, duration metadata, channels and bones. Add animation_play actions using those clip names; speed, loop and crossfade are authored data. Spawned GLB characters receive independent cloned skeletons. Imported rigs retain their existing clips. Use aether_model_rig to construct rigid-part skeletons and clips; smooth skin weights and retargeting are not included.

aether_gameplay_test now returns actual native body transforms/velocities, sensor variables, spawned instances and a bounded media-event trace. It runs the shared simulation in the public Worker and downloaded MCP server. The media trace explicitly reports rendered:false: this test does not render skeletal animation, play audible audio or qualify GPU graphics. Tests allow up to 3600 fixed steps, 2048 input events and 1,000,000 estimated operations, including body costs. Larger projects need shorter runs. Read the editor workflow and resource limits.

Sphere/AABB physics uses the native CP143 WASM binary. Body removal preserves motion by reconstructing the bounded world, resetting sleep/contact caches. No joints, mesh collision, networking, full native parity, rig retargeting or blend trees are implied. WebGPU remains experimental. WebAssembly exports include the native solver; rules and rendering remain JavaScript.

Export targets and desktop games

Call aether_export_targets to discover formats and renderer limits, then aether_game_export with target: "web", target: "web-wasm" or target: "desktop-project". Web and desktop-project accept 2D and supported shared 3D gameplay projects. Web-wasm requires a 3D project with configured native WASM physics. For 3D, select renderer: "webgl2" or "webgpu"; 2D uses "canvas2d".

Web output is ready-to-play 2D HTML or a static-host 3D ZIP. Desktop output is a ZIP build project containing the game, its assets and a sandboxed Electron host. It is not a prebuilt executable. Extract it, install Node.js 22.13+, run npm install, then npm run package:windows or npm run package:linux. Distribute the complete generated platform folder. Players need neither Node.js nor Aether nor a web server. Builds are unsigned portable apps; installers, macOS and store submissions are not included.

2D uses Canvas2D. Shared 3D exports offer WebGL2 and experimental WebGPU. Native rigid-body WASM is included when configured. See the coverage and verification limits below.

Local MCP alternative

Download local shared-engine MCP

Requires Node.js 22.13 or newer on Windows, macOS or Linux. Extract the archive and configure your client:

{
  "mcpServers": {
    "aether": {
      "command": "node",
      "args": ["/absolute/path/mcp-server.cjs", "--workspace", "/absolute/path/AetherProjects"]
    }
  }
}

Use paths such as C:/AetherMCP/mcp-server.cjs on Windows. Local projects are saved as .aether-ui.json; open them using Open project file. Local 3D export writes a ZIP into your project folder’s exports directory and fetches the published player assets while building. The finished export runs independently. Local file projects do not automatically sync to your cloud account. A local MCP session reserves each project it writes until disconnect; close that session before another local client writes the same project. Revision guards remain enforced. After a crashed process, inspect a stale .lock file before removing it, and never remove a lock while a writer is running.

Browser and native capabilities

The browser supports 2D games, general 3D rule programs, shared 3D adventure/squad runtimes and configured native WASM rigid-body physics, terrain creation, mesh modeling, embedded models, materials and mission authoring. Legacy Logic preview nodes are not executable gameplay and are rejected by the 3D exporter.

The public MCP authors shared browser projects, including configuration for the native rigid-body solver compiled to WASM. It does not host the full native C++ engine, native actor Blueprint graphs, exact CAD kernel, Vulkan GI or native virtualized geometry. Those use the matching desktop runtime and native MCP connection. Shared web version 0.10.147 is not a claim of full CP143 native-engine parity.

Browser tools, WebGPU and WebAssembly

Shared-web 0.10.147 exposes 110 MCP tools. The native reference catalog has 109 entries; the native relay has 99 full-schema tools. Neither indicates an active desktop connection. Call aether_browser_parity for operation-level coverage; matching names do not imply matching schemas or full parity.

Browser authoring now includes dimensioned mesh primitives, OBJ vertex edits and transforms, welding and normals, topology inspection, OBJ/STL base-mesh export, tube curves, four shared modifiers, terrain heightfields, terrain-to-mesh baking, deterministic model scattering and transform animation sampling. Granular 2D tools author sprites, clips, tilemaps, colliders, bodies, joints, prefabs, inputs and executable Blueprint classes.

Select WebGPU · experimental in the viewport or export renderer menu. It uses node-based terrain, grass and water materials with the existing gameplay sessions. Water uses environment reflections rather than WebGL planar reflections. HTTPS and a compatible WebGPU browser/device are required; failure is reported without silently switching to WebGL. Packaging and build checks are automated; physical-GPU rendering and visual quality are not yet verified.

Open 3D physics to assign box/sphere bodies, mass, gravity, a ground plane and keyboard force/torque/impulse actions. This is the existing native CP143 rigid-body solver compiled to WebAssembly. Author the same configuration through aether_3d_physics_catalog and aether_3d_physics_apply. Export with aether_game_export, target: "web-wasm", and renderer: "webgl2" or "webgpu". The archive includes the actual WASM binary and license/build identity. Rendering and other gameplay remain JavaScript. The 3D physics interface supports box/sphere bodies and a ground plane. It does not include joints, terrain-mesh collision, every native Blueprint host callback, native GI or virtualized geometry. Sculpted terrain does not automatically become a native physics collider. In the export menu, choose Web + native WASM physics, select the renderer, then choose Export game. This bundles the existing solver; it does not compile arbitrary gameplay or the whole engine to WebAssembly.

Import Godot, Unity and Android assets

Use Import project in the editor, or aether_import_formats, aether_import_inspect and aether_import_apply from MCP. Supply files as {path, data, encoding: "text" | "base64"}; choose a scene using entry. Inspect first. If the report lists losses, application requires accept_lossy: true.

• Godot: a .tscn scene with Node3D hierarchy, transforms, supported primitive MeshInstance3D geometry and supplied GLB/OBJ resources. GDScript/C#, animation trees, physics/gameplay, inherited scene instances and custom materials are not converted.
• Unity: text .unity/.prefab scenes with GameObject/Transform hierarchy and supported MeshFilter geometry. Include model resources and their .meta files. C#, MonoBehaviours, prefab instances, animation controllers, physics/gameplay and renderer materials are not converted.
• Android APK: archive inspection and extraction of loose GLB/OBJ assets only. Compiled DEX/native code, Unity AssetBundles, Godot PCKs and APK execution are unsupported. This does not reconstruct an editable game.

Scripts are never executed. Conversion reports omitted content and requires acceptance of losses. Imported scenes need Aether gameplay configuration before game export. The browser importer limits archives to 256 members, 20 MB decoded total and 5 MB per member. Public MCP requests retain the smaller 8 MB transport limit.

Build rigged models and sound effects

aether_model_rig constructs an embedded GLB from dimensioned parts, a bone hierarchy and named animation clips. It supports doors, cranes, mechanical assemblies and simple articulated models. Each part attaches rigidly to one bone. Positions are in metres; rotation keyframes use XYZ degrees. Bone parents must precede children. Limits: 64 bones, 64 parts, 60,000 vertices, 32 clips. It does not provide smooth weight painting, IK, retargeting or blend trees. The saved actor retains its editable rigRecipe. In the editor, use Rig & clips.

aether_sound_synthesize creates WAV sounds from up to eight sine, triangle, saw, square or noise layers, with pitch sweeps, gain and attack/release envelopes. Duration is bounded to 12 seconds, sampled at 22,050 Hz. A seed makes noise reproducible. The sound and its recipe are saved in the gameplay program. In Gameplay → Sounds, open Create a procedural sound. These are reusable asset tools, with no aircraft-specific behavior.

Harbour Flights — Intercept

Play the exported game · Editable project · MCP recipe and evidence

Open the project using Open project file in the workspace. The example uses ordinary modeling, rigging, sound, physics, spawning and numeric-rule tools. No game-specific engine controller or export patch is used. Pursuit, firing, damage, flight handling, menus and upgrades are authored project rules. The harbour is scaled to fit the shared editor’s scene scale. WebGL2 package and native simulation checks are verified; live browser graphics/audio verification is still outstanding. The installed private Aether Studio connector can expose an older catalog; connect to the public MCP URL above or download the current local browser-project MCP.

Scripts, components and development tools · 0.10.147

The public shared-engine catalog now contains 110 tools: 107 operations usable through the local shared-engine adapter, plus three hosted browser-preview operations. The complete public tool catalog needs no sign-in to read. Project operations still require your account. Call aether_mcp_status to check the server version and exact tool names. Reconnect clients that cache an older catalog; updating the public engine does not replace a connector configured with another server URL.

In the editor, open Development. Scripts, Components, UI widgets and Animation states use the same validated project data and runtime as MCP. Verify runs behavior assertions, checks export readiness and requests evidence from the actual visible viewport. Saved cloud projects retain revision conflict protection.

Reusable gameplay scripts

aether_script_catalog returns the language, schemas and engine API. aether_script_validate checks source without changing a project. aether_script_upsert saves a module with typed field defaults; aether_component_upsert attaches independent state to any compatible actor. aether_script_read, aether_component_inspect and the removal tools support inspection and cleanup. Referenced modules cannot be removed.

{"project_id":"your-project","module":{"id":"Mover","fields":{"speed":{"type":"number","default":2,"min":0,"max":20}},"source":"function tick(dt) { let t = engine.getComponent(self, \"transform\"); t.position[0] += state.speed * dt; engine.setComponent(self, \"transform\", t); }"}}
{"project_id":"your-project","component":{"id":"moving_box","actorId":"box","script":"Mover","state":{"speed":4}}}

Create an actor named box first. Modules are reusable: attach Mover to multiple actors with different speed values. AetherScript supports start(), tick(dt), event(name,value), helper functions, typed state, JSON values, arithmetic, conditions and bounded loops. It is an interpreted engine language, not JavaScript or C#. Host APIs expose transforms and custom components, declared variables, keyboard input, seeded random numbers, events, spawning, native force/impulse, sounds and clip playback. Physics, bindings and timelines retain transform ownership. Scripts cannot access the DOM, network, filesystem, imports or eval.

Limits: 16 modules, 32 KB UTF-8 per module, 128 KB source total, 64 authored components, 256 runtime components, 32 KB component state, 16,384 interpreter steps per fixed update and 16 helper-call levels. A fault disables the affected component and reports its source line. Its own state is restored; engine actions already issued are not transactional. Set a component's template:true to instantiate fresh state when its actor is used by a spawned prefab. The new components extend the general 3D runtime; existing 2D games keep their Blueprint runtime.

Interface and animation

aether_ui_apply authors text, buttons, progress bars, sliders, toggles and selects. Editable controls bind to declared numeric variables; buttons and controls can emit custom events. Widgets render in browser Play and all supported shared 3D exports. aether_animation_controller_apply authors clip state machines, conditions, minimum state durations and crossfades. Targets must have compatible embedded GLB clips; missing clips fail validation. Smooth weight painting, IK, blend trees and rig retargeting remain separate gaps.

Behavior tests and export checks

aether_runtime_test runs the actual fixed-step simulation and native WASM physics when configured. It returns component state, worldPoses (positions, quaternion rotations and scales), source-tagged logs, measured CPU update times, bounded replay events, observations and state assertions. Example:

{"project_id":"your-project","frames":120,"observe":["worldPoses.box.position.0"],"traceEvery":30,"assertions":[{"path":"worldPoses.box.position.0","equals":4,"tolerance":0.001}]}

This assertion assumes box starts at x=0 and its speed is 4. Test events support keyboard input, type:event with name/value, type:widget with name/value, and type:clear. Replay frames run at 120 Hz. A seeded random state makes repeated runs reproducible. Tests allow 3600 frames, 2048 events, 120 trace samples and one million script instructions in addition to the existing runtime work budget. Logs retain 256 entries and preserve a total error count even after older entries are dropped. Timing excludes rendering; a passing simulation is not a GPU or audible-audio check.

aether_build_validate checks project references, scripts, clips and requested export configurations before packaging. The Export game button performs the same preflight. A ready result does not mean a desktop executable was compiled or signed. Use the existing export tools to obtain the actual HTML/ZIP/build project.

Connect a browser preview to remote MCP

1. Open the current cloud project in the public workspace and save changes.
2. In Development, choose Connect agent preview. Keep this tab open. Choose Play game before requesting a rendered replay.
3. Call aether_preview_status with project_id, then aether_preview_request with action:inspect, capture or replay. For replay, input contains the same test schedule, bounded to 1200 frames. It restarts and pauses the visible game.
4. Poll aether_preview_result with project_id and job_id. Only a completed report came back from the browser; queued/running/expired/failed are distinct results.

Preview access is scoped to account, project, revision and session. Connections expire after 60 seconds without a heartbeat; pending requests expire after two minutes. Multiple tabs require an explicit session_id. Capture reports include a JPEG of the real 3D canvas, up to 640 × 480, plus runtime state and renderer counters. HTML menus/HUD are excluded. Reports do not claim human visual/audio approval or measured GPU timing. Save changes and reconnect after a revision change. No browser connection means no rendered evidence; the server does not fabricate a screenshot.

Browser-local WebMCP exposes aether_editor_inspect, aether_editor_capture and aether_editor_replay when the browser supports document.modelContext. Local stdio cannot connect a visible browser by itself; the three hosted preview tools return an explicit unavailable message there. The native relay retains 99 full-schema entries; the broader native reference comparison has 109 entries. Neither count proves a desktop is connected. These additions do not claim Unity/Unreal parity, native GI/virtualized geometry or AAA production readiness.