OPEN SOURCE · POWERED BY JEV

The right context.
For this moment.

Your agent doesn’t need every paragraph.
Give it the ones that matter.

Codex · Claude Code · Hermes · Your agent · Codex · Claude Code · Hermes · Your agent ·

THE LIVE PLAYGROUND

Ask differently.
Watch context change.

A fictional team. Twelve paragraphs of memory.
Every relevance judgment comes from Jev.

Try a request1 / 4

Requests are sent to TypeSafe with the public sample paragraphs. Please don’t enter secrets.

Choose a request to see real model selection.

Paragraph library

Sample memory · Orbit

12

Dynamic context

Only what the request needs

[   ]

A little less noise.
A lot more focus.

Run a request. Selected paragraphs appear here, with their sources intact.

Inspect the agent payload
No selection yet.

Relevance is Jev’s estimated probability that a paragraph helps with this request. The cutoff is adjustable, not a calibrated guarantee. Budgeting preserves whole paragraphs and counts the complete payload using o200k_base; other models may tokenize it differently.

MEASURED ON EIGHT EXISTING SITES

Less context.
Measured, not assumed.

Exact archived website requests, replayed through Jev.
Default relevance cutoff: 0.50 · September 20, 2026.

14.8%fewer generation-input tokens

230,057 → 195,953
34,104 tokens removed across eight requests.
All 80 required-paragraph checks passed.

Paired bars compare full and reduced generation-input tokens for eight existing sites. Individual reductions range from 9.3% to 27.2%. Exact values appear in the table below.
Both bars include the unchanged request. The selected-context bar also includes source metadata and its instruction wrapper. Jev’s own processing tokens are excluded from these bars.
Fewer generation tokens ≠ the same reduction in cost.

After Jev’s selection cost, estimated uncached input cost fell from $0.17254 to $0.16785: 2.7% savings. With cached generation prompts, the dynamic path cost more. This replay did not regenerate sites or establish equivalent output quality.

View exact token counts and test sites
Test siteFull inputDynamic inputReduction
Trade negotiation matrix28,71624,79513.7%
Forecast ensemble lab28,77720,94827.2%
Skincare routine auditor28,99423,29419.7%
Command deck melder28,96325,84310.8%
Documentary release risk modeler28,71624,81413.6%
Tribute concert setlist planner28,48425,8259.3%
Prosthetic chair optimizer28,79925,23212.4%
Vehicle packaging studio28,60825,20211.9%
All eight sites230,057195,95314.8%

QUESTIONS, ANSWERS, AND EVIDENCE

Does less context
keep the answer right?

29 questions in a revised subset. One answer model. Three independent arms.
Public text from the eight sites plus the demo’s sample memory.

29/29dynamic-context answers correct

96.1% less answer-model input
Full context: 29/29 (100.0%) · No context: 9/29 (31.0%)
Accuracy change: +0.0 percentage points.
Answerable questions: 20/20 · Missing-information checks: 9/9.

Answer accuracy: full 29/29 (100.0%), dynamic 29/29 (100.0%), no context 9/29 (31.0%). Dynamic input tokens decreased 96.1 percent.
Gemini 3.8 Flash answers; Jev selects at cutoff 0.50. Exact all-fields-correct scoring against answers frozen before the run. Input includes the question, instructions, and source metadata. Jev processing tokens are additional. Revised subset: three prior failures excluded.
Fresh rerun of the revised subset.

These questions use 71 paragraphs of published site text and sample memory, not the full website-generation prompt above. The compression rates are not interchangeable. Three questions were excluded after failing the original run; this is not evidence of improved accuracy on the original workload. No dynamic answers failed this run; a small sample does not prove equivalence. One model, one fresh run, 29 hand-authored questions; this does not establish regenerated-site quality.

Compare accuracy and input saved by source
SourceFull accuracyDynamic accuracyInput removed
Command deck3/3 (100.0%)3/3 (100.0%)96.4%
Documentary3/3 (100.0%)3/3 (100.0%)96.2%
Forecast3/3 (100.0%)3/3 (100.0%)95.7%
Orbit8/8 (100.0%)8/8 (100.0%)96.4%
Prosthetic2/2 (100.0%)2/2 (100.0%)95.1%
Skincare3/3 (100.0%)3/3 (100.0%)94.9%
Trade3/3 (100.0%)3/3 (100.0%)96.1%
Tribute2/2 (100.0%)2/2 (100.0%)96.9%
Vehicle2/2 (100.0%)2/2 (100.0%)97.1%

MEASURED WITH LIVE JEV CALLS

Parallel selection.
Measured overhead.

81 cold queries. Three corpora. One, three, and eight workers.
Same paragraph coverage, request, batch size, and relevance policy.

0.76smedian website-prompt retrieval

5.0× faster than sequential
3.82s with one worker → 0.76s with eight.
2.0× faster than the previous three-worker default.

Cold retrieval medians compare one, three and eight workers on 12, 71 and 78 paragraphs. The website prompt drops from 3819 to 763 milliseconds; exact medians and P95 values follow.
Bars and labels show median wall time; thin extensions and dots show P95. Nine runs per configuration. Eight workers reach six concurrent calls for 71 paragraphs and seven for 78. The 12-paragraph sample needs just one call.
Parallel does not mean zero overhead.

Across 12 paired questions, median complete-answer time was 3.03s with full context and 2.90s with dynamic context, including Jev. P95 was 3.56s versus 11.26s. The median paired difference was +3 ms; 6/12 dynamic requests took longer. Exact accuracy was 12/12 versus 11/12. This is a small measured sample, not a latency guarantee.

Immediate cache repeats made no new Jev calls: median 1.1 ms on the question corpus and 52.4 ms on the website prompt. Local context assembly still takes time.

Inspect median and tail retrieval times
CorpusWorkersMedianP95
Demo memory · 12 paragraphs1476 ms722 ms
Demo memory · 12 paragraphs3452 ms775 ms
Demo memory · 12 paragraphs8489 ms506 ms
Question corpus · 71 paragraphs12994 ms3740 ms
Question corpus · 71 paragraphs31022 ms1166 ms
Question corpus · 71 paragraphs8566 ms784 ms
Website prompt · 78 paragraphs13819 ms5448 ms
Website prompt · 78 paragraphs31514 ms1872 ms
Website prompt · 78 paragraphs8763 ms1280 ms

A memory that adapts.
Without rewriting
what you know.

Store

Your paragraphs.
Your database.

Import Markdown or text into a local SQLite collection. Keep exact words and source references. Replace a document to update its memory.

Select

Meaning over
matching words.

Jev judges each paragraph against the full request. A shared keyword isn’t enough. Useful constraints and dependencies belong in context, too.

Assemble

A focused context.
A clear provenance.

Relevant paragraphs become a source-tagged payload within your chosen budget. Your agent uses it as reference material for the task.

ONE ENGINE. YOUR AGENT.

Make memory
part of the workflow.

Download the self-contained skill or install the Python CLI.
Use your TypeSafe key. Keep the database on your machine.

Get the open-source engine ↗

The skill runs retrieval when invoked. It does not silently intercept every agent request. Add the supplied instruction to your agent’s project guidance for consistent use.

Read the setup guide ↗ · Download skill ZIP ↓