Supply a project note, its confirmation and relevant existing memory. Compare reusable decisions with temporary progress or conflicts before any memory write.
Review one proposed memory noteLive API
The decision
Reusable evidence is different from recent text.
A confirmed project decision can help future work. A progress update usually cannot. This example asks Jev to distinguish those cases using the confirmation, scope and existing context supplied with each note. It does not assume that a sentence is true just because it looks like an instruction.
Save candidate means the note is eligible for a proposed memory entry under this example policy. It does not authorize a write. Skip covers greetings, temporary progress and explicitly session-only information. Needs review keeps tentative claims, missing scope and contradictions out of a trusted memory store until someone resolves them.
Claude Code documentation distinguishes authored project instructions from learned project context and recommends concise, consistent information. That distinction informs the scenario, but this demo is not connected to Claude Code. The X source describes typed questions used by a memory harness; our original six-note exercise tests one admission decision without reproducing that harness.
AI-generated concept illustration of memory admission review; the demo does not write an archive.
How it works
Review a memory candidate in four steps.
Preserve evidence before deciding what future sessions should inherit.
01
Scope the candidate
Identify the project, original note and whether the information applies beyond the current session.
02
Include confirmation
State who confirmed the decision and include any supplied existing rule that could conflict.
03
Classify admission
Compare durable decisions, temporary progress and unverified claims using the same explicit policy.
04
Review the proposed edit
Keep the original text and label in a proposal. Require separate approval before writing or replacing any memory entry.
Our API test
Six notes, with uncertain evidence held for review.
Six notes, with uncertain evidence held for review.
Synthetic project note
Observed label
Leading probability
Confirmed project decision
Save candidate
94%
Confirmed correction
Save candidate
96%
Temporary progress
Skip
97%
This session only
Skip
97%
Unverified guess
Needs review
98%
Conflicting evidence
Needs review
100%
Six live Jev requests on September 27, 2026. Original synthetic functional checks, not an accuracy or speed benchmark. Fresh distributions may differ.Verified
Understand the results
Using the result in your application
For the timezone sample, a proposed review record would preserve candidateId: timezone, scope: demo-repository and the exact original note.
Read the example notes
It would add decision: Save candidate, proposalStatus: pending-human-review and memoryWritten: false. These fields describe a deterministic application mapping; this website does not create a queue or write a memory file.
Source and example scope
Handle the other labels differently.
Read the example notes
Skip creates no memory proposal. Needs review keeps the candidate and any supplied conflicting rule together as a review issue. An authorized reviewer checks the original evidence and decides whether an existing entry should change. A higher model probability does not supply missing authorization or resolve an unverified policy change.
Using the result in your application
Download observed-memory.json and run-choice-sample.mjs into a private Node.js project.
Read the example notes
Tested setup is Node.js 24.18.0 and @typesafe-ai/sdk 0.6.0. Run npm init -y and npm install @typesafe-ai/sdk@0.6.0. Set TYPESAFE_API_KEY privately, then run node run-choice-sample.mjs observed-memory.json conflict. One selected sample produces one fresh request without retries.
The fixture includes every exact note, policy, choice and recorded distribution
The fixture includes every exact note, policy, choice and recorded distribution.
Read the example notes
Fresh results can differ. Try changing an unverified claim into a documented owner confirmation, while keeping its project scope explicit. Then compare the new distribution. These synthetic checks illustrate admission rules; they do not establish the quality of an agent's long-term memory or perform any storage operation.
import { readFile } from 'node:fs/promises';
import { choice, TypeSafeClient } from '@typesafe-ai/sdk';
// Run one selected sample. There are no retries or automatic batch requests.
const [file, sampleId] = process.argv.slice(2);
if (!file || !sampleId || !process.env.TYPESAFE_API_KEY) {
throw new Error('Set TYPESAFE_API_KEY, then run: node run-choice-sample.mjs FIXTURE.json SAMPLE_ID');
}
const raw = await readFile(file, 'utf8');
if (Buffer.byteLength(raw) > 1_000_000) throw new Error('Fixture is too large');
/** @type {{samples: Array<{id: string, request: {context: string, question: string, choices: string[]}}>}} */
const fixture = JSON.parse(raw);
const matches = fixture.samples.filter(sample => sample.id === sampleId);
if (matches.length !== 1) throw new Error('Select exactly one existing sample ID');
const { context, question, choices } = matches[0].request;
if (typeof context !== 'string' || typeof question !== 'string' || context.length > 12000
|| question.length > 500 || !Array.isArray(choices) || choices.length < 2 || choices.length > 12
|| choices.some(label => typeof label !== 'string' || !label || label.length > 120)
|| new Set(choices).size !== choices.length) throw new Error('Invalid sample request');
const client = new TypeSafeClient({ logLevel: 'off' });
const start = performance.now();
try {
const result = await client.systemOne({ model: 'jev-latest', state: { context, question, choices },
questions: { decision: choice(question, Object.fromEntries(choices.map(label => [label, null]))) } },
{ timeout: 10000, retry: { maxRetries: 0 } });
console.log(JSON.stringify({ sampleId, elapsedMs: Math.round(performance.now() - start), result }, null, 2));
} catch {
console.error('The API request failed. No retry was sent; check your account and network privately.');
process.exitCode = 1;
}
Scope of this demo
What this example helps you test.
Supplied choices
What you can test
Separating confirmed reusable notes from temporary progress
Keeping uncertain or conflicting evidence visible
Testing a review gate before an application writes memory
Application responsibilities
What this demo does not do
Verifying a note against an unseen repository or conversation
Treating a model label as permission to persist information
Writing, replacing or deleting real memory files
Example FAQ
Questions before you use the result.
Understand the choices, the source and what a live result means.
Does Save candidate write a memory entry?
No. It is an admission label. A separate application and an authorized reviewer would need to approve and perform any write.
Why skip a current build update?
It describes temporary run progress rather than a reusable fact for future sessions. The example policy explicitly excludes that kind of note.
What if a new note conflicts with existing memory?
Needs review preserves the conflict. The model does not decide which source is authoritative when confirmation is missing.
Can Jev verify the supplied confirmation?
No. This demo only reads the provided text. A reviewer must verify provenance outside the classification request.
Should I paste real secrets or private conversations?
Use authorized, minimized information. The supplied examples are synthetic and require no credentials, private conversations or personal history in the input.
Test your own decision
Try another input here or build a different Choice question in the Playground.