Integrating Jev with Ollama and Local LLMs: A Practical Guide

By this point in the series you know Jev doesn’t generate text and a local model like Ollama doesn’t make bounded, typed decisions – which is exactly why they work so well stacked together. This post is about actually using Jev with Ollama and local LLMs together: wiring Jev into a local-model setup you’ve already got running.

Why Pair a Local Model with Jev at All

If you followed our guide to running Claude Code against a local model via Ollama, you already have a fast, free, private text generator on your own machine. What that setup doesn’t give you is a reliable way to gate what the agent built on top of it is actually allowed to do. Bolting a second local model onto the problem doesn’t help much, since it would just be another text generator prone to the same kind of confident wrong answer. This is where Jev’s job – and only Jev’s job – is to make the small, bounded, high-stakes decisions your local model shouldn’t be trusted with alone.

The Architecture: Local Model Generates, Jev Decides

The division of labour that keeps showing up across real Jev integrations is the same one, regardless of the task:

1. A local model handles generation – writing code, drafting a reply, producing the text or plan a task actually needs.
2. Jev handles the decisions in between – is this step safe, which of these options fits, is this output good enough to ship – anywhere a wrong guess needs to be caught rather than generated more convincingly.

Everything stays on your machine except the handful of typed questions you send to Jev, which is usually a few short lines of state, not your whole codebase or conversation history.

Example: A Local Claude Code Setup With a Jev Safety Gate

Take the Ollama-backed Claude Code setup from our local-LLM guide and add the guardrail hook from our earlier post on guarding coding agents on top of it. Nothing about the hook changes based on where the agent’s plan came from – Jev only ever sees the proposed command, never the model or the prompt that produced it:

# Local generation (your existing setup)
export ANTHROPIC_BASE_URL=https://localhost:11434
export ANTHROPIC_AUTH_TOKEN=ollama
claude --model qwen2.5-coder:14b

# Jev safety gate (runs as a PreToolUse hook on Bash)
export TYPESAFE_API_KEY="ts_live_..."
# hook script sends each proposed command to Jev before it executes

The result: a fully local coding agent for everyday work, with one small hosted call standing between it and anything genuinely destructive.

A Real-World Example: macOS Computer Use

A recent write-up on building a privacy-focused macOS computer-use loop is one of the clearest illustrations of this pattern outside of coding agents. The loop splits into distinct roles, almost none of which touch a hosted general-purpose LLM at all:

• Perception, done locally: the screen is turned into structured elements using OmniParser running as CoreML on-device, plus Apple’s Vision framework for OCR – no pixels ever leave the Mac.
• Decision, done by Jev: given the structured screen state and the task goal, Jev picks the next action and target element – the one part of the loop that has to choose reliably, over and over, without drifting.
• Text generation, done locally: when a field actually needs typed text, Apple’s on-device Foundation Model handles it – a small, focused job, not the whole loop’s reasoning.

Only observed screen text, accessibility labels, the task goal, and recent actions are sent to Jev – never raw pixels, detector boxes, or click coordinates, which stay on the machine. It’s a good template even if you’re not building computer-use automation: keep your local model doing what it’s good at, and hand Jev only the narrow decision it needs to make, with nothing extra riding along.

Keeping Everything Local Except the Decision

If you’re specifically running local models for privacy, it’s worth being deliberate about what actually crosses the wire to Jev. In practice that’s usually a short state string and a handful of typed options – not full file contents, full conversation history, or anything you wouldn’t be comfortable sending to any third-party API. Keep the state minimal and task-specific, the same way you’d design a well-scoped function call.

Wrapping Up the Series

That’s the beginner series end to end: what Jev actually is, making your first typed decision call, using it to guard a coding agent, how it compares to a prompted LLM classifier, and now pairing it with a local model. The common thread through all five: let the model that’s good at generating keep generating, and let Jev make the decisions that can’t afford to be a guess.