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 · illustrativeRequest
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
Your skills
Jev's answer · tick marks the 50% threshold
Result
code-review92%Addedapi-compatibility88%Addedrelease-notes12%Left outsql-migrations7%Left outbrand-handbookNo answer: too largeLeft out
Your agent starts
Its own instructions, plus the full text of each added skill
- Your instructions
code-reviewapi-compatibility
For this run only. Left-out skills never appear, and an unavailable check never stops the run.
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
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-reviewSelectedReviewing a code change for bugs, missing tests, and risky edits.
api-compatibilitySelectedChecking a change against a public API's contract.
release-notesSkippedTurning merged changes into short, customer-facing release notes.
sql-migrationsSkippedWriting and verifying a reversible database schema migration.
Added to this run's instructions
code-reviewapi-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.
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
Python1from 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)Plain text works too, but each piece gets a numbered name and the same generic description, so Jev judges it from its text alone and the results are harder to read.
Pass plain text
Python1from pathlib import Path 2 3# Each string becomes a skill named inline_skill_1, inline_skill_2, ... 4# with the same generic description, so Jev judges it from its text alone. 5skills = ( 6 "When reviewing a change, read every edited function and its tests first.", 7 Path("skills/release-notes.md").read_text(encoding="utf-8"), 8)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
Python1from 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)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
Python1reply = 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 selectedSystem 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
skills/code-review.mdfull text - 2
skills/api-compatibility.mdfull text
Not added
release-notes· skippedsql-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.
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
| Result | What happened | Loaded into the run? |
|---|---|---|
| Selected | Jev answered, and its probability was at or above your threshold. | Yes, its full text |
| Skipped | Jev answered, and its probability was below your threshold. | No |
| Unavailable | Jev gave no usable answer: no key, a provider error, or a skill too large to send. | 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.