How to use System One models like Jev to cut down agentic AI costs

The most expensive agent runs are the ones that should never have started

Imagine a broker uploading a loan application at 4:45 on a Friday afternoon. The file looks substantial. It contains bank statements, a payslip, a partially completed application form, and several pages of supporting material in one single PDF. The upload succeeds, so the agentic assessment pipeline gets to work.

One agent extracts employment details. Another interprets income. Others categorise transactions, check identity information, apply lending rules, resolve inconsistencies, and produce a polished report. Each step adds model calls, context, tool use, and sometimes retries. By the time the report reaches a credit reviewer, the pipeline has done exactly what it was designed to do.

Then the reviewer notices the obvious problem: the applicant supplied only one payslip, and no identity document. The application cannot be assessed. It goes back to the broker with a request for more documents. When the missing files arrive, the whole process begins again.

Nothing technically failed. Every service may have returned a successful response. The agents may have reasoned correctly from the material available. The report may even be excellent. Yet the first run produced no usable lending decision because its inputs were never good enough.

This is a common weakness in agentic systems. We spend most of our design effort on what happens inside the pipeline: better prompts, stronger models, more tools, richer memory, and more elaborate orchestration. We spend less time asking whether a request deserves to enter that pipeline at all. This is because the quality check happens to be part of the agentic pipeline, as the technology for reasoning is locked inside the LLM. This handicap makes data quality review inseparable from the data processing pipeline. We end up running the costlier data processing pipeline for data quality reviews as well.

Traditional software usually validates inputs at the boundary. A form checks required fields before submission. An API rejects an invalid payload before starting an expensive job. Agentic workflows need the same discipline, but their inputs are often unstructured. A 25-page PDF does not arrive with a reliable field saying, "two recent payslips and a valid ID are present." Someone, or something, has to read it to understand which pages correspond to identification, which to income and which to proofs, and whether they are in line with company policy.

That is where a fast System One model such as Jev becomes useful. It can act as a semantic gatekeeper between document extraction and the costly reasoning pipeline. Models like Jev can quickly and cheaply review whether the inputs to the agentic pipeline are up to standard and provide the right intervention needed.

Bad inputs waste more than tokens

It is tempting to treat an unnecessary model run as a small infrastructure expense. In isolation, it often is. In the example cost model, processing a typical application kit costs about $1.65 in model usage. Document extraction accounts for roughly $0.24. The downstream agent calls, report generation, retries, and tool loops account for about $1.40 that can be avoided if the application is incomplete.

At one application, the difference barely registers. At portfolio scale, the pattern matters. A mid-sized non-bank lender that we worked with received 70,000 personal loan applications per year. Roughly 35 percent arrive incomplete, meaning 24,500 submissions enter a workflow that cannot yet reach a decision. At an avoidable model cost of $1.40 per run, those premature executions consume about $34,300 annually. The larger cost sits outside the model bill.

A generated report still lands in a review queue. A credit reviewer opens it, understands the findings, identifies the missing or stale evidence, records the issue, and sends the application back. If that takes ten minutes and the loaded reviewer cost is $65 per hour, the wasted reviews cost about $265,400 a year. They also consume roughly 4,083 hours, equivalent to about 2.3 full-time employees using a 1,760-hour working year.

After subtracting an estimated gate cost of about $60 for all 70,000 checks, the corrected mid-case saving is approximately $299,700 per year. Only around 11 percent comes from avoided downstream model usage. Most of the value comes from returning human attention to applications that are actually ready to assess.

The range widens with volume and incompleteness for Tier 1 financial institutions. Premature processing lengthens queues for complete applications. Brokers receive feedback later than they need to. Customers wait while documents make another trip around the system. Operations teams investigate reports that were never actionable. Engineers see more retries, traces, and failure paths. Leaders may respond to growing queues by buying more model capacity or adding reviewers, even though part of the workload should have been rejected at the door.

Poor inputs can also create false confidence. A well-written report looks authoritative, even when it rests on incomplete evidence. The further an inadequate file travels, the easier it becomes for downstream users to assume earlier stages already checked its basic fitness. In regulated workflows, that is not only wasteful. It can make control ownership unclear.

Without proper data quality, every downstream component has to cope with missing information. Prompts become longer. Agents repeat checks. Error handling spreads across the graph. One simple boundary problem turns into a system-wide concern.

Fast and cheap preflight checks and inflight gates optimise costs

The answer is not another large agent at the beginning of the workflow. It is small, focused and grounded gating with a narrow mandate: decide whether the available input is sufficient to begin the costlier next steps.

The example in this project follows a straightforward pattern. First, it extracts text from each uploaded PDF. It then sends that text to Jev's system_one endpoint with sample questions common in all income verification pipelines:

1. Does the material contain identity documents for the loan applicant?

2. Does it contain at least two payslips?

3. How many payslips are present: zero, one, two, or more than two?

4. Are all supplied payslips no more than 90 days old as of today?

   

Jev's three checks return Noul, while the payslip count returns one Choice from a constrained set. Business logic is encoded into the quality check gate using thresholds and boolean checks. That gives the workflow simple, typed outputs instead of asking a general-purpose agent to write an open-ended opinion and parsing stochastic outputs.

The code showcases correct outcomes appropriate to different scenarios we tested Jev on. A combined application kit passes because it contains identity documents and two recent payslips. A file with one payslip is flagged for both missing identity and insufficient payslips. A payslips-only kit passes the minimum payslip check but fails identity. These are exactly the cases that should be resolved before income verification, policy analysis, and report writing begin.

In production, the routing logic can be simple:

• If every required check passes, release the application to the agentic pipeline.

• If a required item is missing, stop and return a specific request to the broker.

• If confidence is low or the evidence is ambiguous, send the file to a small exception queue instead of guessing.

This design works because System One and agentic reasoning (System Two) serve different purposes. The gate is fast pattern recognition over a bounded question. The downstream pipeline is slower, more deliberate work across multiple steps and tools. Using the expensive reasoning system to discover that a basic document is absent is like convening a credit committee to check whether the envelope was sealed.

Jev performs the semantic checks directly against the text extracted from the application kit, either before the agentic pipeline or as the starting step in it. It determines whether identity documents are present, whether there are enough payslips, and whether those payslips are recent. The surrounding application code then applies a simple threshold to those answers and makes the routing decision. If the required checks pass, processing starts by passing the extracted text to the next phase. If they fail, processing stops and the broker receives a request for the missing or outdated material. This allows developers to update their existing pipelines without significant teardowns. It does not require a separate LLM to convert the documents into structured fields before validation. The evidence available from Jev, including its scores and constrained answers, can be added to observability and tracing so that operations teams can review errors, tune thresholds, and monitor false rejections.

Where to begin

Implementation should begin in shadow mode. Run the gate beside the existing pipeline without allowing it to block applications. Compare its decisions with the files reviewers actually return. This establishes the real incomplete rate and exposes false rejections before they affect brokers or customers.

False rejection is the key risk. Holding back a complete application can delay settlement and damage trust. Teams should track precision and recall by failure reason, not just one overall accuracy number. Identity detection may behave differently from payslip recency. Thresholds can then reflect the cost of each error. A borderline identity match might require human review, while a clearly absent second payslip can trigger an automatic request.

The business case should also use local evidence. Four inputs determine most of the value: annual submission volume, the share returned for missing or stale documents, avoidable downstream model cost per run, and reviewer minutes spent on each returned report. Pipeline traces can provide token usage. Origination systems can provide volumes. Queue timestamps or a short time-and-motion study can reveal review effort.

The core calculation is uncomplicated:

net saving = avoided runs x (avoidable model cost + reviewer cost per returned file) - total gate cost

Extraction is deliberately excluded from the avoided model cost because the gate still needs machine-readable text. The eventual valid assessment is excluded too, because it still has to happen after the broker supplies the missing material. The saving is the premature run that no longer occurs. This keeps the estimate honest.

The architecture also makes the broader agent system cleaner. Downstream prompts can assume minimum evidence is present. Agents spend their context on analysis rather than repeatedly defending against empty inputs. Review queues contain more actionable work. Broker feedback becomes immediate and specific: "Please provide one additional payslip" is more useful than a delayed generic rejection.

The key criterion for developers to keep in mind is that System One models like Jev cannot explain their output, unlike System Two models which can be coerced to explain their reasoning through text generation. Jev cannot tell you why its confidence is high. This constraint limits the implementation of these models to use cases conducive to black box models.

Beyond gating

This pattern extends to a broad spectrum of use cases. The same logic applies wherever a quick, bounded decision can prevent slower or more expensive work. Jev can route simple requests to cheaper models and reserve premium reasoning for tasks that need it. It can check whether any available tool genuinely matches a request, and return none of the above when none does to improve Intent Routing. It can triage emails, tickets, leads and CVs before they reach a queue. The cost savings will differ by workload but the principle in approach remains the same.

In the end

The principle is the same in every case: use a small amount of fast intelligence to protect a large amount of deliberate intelligence.

Agentic pipelines are powerful precisely because they can do many things. That power makes indiscriminate execution expensive. A lightweight Jev gate gives the system permission to say, "Not yet," before tools, agents, reviewers, and customers pay the price. The best optimisation is not always a cheaper model call or a shorter prompt. Sometimes it is recognising that the workflow should not run at all.

If you are a data-protected organisation and want to use System One models with PII or in air-gapped environments, read our follow-up post on local System One models next.