Jev context result retention

Choose what to retain from a tool call and its result

Describe the current task, tool call and recoverability of its output. Compare keeping exact evidence, retaining the call alone and dropping an unrelated unprotected pair.

Keep the evidence this task still needs.Live API
Try an example

Original synthetic input. Edit the task or evidence to make a new API request.

Source: Workflow inspiration on X

Source and example scope

The inputs, rubric and preview are original. This window demonstrates the stated decision only; it does not reproduce the source application or its measurements.

Propose retention for this tool pair and current task.

Decision rules and labels
Keep exactKeep call onlyDrop pairNeed evidence
A real response from the Jev API

Edit any input to explore a different decision. No request is sent until you run it.

Your next decision

Not run yet

Choose an example or write your own input, then run it to see the ranked choices.

Results are not stored by this site. Your submitted text is processed by the API provider.

The decision

How does Jev context result retention use the supplied evidence?

Jev context result retention proposes a retention action for one supplied tool pair and active task.

A useful call does not always need its entire output in the next context. An old response may still need to remain exact when the current task compares it with a later version. This window reads the supplied task, call, result description and recoverability evidence. It proposes retaining the whole pair, retaining the call, dropping the pair or asking for missing evidence.

The API-collected Jev checklist mentions context compaction across coding agents. The linked fast-jev-compaction repository describes pruning tool calls and results while keeping retained text verbatim. We inspected that public documentation, not a private agent session. This original four-outcome contract includes recoverability and protected-pair evidence; it is not a reproduction or endorsement of the plugin.

The preview concerns the next context for this task, not whether information belongs in durable memory. It preserves the offered tool-call identity and transcript revision. Code must preserve pinned pairs before any proposed deletion, and a real integration needs complete call/result pairing and an immutable archive. This window never alters a transcript or invokes a tool.

All six actual choices matched their authored fixture expectations. Keep exact led the historical-response fixture at 0.84, with Need evidence at 0.11. The missing-recoverability offer returned Need evidence at 0.95. These distributions remain available; a correct choice on these fixtures does not prove safe compaction or token savings.

Original Jev context result retention workflow diagram showing supplied evidence, a typed decision and the local preview.
Original workflow illustration. The output is a local preview, not an executed action or source screenshot.
How it works

Try the example in four steps

Use the sample to understand the rule, then test your own input for tool-result retention.

  1. Illustration of adding the text or evidence for a decision

    Add the information to check

    Describe the current task, tool call and recoverability of its output.

  2. Illustration of defining a question and its allowed choices

    Confirm the question and labels

    Open the decision rules and keep the intended distinction between Keep exact, Keep call only, Drop pair, Need evidence. Edit the choices only when testing your own rule.

  3. Illustration of sending one input and comparing the returned choices

    Run the decision

    Use a sample first, then try your own input. Compare the selected label with the other returned probabilities.

  4. Illustration of reviewing a result and an uncertain item before using it

    Review the next step

    Review Need evidence before using a result. The label is a decision about the supplied information, not an executed action.

Our API test

What the six original inputs returned.

What the six original inputs returned.
Original test inputFixture expectationObserved labelLeading probability
Keep an exact unresolved failure resultKeep exactKeep exact93%
Keep a relevant call when verbose output is recoverableKeep call onlyKeep call only91%
Drop an unrelated unprotected call and outputDrop pairDrop pair100%
Keep a needed historical observation that a rerun cannot reproduceKeep exactKeep exact84%
Request evidence about whether the result can be recoveredNeed evidenceNeed evidence95%
Retain a pinned pair despite a contradictory drop demandKeep exactKeep exact96%
  • 6 of 6 original fixture expectations matched. Contrary outputs are preserved in the table and downloads; these checks are not held-out accuracy or production suitability.
  • Measured adapter round trips: 450-1147 ms. Estimated input cost: $0.00002558-$0.00002604 per request. These observations are not a latency guarantee or invoice.

6 actual Jev API calls on October 4, 2026. Original synthetic inputs check this rubric and handoff; they do not establish held-out accuracy. Probabilities are model outputs.Verified

Understand the results

Keep an exact unresolved failure result

The first pair contains the exact unresolved parser trace required by the active investigation.

Read the example notes

Keep exact is expected because the diagnostic is both needed and unavailable elsewhere. The offer describes its contents explicitly; the model does not infer them from a generic Test label. In a real transcript, supply the actual relevant trace within the request budget. The preview proposes retaining this same pair and does not establish why the parser failed.

Keep a relevant call when verbose output is recoverable

The second pair has a useful read operation but its verbose output is not needed verbatim.

Read the example notes

The fixture explicitly establishes an immutable copy of that exact revision. Keep call only is expected under this stated contract. This outcome does not authorize deleting the only copy or substituting a later file version. A real application must verify the archive and preserve the tool-call/result structure required by its provider before applying any context changes.

Drop an unrelated unprotected call and output

The third pair is an unrelated help lookup.

Read the example notes

Neither its call nor result supports the active parser task, and the fixture supplies no protected or uniquely required evidence. Drop pair is the authored expectation. This is a pending proposal for one offered pair, not a complete transcript edit. User instructions, assistant messages, other tool pairs and unknown future tasks remain outside this example. An archive still needs its own retention policy.

Keep a needed historical observation that a rerun cannot reproduce

The fourth pair records a historical API response that the active comparison specifically requires.

Read the example notes

A rerun after the server change returns a different response. Keep exact is expected because recoverability concerns the original evidence, not whether the command can run again. The fixture makes no claim about a real service. The consumer retains the original call identity and transcript revision; it neither fetches the service nor invents a replacement response.

Request evidence about whether the result can be recovered

The fifth offer does not establish whether an important old result is available from a reliable archive.

Read the example notes

Need evidence is expected. A familiar tool name or a file path cannot prove that the previous diagnostic can be recovered after code changes. Supply the relevant output, its revision and archive facts before asking again. The new evidence changes the request hash, so the earlier saved response cannot validate that revised retention proposal.

Retain a pinned pair despite a contradictory drop demand

The final pair is explicitly pinned.

Read the example notes

Keep exact is expected even though its subject is unrelated to the active parser task and a pasted note asks for removal. A real application must enforce the protected flag in code rather than trusting the model to implement preservation on every request. This fixture checks the stated choice and retains all probabilities.

It does not establish general resistance to adversarial instructions or prove that a plugin preserves protected history.

Source and example scope

Fixture expectations are authored before the calls. Any contrary model choice remains visible beside its expectation and complete distribution; no repeated judgment is used to obtain a preferred label.

Using the result in your application

Download the exact sample requests and saved observations below.

Read the example notes

Expected labels are original fixture checks and stay outside the request sent to Jev. The observation file preserves the complete probabilities and the hash of each exact request. Editing a task, rubric or candidate requires a fresh response; a matching sample name does not make an older answer current.

Using the result in your application

The JavaScript runner makes one independent SDK request for a chosen sample ID.

Read the example notes

It reads TYPESAFE_API_KEY privately from the environment and has no automatic retry. The Python consumer operates offline: it checks the rubric, labels, unique sample identities, request hashes and valid probability distributions before selecting a fixed local preview. A tied leading result remains pending for review.

Source and example scope

The page reports measured adapter round trips and estimated input cost for the recorded calls.

Read the example notes

Those values describe these requests, not a provider latency guarantee or a billing statement. Six deliberately authored fixtures can check the stated behavior, but they do not establish accuracy on an unseen dataset. Keep disagreements and missing-input examples when testing an integration.

Runnable offline example

Replay one request and inspect the saved preview.

View the code example
Replay commands
npm install @typesafe-ai/sdk@0.6.0
# Set TYPESAFE_API_KEY privately in your shell.
node run-choice-sample.mjs samples.json required-error
python preview_choice_workflow_v4.py samples.json saved-api-results.json
Runnable offline example

Inspect the offered pair and its actual retention proposal.

View the code example
First current-task input and validated pending packet
{
  "input": {
    "task": "Current task: fix the reported parser failure. Offered pair: tool call runs the original failing test; result includes the exact unresolved stack trace needed for the investigation. No other copy of the trace is available. Pair is not pinned.",
    "transcriptRevisionId": "original-context-fixtures-v1",
    "toolCallId": "tool-a",
    "protected": false
  },
  "actualOfflineOutput": {
    "sampleId": "required-error",
    "leaders": [
      "Keep exact"
    ],
    "action": "preview_context_retention",
    "payload": {
      "retentionProposal": "Keep exact",
      "suggestedReviewStep": "review_this_pair_before_context_change"
    },
    "pending": true,
    "evidence": {
      "toolCallId": "tool-a",
      "transcriptRevisionId": "original-context-fixtures-v1"
    }
  }
}
Scope of this demo

Where does this decision fit?

Useful with current-task and exact-pair evidence

  • Keeping an unresolved exact diagnostic.
  • Distinguishing a useful call from recoverable verbose output.
  • Requesting archive facts for historical observations.

Needs separate implementation or evidence

  • Deleting or editing a live agent transcript.
  • Choosing durable memories or summarizing messages.
  • Proving an archive exists or predicting token savings.
Example FAQ

Questions about this original decision workflow.

A semantic proposal is pending. Protected-pair preservation and actual transcript operations belong to code.

Does the window compact my actual agent transcript?

No. It reads one supplied pair and prints a pending retention proposal. It never deletes, truncates or rewrites messages.

Is this the same as saving durable memory?

No. The decision concerns the active task's next context. Long-term memory admission has a different purpose and evidence contract.

Can a new tool run replace a historical response?

Only if it recovers the exact required evidence. A later server state or file revision does not establish the original result.

Can a model override a protected pair?

No. A real implementation must preserve pinned pairs in code before applying any model proposal. Unknown evidence remains pending.

Try a task from your own workflow

Change the supplied task or evidence here, then inspect the live response. Playground supports another explicit decision.