State

The state is what the engine evaluates: a support message, a document, an application record. It goes in the state field next to the questions.

Formats

• a string: "My card was charged twice."
• an object with named fields: {"message": "My card was charged twice.", "order_id": "A-104"}
• an array of strings: ["Hi", "My customer number is TS1337.", "My card was charged twice."]

Text only; images, audio and video are not read. English first: Jepela's English checkpoint is the measured one; its multilingual checkpoint covers more languages with lower accuracy.

How much the engine reads

The request body is capped at 1 MB, but the engine reads far less. Each question is read together with the state in one window, and the question and its options take their share first. Measured on 2026-09-23 with a long state:

The rest of a string or an object is cut from its end. An array is cut from its start instead: the engine keeps its newest elements and drops the oldest. Memory lines and computed facts are placed before the state (below) and take their share of the same room: in a string or an object they are read first. In an array they would be the first to go, so when an array that carries such lines is longer than the engine reads, Jepela leaves out the array's oldest elements, whole, until the lines and the remaining elements fit, and sends that. It never leaves out a line or the newest element. An array that fits is sent exactly as before. Measured on 2026-10-16 with the English checkpoint: a chat of 41 turns with a priority-support line gave 0.174 to "escalate?" before, the same as without the line, and gives 0.8955 now, with the oldest 13 turns left out. A choice of more than 20 options answered by matching reads an array the same way: the elements the engine kept, and within the matching model's own room its newest ones (see Choice). With quality balanced or best, the second tier is sent the same elements, with the lines in front.

Every answer says what was read: reading per question (state_tokens, read, room, chars_read, truncated; with memory or derive these count the lines placed before the state too, and context_lines_read says how many of those lines were read; chars_read counts the characters read from the start, or for an array the last ones; with windows, see below) and, in usage, state_tokens, state_tokens_read and state_truncated, over the questions the engine read (a matched choice's own reading stays in reading). When Jepela left out an array's oldest elements, turns_dropped says how many, truncated is true, state_tokens counts the whole array with its lines, and read and chars_read count what was sent: the lines and the newest elements, read whole. A cut state also brings a state_cut warning; when elements were left out, it says how many. A matched choice (see Choice) is read by the matching model, not the engine: its reading has method match, counts that model's tokens, and says what it read of its 512 tokens with the search prefix: a string or an object from the start, an array as described above (with turns_dropped when it left out the oldest elements); its context_lines_read counts the lines that model read. When the lines and the newest element alone are longer than the engine reads, Jepela leaves out as few older elements as let the most lines be read, and the memory_cut warning says how many lines were read.

What to do about a long state:

• Put the part that matters first (last in an array), or send only that part.
• Send "windows": true: when the state is cut, the engine reads it in overlapping windows (neighbours share 32 tokens), at most 16, each with the memory lines in front, so nothing is left out to make room for them. A string or an object is read from its start, so one too long for 16 windows is read up to the 16th window. An array too long for 16 windows is read from its end instead: the windows keep its newest elements and leave out its oldest, as one pass does. An array the windows cover whole is read from its start, as before. When the windows do not cover the state, windows.covered_all is false and the state_cut warning stays. With windows, read and chars_read count the tokens and characters of your state that the windows covered (from its start, or for an array too long for them, up to its end), without the lines in front. By default a yes/no question takes the window with the highest yes, a score the highest level, and a choice the most confident window (for a choice min and max both take the most confident window); "windows": {"combine": {"question_id": "mean"}} sets min, max or mean per question. Each window bills the request's answers once more; see Request options.

What the memory adds

When the request names a subject, the recalled lines are placed before the state, so the engine's cut from the end can never remove them from a string or an object: for a string, a block headed What this customer's memory knows: with one line per fact (the wording every measurement here was made with); for an object, a known_facts key placed first; for an array, a leading element. An array is cut from its start, so when an array with memory is longer than the engine reads, Jepela leaves out its oldest elements so that the memory is read, and reading.turns_dropped says how many (see above). Facts computed by derive come first of all: under Computed by the system: in a string or an array, as a computed_facts key in an object. The answer's memory.hits lists the recalled lines, each with read (true when the engine read it), and memory.lines_seen how many of them the engine actually read.

Guidance

• Put facts in the state and judgments in the questions.
• Use an object when several things must be compared: the message, the order, the policy.
• Decompose: one state per subject, not a batch of unrelated records.
• Reference fields from the instructions with their names in backticks, `order.total`, when the question is about one field.