Jev x Codex Practical Guide: Boosting Accuracy with TypeSafe Skill

"What changes when you put Jev's skills into Codex?"

The biggest shift is moving from a design where Codex thinks and decides everything, to one where the processing that creates text or code is separated from the processing that judges its content.

However, installing it does not instantly boost Codex's base capabilities. The TypeSafe Skill teaches Codex how to use Jev's API and design patterns. Integration only works once you implement processes that actually use Jev.

The accuracy improvement discussed here is not about further training the model itself, but about organizing inputs, judgment criteria, task division, and verification methods.

This article reviews official documentation and public code as of September 21, 2026, and organizes installation methods, public experiments, practical applications, and ways to improve accuracy. Application examples are implementation proposals, not verification results obtained by running APIs for this article.

1. First Correction: It's "Text Only," Not "Multimodal Only"

Jev is not an all-purpose AI that understands any image or video and returns text. Current input is text; it accepts sentences or JSON and returns fixed-format judgments like selection, scoring, or probability. It is not a model that directly inputs images, audio, or video, nor is it intended for generating long answers or code.

Therefore, if handling videos, you must create transcripts or scene descriptions using another mechanism and have Jev judge that text. Use cases include questions like "Is this scene suitable for beginners?" or "Does the topic change in this segment?"

Also, "approval on the same day as application" could not be confirmed as an official guarantee. While official announcements mention early access, it is better to avoid scheduling work based on assumed approval times.

Being able to make fast judgments is different from being able to do anything. Grasping this premise clarifies the value of combining it with Codex.

2. Separate Installation into Skills, API Keys, and Verification

First, proceed with registration on the official site. Once available, create an API key in the console. The official quick start recommends using the environment variable TYPESAFE_API_KEY in your execution environment. Do not paste keys directly into conversations; pass them via secure app-side settings.

Next, run the following in your Codex project:

npx skills add typesafe-ai/skills --skill typesafe-ai

Note that the "–skill" in original introductions often uses a long dash. The correct syntax is two half-width hyphens --skill. Select Codex as the installation target. The standard is per-project; add -g for global installation.

Then tell Codex:

use the TypeSafe skill

Please load the TypeSafe Skill in this project.

First check the current official documentation,

and separate processes where using Jev is effective from those sufficient with normal code.

Do not display the API key value.

With Codex CLI or IDE extensions, you can verify with /skills or explicitly specify $typesafe-ai. If it doesn't appear, check the installation path and restart Codex.

Note that Skills and SDKs are different. A Skill is an instruction manual for Codex, while an SDK is a library for calling the API from your programs. For Python, the official example is:

pip install typesafe-sdk

Run this in your existing project's virtual environment.

Once done, use one fictional inquiry to verify connectivity without displaying keys. Separating "installed successfully" from "API actually works" reduces initial setup oversights.

3. The Essence of the Skill is "Not Letting Jev Do Everything"

The published SKILL.md outlines a policy of referencing the latest docs and delegating only necessary judgments to Jev. It is not just about how to call the API, but teaching where to leave tasks to AI and where to keep them in code.

Jev's basic functions are these three:

Combine these for the same input and process results in code. The feature is receiving answers in fixed formats rather than extracting them from free-form text.

For example, in refund handling, let Jev judge "is a refund request readable?", while code checks days since purchase and refund limits. Leave reply generation to Codex, and ensure actual refunds are processed only by authorized handlers.

Meaning judgment goes to Jev, calculations/branching to code, and text/implementation to Codex. This division is fundamental. Official design guides also recommend managing process flow and external actions on the code side.

4. Does Accuracy Really Improve? Check Public Experiments

A reference is TypeSafe's "Skill Selection Assistance" experiment.

Targeting 182 skills, it first narrows candidates, then closely examines the top 3. It retains the option of "using none," presenting candidates to the agent.

Public results from 488 requests show:

However, this used Hermes' skill set, Claude Haiku 4.5, and Jev 1.12. Requests included problems generated from skill descriptions, potentially making judgment easier than real-world use. This is not a result showing Codex's code correctness improved by the same ratio.

Still, it provides evidence for trying the structure of "narrowing candidates before dumping judgment on generative models." We apply this thinking to Codex practice below.

5. Seven Use Cases for TypeSafe Skill

① Don't stop at "classifying inquiries"

"Can't log in. Work has been stopped since yesterday. Please connect me to someone."

Simply classifying this as "Account Related" misses the work stoppage and desire for human support.

Use Choice for department, Noul for human support desire, and Score for impact level separately. Have Codex create a response list for staff based on results. Use it as sorting assistance before starting auto-replies. Multiple independent conditions are shown officially.

② Select relevant parts from internal documents

Instead of passing all search results to Codex, use Jev to check relevance to the question and usability as evidence.

For "this year's training refund conditions," separate last year's terms, this year's terms, and unrelated notices. Code verifies definite info like years; Jev judges content relevance.

Caution: Do not discard documents contradicting the question's premise. Terms stating "no refund system exists" are important evidence. Official retrieval augmentation examples handle contradictions and suspicious instructions separately from relevance.

③ Detect "cited but unsupported" claims in articles

Extract claims from Codex drafts and pass the claim plus source text to Jev.

Find discrepancies like: "Article says sales doubled, but source only says inquiries doubled."

Verify citation existence via string matching; let Jev judge if the citation supports the claim. Official examples show this two-step citation check.

Note: Jev does not auto-search latest info. Retrieval is separate. "Source supports claim" and "source is correct" are different issues.

④ Prevent hallucinated numbers in invoices/applications

Instead of letting AI generate amounts/phones/emails freely, extract candidates via code first. Let Jev select which is the total/contact, then copy the original text via code.

It's "selecting existing candidates," not "creating new characters." Official extraction examples use this. Handling missing candidates and "not applicable" is crucial.

For image invoices, OCR is needed beforehand. Selection logic cannot fix misread numbers.

⑤ Review Codex text by specific viewpoints

Don't ask "Is this good?" Evaluate separately: "Does it answer reader pain points?", "Are jargon explained?", "Are assertions backed?"

Have Codex fix only problematic viewpoints. Avoid rewriting accurate paragraphs just to improve readability.

Weighted scoring exists officially. But do not hide critical issues with averages. If key numbers lack backing, block publication even if readable. Separate preference from mandatory conditions.

⑥ Narrow down skills Codex uses

Create a helper to match requests against skill conditions, narrowing candidates to a few.

Note: Installing TypeSafe Skill does not automatically replace Codex's standard skill selection. You need scripts to provide candidate lists for Codex to reference.

Before complex systems, reduce unnecessary skills and clarify usage conditions. OpenAI notes too many skill descriptions cause omission/conflict.

⑦ Use expensive models only for hard cases

Extract info with small models, check mismatches with Jev. Route only suspicious items to top models/humans.

E.g., don't redo all 100 extracted items; re-check only those unverifiable against source. Official examples show item-wise evaluation switching.

But if the checker misses errors, they remain. Measure net benefit including miss rates and human review time, not just API costs.

6. Six Designs to Improve Jev Accuracy

① Make questions small and targets concrete

"Is there a problem?" is vague (price? emotion? violation?).

Split into "Refund requested?" "Feature unavailable?" But don't break context. Keep surrounding text if distinguishing complaint vs. refund request. Official guidelines balance narrow judgment with necessary context.

② Don't rely solely on Question IDs for meaning

Overlooked spec: Question IDs are not sent to the model.

Naming ID refund_requested isn't enough if the question is just "Applicable?" Write criteria like "Customer seeks money return. Dissatisfaction alone is not applicable." Clarify boundaries in Choice.

③ Structure State to show relationships

Separate customer_message, order, policy instead of pasting logs. Don't mix customer desires and company policies in one text.

Specify targets like "judge customer_message" to clarify what to read/decide. Official docs suggest named JSON for multiple info relations.

④ Don't settle for Score "1-5"

Define states: "Work continues," "Alternative exists but cumbersome," "Main work stopped, no alternative."

Score stages are evaluated independently; "more severe than previous" is unsuitable. Check probability distributions if needed, as same average implies different splits.

⑤ Don't confuse Probability and Confidence

Noul's 0.8 is estimated probability of condition, not severity score. No separate confidence for Noul.

Choice/Score confidence indicates distribution concentration. 0.9 doesn't mean 90% accuracy.

Set automation thresholds on your data. High-loss actions require hold/human check.

⑥ Don't assume Japanese equals English accuracy

Official docs state English is primary/best. Japanese is supported but less accurate.

Compare: "Q&A both JP," "Q EN / Doc JP," "JP original + EN translation."

Check if polite "I'd appreciate a refund" is caught as request, and "No refund needed" isn't misjudged. Translation adds errors; compare on same validation data.

7. Codex Side: Create "Verifiable States" Rather Than More Instructions

First, don't let it write APIs from old memory. TypeSafe Skill requires checking latest docs before implementation. If inaccessible, state constraints; don't invent unverified fields.

Second, put recurring project info (tests, env, forbidden zones) in AGENTS.md. Codex reads this during work.

But adding "read all docs every time" or "triple check everything" backfires. OpenAI guides suggest organizing unnecessary instructions and clarifying completion conditions.

Treat Jev scoring and actual tests separately. "Seems compliant" isn't proof of execution. Verify connection, exceptions, storage, permissions individually.

Jev can be affected by malicious inputs (official warning). Protect API keys and permissions; don't rely solely on model judgment.

Set loop termination conditions: "Pass tests for changed parts," "No regression in pre-defined eval," "Stop after max 3 tries." Compare against previous good versions rather than infinite rewriting.

8. Compare Accuracy, Speed, Cost Under Same Conditions

Split eval data into tuning and final confirmation sets. Include ambiguous, insufficient, negated, multi-request, and adversarial inputs. Compare before/after against human-verified ground truth under same conditions.

Measure two improvements separately: 1) Jev-integrated process error/miss rates vs. traditional. 2) Codex implementation success/fix counts with/without skill.

View automated case accuracy AND automation rate together. Routing all hard cases to humans inflates automated-only accuracy.

Current model: jev-1.13.0. $0.042 per 1M input tokens, output free. 100M tokens = $4.20 for Jev part (other costs separate). Fix specific model IDs in comparisons for traceability.

Independent questions can be parallelized in one request, but they don't see each other's answers. Chaining requires next calls. Parallelism increases input cost.

Official 70-500ms latency is US West Coast based. In Japan, measure end-to-end time including retrieval.

9. Practical Prompt for Codex

Start with local prototype for "inquiry sorting" with no external impact. Swap purpose for doc classification/draft checking.

1$typesafe-ai
2use the TypeSafe skill
3
4Purpose:
5Create a local prototype to classify Japanese inquiries, organizing responsible field, human support desire, and business impact.
6No external replies, sending, or production data changes.
7
8Respect existing project language, structure, dependencies.
9Check latest TypeSafe docs and installed SDK types;
10do not guess unverified APIs or return fields.
11
12Judge responsible field, human support desire, and impact separately.
13Do not force insufficient/not-applicable inputs into existing categories;
14provide a hold path for human review.
15Perform calculations, date comparisons, permission checks in normal code.
16
17Summarize questions, criteria, thresholds, model IDs in a reviewable place.
18Track input-judgment correspondence.
19Do not log API keys or unnecessary PII.
20
21Run local tests with fake data first.
22Include normal, indirect, negated, multi-request, insufficient, and adversarial ("ignore instructions") examples.
23Mark auto-generated expected answers as provisional.
24
25Separate tuning and final eval data.
26Enable comparison of traditional vs. Jev methods under same conditions.
27Record misclassification, misses, hold rate, automation rate, time, token usage.
28Do not alter ground truth labels to pass eval.
29
30Test real API only if TYPESAFE_API_KEY is set and send/cost limits confirmed.
31Cap call count and budget.
32
33Completion criteria: Working code, steps, eval method, verified results, unresolved failures.
34Do not mark unexecuted tests as success.
35If key/network unavailable, mark as unverified.

Crucially, don't just ask "improve accuracy." Define what is correct, what stays manual, and which results signal improvement.

Jev's value lies in embedding cheap, fast judgments where needed. Build with Codex, verify narrow conditions with Jev, restrict processing with code, and confirm behavior with tests.

The goal is not "letting a powerful AI do everything at once," but building a system where mistakes don't easily propagate to the next step.