OpenJarvis 1.0.3: Local-First AI Assistant Install Guide

The first question most people ask when they hear about OpenJarvis is: can I really run a capable AI assistant entirely on my laptop, or is this yet another wrapper that phones home? Fair question. The short answer: yes, and this guide walks through deploying OpenJarvis 1.0.3 – a local-first AI assistant built at Stanford – end to end.

OpenJarvis is not a chatbot app. It’s a framework. According to the Stanford Scaling Intelligence Lab, it’s released under Apache 2.0 and provides shared primitives for building on-device agents, efficiency-aware evaluations, and a learning loop that improves models using local trace data. The motivation is grounded: their Intelligence Per Watt study (covering 2023-2025) found local models can accurately service 88.7% of single-turn chat and reasoning queries at interactive latencies, with intelligence efficiency improving 5.3× over that period.

System requirements for OpenJarvis

The pip package targets a narrow Python range. The latest release on PyPI is 1.0.3, released Jun 29, 2026, and requires Python <3.14, >=3.10. That upper bound matters – see the errors section.

OpenJarvis needs at least one inference backend running underneath it. Four local engines are supported (Ollama, vLLM, SGLang, llama.cpp) plus five cloud engines (OpenAI, Anthropic, Google Gemini, OpenRouter, MiniMax), all behind a single Engine interface. Ollama is the default and by far the least painful starting point.

The one-line install (macOS and Linux)

Grab it straight from the project’s GitHub Pages domain:

curl -fsSL https://open-jarvis.github.io/OpenJarvis/install.sh | bash

Small detail worth calling out: this script is served from the project’s own GitHub Pages site, so HTTPS always works – you may see https://openjarvis.ai/install.sh referenced in older blog posts, but that domain is community-operated and has had intermittent TLS issues (GitHub issue #337), so the open-jarvis.github.io URL is the canonical one. Use it.

The installer downloads everything for you – uv (the Python package manager), the Python venv, Ollama, and a small starter model. You don’t need to install uv or any other prerequisite first. The whole thing runs about 3 minutes on broadband.

Pro tip: If the curl step exits halfway through – flaky network, killed terminal, whatever – just run it again. Re-running the curl line is safe. The installer reads ~/.openjarvis/.state/install-state.json and skips completed steps. If your venv got nuked, re-running heals it. Very few installers do this well; this one does.

Windows: two options

Native PowerShell (contributor install) or WSL2. From the GitHub README:

# Native PowerShell
irm https://open-jarvis.github.io/OpenJarvis/install.ps1 | iex

# Or WSL2 - same bash one-liner as Linux
curl -fsSL https://open-jarvis.github.io/OpenJarvis/install.sh | bash

Alternatively grab the .exe / .dmg / .deb / .rpm / .AppImage desktop build from the latest GitHub release (desktop-v1.0.2 as of May 25, 2026).

First-time configuration

After install, drop into a new terminal and start chatting:

jarvis # start chat (default: chat-simple)
jarvis init --preset code-assistant # or another preset
jarvis model pull qwen3:8b
jarvis ask -m qwen3:8b "summarize this readme"

To pin a default model, edit ~/.openjarvis/config.toml:

[intelligence]
default_model = "qwen3:8b"

Starter presets bundle an agent with a hardware-appropriate engine, connectors, and tools, installable with jarvis init --preset <name>. Variants cover Apple Silicon, Linux GPU servers, and CPU-only laptops. Pick the one that matches your box – the CPU-only preset chooses smaller quantizations, which matters if you don’t have a GPU.

Verify it works

Three commands. Run them in order:

1. jarvis --version – should print something like jarvis, version 0.1.0 (yes, the CLI version string lags the package version; the pip package itself is 1.0.3).
2. jarvis doctor – reports engine reachability, model availability, and background build status. The Rust extension and larger models continue downloading in the background; jarvis doctor shows status.
3. jarvis ask "What is the capital of France?" – end-to-end sanity check.

If jarvis doctor shows Ollama Reachable but jarvis ask fails – keep reading. That’s a known one.

Common errors and the fixes that actually work

This is where the official quickstart trails off. The real fixes come from GitHub issues.

“OpenAI client not available” even though Ollama is reachable

Reported in issue #520. jarvis ask and jarvis chat fail with an OpenAI client error even though jarvis doctor confirms the ollama engine is reachable and models are ready. Talking to Ollama directly (ollama run qwen3:8b) works fine, so the local model itself is healthy – the failure is in OpenJarvis’s engine routing. The workaround: pass -m ollama/qwen3:8b explicitly to force engine selection, and check that your [intelligence] block in config.toml names an engine, not just a model.

Qwen 3-Coder streams die with “NoneType has no len()”

This one’s a cross-tool bug. From issue #276: on Ollama 0.21.0, the agent silently fails after the first turn – the text response from Qwen 3-Coder lands in response.thinking instead of response.content, triggering a NoneType has no len() crash in openjarvis/engine/ollama.py. Fix: downgrade Ollama below 0.21.0, or switch to a non-thinking Qwen variant.

macOS: “OpenJarvis is damaged and can’t be opened”

Not damage – quarantine. macOS Gatekeeper quarantines apps downloaded from the internet that aren’t notarized by Apple. Run this in Terminal to clear the quarantine flag:

xattr -cr /Applications/OpenJarvis.app

This removes the quarantine extended attribute. It does not modify the app. Documented on the official downloads page.

Python 3.14 maturin build fails

Only matters if you’re doing a source install. On Python 3.14+, set PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 before the maturin command. The main PyPI package caps at <3.14, so if you’re on 3.14, you’re already off the paved road.

“jarvis: command not found” after install

Almost always PATH. ~/.local/bin isn’t on your PATH. Run source ~/.bashrc (or ~/.zshrc) or open a new terminal.

Why re-runnable installers are underrated

A quick aside. Most Python tooling I’ve installed over the years treats “install” as a one-shot: it fails partway, and you’re left cleaning up half-written state by hand. OpenJarvis’s install-state file is a small design choice that says the authors have actually watched people install this thing on unreliable networks. It’s the kind of detail you only notice when you need it – and then you notice hard.

Upgrade and uninstall

Upgrade is boring in the best way:

pip install --upgrade openjarvis
jarvis init # re-check config against new defaults

If you installed via the shell script, running it again pulls the latest source, refreshes the editable install, and rebuilds the Rust extension in the background. Your models aren’t touched.

Uninstall is deliberately narrow. It removes ~/.openjarvis/, ~/.local/bin/jarvis, and ~/.local/bin/jarvis-uninstall. It leaves Ollama, uv, and the Rust toolchain in place because they may be used by other tools; the script prints removal hints. If you want a full purge, follow those hints – otherwise you’ll be re-downloading multi-gigabyte model files next week.

FAQ

Does OpenJarvis actually work offline?

Yes, once models are downloaded. The Ollama/vLLM/llama.cpp engines run locally; the only network calls come from optional cloud engines or tools like web_search that you explicitly enable.

Can I use OpenJarvis with an API key instead of a local model?

You can – add the cloud inference extras (see the official install docs for the exact command), then export OPENAI_API_KEY or ANTHROPIC_API_KEY and set the engine in config.toml. But you’ll be running a framework designed around local-first primitives – energy and latency telemetry, on-device learning loops, local trace data – against a remote endpoint that ignores half of them. Fine for prototyping, wasteful as a final target. If API cost is your only concern, the local engines handle the majority of single-turn queries well enough that a hybrid approach rarely makes sense.

How is this different from just using Ollama by itself?

Ollama serves a model. OpenJarvis gives you agents (deep-research, code-assistant, scheduled monitor), a memory store, tool orchestration, and a common Engine interface across Ollama, vLLM, SGLang, and llama.cpp. Ollama is a component; OpenJarvis is the framework around it.

Next: run jarvis init --preset deep-research, point it at a folder of PDFs, and ask a question that would normally require Perplexity. If the answer surprises you, read the OpenJarvis paper (arXiv:2605.17172) to see why.