Tomorrow Lives Engines

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

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.

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

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.

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

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

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.

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.

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.

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

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).

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.

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.

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

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

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.

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

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

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).

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.

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).

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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, flips and a multiply blend (a shadow, a vignette, a night grade); characters who talk (cast, timed lines with their own reading, ducked music, subtitles made from the lines, a mouth that moves on the words 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), animals and forms, and a camera that follows, orbits or cranes; music with a melody, a lead instrument and tempo changes; 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).

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, flips and a multiply blend (a shadow, a vignette, a night grade); characters who talk (cast, timed lines with their own reading, ducked music, subtitles made from the lines, a mouth that moves on the words 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), animals and forms, and a camera that follows, orbits or cranes; music with a melody, a lead instrument and tempo changes; 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.