An AI worker fails. Another rebuilds something the team already accepted. A reviewer opens a change before its evidence is ready. These are different problems, but each can start with a small decision: what should the owner look at next?
We have connected TypeSafe Jev to six of those decision points. It offers bounded advice inside the system we already use to coordinate work. The owner still decides what to do and checks what happened.
The opportunity is less repeated work. The cost is another check, more tokens and more runtime. We have verified the integration described here; we have not demonstrated net production savings or an accuracy improvement. The calculator below lets you explore the assumptions without confusing them with results.
Jump to the interactive calculator, or read how each use fits first.
Where Jev fits
- 01 / ObserveA useful event
A failure, edit or evidence checkpoint. Hooks gather only the context needed and deduplicate it.
- 02 / BoundProgram checks
Current inputs, permission, ownership and holds determine what is eligible.
- 03 / AdviseTypeSafe Jev
A typed, probabilistic classification among the allowed options.
- 04 / DecideThe current owner
Inspects the advice, performs any action and verifies the outcome.
Used · dismissed · accepted · regressed. Feed outcome evidence and random audit examples into later evaluation.
BORG is the surrounding memory, context and coordination system. It helps the worker arrive with the right task and source material. Jev is a typed, probabilistic adviser: it classifies a bounded question using options the surrounding program permits. It does not replace BORG’s memory store, become the task owner or approve its own review.
Our current integration calls TypeSafe Jev 1.13.0 directly through the existing vault-backed transport. Automatic hooks collect minimized events, deduplicate decisions and offer advice at work boundaries. Fixed program checks handle eligibility, permissions, ownership and evidence. The current owner acts on advice and records an outcome: used, dismissed, accepted or regressed.
A six-second fail-open budget bounds hook overhead. If the check cannot finish, the original workflow continues. An unknown provider outcome is not blindly replayed. A hold remains a hold, an unavailable route remains unavailable, and missing proof does not become acceptance because a model sounds confident. CPU or GPU autoscheduling is not an established Jev production feature.
TypeSafe documents limitations around numeric precision, indirection, irrelevant context and adversarial text. We keep arithmetic and fixed permission checks in code, and keep the model’s question narrow. Its confidence describes concentration in an answer distribution; it is not an observed accuracy score. Model limitations · Confidence explained.
Rescue a failed free-model worker
BEFORE — A free-model worker fails, and an owner may repeat the same attempt or restart the task without first establishing which recovery options are usable.
WITH JEV — The program supplies the failure and currently eligible recovery options. Jev classifies the situation and offers bounded advice. The owner checks it and chooses the action. If no route is available, that is a valid answer.
WHY AN IMPACT IS POSSIBLE — A useful classification could avoid an ineffective retry or an unnecessary restart. It does not make a free route exist, bypass a hold or guarantee a successful repair. Count a benefit only when the chosen recovery actually avoids work and its result is accepted.
Reuse work that is already accepted
BEFORE — A worker begins again because it has not seen a compatible artifact another owner already accepted.
WITH JEV — The current owner supplies an artifact index bound to the current prompt and task. Fixed scope, revision, input and hash checks narrow the candidates before Jev ranks the relevant options. The owner confirms that the proposed reuse fits.
WHY AN IMPACT IS POSSIBLE — Reusing a valid result could remove duplicated research or implementation. A stale artifact, incompatible input or missing acceptance record is not reusable just because its wording looks similar. This is a check of supplied candidates, not automatic discovery of every artifact in the organization.
Check whether a change is ready for review
BEFORE — A reviewer receives a change, discovers missing proof and sends it back for another round.
WITH JEV — A current, prompt-bound evidence checklist gives Jev a narrow readiness question. It can flag gaps or recommend manual review before the owner requests a review.
WHY AN IMPACT IS POSSIBLE — Finding a missing test or unsupported completion claim earlier could reduce review churn. Readiness advice does not replace independent review, prove a test passed or allow the author to approve its own change. Both the checklist and the evidence must still be current.
Inspect changes in meaning
BEFORE — A small edit looks harmless in a text diff, even though it changes a requirement, a boundary or the behavior a user receives.
WITH JEV — Bounded old and new fragments become a classification question about their meaning. The owner receives a signal about where closer inspection may be useful.
WHY AN IMPACT IS POSSIBLE — Review effort could go to consequential differences sooner. A short fragment can also hide important context. The classification remains advice; the diff, tests and accountable reviewer establish whether the change is correct.
Classify wasted token spend
BEFORE — Repeated reads, duplicated context and unproductive retries consume model calls without an owner seeing the cause clearly.
WITH JEV — Minimized usage observations and repeated tool fingerprints become candidates for waste classification. An owner can inspect the category and repair the process that produced it.
WHY AN IMPACT IS POSSIBLE — A verified fix could prevent that wasted work from recurring. Receiving a label saves nothing by itself. Attribution also matters: a necessary repeated check is not waste simply because it resembles an earlier call. Include the cost of diagnosis, the fix and any regression when measuring the result.
Choose calibration examples, with an audit
BEFORE — A team reviews whichever examples are easiest to find and may miss failures outside that selection.
WITH JEV — Decision records help select useful examples for labeling, alongside reproducible random audit coverage. Owners label what happened and retain cases that contradict the advice.
WHY AN IMPACT IS POSSIBLE — Selection could become less laborious, and the audit could expose blind spots in the targeted set. Neither benefit establishes an accuracy uplift. Keep the random sample, labeling effort and regression checks in the workload; do not treat them as work the calculator can simply erase.
Try your workload
What would have to be true?
Change the assumptions to fit one repeatable kind of work. All results are monthly estimates calculated in your browser. Nothing here calls an AI model.
Defaults are illustrative, except the dated Jev list prices. Blank or invalid entries count as zero; out-of-range entries are capped at the field limit.
- Net tokens avoided
- Model API estimate
- Net agent-hours freed
Positive means avoided; negative means additional use. Agent-hours are aggregate effort, not wall-clock speedup or payroll savings. A paid subscription may yield capacity, not a lower bill.
Includes 1,760,000 of overhead.
Includes $0.07 of overhead.
Includes 0.0556 of overhead.
02 / Six opportunities
Each factor narrows the previous one. “Accepted outcome” means advice was used and its result held up, including any fix or rework. It is an assumption about adoption and results, not model confidence or accuracy.
01Rescue a failed workerOn
Count only eligible recovery that an owner uses and verifies.
Work reached is a share of tasks still left; eligible is a share of reached tasks. Eligibility is checked by the program before calling Jev. One Jev check per eligible task is assumed. If eligibility itself needs a model check, include those calls by raising the eligible share. Include required review and random audit work in what remains.
02Reuse accepted workOn
Count compatible work from a current, owner-supplied index.
Work reached is a share of tasks still left; eligible is a share of reached tasks. Eligibility is checked by the program before calling Jev. One Jev check per eligible task is assumed. If eligibility itself needs a model check, include those calls by raising the eligible share. Include required review and random audit work in what remains.
03Check review readinessOn
Count avoided review churn, while retaining independent review.
Work reached is a share of tasks still left; eligible is a share of reached tasks. Eligibility is checked by the program before calling Jev. One Jev check per eligible task is assumed. If eligibility itself needs a model check, include those calls by raising the eligible share. Include required review and random audit work in what remains.
04Inspect meaning changesOn
Count review effort avoided after the owner checks the advice.
Work reached is a share of tasks still left; eligible is a share of reached tasks. Eligibility is checked by the program before calling Jev. One Jev check per eligible task is assumed. If eligibility itself needs a model check, include those calls by raising the eligible share. Include required review and random audit work in what remains.
05Find wasted token spendOn
Count savings only after an owner implements and verifies a fix.
Work reached is a share of tasks still left; eligible is a share of reached tasks. Eligibility is checked by the program before calling Jev. One Jev check per eligible task is assumed. If eligibility itself needs a model check, include those calls by raising the eligible share. Include required review and random audit work in what remains.
06Choose calibration examplesOn
Count avoided selection effort; keep the random audit and labeling work.
Work reached is a share of tasks still left; eligible is a share of reached tasks. Eligibility is checked by the program before calling Jev. One Jev check per eligible task is assumed. If eligibility itself needs a model check, include those calls by raising the eligible share. Include required review and random audit work in what remains.
03 / Model prices and Jev overhead
Prices are USD per million tokens. Model rates are illustrative. TypeSafe’s posted Jev 1.13.0 rates, checked September 18, 2026: input $0.042; output free. Both are editable. No invoice has been audited.
Runtime includes gathering context, the request, validation and handling its result. Spread any fixed hook overhead across checks. Extra validation tokens use the baseline model prices, not Jev prices. These averages are assumptions, not latency measurements. This simple scenario does not model mixed task sizes, caching, infrastructure or human costs.
04 / See the math and break-even
For each mode, multiply coverage × eligible share × accepted outcome × work avoided. Apply that fraction to the work remaining after earlier modes, in the order above. Each benefit is an assumed share of remaining work. This caps the total but does not establish the real overlap between correlated tasks; measure task-level attribution.
Checks = original tasks × coverage × eligible share. Every check incurs overhead, including unsuccessful advice and checks on work another mode could avoid. Keeping all those checks is conservative about overhead, not a guarantee of conservative real-world savings. Standalone contributions use the original workload and must not be added together.
| Mode | Standalone | In total | Checks |
|---|---|---|---|
| Rescue a failed worker | 25 | 25 | 100 |
| Reuse accepted work | 40 | 39 | 100 |
| Check review readiness | 20 | 18.72 | 200 |
| Inspect meaning changes | 10 | 9.17 | 200 |
| Find wasted token spend | 10 | 9.08 | 100 |
| Choose calibration examples | 5 | 4.5 | 100 |
| Combined | Do not sum | 105.47 | 800 |
| Unit | Avoided | Overhead | Net |
|---|---|---|---|
| Tokens | 1,054,690.03 | 1,760,000 | -705,309.97 |
| Model API USD | $3.38 | $0.07 | +$3.31 |
| Aggregate agent-hours | 17.5782 | 0.0556 | +17.5226 |
Token net = avoided work × (task input + output tokens) − Jev and extra validation input and output tokens. API net prices each input and output separately per million tokens. Agent-hour net subtracts check runtime from avoided task time.
- Token break-even
- 176 work equivalents
- API cash break-even
- 2.1 work equivalents
- Agent-time break-even
- 0.333 work equivalents
Break-even is overhead divided by the value of one baseline work equivalent. Avoid more than this amount to come out ahead in that unit. Token, cash and time break-even differ; one can improve while another gets worse.
The calculator models one average task and six opportunities to avoid a fraction of its work. All workload, coverage, eligibility, acceptance, avoided-work and runtime defaults are illustrative. They are not observations from our fleet. Start with your own baseline and lower any assumption you cannot support.
The combined estimate applies each mode’s assumed benefit to the work still remaining, in the displayed order. Its standalone contributions deliberately do not add up to the total. This caps the combined benefit; it does not establish the real overlap between correlated tasks. Every modeled Jev check still incurs token and runtime overhead, even on work another mode could avoid. That treatment is conservative about overhead, not a guarantee of conservative real-world savings. Optional extra validation tokens are priced at the baseline model rates. Actual overlap and savings need task-level attribution.
Net tokens, model API cash and aggregate agent-hours are different quantities. A cheaper classification can add tokens while lowering a pay-per-token estimate. An agent-hour is aggregate effort across workers, not an hour off the project deadline or an hour of payroll saved. A subscription may return usable capacity without reducing the bill.
TypeSafe’s posted price on September 18, 2026 was $0.042 per million input tokens, with output tokens free. The calculator exposes both prices separately so you can change them. Posted prices and scenario arithmetic are not audited invoices. TypeSafe model pricing.
What we know, and what comes next
The next useful evidence is a chain from an eligible event to delivered advice, owner action, accepted work and any later regression. Compare equivalent tasks with and without the advice. Retain dismissed recommendations, random audit coverage, extra review and rework. Measure actual input and output usage, bills and aggregate agent time separately. That is how a promising classification becomes a defensible claim about an improvement.
Our earlier Jev memory-filter trial used frozen synthetic cases and exposed useful candidates being excluded. This six-use integration does not turn that trial into approval for automatic memory filtering. Owner checks and measured outcomes still matter. For the surrounding system, see BORG memory and the conductor workflow.
The practical starting point is one recurring decision with a clear owner, a small input and an outcome you can inspect. Give the adviser a bounded question. Keep the proof outside the adviser.
Contributors
James Brady
Direction · Publish decision
GPT-6 AstraAI
Article drafting · Calculator design and implementation · Verification