Optional capability · SDK main

JevAgent Skill Preloading

Give JevAgent a library of skills, and before each run Jev checks every skill against the request and loads only the ones that fit into your agent's instructions. Skill preloading is on the SDK's main branch and isn't in a tagged SDK release yet.

Offer many skills, load only the ones that fit

A skill is a written guide your agent can follow, such as a review checklist or a release-notes style guide. Loading every skill into every run spends your agent's attention on guidance that doesn't apply, so Jev picks the skills that fit each request.

Before your agent starts, Jev asks one question about each of your candidate skills: would its guidance help with this request? Each skill that passes is added, in full, to your agent's instructions for this run only. The rest stay out.

One request, every skill checked

On SDK main · illustrative

Request

Review PR 182 for breaking API changes

Jev · System 2 · asked once per skill

Would this skill's guidance help with this request?

Jev's answer · tick marks the 50% threshold

  1. code-review
    92%
    Added
  2. api-compatibility
    88%
    Added
  3. release-notes
    12%
    Left out
  4. sql-migrations
    7%
    Left out
  5. brand-handbook
    No answer: too large
    Left out
Only added skills reach your agent

Your agent starts

Its own instructions, plus the full text of each added skill

  • Your instructions
  • code-review
  • api-compatibility

For this run only. Left-out skills never appear, and an unavailable check never stops the run.

Illustrative values, not recorded Jev output. Every skill is judged on its own, and each one at or above the threshold (0.5 by default) is loaded, so a request can load several skills, one, or none. Illustrative request: review PR 182 for breaking API changes. Before the main agent starts, Jev asks one yes-or-no question per configured skill: would this skill's guidance help with this request? code-review 0.92 and api-compatibility 0.88 are at or above skills_threshold (0.5 by default), so each one's full text is appended to this run's system prompt. release-notes 0.12 and sql-migrations 0.07 are below the threshold and are left out. brand-handbook gets no usable answer (here, too large to send; a missing key or a provider error does the same), so it is left out and the run continues without it. Then the main agent starts with its own instructions plus the added skills, for this run only. No real Jev output is shown.

Each skill gets its own yes or no

Jev doesn't rank your skills or pick a single winner. It scores each skill on its own, and every skill that reaches the threshold is loaded, so one request can load several skills, one, or none.

Pick a sample request to see four skills judged. Sharing a topic with the request isn't enough: a skill's guidance has to help with the work the request asks for. A request that asks for no work, such as a thank-you, loads no skills.

Four skills, one request at a time

Illustrative

Request

“Review PR 182 and check it doesn't break the public API.”

Jev · System 2 decision

Asked once per skill: would its guidance help with this request?

A skill loads at 50% or higher, the default threshold.

code-reviewSelected

Reviewing a code change for bugs, missing tests, and risky edits.

92%
api-compatibilitySelected

Checking a change against a public API's contract.

88%
release-notesSkipped

Turning merged changes into short, customer-facing release notes.

12%
sql-migrationsSkipped

Writing and verifying a reversible database schema migration.

7%

Added to this run's instructions

  • code-review
  • api-compatibility

Sample probabilities are made up to show the rule; they are not real Jev output. Jev scores every skill again on every run.

Set up skill preloading

Three steps: write each skill as a named document, add the skills to your JevAgent, then run it and check which skills were picked. Setting up skills never calls Jev; Jev needs a key only when a run starts.

  1. Write each skill as a named document

    Give each skill a unique name, a short description of the work it guides, and its full text. A source, such as the file it came from, is optional and only labels the skill.

    Load skills from files

    Python
    1from pathlib import Path 2 3from vidbyte import SkillDocument 4 5# One Markdown file per skill, for example skills/code-review.md. 6SKILLS = { 7 "code-review": "Reviewing a code change for bugs, missing tests, and risky edits.", 8 "api-compatibility": "Checking a change against a public API's contract.", 9 "release-notes": "Turning merged changes into short, customer-facing release notes.", 10 "sql-migrations": "Writing and verifying a reversible database schema migration.", 11} 12 13skills = tuple( 14 SkillDocument( 15 name=name, 16 description=description, 17 text=Path(f"skills/{name}.md").read_text(encoding="utf-8"), 18 source=f"skills/{name}.md", 19 ) 20 for name, description in SKILLS.items() 21)
  2. Add the skills to your JevAgent

    Pass the skills in your agent settings. Jev runs through Vidbyte's managed option, so set your Vidbyte API key before a run. The threshold sets how sure Jev must be before a skill loads. The default is 0.5, and a skill exactly at the threshold loads.

    Turn on skill preloading

    Python
    1from vidbyte import JevAgent, JevAgentSettings, JevAlignmentSettings, JevRuntimeSettings 2 3# Jev runs through Vidbyte's managed gateway, which reads your 4# Vidbyte API key (vb_live_...) from VIDBYTE_API_KEY. 5 6agent = JevAgent( 7 JevAgentSettings( 8 name="dev-assistant", 9 system_prompt="You help engineers review, ship, and document code changes.", 10 provider="openai", 11 model_name="gpt-4.1-mini", 12 alignment=JevAlignmentSettings(skills=skills), 13 ), 14 JevRuntimeSettings( 15 skills_threshold=0.5, # the default; a skill loads at or above it 16 ), 17)
  3. Run the agent and check which skills loaded

    After each run, the results list every skill in the order you gave them, with its status and Jev's probability. They never include the skill text.

    See which skills were picked

    Python
    1reply = await agent.arun("Review PR 182 and check it doesn't break the public API.") 2 3for skill in agent.response.skills.results: 4 print(f"{skill.name:<18} {skill.status.value:<12} {skill.probability}") 5# code-review selected 0.92 <- illustrative; Jev scores every run 6# api-compatibility selected 0.88 7# release-notes skipped 0.12 8# sql-migrations skipped 0.07 9 10# Jev's token use for this run's skill check, for your own cost tracking. 11usage = agent.response.skills.usage 12if usage: 13 print(usage.input_tokens, usage.output_tokens)

What your agent receives

Selected skills are added after your agent's own instructions, in the order you listed them, under one heading. Skipped and unavailable skills never appear.

Your agent's instructions for this run

Illustrative · two skills selected

System instructions

Built before your agent starts

Your agent's own instructions

You help engineers review, ship, and document code changes.

--- Caller-selected skill guidance for this request ---

Added by Jev, in the order you listed them

  1. 1skills/code-review.mdfull text
  2. 2skills/api-compatibility.mdfull text

Not added

  • release-notes· skipped
  • sql-migrations· skipped

Skipped and unavailable skills never appear in the instructions.

Added text lasts for this run only

The next request starts again from your original instructions, and Jev checks every skill again.

Illustrative layout for a run where two skills were selected. The heading line is the exact text the SDK adds; skill text is shown as placeholder lines. You help engineers review, ship, and document code changes. --- Caller-selected skill guidance for this request --- <full text of skills/code-review.md> --- <full text of skills/api-compatibility.md>

Read each skill's result

Every skill ends a run with one of three results, and only selected skills are loaded.

Selected
What happenedJev answered, and its probability was at or above your threshold.
Loaded into the run?Yes, its full text
Skipped
What happenedJev answered, and its probability was below your threshold.
Loaded into the run?No
Unavailable
What happenedJev gave no usable answer: no key, a provider error, or a skill too large to send.
Loaded into the run?No

Limits to plan around

Skill preloading keeps your agent's instructions focused, but Jev still reads every skill on every run. Keep these limits in mind as your library grows.

  • Every run checks again — Skills are picked per request, and nothing carries over to the next run.

  • Jev reads every skill in full — Each check sends Jev the request plus each skill's name, description, source, and full text, so Jev's input grows with your whole library, not just the skills it picks. Skills are checked in parallel.

  • Keep each skill under about 8,000 characters — A skill too large to send to Jev alongside the request is marked unavailable and never loaded; it is never cut short. The limit is lower when the request itself is long, or when the text uses many symbols or accented letters.

  • Only your main agent gets skills — If a preflight question stops the run, or a specialist takes the request, no skills are checked and specialists never receive your skills. The results are then empty.

  • Picked means relevant, not safe — Jev judges only whether a skill fits the request, not whether it is correct or safe, and a selected skill is added to your instructions as written. Only offer skills you trust. Nothing in a skill is run or fetched, and your agent keeps its own tools and permissions.

  • Names must be unique — Each name identifies one result, so duplicates are rejected when you create the agent. Creating the agent never calls Jev.

Loading skills from other sources comes later

Pulling skills from outside sources, such as GitHub URLs, Anthropic's Skills API, skills.sh, or other catalogs, is separate work and isn't available yet.

For now, load each skill's text yourself, for example from a file in your repository as the setup example does, and pass it in as a named skill.

Next steps