Jev agentic harness

What is an agent harness?

An agent harness is the code around a model: it holds the task, offers the tools, enforces the permissions and collects the results. The model writes; the harness decides what it is allowed to see, what it is allowed to run, and what happens to the output. Take the harness away and a coding agent is a text box.

An agentic harness is the same thing running a loop rather than a single turn: propose, act, check, repeat, until the work is done or the budget is spent. Every pass around that loop contains bounded questions — which model, which tool, did that pass, stop or keep going — and those questions are where a decision model fits. The harness is not the agent and it is not the model. It is the part you write, and it is the only part you can enforce a rule in.

Where Jev sits in an agent harness: the three-part split

A coding agent is usually described as one call: prompt in, patch out. Real work is a chain of forks — which model, inspect or edit, which tools, did that pass. The harness gives each fork a place to land, and the only question that decides where Jev belongs is a plain one: can the application still check the choice?

The narrow interface is the point, not a limitation to grow out of. Let a model return any instruction it likes and every caller has to work out what it means. Let it pick an id from a list the host already built, and the caller reads a value, checks it, and moves on. TypeSafe publishes its own version of this harness at TypeSafeAI/jev-harness, summarised in the repository as “an LLM proposes, Jev answers, code decides, every step leaves a receipt.”

The Jev harness builds, grouped by what they decide

The decision layer itself

A harness where the model proposes, Jev answers narrow questions and code decides, with a receipt for every step. TypeSafe's own repository sets the shape; JevHarness tunes the harness rather than the model.

GitHub·Agents and browsers

Pick

jev-harness

An LLM proposes, Jev answers, code decides, every step leaves a receipt.

TATypeSafe AI

126Stars

GitHub·Agents and browsers

JevHarness

LLM-written Jev harnesses, with reward reflection over the full trajectory.

TTianyuCodings

Spikez 99.9%

@0xSpikez

Jev Founder, Diogo Amogo, just released 12-page PDF on building a Jev Harness for coding agents this is a 10-step blueprint on how to make your coding agents 200× faster and 400× cheaper: step 1 → meet Jev: the LLM writes, the harness executes, Jev decides what each turn sees, where it routes and whether it runs step 2 → ask the question that breaks every agent: how would you design one if LLMs had no KV cache? step 3 → stop routing blind: Opus → Sonnet → Opus costs 6.19 vs 4.15 for pure Opus, because handing back reprocesses the whole context step 4 → follow the tokens: reading and searching take 56.2% of tool turns and 46.5% of tokens. Writing code is under 10% step 5 → score every chunk per query: hide, short summary, long summary or full. Compress after the question, not before step 6 → disclose tools in tiers: one-line snippets for 100s of tools, schema on demand, docs for one-off queries. Batteries stop costing context step 7 → load instructions by condition: touching *.tsx loads the style guide, billing/ loads its gotchas file, and compaction can't erase either step 8 → route by trust, not just difficulty: secrets and infra stay on first-party frontier models, public docs go to the cheapest one step 9 → share one retrieval pass: cross-model review, eval generation, ELI5 explainers and live progress pages all run read-only in the background step 10 → gate every command: programmable allow / ask / deny policies that read a script before it runs, not just its name Send this PDF and the article below to your Claude Code or Codex instance and start shipping 200× faster.

X·Documents and OCR

A 12-page PDF on building a Jev harness

Choosing the model, the tool or the skill for each turn

One batched call picks the tier, the tools, the skill and the effort budget before anything is spent. The router runs behind a latency deadline, so an answer that arrives late is treated as no answer.

GitHub·Routing and model choice

jev-harness-router

One batched call picks model tier, tools, skill and effort for each turn.

JMJoaquin Marcoff

1

4Stars

GitHub·Context and memory

jev-harness

Every tool result is filtered by Jev before the model reads it.

AAstroHan

The same pattern, written down

A study group's notes on why the efficiency only shows up once Jev sits inside a harness rather than beside one.

たてこ｜AI好き社会人

@tateko_ai

今日のgakuse.aiの勉強会テーマは「Jev」 Jevの基本的な仕組みとか、海外での活用事例など、Jevでできることの広さを知れてめっちゃ勉強になったな！ 特に印象に残ったのは、ハーネスにJevを組み込むことで、トークンを効率的に使えるという話 早速Jev使って人狼ゲーム作ってみた！

X·Agents and browsers

Jev inside a harness, from a study group

keel: a Jev harness with a decision record per step

The fullest public walk-through is Avid’s Build an agentic harness using Jev, and its value is that it draws the boundary where the code can enforce it rather than where the diagram looks tidy. The build is keel, a local-first Mac coding app in Rust on GPUI, and Jev appears in two places and nowhere else: choosing a route for a fresh unpinned task, and choosing the next focus — inspect, implement, verify, answer — inside an embedded loop.

Five rules from it belong in any harness, whatever the language:

1. Filter the options before Jev sees them. Remove any route the host cannot actually run — provider not installed, model not found, reasoning level unsupported. A selector cannot choose a good option the host forgot to offer.
2. Preserve user intent. A pinned route, a live session and a resumed session bypass the automatic choice. Only fresh, unpinned work is the place for it.
3. Check the answer against current state. Before acting, re-check that the chosen route is still eligible. If the provider list changed, the host rejects the action and uses the fallback.
4. Give uncertainty a path. Define the fallback before you call the selector, and record when it fires, so a fallback is never counted as a selector win.
5. Keep choosing and doing apart. Selection does not grant permission. A tool that needs approval still follows the normal permission path, whatever confidence Jev returned.

What a Jev harness has not proved yet

Most of what circulated in the first week is an architecture sketch with no number attached. Three gaps are worth naming before you copy any of it.

The extra call has to earn its place. If choosing a worker takes longer than the task, you have built an elaborate waiting room. The figure that matters is total task cost — selector time, worker time, retries, review — and no harness here has published it as a benchmark. The computer-use builds come closest, because they publish a stopwatch: a flight search in about seven seconds, a desktop step at about $0.0002, and 49 of 49 WebMCP tasks with Jev picking the tool.

The boundary is drawn by the code you control, not the diagram. keel hosts several providers over the Agent Client Protocol, and those providers keep their own inner loops. Jev does not take over their next tool call, and a listed slash command is not automatically a callable action — in the current path it can become plain prompt text.

“Self-improving” means a replay, not a rewrite. A decision receipt lets you reconstruct the case: the options offered, the chosen id, the host’s check, the fallback. Replay it against a changed prompt or policy, compare valid selection, abstention, fallback and latency, and let a person approve which version becomes the baseline. A passed task on its own credits nothing — the worker might have solved it on the original route.

How to build an agent harness with Jev, at the smallest size that works

Start with one decision the host can check, write down the four things that make it a decision rather than a hope, then build the smallest path that runs them.

1. One decision the harness is allowed to make.
2. The exact options it can see, prepared and filtered by code.
3. What happens when it abstains.
4. How you will know whether the outcome helped.

For the concept behind the split, read what Jev Engineering is; for the concrete agent those decisions fit into, Jev with Claude Code and Jev in a multi-agent system. The first call itself is on how to use Jev.

The harness write-ups, in reading order

Start with Avid’s builder’s guide for the full pattern, then LangChain’s for the framework version, then the working notes from people who wired one up and said what broke.

Avid

@Av1dlive

everything you need to start building with jev, in one article. code, architecture, diagrams... everything you need to follow the build and make it your own. x.com/i/article/2102…

Guide·x.com

Build an agentic harness using Jev

Avid’s builder’s guide, and the fullest public write-up of the pattern: where the decision layer sits in a coding harness, the five rules that keep it enforceable, and keel, the Rust app it was built in. Honest about the self-improvement part it has not proved.

Guide·langchain.com

Building a harness with Jev

Routing between models, and blocking risky tool calls with a Jev decision.

Guide·youtube.com/@LangChain

How to build a harness with Jev

A LangChain and TypeSafe conversation on building a harness around Jev.

Guide·youtube.com/@LangChain

Building a harness with Jev

LangChain walks through putting Jev inside an agent harness.

st1ne

@SolSt1ne

Jev Founder, Diogo Almeida, just released an independent working note on building a Jev harness for coding agents Not affiliated with the Jev team, just a builder mapping the loop Section 1 - the split: why harnesses already make these calls, just badly, with regex parsing prose replies Section 2 - five calls to move: files, model, safety, done, context, each one a typed Score, Choice or Noul instead of free text Section 3 - what it saves: ~400x cheaper per decision vs a cached frontier model, 0.2s median per call vs seconds of LLM latency $605 per 1,000 decisions on cold frontier calls down to $0.17 on Jev Bookmark it and read it tonight Then go rebuild your own agent loop

Guide·x.com

A working note on building a Jev harness

An independent working note on building a Jev harness for coding agents.

Guide·academy.dair.ai

Jev decisions in a Pi SDK harness

DAIR Academy on building a custom harness with Jev and Pi.

Common questions

What is an agentic harness?

The code around a model: it holds the task, the tools, the permissions and the results, and it decides what the model is allowed to see and do. A harness with Jev in it asks Jev the narrow questions — which model, which tool, done or not — and keeps the exact rules in code.

Where does Jev sit in the harness?

Between the decision and the action, never owning either. The host prepares a finite list of options, Jev returns one or abstains with a confidence, and the same code that offered the options checks the answer against the current state before acting on it.

Can Jev control the whole agent?

No, and the builds here say so. A provider that runs its own tool loop keeps that loop; Jev only decides where the host can enforce the result. Drawing an arrow on the architecture diagram does not create an API.

Does this make an agent self-improving?

Not by itself. A decision record lets you replay a choice against a changed prompt or policy and compare the two, but keel records decisions rather than training on them, and every improvement loop in the article still ends with a person approving the new baseline.

What does a decision cost?

Jev is $0.042 per million input tokens and output is free. In a harness the useful figure is the whole job, not the call: decision time, worker time, retries and review. The three computer-use builds here land between $0.0002 and roughly $0.004 a run.