Season outline as nested input: one key, 64-key limit, 2 MiB

Put a whole season outline under one key of a Format run's input. Only top-level keys count toward 64, and the body can be up to 2 MiB, so 40 episodes fit.

4 min readSume
All posts

Send the season outline as one nested object under a single key of input, for example season. Sume limits input to 64 top-level keys and 2 MiB, but nested keys are not counted, so a 40-episode outline is one key, not 40. Reaching either limit returns a 400, so structure matters more than size.

The limits

Limits on the input object of a Format run (read 2026-10-07)
FieldRule
inputA JSON object, at most 64 top-level keys, at most 2 MiB
Nested keysNot counted toward the 64
instructionUp to 8,000 characters accepted; about the first 4,000 are carried to the run
Media URLs inside inputCounted in the shared budget of 30 media files
Where the agent sees itWritten to a file in the run workspace and described as caller data, not as instructions

Why one key

A series outline is naturally a list: episodes, each with a title, a beat and a cliffhanger. If you spread it across top-level keys like ep1_title, ep1_beat, you hit 64 after about 21 episodes. Put the list under season.episodes and the count never matters. The same goes for the cast: one cast key holding an object per character.

A good test is to ask whether a human reader would put it in a spreadsheet column or in a folder. Columns are top-level keys; folders are nested objects. A season is a folder.

Shape that stays readable

The agent reads input as a file, so keep names plain and put the facts it must not invent in it: runtime in seconds, the aspect ratio, the model id you want and the episode number to render now. Keep the instruction itself short. Because only about 4,000 instruction characters arrive, anything long belongs in input, where the 2 MiB limit gives you far more room.

{
  "instruction": "Render the episode named in input.render.",
  "input": {
    "season": {
      "title": "Night Shift",
      "aspect_ratio": "9:16",
      "episodes": [
        { "n": 1, "beat": "Maya finds the locked door", "hook": "A key arrives by post" },
        { "n": 2, "beat": "The key fits", "hook": "Someone is already inside" }
      ]
    },
    "cast": { "maya": { "look": "short black hair, green coat" } },
    "render": { "episode": 2 }
  }
}

What to avoid

  • Do not paste secrets or API keys into input; it is written to a file and visible to the run.
  • Do not send the whole outline when only one episode is rendering. Send the episode and one line of recap, to keep the context the run reads small.
  • Do not rely on key order. If order matters, use an array.
  • If the body is above 2 MiB, move large text to a hosted file and send its HTTPS URL, remembering that URLs to media count toward the 30-file budget.

In a bulk queue

A bulk request takes 1 to 100 items, and each item has its own input. Share the outline once by putting the same season object in each item, or send only each item's own episode. Both work; the second keeps every run's context smaller and makes retries of one episode independent of the rest.

If you need a record of what was sent, keep the same JSON in your own repo next to the idempotency key you used. Since the key plus the body identifies a request, a replay with the same pair returns the original run with idempotency_hit, and a changed body under the same key returns 409.

Sources

Related posts

More in Formats

All Formats posts

Written by Sume