Jev agent memory admission

Choose which project notes deserve memory review

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
Try an example

Original synthetic project note; no actual user memory is read or changed.

Source: Workflow inspiration on X

Source and example scope

Independent admission decision, not a reproduction of the source memory harness. This demo never writes memory files.

Save candidate: a confirmed reusable project decision, correction or stable preference with clear scope.

Decision rules and labels
Save candidateSkipNeeds review
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

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.

Conceptual project notes separated into durable candidates, temporary information and an amber review tray before archiving.
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.

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

    Scope the candidate

    Identify the project, original note and whether the information applies beyond the current session.

  2. Illustration of defining a question and its allowed choices

    Include confirmation

    State who confirmed the decision and include any supplied existing rule that could conflict.

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

    Classify admission

    Compare durable decisions, temporary progress and unverified claims using the same explicit policy.

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

    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 noteObserved labelLeading probability
Confirmed project decisionSave candidate94%
Confirmed correctionSave candidate96%
Temporary progressSkip97%
This session onlySkip97%
Unverified guessNeeds review98%
Conflicting evidenceNeeds review100%

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.

One live request

Replay one admission decision from Node.js.

View the code example
run-choice-sample.mjs
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.