Give your agent a System One capability.
Use Jev during everyday agent work, and find what it can improve in your product.

Get started · Community examples · Question design · Read the skill

An agent can have access to Jev and still read every document, load every tool result, and repeat every judgment itself. Jevify teaches it to recognize work that a fast, inexpensive decision model can handle, then gives it the tools to act.

TypeSafe Jev returns typed judgments and probabilities. It can select useful passages, rank candidates, check many items, or choose a handler. Jevify helps the agent send those decisions to Jev, bring selected source evidence into context, and continue reasoning toward your answer.

The agent's own reading and reasoning cost tokens too. Jevify makes Jev the default for bulk semantic judgments, assuming it is faster and cheaper than spending reasoning-model tokens on those judgments. The agent delegates the first pass, reads selected evidence, and finishes the task. It does not stop to build a cost comparison before using the tool.

There are two entry points:

• Ordinary tasks: a large document, noisy tool output, or repeated semantic checks can trigger Jevify even when you never mention Jev. The agent uses it where the task, available runtime, and external-inference permissions allow.
• "Jevify this": ask it to inspect a product or workflow and identify concrete improvements, including capabilities that frequent, inexpensive judgments could enable.

The skill teaches Choice, Noul, and Score, shared-state batching, question design, source preservation, and evaluation. Its Python helpers need no npm or third-party packages. Existing TypeSafe tools and official SDKs work too.

Jevify is an independent skill from the ThursdAI community. It includes optional helper scripts; it is not the Jev model or an official TypeSafe product. Skill activation depends on the host agent, and installation does not intercept tool outputs automatically.

Install with the open agent skills CLI:

npx skills add altryne/jevify --skill jevify

The CLI asks which agents to install for (Claude Code, Codex, Cursor, and others) and whether to install for this project or globally. Common variations:

# Skip the prompts: install globally for Claude Code
npx skills add altryne/jevify --skill jevify -g -a claude-code -y

# See what the repository offers before installing
npx skills add altryne/jevify --list

# Later: check what is installed, pull the latest version, or uninstall
npx skills list
npx skills update
npx skills remove jevify

npx comes with Node.js. Start a new agent session after installing so the skill is picked up. TypeSafe's own skill (npx skills add typesafe-ai/skills) also covers building, question design, composition, and verification. Jevify adds agent execution habits, runnable helpers, and proactive product opportunities; it does not require the other skill.

No CLI? Give an agent this repository and ask it to read SKILL.md and its linked references.

For an ordinary task, ask normally:

This report is long. Find the passages that explain migration failures,
rollback prerequisites, and exceptions, then answer with source references.

With the skill loaded and TypeSafe use authorized, the agent can scan before reading the full report into its reasoning context. It still checks original evidence before answering. For a product review, ask:

Jevify this codebase. Find repeated LLM judgments or fragile semantic
heuristics that could benefit from Jev. Recommend the best opportunities,
write the actual questions, and explain how the result improves the experience.

No repository? Start with an idea:

Use Jevify to design a memory selector for my assistant. Several memories
can be useful at once. Show the state, primitives, exact questions,
batching strategy, fallback behavior, and evaluation cases.

Or improve an existing design:

Use Jevify to review these questions. Are the primitives right?
Rewrite ambiguous criteria, identify missing context, and show
which questions can run together.

Requirements: an agent that can read skill files and browse public docs. Live execution also needs a TypeSafe tool, SDK, or Python 3.10+ with outbound HTTPS for the bundled helpers. last30days is recommended for community research; the skill discloses when it falls back to public search. Installing the skill does not make API calls or grant permission to send data. Existing task or session authorization can cover repeated Jev calls without a separate request for each one.

A ready-to-run scan is available without package installation. Resolve JEVIFY_DIR to your installed skill directory, then run from your task directory:

python3 "$JEVIFY_DIR/scripts/scan.py" report.txt \
  --query "Migration failures and rollback requirements" --dry-run

python3 "$JEVIFY_DIR/scripts/scan.py" report.txt \
  --query "Migration failures and rollback requirements" \
  --output report-scan.json --top 8

The dry run needs no key or network. The live scan returns a compact reading shortlist and saves all judgments with source offsets. It supports plain UTF-8 text and JSONL records with a text field. It includes low-ranked and uncertain samples to check for missed evidence. For conversation archives, the corpus review workflow preserves roles, recurring concerns, and evidence through synthesis. The scan is a first pass, not an exhaustive review. See agent workflows for reopening selected passages and handling large tool outputs.

API key (only for live runs). Create a key in the TypeSafe console and make it available as TYPESAFE_API_KEY, either exported in the shell that launches your agent or in a git-ignored .env in the project:

export TYPESAFE_API_KEY=...          # or: echo 'TYPESAFE_API_KEY=...' >> .env

Without a key the agent can keep working locally, design questions, and dry-run request sizing. It explains setup once instead of searching unrelated files for credentials.

A few discoveries from September 14–17, 2026. These are examples of people using Jev, not claims that they used this skill. Results below are reported by the authors and were not reproduced here.

Speed is only half the story. Every's small writing comparison found a missed defect; Aera's wider candidate pools could cost more. Different task sizes and reasoning settings change the comparison. The full research notes preserve methods, numbers, caveats, and sources.

The skill refreshes community research for new discovery work, so this snapshot is a starting point rather than a frozen list of possibilities.

A good question defines the decision boundary. “Is this good?” tells the model very little. “Does this passage supply a step or prerequisite needed to answer the query?” gives it a job.

One request, shared context, independent judgments. Both passages may be useful, so this uses two Nouls rather than a single Choice.

{
  "model": "jev-1.13.0",
  "state": {
    "query": "How do I rotate an API key without downtime?",
    "passages": {
      "a": "Create a second key, migrate clients, then revoke the old key.",
      "b": "The service supports two active keys per project."
    }
  },
  "questions": {
    "keep_a": {
      "type": "noul",
      "instructions": "Does `passages.a` help answer `query` with a step, prerequisite, or constraint?"
    },
    "keep_b": {
      "type": "noul",
      "instructions": "Does `passages.b` help answer `query` with a step, prerequisite, or constraint?"
    }
  }
}

This is an illustrative native TypeSafe request body, not a recorded model result. Code applies a threshold validated on your data, keeps qualifying passages, and enforces the context budget. Question IDs are for your code; the target must also appear in the instructions, as a backticked state path. Check the current model and API contract before running.

Explore three complete request examples, nine boundary cases, a complete worked question pack, and the question-design guide.

Have an API key? Check the shapes for free, then run the examples:

python scripts/run_cases.py --dry-run
TYPESAFE_API_KEY=... python scripts/run_cases.py

A live run bills your TypeSafe account and sends the request state to TypeSafe.

flowchart LR
    T[Your task] --> D{What is needed?}
    D --> S[Repeated semantic judgments]
    D --> C[Exact search or computation]
    S --> J[Jev batches over local data]
    J --> E[Selected source evidence]
    E --> A[Agent reasons and completes the task]
    C --> A

For product work, Jevify also identifies improvements, designs questions, and tests the resulting behavior against the current approach. Current TypeSafe docs guide the implementation. Community experiments help with open-ended discovery. Exact calculations and hard rules stay in code; generation and deeper reasoning stay with the appropriate model.

Built by Alex Volkov, from the conversations and experiments around ThursdAI: the weekly AI show, podcast, and newsletter.

Visit ThursdAI →

Tried something useful with Jev? Open an issue or a PR with the original source, date, question shape, workload, result, and what failed. Reproducible experiments and better question designs are especially welcome. Use synthetic or public examples.

Maintaining the skill. Keep it portable: no install paths, private project paths, tickets, credentials, transcripts, or one project's rules inside the skill folder. Add new research as a dated snapshot at the top of community-discoveries.md and keep each snapshot small. When the TypeSafe docs change, update the verified date and facts in product-evidence.md, including the price and limits in scripts/run_cases.py. Run the prompts in evals/evals.json before and after a change; Compare the same agent without Jevify, with TypeSafe's official skill, and with Jevify. Test ordinary tasks that never name Jev, as well as explicit product reviews. Skill discovery and execution after loading are separate outcomes.

Thanks to TypeSafe for the model and documentation, last30days for community research, and the builders sharing their experiments.

MIT licensed. Third-party findings remain attributed to their authors.