Jev: A Decade of Agentic Engineering

By shifting to JSON-based configurations, Jev functions as a programmable engine that provides a faster, cheaper alternative to specific agent calls.

The model aims to replace specific agent calls with a faster, cheaper alternative for decision-making and classification tasks.

At Level 1, Jev functions as a smart, cheap, and fast boolean classifier for basic decision-making, such as detecting prompt injection in API requests.

An example demonstrated Jev classifying a malicious prompt as an injection with 99% confidence, while another prompt was identified as an injection with 64% confidence, providing developers with specific confidence intervals to inform their actions.

Level 2 of Jev handles selecting from a predefined list of options, moving beyond simple binary choices, which is particularly useful for tasks like support ticket triage to identify issue type and priority.

Jev offers significant cost savings compared to other models: it is 4 times cheaper than Deepseek Flash, 44 times cheaper than Gemini 3.8 Flash, and an astonishing 600 times cheaper than Fable 5.1.

This economic efficiency means a task that would cost $11,000 with Fable 5.1 could be done for approximately $20 with Jev, enabling high-volume production use previously deemed unaffordable.

Jev allows developers to define context and criteria directly within JSON sub-key value pairs, such as explicitly stating what constitutes a "high priority" issue.

For instance, a high priority could be defined as situations where an author is blocked, losing money or customers, or is very angry, with the system adjusting its confidence and output based on these specific, user-defined boundary conditions.

At Level 3, Jev enables composite scoring, allowing items to be graded on a concretely defined scale.

This feature is useful for evaluating engineering tickets based on multiple critical factors, such as risk, pattern adherence, and commit quality, with adjustable weights that can be managed in code without modifying prompts.

Level 4, confidence gating, prevents erroneous agent actions that are more costly than human intervention, acting as a classifier to determine if a bash command is reversible or destructive.

For example, a 'git push-force' command is flagged as highly irreversible with destructive intent, whereas 'ls -la' is marked as safe with high confidence.

Jev effectively handles unknown dangerous commands, addressing the 'damage control' problem where developers cannot predict all harmful inputs.

The model's high scalability further ensures operational costs remain extremely low compared to alternatives like Opus or Claude 3.5 Sonnet.

Jev functions as a lightweight decision-maker, making cheap decisions before invoking more expensive agentic resources.

It enables developers to route tasks to specific agents, such as a browser agent or a fast agent, based on their capabilities.

These decisions are encoded in simple JSON, ensuring easy integration into existing backend pipelines and providing high value at a very low cost, even at scale.

It identifies destructive or irreversible intent, such as 'rm -rf node_modules' or 'force push,' in real-time.

By functioning as a pre-hook, Jev blocks unauthorized or risky commands before they are executed, mitigating the risk of agents performing unintended actions.

This approach directly addresses common security concerns in autonomous systems by providing a proactive defense mechanism.

By monitoring agent memory and state, Jev triggers compaction processes and issues recommendations to the agent harness to maintain system performance.

This integration enables agents to stay performant without constant, manual oversight, thereby optimizing their operational efficiency.

This approach demonstrates Jev's utility as a model-within-a-model for tasks like switching context, where it monitors the state to decide whether to trigger context compaction.

The speaker rejects the idea of a singular 'god model' in favor of specialized, cost-effective models, asserting that performance is achieved by having models take care of other models, such as summarizing or checking for compaction.

Jev thus provides an efficient mechanism for agents to perform self-compaction, enhancing overall performance in a distributed, multi-model environment.

Level 8 focuses on performance, speed, and cost efficiency by allowing agents to evaluate file content for credentials or relevance without requiring the full file to be read.

Jev operates through a tool-based approach, such as 'Ask Jev filebool', serving as an addition to existing AI tooling rather than a replacement for primary models like Astra.

This method significantly reduces token costs by offloading QA and classification tasks to Jev, thereby optimizing the utilization of expensive language models.

The system further demonstrates high-level agentic planning through the classification of code structures, ensuring that expensive language models are only used when absolutely necessary for deeper analysis.

Level 9 introduces the capability to handle files at scale, enabling uniform questions to be asked across many files in parallel without consuming context window space.

The speaker predicts that every agent will soon include an 'AskJev' tool call, significantly saving time and tokens by allowing agents to query file information without reading the entire contents.

Jev functions as a system-one model, demonstrated by its ability to efficiently identify authorization layers and specific code patterns across files through the 'AskJev' tool.

Gemini 3.8 Flash serves as the primary agent, orchestrating these Jev tool calls in parallel to achieve high efficiency.

The speaker demonstrated Jev processing 10 TypeScript files simultaneously to detect bugs, to-dos, and shortcuts, highlighting its incredibly fast performance.

This process is described as hyper-cheap and extremely fast compared to full-scale language models, serving as a preliminary filter before deploying more expensive, powerful models for deeper analysis. The host also credited Gemini 3.8 Flash for its role in quickly running the analysis and compiling results.

Jev's recursive search capability allows the system to examine an entire repository to find files relevant to specific bugs, providing them with high confidence scores for targeted debugging.

The speaker emphasizes that complex tasks necessitate a 'species' of models, ranging from deterministic code to lightweight classifiers like Jev, thereby rewiring the approach to building with agents.

At Level 10, 'Agentic Jev' is introduced, where the agent autonomously determines when and how to utilize Jev.

This shifts control from manual prompt design to an agent that independently decides its tool-use strategy.

The core focus remains on employing the right tool for the right job to drive measurable business results efficiently.

Distinguishing Jev from LLMs helps to avoid marketing hype and focuses on its unique technical utility, emphasizing that effective engineering involves using the right combination of specialized tools.

Engineers are encouraged to move towards 'outloop' agentic engineering systems and to study codebase examples to master token-efficient development, particularly for building and understanding these evolving model species.