I vibe-coded JEVia to put Jev in charge of decisions

I built an agent harness called JEVia. It runs on your computer with your own API keys and a workspace you choose. The code is on GitHub under the MIT license.

I did not write it line by line. I described what I wanted, had AI write the code and tried it on tasks. When something behaved differently from what I intended, I went back to the conversation. That is how I vibe-coded JEVia.

I wanted to change the decisions an Agent makes before and during its work. Does this task need web research? Is the material sufficient? Should this file operation proceed? When a language model answers each question in prose, the program still has to extract the decision it needs.

Jev, a model from TypeSafe, offers a different interface. It receives questions and returns structured results with probabilities. The program can compare those results with thresholds and choose its next step. I built that into JEVia.

When a task arrives, JEVia batches several questions into one Jev call. It evaluates whether web research or a multi-step plan is appropriate, alongside the output format and skill choice. The returned decisions remain individually inspectable.

For example, P(yes) 0.78 for web research exceeds a configured threshold of 0.50, so the program searches. A probability is not a guarantee, and the model does not set the threshold. Together they determine when the program acts.

Language models still generate content and participate in plan compilation and tool calls. Jev handles decisions that can be expressed as structured questions. The program retains the execution rules.

A multi-step task introduces another choice. Extracting facts and weighing trade-offs may need different capabilities. Jev rates each step; local policy selects from your configured models. The economical setting looks for a cheap qualified model. The strongest setting uses a stronger configured model for generation. By default, a step with no qualified model waits for review.

In one development run, I asked JEVia to read workspace material and prioritize three requirements. The record showed 8.6 seconds, eight decisions, two Jev calls and two language-model calls, with a displayed cost of $0.000552.

Eight decisions did not require eight requests. Batching fit them into two Jev calls. I find that more useful to examine than the latency of an isolated decision, since the task also waits for generation and tools.

Another task took five steps and four tool calls, with 88 decisions in total. It read three files and wrote a result. The recorded duration was 54.3 seconds and the displayed cost was $0.0069.

These figures come from my supplied development records. They were not independently rerun for this article and are not a comparative benchmark. JEVia distinguishes provider-reported costs from price-table estimates; many decimal places do not mean every digit comes from a settled bill.

The decision panel is the part I most want people to open. It lets you trace which questions were asked, what values came back and which thresholds the program applied.

For example, an application probability of 0.11 falls below a 0.60 threshold, so the task continues as text. A skill match with 0.85 confidence selects compare-options. The panel keeps these results beside their questions.

Some decisions enter review when confidence falls below the configured requirement. The default abstention threshold is 0.55; unresolved parts can be handed to a language model while accepted decisions are retained.

The numbers can still be wrong. Their value is in leaving a specific point to inspect. If the system searched when it should not have, I can examine that decision and its threshold, change one of them and rerun the same task.

Tasks that need tools enter a loop. A language model requests tools, the program executes them and returns their results, and the model chooses the next step. One model request and its associated tool calls count as a step. The turn ends when no more tools are requested.

JEVia can read and write workspace files or replace an exact passage. It can maintain a todo list and delegate independent work to another model. Its question tool stops and waits for the user. Python execution and background commands require execution permissions to be enabled separately.

In the supplied test record, write_file received an approval probability of 0.70. After Jev approved it, code still checked the path; it could not write outside the workspace. Web access has separate address checks. A model decision cannot override these restrictions.

Users set permissions. A read-only task cannot acquire write access because the model wants it. With approval for every change enabled, side effects wait for your confirmation. Command execution is off by default; enabling it runs commands on your machine, not in an isolated sandbox.

Plan mode shows the plan before execution. You can ask for two parts instead and review the revised plan. The MCP client uses JSON-RPC over stdio. Users configure servers in the workspace; the model cannot add them. Their tool calls also pass through the decision flow.

Skills are Markdown files. You can describe how a research brief should be organized or what to examine when comparing options, then import the file. Both Markdown and ZIP uploads are supported. Installed skills show their names and descriptions and can be selected for a task.

Web tasks filter sources and passages before checking whether the material delivered to the writer is sufficient. An answer in the original results may not survive filtering. This check happens afterward; missing decisions and failed requests remain unknown.

Some tasks suit a form or small dashboard. The component path lets Jev select a structure from predefined components while a language model fills the content. A separate path can generate a complete page. Pages are previewed in a restricted iframe and saved into the workspace.

Run records are append-only. When context grows too long, earlier conversation can be summarized while the original records remain available for export. If an answer loses something, I can inspect the material before compression.

JEVia uses the Python 3.9+ standard library and native ES modules, with no third-party Python packages required. Download the repository, run python3 app.py and open http://127.0.0.1:8765. Configure your own credentials and workspace. The interface supports Chinese and English.

The engineering records supplied with this introduction describe 429 Python tests and 24 frontend tests. MCP tests start server processes to check communication. These checks do not replace real tasks from different users; I still want to learn where it fails.

Keys are stored in local configuration or the browser and sent to the provider you configure when making model calls. Scheduled jobs also write their configuration and credentials into the workspace. Running locally does not mean all processing stays offline.

Please download it from GitHub and try it. If it selects an unsuitable model or stalls, leave reproduction steps and a run record in Issues, with credentials and private material removed. You can also reach me on X to discuss a feature that is still taking shape.

I am Sleepy, editor-in-chief of Beating. JEVia is still changing. Bug reports are welcome, as are suggestions about how you want it to work.