Tomorrow Lives Engines

Measured conclusion: Deep-tested. L2 outcome: tools_ok.

Reproducible, IP-clean assets for agents: seven engines, from print designs to voice and video.

Add to your agent

Copy this into your MCP client config:

{
  "mcpServers": {
    "Tomorrow Lives Engines": {
      "url": "https://tomorrowlives.com/api/agents/mcp",
      "transport": "streamable-http"
    }
  }
}

Measured tools (57)

• art_schema read-only

  Every key, range and word a print design may use. Call this first when designing a print. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• art_presets read-only

  The canvas presets: shirt-front 4500x5400, shirt-pocket 1200x1200, sticker 2400x2400, poster 5400x7200, all at 300 DPI. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• art_materials read-only

  The shipped material library: each id, a line on its look, and whether it is a metal. Any id here can fill a layer or be baked. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• art_starter read-only

  A valid starting design for a canvas preset, ready to edit. Costs no units.

  Parameters:

  • preset (required) — string — The canvas preset to start from: shirt-front, shirt-pocket, sticker or poster.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• art_check read-only

  Checks a design without rendering it: ok, or one sentence naming the first problem and where it is. Costs no units.

  Parameters:

  • design (required) — object — The print design document, written inline as JSON. art_schema lists every key.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• art_render

  Renders a design to a PNG with its DPI written in. Without width it renders the canvas at full print size (a shirt-front is 4500 x 5400). width renders a draft that many pixels wide. A render 1200 pixels wide or less costs 1 unit; anything wider costs 5. preview_width adds a small preview, and preview_on sets the shirt colour behind it. Returns print.png (and print.preview.png) as signed URLs.

  Parameters:

  • design (required) — object — The print design document, written inline as JSON. Start from art_starter and check it with art_check.
  • width — integer — Output width in pixels. Omit it to render the canvas at full print size; a width above the draft limit is a full-size print and costs more.
  • preview_on — string — Background colour for the preview as #rrggbb, so a design with transparency can be judged on a shirt colour.
  • preview_width — integer — Width in pixels of the small preview image written beside the print.

  Hints: read-only no · destructive no · idempotent no · open-world no

• art_swatch

  Renders one material (a shipped id, or a whole material document) as a lit square swatch PNG. size is 64 to 1024 (default 512); 512 or less costs 1 unit, larger costs 2.

  Parameters:

  • material (required) — A shipped material id (art_materials lists them) or a whole material document written inline.
  • size — integer — Swatch side in pixels, 64 to 1024 (default 512). Above 512 costs more.

  Hints: read-only no · destructive no · idempotent no · open-world no

• material_bake

  Bakes a material (a shipped id, or a whole material document) to its seven channels (albedo, normal, roughness, metallic, height, emissive, ambient occlusion) as PNGs at res pixels square: 64, 128, 256, 512 or 1024 (default 256). 512 or less costs 1 unit; 1024 costs 2.

  Parameters:

  • material (required) — A shipped material id (art_materials lists them) or a whole material document written inline.
  • res — number — Bake resolution in pixels square: 64, 128, 256, 512 or 1024 (default 256). 1024 costs more.

  Hints: read-only no · destructive no · idempotent no · open-world no

• material_check read-only

  Checks a material document against the engine's strict reader: admissible, or the refusal. Costs no units.

  Parameters:

  • material (required) — object — The material document, written inline as JSON.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• material_cost read-only

  What baking a material document costs at res pixels square (default 256): operations and bytes. Costs no units.

  Parameters:

  • material (required) — object — The material document, written inline as JSON.
  • res — integer — Bake resolution in pixels square to price (default 256).

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• material_apply

  Applies a batch of ops (set_material, add_node, remove_node, set_node_param, connect, disconnect, set_out, add_ramp_stop, remove_ramp_stop, set_ramp_stop, add_curve_point, remove_curve_point, set_curve_point, clear_nodes) to a material document, whole or not at all. Returns the edited document or the refusal. Costs 1 unit.

  Parameters:

  • material (required) — object — The material document, written inline as JSON.
  • ops (required) — array — The edits to apply in order, each an object with an op name (set_material, add_node, remove_node, set_node_param, connect and the rest). The batch applies whole or not at all.

  Hints: read-only no · destructive no · idempotent no · open-world no

• form_starter read-only

  A blank form document for a generator kind (growth, rock, face, blades, canopy, masonry, lathe, sweep, truss, frond), named by id. Costs no units.

  Parameters:

  • kind (required) — string — The generator kind to start from: growth, rock, face, blades, canopy, masonry, lathe, sweep, truss or frond.
  • id (required) — string — The id to give the new form: lower-case letters, digits and hyphens.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• form_check read-only

  Checks a form document against the sculptor's strict reader. Costs no units.

  Parameters:

  • form (required) — object — The form document, written inline as JSON.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• form_apply

  Applies a batch of ops (set_form, set_generator, set_range, reset_range, clear_params) to a form document, whole or not at all. Costs 1 unit.

  Parameters:

  • form (required) — object — The form document, written inline as JSON.
  • ops (required) — array — The edits to apply in order, each an object with an op name (set_form, set_generator, set_range, reset_range, clear_params). The batch applies whole or not at all.

  Hints: read-only no · destructive no · idempotent no · open-world no

• form_build

  Builds a form (a shipped id such as scots-pine, oak or boulder, or a whole form document) at one variant and reports what the sculptor drew: the knob values for that variant and each level of detail's vertex and triangle counts. lod is near, mid, far or horizon. Costs 1 unit.

  Parameters:

  • form (required) — A shipped form id (scots-pine, oak, boulder and the rest) or a whole form document written inline.
  • lod — string — The level of detail to build at: near, mid, far or horizon.
  • variant — integer — Which variant of the form to build, 0 to 255; the same variant always builds the same shape.

  Hints: read-only no · destructive no · idempotent no · open-world no

• character_list read-only

  The body kinds (person, dog, cat, rat, sheep), the levels of detail and each kind's gaits. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• character_generate

  Generates a character from a seed. A person is one of the game's townspeople: sex, age, complexion, hair, build and working clothes are drawn from the seed, and the body is sculpted as one surface with a face, hair and cloth. as makes the seed a foe, a machine, an android or a child, and presents chooses a woman or a man; age young, adult or old takes the first seed from seed on whose person the town rolls at that age, and the answer names that seed (with the age, the frame and the height in metres), so the same request returns the same person; body loft returns the older lofted figure instead. kind may also be dog, cat, rat or sheep. The glTF 2.0 file holds the body in its bind pose, skinned to the 62-joint skeleton, with the skeleton standing at the gait and phase asked for (the rest pose when neither gait nor speed is given). A gait or speed also comes as one looping animation clip named for it: a rotation and a translation for every joint across thirty phases of its cycle, lasting the seconds that stride takes at that speed and ending on the pose it began with, so it loops without a jump. The clip walks on the spot; travel true also carries the root forward across the ground, a cycle's distance at the gait's speed. clips asks instead for a set of named looping clips in the one file, over the rest pose, for a character controller: idle (a breath and a weight shift, sixty seconds before it repeats), walk (1.4 m a second), run (5 m a second), sit (on the ground), chair (on a chair's seat) and the gestures wave (the right hand raised and waving), point (the right arm held out ahead) and nod (two dips of the head), each a short loop, for a person; idle, walk, run, sit and lie for an animal, or any gait character_list names; the walk's stance foot stays on the floor. Each garment has a material cut from the engine's own cloth: base colour, roughness and normal maps, its colours carried as vertex colours (COLOR_0) under a base colour factor, so the file passes the Khronos glTF validator. A garment of many colours comes in parts of one brightness (coat, coat 2 and so on), each under its own factor, so a viewer that leaves vertex colours out still draws a navy coat navy. formats glb returns the same file as a binary GLB (the buffer as its binary chunk, a fifth to a quarter smaller), in place of the .gltf when both are asked. The Wavefront OBJ is the posed mesh, a group for each garment. Costs 3 units for a person at near detail, 1 unit at mid or far, for the lofted figure and for an animal.

  Parameters:

  • as — string — What the person is: townsperson, foe, machine, android or child.
  • age — string — Age band for a person: young, adult or old, or leave it to the seed.
  • body — string — sculpt (the default) is the game's sculpted body; loft is the older lofted figure.
  • gait — string — A gait name from character_list to pose the skeleton at and to return as a looping clip.
  • kind — string — The body kind: person (the default), dog, cat, rat or sheep. character_list shows each kind's gaits.
  • seed — integer — A whole number that picks the character; the same seed and options return the same one.
  • clips — array — Named looping clips to put in the one file for a character controller, such as idle, walk, run, sit, wave, point, nod.
  • phase — number — Where in the gait cycle to pose the skeleton, 0 to 1.
  • speed — number — Travel speed in metres a second for the gait and its clip.
  • detail — string — Level of detail: near (the default), mid or far. Near costs the most for a person.
  • travel — boolean — True to let the gait clip carry the root forward across the ground instead of walking on the spot.
  • formats — array — Mesh formats to return: obj, gltf or glb. glb replaces gltf when both are asked.
  • presents — string — Whether a person presents as a woman or a man, or leaves it to the seed.

  Hints: read-only no · destructive no · idempotent no · open-world no

• terrain_heightmap

  Builds open country from a seed word and writes its ground as a greyscale PNG (row 0 is north; chunk (i, j) is 128 by 128 tiles). By default the picture is one chunk at 8 bits and black is its lowest tile, white its highest; bits 16 writes it at 16 bits (65535 greys, so a 40 unit relief steps by under a thousandth of a unit and a game's terrain built from it shows no stairs), and raw (true) also returns heights.f32, every tile's exact height as little-endian float32, width by height, row 0 north. area {w, h} (each 1 to 8) makes a w by h block of chunks from (i, j) one picture on one grey scale, so a landscape is one call; range [lo, hi] fixes the grey scale in world units so separate calls tile. params sets country knobs by name (terrainAmp 0 to 40, terrainOctaves 1 to 5, slopeLimit, treeDensity, rockDensity, clumping, portWidth, padRadius, padJitter, corridorWidth, meander, palette, waterTable, ridgeHeight 0 to 400 with ridgeX0, ridgeZ0, ridgeX1, ridgeZ1 for a long hill along that line); an unknown or out-of-range knob is refused with the reason. The answer carries the height range, the grey scale used (greyFrom, greyTo, unitsPerGrey, so height is greyFrom plus grey times unitsPerGrey), the bits, wall and scenery counts and the digest. mesh (true, or {step} of 1 to 16 tiles between vertices) also returns the ground as terrain.obj, a Wavefront OBJ in world units (x east, y up, z south) with normals and UVs that runs to the area's far edge so the next area's mesh starts where it ends; by default the step is the smallest that keeps a side to 256 cells. glb (true) returns the same mesh as terrain.glb, a glTF binary with normals and UVs, at mesh's step. features (true) also returns features.json: where each tree and rock stands (x, y, z and half extents) and the scenery (kind, position, turns, scale), each listed once, with the ground's height under it. Costs 1 unit for any area.

  Parameters:

  • seed (required) — string — The seed word that makes the country; the same word, chunk and knobs give the same ground.
  • i (required) — integer — The chunk column (east) to start from; chunks are 128 by 128 tiles.
  • j (required) — integer — The chunk row (south) to start from; chunks are 128 by 128 tiles.
  • glb — boolean — True to also return the mesh as terrain.glb, at the mesh step.
  • raw — boolean — True to also return heights.f32, every tile's exact height as little-endian float32.
  • area — object — A block of chunks, w by h (each 1 to 8) from (i, j), drawn as one picture on one grey scale.
  • bits — number — Grey depth of the PNG: 8 (the default) or 16.
  • mesh — True, or {step} of 1 to 16 tiles between vertices, to also return the ground as terrain.obj.
  • range — array — Optional [lo, hi] in world units that fixes the grey scale, so separate calls tile on one scale.
  • params — object — Country knobs by name (terrainAmp, terrainOctaves, slopeLimit, treeDensity, rockDensity, clumping, portWidth, padRadius, padJitter, corridorWidth, meander, palette, waterTable, ridgeHeight, ridgeX0, ridgeZ0, ridgeX1, ridgeZ1). An unknown or out-of-range knob is refused with the reason.
  • features — boolean — True to also return features.json: where each tree, rock and scenery piece stands.

  Hints: read-only no · destructive no · idempotent no · open-world no

• city_plan

  Makes a city from a seed number and a size (the side of a square, 300 to 2000 metres, 800 by default): streets at varied spacing, closer together toward the centre, some of them curving, some ending at a cross street so blocks vary in size, an avenue every few, one or two diagonal avenues and usually a ring road. The town does not fill the square: it thins toward an outline of its own (answered as outline), lots grow and houses scatter toward the edge, most streets stop short of it and a few avenues run on out of the square, and the ground beyond the town holds fields, pastures and copses (answered as fields, each clear of every road, hedged by trees). Between the dense core and the outskirts lies a suburban ring: residential streets that curve and branch (crescents that leave a street and return to it, cul-de-sacs ending in turning circles), small lots marked suburban, each with a house of one or two floors turned to its street and set back from it (a building's kind says house, semi for a pair, shop on a corner or school on a large lot, and the view, the obj and the glb roof them with pitched roofs), the houses lining both sides of narrow residential streets (about seven metres wide, with lanes running into deep blocks) and a garden with trees round every house, and a few local parks. The blocks the streets leave, with a plaza near the centre and parks; the lots each block divides into; and the buildings, each a footprint with a height and a floor count, rising toward the centre. Footprints are cut along the roads' own lines (a building beside a diagonal avenue is a trapezoid or a wedge, never a staircase), a block the buildings would leave mostly empty becomes a park, a lot left unbuilt is a yard with trees (a paddock, hedged, in the outskirts), and every park carries footpaths from street to street, benches beside them and trees kept clear of them. formats picks the files (json, png, obj, glb; json, png and glb by default): city.json is the plan, every street as a polyline with its kind and width and every block, park (with its trees), lot and building footprint as an outline, in metres with x east and z south from the middle of the square; city.png is the plan seen from above, north up, px pixels a side (256 to 2048, 1024 by default), buildings shaded by height; city.obj and city.glb are the massing model, the ground, streets, parks and every building extruded to its height, in metres with y up. terrain (a seed word, as terrain_heightmap takes) stands the city on that country's ground instead of a plane, centred at origin {x, z} in metres (0, 0 by default) with relief 0 to 40 as terrainAmp: every lot is levelled to a terrace and its buildings stand on it, every road point carries a height (y, held to a 12 percent grade by cutting and filling), a building whose corners would be more than 2.5 metres off its terrace stands in steps (its footprint is cut across the fall into pieces, each on its own base, and the answer counts those buildings as stepped) and is left out only where even that cannot hold the ground (counted as tooSteep, with the ground's low and high), two roads that meet carry one height at the junction, the terraces fade into the country over a fifty metre apron whose edge heights are listed under terrain.apron, the picture is shaded by the relief, and the obj and glb carry the terraced ground, apron included, with the streets lying on it. view (a list of cameras from aerial, a high oblique over the whole square, corner, a low oblique from the south-east, and skyline, a low view from the south across the roofs) also draws the massing model lit, with an afternoon sun, shadows and sky, as city-view-<camera>.png at viewPx pixels wide (320 to 1600, 960 by default, two thirds as tall), country shown round the square: it is the picture of what the other files hold, for when there is no model viewer to open them in. Where a stepped building's pieces meet on a slope, each uphill piece lists its seam (the shared edge and the drop) and the obj and glb carry a retaining wall there; a park on the edge of a hill follows the ground instead of a terrace (graded), the city's surface at its edge is held within three metres of the country's, and the picture shows the apron's fifty metres past the square. The answer carries the counts, the tallest building, the mean heights of the core and of the edge and the plan's sha256. The same seed and size give the same city. Costs 1 unit; views add to it (three wide views of the largest city cost 2).

  Parameters:

  • seed (required) — integer — A whole number that makes the city; the same seed and options give the same plan.
  • px — integer — Width in pixels of the plan picture, 256 to 2048.
  • size — integer — The side of the city square in metres, 300 to 2000 (default 800).
  • view — array — Camera views of the massing to render: aerial, corner or skyline. Each adds to the cost.
  • origin — object — Where on that terrain the city sits, as {x, z} in metres.
  • relief — number — How far the ground may rise and fall under the city, in metres, 0 to 40.
  • viewPx — integer — Width in pixels of each view, 320 to 1600 (the height is two thirds).
  • formats — array — Files to return: json, png, obj or glb.
  • terrain — string — A terrain seed word to build the city on, so it sits on that country.

  Hints: read-only no · destructive no · idempotent no · open-world no

• world_schema read-only

  The ops world_apply accepts (add_zone, add_npc, add_quest, add_link, set_worldgen and the rest), each with its fields as JSON Schema: types, bounds, the closed lists of words and which keys are required. Printed from the same table the engine validates against, so it cannot drift from what is accepted. Pass op to get one op's schema alone. Costs no units.

  Parameters:

  • op — string — One op's name (add_zone, add_npc, add_quest and the rest) to get only that op's schema; omit it for all of them.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• world_starter read-only

  A starter world document (two zones joined by a passage, a spawn, no quests) with the id and title given. The title passes the same scrubber world_apply uses: no markup, braces or web addresses. Costs no units.

  Parameters:

  • id (required) — string — The id to give the world: lower-case letters, digits and hyphens.
  • name (required) — string — The world's title, shown to players. Plain text: no markup, braces or web addresses.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• world_check read-only

  Checks a world document with the engine's strict reader and its spatial rules (every spawn, passage, item and character stands on open ground reachable from the spawn; no two zones overlap; no door is under water). Answers ok with warnings, or the errors; the doors report says how many exits were examined. Costs no units.

  Parameters:

  • world (required) — object — The world document, written inline as JSON.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• world_apply

  Applies a batch of ops (see world_schema) to a world document, in order. An op that cannot apply is rejected with its reason and changes nothing; if the result as a whole would not be a valid world, the whole batch rolls back and says why. Answers the edited document, what applied, what was rejected and the check of the result. Costs 1 unit.

  Parameters:

  • world (required) — object — The world document, written inline as JSON.
  • ops (required) — array — The edits to apply in order, each an object with an op name; world_schema lists them. An op that cannot apply is rejected with the reason and the rest still apply.

  Hints: read-only no · destructive no · idempotent no · open-world no

• world_heightmap

  Draws the open country a world document generates (its worldgen block: seed, knobs, regions with their own relief, a ridge) as one greyscale PNG, row 0 north, so a world built with world_apply can be looked at before anyone walks it. area {w, h} makes a block of chunks from chunk (i, j) (w times h at most 25); range [lo, hi] fixes the grey scale in world units. The answer carries the height range, the grey scale used (greyFrom, greyTo, unitsPerGrey) and the name of the country each chunk sits in. A world with no worldgen block is bounded and is refused by name; set_worldgen opens it onto boundless country. Costs 1 unit.

  Parameters:

  • world (required) — object — The world document, written inline as JSON. It needs a worldgen block to have country to draw.
  • i (required) — integer — The chunk column (east) to start from; chunks are 128 by 128 tiles.
  • j (required) — integer — The chunk row (south) to start from; chunks are 128 by 128 tiles.
  • area — object — A block of chunks, w by h (each 1 to 25) from (i, j), drawn as one picture.
  • range — array — Optional [lo, hi] in world units that fixes the grey scale, so separate calls tile on one scale.

  Hints: read-only no · destructive no · idempotent no · open-world no

• voice_speak

  Synthesises a line of English as a 44.1 kHz WAV with the engine's own voice. The voices are synthesised by the engine, never cloned from a recording, and no voice can be uploaded. seed varies the voice; woman, age (0 to 1) and machine shape it; speed (0.5 to 2) sets how fast it speaks (1 is the speaker's own); rate sets the sample rate. Every line comes back at one loudness (level_db, default -16 dBFS of speech, so lines from different voices sit together on a timeline and none clips; level_db false leaves the voice's own level) and with its silence trimmed to a breath either side (trim false keeps the voice's half-second tail). text is at most 1000 characters, and a line that presents itself as spoken by a real, famous person is refused. Costs 1 unit.

  Parameters:

  • text (required) — string — The English line to speak, at most 1000 characters. A line that presents itself as spoken by a real, famous person is refused.
  • age — number — How old the voice sounds, 0 (young) to 1 (old).
  • rate — number — Sample rate in hertz: 16000, 22050, 44100 or 48000.
  • seed — integer — A whole number that varies the voice.
  • trim — boolean — False to keep the voice's half-second silent tail; the default trims silence to a breath either side.
  • speed — number — How fast it speaks, 0.5 to 2; 1 is the speaker's own pace.
  • woman — boolean — True for a woman's voice, false for a man's.
  • machine — boolean — True to give the voice a machine quality.
  • level_db — Loudness in dBFS of speech, -30 to -6 (default -16); false leaves the voice's own level.

  Hints: read-only no · destructive no · idempotent no · open-world no

• sound_list read-only

  The twenty-one sounds (steps on twelve surfaces, doors and stairs, blows, thunder, splashes, a siren, animal calls, notes and the rest) with what each of a, b and c does, and the seven beds an ambience is mixed from. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• sound_effect

  Renders one sound from the engine's own synth as a stereo WAV, or an ambience of the beds mixed together. Give sound (a name from sound_list) with a, b and c as sound_list says, or give ambience: any of engine, air, surf, rain, drum, gull and creak, each 0 to 1, with seconds (1 to 30, default 10; loop true makes it seamless, its end crossfaded into its start, for a game that plays it on repeat; an ambience otherwise fades out). seed varies a one-shot, rate is 44100 or 48000, and peak_db (-30 to 0, default -3) is where the loudest sample sits, so a footstep and a thunder come back at one level; raw true keeps the synth's own. Nothing is sampled from a recording. Costs 1 unit.

  Parameters:

  • a — number — The sound's first parameter, as sound_list says what it does for this sound.
  • b — number — The sound's second parameter, 0 to 1, as sound_list says.
  • c — number — The sound's third parameter, -1 to 1, as sound_list says.
  • raw — boolean — True to keep the synth's own level instead of normalising to peak_db.
  • loop — boolean — True to make an ambience seamless, its end crossfaded into its start.
  • rate — number — Sample rate in hertz: 44100 or 48000.
  • seed — integer — A whole number that varies a one-shot sound.
  • sound — string — A sound name from sound_list. Give this, or ambience.
  • peak_db — number — Where the loudest sample sits in dBFS, -30 to 0 (default -3).
  • seconds — number — Length of an ambience in seconds, 1 to 30 (default 10).
  • ambience — object — Instead of sound: a mix of beds (engine, air, surf, rain, drum, gull, creak), each a level from 0 to 1.

  Hints: read-only no · destructive no · idempotent no · open-world no

• video_schema read-only

  Every key, range and word a scene document may use: the output, visual tracks of clips (designs, material fills, colours, gradients, titles and shots), the camera, audio (voices, sounds, music) and subtitles. Call this first when making a video, and video_examples for whole scenes to start from. A scene can hold: drawn pictures with groups (a character's parts move, turn and fade together) and mirror x, y or both on any layer or group, layer and track blends (multiply for a shadow, a vignette or a night grade; screen and add for a glow or a flare, on a layer or a track alike), closed paths filled nonzero (the default) or evenodd (a self-overlapping star leaves its centre bare);characters who talk (cast, timed lines with their own reading, ducked music, subtitles made from the lines, a mouth that moves on the words, or swaps between closed, open, wide and round drawings (with an idle breath and a listening beat, as a moving mouth has), and eyes that blink); shots with people on paths, action beats (guard, strike, hit, fall, get-up) and gestures on cue (a wave, a point, a nod), a directed character (a figure by seed, dressed by its look, standing in a named gait from the schema, speaking through its cast name, set among forms, props and a ground, filmed by a dolly or an orbit), animals and forms, and a camera that follows, orbits or cranes; music cues with a melody, a lead instrument, tempo changes and fades, that duck under lines and under any sound marked ducks_music; and sounds that move across the ears. Designs go inline in a scene; a path to a file is refused. A shot can stand in a world of ours, named by id and never by a path: copperside and low-quarter. In a scene it is a shot subject {"kind": "world", "id": "copperside", "at": [x, 0, z], "radius": metres}; copperside is Brasshollow's Copperside, the streets and buildings of its start zone around that point, and low-quarter a small generated quarter. A street draws its crowd by default, and the crowd is most of its price: set extra.crowd to false (or {"most": 0}) for the plain price, or {"most": 3} for a few people. A clip in a world costs 5 units more than a flat one and 0.2 a frame for a street; one that draws the crowd 25 more and 1.2 a frame. video_examples has copperside-street, 30 units. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• video_presets read-only

  The engine's frame presets (landscape 1920x1080, square 1080x1080, vertical 1080x1920 and their 720 versions) and frame rates. This service renders up to 1920 by 1080 either way up, 30 frames a second and 60 seconds. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• video_examples read-only

  Without a name, lists the example scenes (what each is, what it shows, its length, size and price in units). With a name, returns that scene whole, written inline as video_render wants it: copy the nearest one and change its words, seed and numbers. Each was rendered by this service's own engine and looked at before it was listed. Costs no units.

  Parameters:

  • name — string — An example scene to return in full: two-voices, meadow-chase, lamplighter or copperside-street. Omit it to list them all with their prices.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• video_check read-only

  Checks a scene document with the engine's strict reader without rendering it: ok, or one sentence naming the first problem and the key it is at, with every other problem in the scene listed in result.errors (up to fifty), so one call finds them all. A scene with dialogue is spoken while it is read, so a long one takes a few seconds, and a line that overlaps the same character's last, or ends after the scene, is named. Costs no units.

  Parameters:

  • scene (required) — object — A scene document written inline: output (size, frame rate, length), tracks of clips, optional cast and lines, audio and subtitles. Start from video_examples and read video_schema for every key.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• video_cost read-only

  Reads a scene and reports what rendering it takes (frames, size, design renders, shot frames, audio seconds) and what it costs here: units, and whether it is within this service's limits (60 seconds, 1920 by 1080, 30 frames a second, 600 units a job). Renders nothing. A shot costs most, because every frame of it is drawn from geometry: the nine-second two-person chase in video_examples is 130 units at 1280 by 720, the eleven-second talking card 7, and the two-second street in a world 30; a street with its crowd drawn costs far more (see video_schema). Costs no units.

  Parameters:

  • scene (required) — object — A scene document written inline: output (size, frame rate, length), tracks of clips, optional cast and lines, audio and subtitles. Start from video_examples and read video_schema for every key.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• video_still

  Renders one frame of a scene at t seconds as a PNG at the scene's size: the way to look at a moment (just after a transition, mid-reveal, the last frame) before rendering the whole video. Costs 1 unit, plus a shot's price when the scene has shots (3 plus 1 for each 1.6 megapixels). It runs as a queued job: the answer is 202 with a job id at once, and GET /api/agents/jobs/<job> (or the MCP tool job) says when it is done and signs its files. A queued call is refused on the free plan with 402: its units buy only calls that answer at once, and queued jobs need a paid plan (a pass or the card plan). Returns still.png.

  Parameters:

  • scene (required) — object — A scene document written inline: output (size, frame rate, length), tracks of clips, optional cast and lines, audio and subtitles. Start from video_examples and read video_schema for every key.
  • t (required) — number — The moment to draw, in seconds from the scene's start.

  Hints: read-only no · destructive no · idempotent no · open-world no

• video_render

  Renders a scene to video.webm (VP9 and Opus), video.wav (its sound) and video.vtt (when it has subtitles); with preview (the default) also video.contact.png, twelve moments on one sheet, and video.preview.gif, 480 pixels wide. A scene can hold: drawn pictures with groups (a character's parts move, turn and fade together) and mirror x, y or both on any layer or group, layer and track blends (multiply for a shadow, a vignette or a night grade; screen and add for a glow or a flare, on a layer or a track alike), closed paths filled nonzero (the default) or evenodd (a self-overlapping star leaves its centre bare);characters who talk (cast, timed lines with their own reading, ducked music, subtitles made from the lines, a mouth that moves on the words, or swaps between closed, open, wide and round drawings (with an idle breath and a listening beat, as a moving mouth has), and eyes that blink); shots with people on paths, action beats (guard, strike, hit, fall, get-up) and gestures on cue (a wave, a point, a nod), a directed character (a figure by seed, dressed by its look, standing in a named gait from the schema, speaking through its cast name, set among forms, props and a ground, filmed by a dolly or an orbit), animals and forms, and a camera that follows, orbits or cranes; music cues with a melody, a lead instrument, tempo changes and fades, that duck under lines and under any sound marked ducks_music; and sounds that move across the ears. Its files together are at most 50 MB, so a long, busy scene renders with preview false. At most 60 seconds, 1920 by 1080 either way up and 30 frames a second. The price is read off the engine's own cost report: units = design renders x megapixels / 45 + frames x megapixels / 200 + shot frames x megapixels / 1.6 + 3 a shot clip, rounded up; at most 600 a job, and video_cost says it first. It runs as a queued job: the answer is 202 with a job id at once, and GET /api/agents/jobs/<job> (or the MCP tool job) says when it is done and signs its files. A queued call is refused on the free plan with 402: its units buy only calls that answer at once, and queued jobs need a paid plan (a pass or the card plan). Each account may have 4 queued jobs waiting or running (1 running at a time), and may submit 20 videos and 10 minutes of video a day (UTC).

  Parameters:

  • scene (required) — object — A scene document written inline: output (size, frame rate, length), tracks of clips, optional cast and lines, audio and subtitles. Start from video_examples and read video_schema for every key.
  • preview — boolean — Also write the contact sheet and a small preview GIF (the default); false for a long, busy scene whose files would pass the size cap.

  Hints: read-only no · destructive no · idempotent no · open-world no

• raster_schema read-only

  Every key and range a shot document may use: the camera (keys or an orbit), the sun, the air and fog, and the subjects (forms, characters, animals, open country and primitives) placed by position or by time keys. The same keys go in a video shot clip's extra. A zone subject and a terrain subject name a shipped world by id in their world key (see raster_render). Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• raster_check read-only

  Checks a shot document with the renderer's strict reader: its name, size, subject count and length, or the key that is wrong and why. Forms and materials are named by shipped id or written inline. Costs no units.

  Parameters:

  • shot (required) — object — A shot document written inline: a camera, the sun and air, and subjects. raster_schema lists every key.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• raster_render

  Renders a shot (a camera through the engine's world: forms from the sculptor, people and animals from the rig, open country, primitives, under the game's own sky, sun, shadow and haze) at t seconds as shot.png. width and height (both or neither) set the size, else the shot's own; at most 1920 by 1080 either way up. Costs 3 units plus 1 for each 1.6 megapixels: 4 at 1280x720, 5 at 1920x1080. A shot can draw a world of ours, named by id and never by a path (copperside and low-quarter): a zone subject {"kind": "zone", "world": "copperside", "zone": "city", "cut": [x, z, radius], "crowd": false} draws a street (copperside's start zone is city), and a terrain subject with the same world key draws its country. A street draws its crowd by default, which is most of its price: a still in a world costs 5 units more, one that draws the crowd 26.2 more again. It runs as a queued job: the answer is 202 with a job id at once, and GET /api/agents/jobs/<job> (or the MCP tool job) says when it is done and signs its files. A queued call is refused on the free plan with 402: its units buy only calls that answer at once, and queued jobs need a paid plan (a pass or the card plan).

  Parameters:

  • shot (required) — object — A shot document written inline: a camera, the sun and air, and subjects. raster_schema lists every key.
  • t — number — The moment to draw, in seconds from the shot's start, for a shot with motion.
  • width — integer — Output width in pixels, 16 to 1920; overrides the shot's own.
  • height — integer — Output height in pixels, 16 to 1920; overrides the shot's own.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_schema read-only

  Every document the pull engine reads, with its keys: a session (its generators, their onsets on one integer-nanosecond clock, states, declared intentions, the follower's report and the sealed schedule), a schedule, a pre-registration, a twin, a performer and a device. Call this first. Costs no units.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• pull_prereg read-only

  Reads a pre-registration (what is measured, the conditions, trials per session, sessions, alpha, power, the number of comparisons and the correction) and returns its hash, to record in each session's prereg.hash before the run starts. Costs no units.

  Parameters:

  • prereg (required) — object — The pre-registration document, written inline as JSON; pull_schema lists its keys.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• pull_analyse

  Analyses the sessions of one condition (one session, a list, or {"sessions": [...]}) together, and each alone, and returns the report: its label (significant; null, with the smallest effect these sessions could have found; unlabelled, with what is missing; or not testable) and the sentence behind it, the mean signed shift against three surrogate families, the placebos, the four cells (deliberate, programmed, luck and sync), intended against unintended changes, recovery, locking, and the report's hash. prereg registers the run; replication analyses a second set under it, beside the first; measure is phase (timing, the default) or state (the stance along the leader's declared direction, for two agents); surrogates (19 to 9,999, default 199) sets an unregistered run's draws a family, a registered run taking its pre-registration's; seed fixes them; a session of three or more generators is tested pair by pair, every ordered pair with its own ledger and the correction for their number, unless pairs is false; detail adds every pull record. It costs one unit for each 40,000 session-draws over a thousand events (a session's own reading counts as 200 draws), at least 1. A group costs its ordered pairs' worth. A call priced at more than 2 units is queued: the answer is 202 with a job id and its price, GET /api/agents/jobs/<job> (or the MCP tool job) says when it is done, and the whole report comes back as report.json beside a short verdict. A queued call is refused on the free plan with 402: its units buy only calls that answer at once, and queued jobs need a paid plan (a pass or the card plan). Sessions are not kept.

  Parameters:

  • sessions (required) — One session, a list of sessions, or {"sessions": [...]} of one condition, as JSON documents.
  • seed — integer — A whole number that makes the run reproducible: the same seed and inputs give the same answer.
  • pairs — boolean — True to analyse performer pairs as well.
  • detail — boolean — True to return the fuller per-session detail.
  • prereg — The pre-registration the sessions were run under, to check the analysis against it.
  • measure — string — The measure to analyse, by name.
  • surrogates — integer — How many surrogate runs to draw for the null, 19 to 9999.
  • replication — Sessions of a replication, analysed against the first set.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_twin

  Runs twin sessions (scripted performers and the machine follower, each session drawn, sealed, released, closed and opened like a real one) and analyses them under the twin's own pre-registration: how many sessions were labelled significant, that rate with its 95% interval, and the pooled report with its hash. Give a twin document (pull_schema lists its keys: others for a group, a room of beings, the system generator, a field lattice), or condition (P1 to P4, R1 to R4), coupling (0 to 1) and planted ([intended, unintended] gains, each -2 to 2) for the engine's default pair; field (toda) strings a lattice between leader and follower. Uncoupled twins measure the false-positive rate; coupled ones should come out significant. The same document and seed give the same report hash as ae_pull itself. sessions is 1 to 1,000 (default 20, or the document's own); a schedule runs to at most 5,000 beats a session. It costs one unit for each 40,000 session-draws over a thousand events (a session's own reading counts as 200 draws), at least 1. A plain pair of up to 20 sessions and 2 units answers at once. Anything more, and any field, group, room or system generator, is queued and priced by the engine's own count of the twin (events a session at the schedule's widest gaps, its draws and its pairs, and the CPU-seconds a lattice or a spiking network takes), at least a unit for each 5 CPU-seconds it estimates, times the sessions. A queued call is refused on the free plan with 402: its units buy only calls that answer at once, and queued jobs need a paid plan (a pass or the card plan).

  Parameters:

  • seed — integer — A whole number that makes the run reproducible: the same seed and inputs give the same answer.
  • twin — object — A twin document written inline; or use condition, coupling, planted and field instead.
  • field — string — The field to run the twins in, by name.
  • detail — boolean — True to return the fuller per-session detail.
  • planted — array — The planted effect as a pair of numbers between -2 and 2.
  • coupling — number — How strongly the follower is coupled to the performer, 0 to 1.
  • sessions — integer — How many sessions to run, 1 to 1000.
  • condition — string — The condition to run: P or R followed by 1 to 4.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_cost read-only

  Prices a call without making it: give the arguments of pull_twin (a twin document, or condition, coupling, planted, field, sessions as a number and seed; nothing at all is the default twin), of pull_analyse (a sessions document, with prereg, replication, surrogates and pairs) or of pull_lab (a theory, one-dimensional or with a model, or reference skyrme or hopfion). The engine counts the document without running it: a twin's or an analysis's sessions, events, draws, work and an estimate of CPU-seconds (cpu_pairs and cpu_note say which part of a group's estimate repeats for each pair), a lab theory's lattice, the steps priced and its CPU-seconds. The answer adds what this service makes of the count: for, the call it priced; units, what that call would be charged, null when it would be refused (a queued call's price is the engine's count, so a lattice or a system generator, which the formula that routes a call cannot see, is priced as it will be); queued, whether it would be queued (202) rather than answer at once; within_limits, and when it is false the limit it breaks. A one-dimensional theory is counted too and is queued like any theory (an ordinary one at 1 unit), and the one-dimensional references, which are not counted, are refused here by name. Runs and renders nothing. Costs no units.

  Parameters:

  • seed — integer — A whole number that makes the run reproducible: the same seed and inputs give the same answer.
  • twin — object — A twin document written inline, as for pull_twin.
  • field — string — The field to price in, by name.
  • pairs — boolean — True to price the pair analysis as well.
  • prereg — A pre-registration, to price an analysis under it.
  • theory — A theory document, to price a lab run.
  • planted — array — The planted effect as a pair of numbers between -2 and 2.
  • coupling — number — Coupling to price at, 0 to 1.
  • sessions — A session count for a twin run, or the sessions of an analysis to price.
  • condition — string — The condition to price: P or R followed by 1 to 4.
  • reference — True, or a reference name, to price the lab's reference run.
  • surrogates — integer — Surrogate runs to price, 19 to 9999.
  • replication — Replication sessions, to price an analysis with them.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• pull_schedule

  Draws a schedule of perturbations (tempo up or down, phase advance or delay, and catch trials where nothing changes) placed with a lead-in and random gaps; spec sets its trials, gaps and beat (pull_schema lists the keys). By default the randomness is 32 bytes of this server's operating-system randomness, graded hardware_seeded; seed draws from software instead (graded software, which a research run refuses); entropy_hex with grade brings your own bytes and says where they came from. research refuses software randomness. Returns the schedule and its text, which pull_seal seals. Nothing is kept here. Costs 1 unit.

  Parameters:

  • seed — integer — A whole number that makes the run reproducible: the same seed and inputs give the same answer.
  • spec — object — The schedule specification written inline as JSON; pull_schema lists its keys.
  • grade — string — How the entropy you brought was produced, recorded with the schedule.
  • entropy — string — The entropy source: os, the server's own.
  • research — boolean — True to draw the schedule for a research run.
  • entropy_hex — string — Your own entropy as hex, in place of the server's, when you must bring the bytes yourself; grade then says where they came from.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_seal

  Seals a schedule's text before the run: commits to it (SHA-256 of the text and a nonce) and encrypts it (ChaCha20) under a fresh key. Answers with sealed (the public half, for the session's schedule.sealed) and secret (the key, IV and nonce), to this call alone: this service does not store, log or show again either the text or the secret, so keep the secret, release each cue at its moment, and publish the secret into the session's schedule.opened after the close. held_by names the leader station's generator (default L); at_ns is when it was sealed, before start_ns. By default the randomness is 32 bytes of this server's operating-system randomness, graded hardware_seeded; seed draws from software instead (graded software, which a research run refuses); entropy_hex with grade brings your own bytes and says where they came from. Costs 1 unit.

  Parameters:

  • content (required) — string — The schedule text to seal, as drawn by pull_schedule.
  • seed — integer — A whole number that makes the run reproducible: the same seed and inputs give the same answer.
  • at_ns — integer — The sealing time in integer nanoseconds.
  • grade — string — How the entropy you brought was produced, recorded with the schedule.
  • entropy — string — The entropy source: os, the server's own.
  • held_by — string — Who holds the secret half, recorded with the seal.
  • entropy_hex — string — Your own entropy as hex, in place of the server's, when you must bring the bytes yourself; grade then says where they came from.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_open

  Opens a sealed record (the public half, or {"sealed": ...}) with its secret (key, iv, nonce): the content, and whether the seal is intact. A seal that does not open is a finding, not a refused input: it answers 200 with ok false, intact false and why. Nothing is kept. Costs 1 unit, a broken seal included.

  Parameters:

  • sealed (required) — object — The sealed record (its public half), as JSON.
  • secret (required) — object — The secret half (key, iv, nonce) that opens it, as JSON.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_close

  Closes a session's files at at_ns, at or after its end_ns: the session back with its closed record hash and its hashes recomputed. Costs 1 unit.

  Parameters:

  • session (required) — object — The session document to close, as JSON.
  • at_ns (required) — integer — The closing time in integer nanoseconds, at or after the session's end.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_replay

  Recomputes a session's hashes against those recorded with it and, for a twin session, runs the twin again from what it records: replays is true when everything matches. A session that does not replay is a finding, not a refused input: it answers 200 with ok false, replays false and which of the hashes did not match. Costs 1 unit, a session that does not replay included.

  Parameters:

  • session (required) — object — The session document to recompute, as JSON.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_align

  Aligns two stations' clocks from repeated pings, each [sent_ns, remote_ns, received_ns] (sent and received on this station's clock, remote on the other's): the offset and its uncertainty by the fastest round trip, and the stations record a two-station session carries. Costs 1 unit.

  Parameters:

  • pings (required) — array — Repeated pings, each [sent_ns, remote_ns, received_ns]: sent and received on one station's clock, remote on the other's.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_lab

  Runs the pull engine's field-theory lab on a theory document (its fields, Lagrangian, which quantity is the mass, what fixes the sector and the value expected; pull_schema lists the keys): the equations derived, a static solution found and weighed, a check that the solver finds no lump where there is none, its small oscillations and a collision, in a fixed layout with an honesty box saying what is exact and what is remembered rather than sourced. reference (true, or a reference theory's name) runs the reference suite instead, each known number naming its source. reference true (the one-dimensional suite) answers within 30 seconds for 1 unit. A one-dimensional theory is counted first, by the engine, in its sites and its relaxation and collision steps: one that comes to 1 unit (a second or so, on the lattice the lab picks for most theories) answers at once for that unit, and a larger one is queued and priced like a theory with a model, at least 1 unit. The lab picks a spacing of 0.05 over the heavier meson and a box of 16 over the lighter, so a theory whose vacua differ a hundredfold in mass counts 64,001 sites and some 3,200 CPU-seconds, and a lattice the theory sets itself (lattice.dx as fine as 1e-4, lattice.half_length as wide as 1000) grows as the square of one over the spacing. A theory with a model (the Skyrme model's baryon, the Faddeev-Skyrme model's knot), and reference skyrme or hopfion, relaxes a lattice in three dimensions, which takes minutes of CPU: it is queued, on 4 threads, and priced by the engine's count of its lattice and steps, a unit for each 5 CPU-seconds of one thread it estimates, at least 1 and at most 300 (the reference Skyrmion costs 38; a hopfion relaxes four times, and the reference one, on 128 sites a side, comes to far over the most a job may cost and is refused with its price, while one relaxed on 64 sites a side, 217 units, is accepted; pull_cost says the price first). The steps priced are the steps asked for or, for each site of the relaxed lattice's side less one, 60 (a Skyrmion) or 75 (a hopfion), whichever is fewer, which is more than a relaxation took in a box that holds the soliton (a Skyrmion's 25 to 43 for each side less one at 25 to 161 sites a side, a hopfion's 28 to 56 at 32 to 128); a box narrower than the soliton (a Skyrmion's lattice.half_length must be 2 or more, a hopfion's relax.half_length 4 or more), where a relaxation took several times as long or never settled, is refused, and a relaxation that has not settled by then is stopped at three times its estimate and costs its price. A call priced at more than 2 units is queued: the answer is 202 with a job id and its price, GET /api/agents/jobs/<job> (or the MCP tool job) says when it is done, and the whole report comes back as report.json beside a short verdict. A queued call is refused on the free plan with 402: its units buy only calls that answer at once, and queued jobs need a paid plan (a pass or the card plan).

  Parameters:

  • theory — object — The theory document written inline: its fields, Lagrangian and the quantity to match.
  • reference — True, or a reference name, to compare against a reference run.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_practice

  Grades a practice of five drills: match (the spread of the taps against the click), hold (the click falls silent and the person keeps the beat), follow (the click moves its tempo once, at a beat nobody is told), lead (the click follows the person) and duet (the click meets the person a quarter of the way). Each drill is rounds of taps against a click, graded on one number in milliseconds against its level's tolerance, and printed beside the input's own jitter (practice.input: the clock that stamps the taps and its stated jitter), with a sentence saying so when the input cannot tell the person's spread from its own. The staircase is pinned: two passes in a row move a drill up one level and a miss moves it down one, 20 levels at most. The answer's session (each drill's next level and score) goes back in as the next practice's history, oldest first, and a drill the history holds gets a trend over the sessions. A drill's recorded rounds ([{clicks_ms, taps_ms}], a client's own click and tap times) are graded as played; without them a simulated person (a timekeeper and a motor, correcting toward the click) plays the drill, and practice.person sets it. The engine plays no click and hears no input: the client does both. Give a practice document (pull_schema lists its keys under practice), or nothing, or seed alone, for the default practice of all five drills. Every sentence is checked for wellness language and the answer carries the not-a-medical-device sentence; a drill name the check refuses refuses the whole answer. Answers at once, within 30 seconds. Costs 1 unit.

  Parameters:

  • seed — integer — A whole number that makes the run reproducible: the same seed and inputs give the same answer.
  • practice — object — The practice document: the five drills and the taps recorded for each, as JSON.

  Hints: read-only no · destructive no · idempotent no · open-world no

• pull_call

  Runs an ae_pull verb this list does not name yet, by its name, over one document when it reads one: the way to reach what the engine adds before this service lists it. No flags pass through, and the verbs above (schema, analyse, twin, schedule, seal, open, prereg, replay, close, align, lab, cost, practice) are refused here: each has its own call. Answers at once, within 30 seconds. Costs 1 unit.

  Parameters:

  • verb (required) — string — The ae_pull verb name to run, lower-case with underscores.
  • document — object — The one JSON document the verb reads, when it reads one.

  Hints: read-only no · destructive no · idempotent no · open-world no

• job read-only

  A job's status and, once it is ok, its files as signed URLs (and small PNGs inline). For a queued job (video_still, video_render, raster_render, and a large pull_analyse, pull_twin or pull_lab) the status is queued, running, ok, refused, failed, cancelled or expired; wait_s (at most 25) holds the answer until the job ends. A queued pull job's result is its verdict, and its whole report is the file report.json. Costs nothing.

  Parameters:

  • job (required) — string — The job id from the call that queued it, such as job_ followed by 24 hex digits.
  • wait_s — number — Seconds to hold the answer until the job ends; 0 answers at once.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• cancel_job destructive

  Cancel a queued job (video_still, video_render, raster_render, and a large pull_analyse, pull_twin or pull_lab). One still waiting is cancelled at no charge; one running is stopped and charged for the CPU it had used, one unit for each 10 CPU-seconds rounded up, never more than its price. Answers with the job and the units charged. Costs nothing itself.

  Parameters:

  • job (required) — string — The job id from the call that queued it, such as job_ followed by 24 hex digits.

  Hints: read-only no · destructive yes · idempotent yes · open-world no

• jobs read-only

  This account's newest queued jobs (at most 50), ids and states only, newest first. The job tool reads one in full. Costs nothing.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• usage read-only

  Units used and left (an account with no pass is on the free plan, counted by the calendar month), when they reset, every limit, and the units left in unit packs (under unit_packs). Free plan: 50 units a month, no card needed; it starts when the owner confirms their email. Queued renders need a pass or the card plan. We limit free plans and first-pass offers to prevent abuse. More units: 500 for $10.00 a pack, spent after the included units and kept until used. Costs nothing.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• owner

  The account's owner: the person or business responsible for the agent, by email. Called with no arguments it reads the owner's state (confirmed, unconfirmed, missing or removed, the address hidden in the middle). With owner_email it names the owner, changes it, or sends the confirmation again. The free plan starts when the owner confirms; a pass never waits for it. Costs nothing.

  Parameters:

  • owner_email — string — The email of the person or business responsible for this agent. Omit it to read the owner's state.

  Hints: read-only no · destructive no · idempotent yes · open-world no

• subscription read-only

  The account's plan: a pass (its window of included units, when access ends, and that it never renews) or a person's card plan (its period and renewal), the owner's state, what is paid, and pass_quote: what the next pass costs this account. An agent buys a 30-day pass with a shared payment token: $1.00 the first time (a one-time offer for a new owner), then $20.00, with 1,500 units each. A pass never renews. Buying is a REST call with a payment token, not a tool: POST /api/agents/subscribe for a pass, POST /api/agents/units for a unit pack. Costs nothing.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

Publisher website

Measured by MCPYP probing. Untested fields are omitted, never estimated. Listing is always free; MCPYP never proxies calls or stores user tokens.