OpenJarvis: A Local-First AI Stack That Treats Energy as a First-Class Constraint

What OpenJarvis Actually Solves

Most personal AI agents still route every query through cloud APIs, which means your data and your inference depend on someone else's server. OpenJarvis is a framework that aims to change that by making local-first personal AI practical. It is built around three ideas: shared primitives for on-device agents, evaluations that treat energy, FLOPs, latency, and dollar cost as first-class constraints alongside accuracy, and a learning loop that improves models using local trace data. The intended audience is developers and researchers who want to build personal AI agents that run locally by default, calling the cloud only when necessary. The project's own research, called Intelligence Per Watt, claims that local language models already handle 88.7% of single-turn chat and reasoning queries, with efficiency improving 5.3 times from 2023 to 2025. That statistic is the core justification for the project's existence. Without it, the effort of running models on personal devices would be hard to justify. The README presents OpenJarvis as both a research platform and a production foundation, in the spirit of PyTorch. That is an ambitious comparison, and it sets a high bar for maturity.

How the Architecture Fits Together

OpenJarvis is a Python framework with a Rust extension that continues downloading in the background after installation. The architecture is built around three execution modes: on-demand, scheduled, and continuous. On-demand agents run when invoked, scheduled agents run on a timer, and continuous agents persist with state management. The framework includes eight built-in agents. The morning_digest agent is scheduled and generates a spoken daily briefing from email, calendar, health, and news. The deep_research agent performs multi-hop research with citations across web and local documents. The monitor_operative agent is continuous, with memory, compression, and retrieval for long-horizon monitoring. The orchestrator agent handles multi-turn reasoning with automatic tool selection. There is also a native_react agent that implements the ReAct loop, an operative agent for persistent autonomous work, a native_openhands agent that generates and executes Python code, and a simple agent for single-turn chat with no tools. The skills system is separate from the built-in agents. Skills are tools that agents discover from a catalog and invoke on demand. They follow the agentskills.io open standard and can be imported from sources like Hermes Agent and OpenClaw. The learning loop uses local trace data to optimize skills, as shown by the jarvis optimize skills --policy dspy command. That command suggests a DSPy-based policy optimization, which is a concrete mechanism for improving agent behavior over time.

Getting Started: One Command, Then Background Downloads

Installation is designed to be a single command. On macOS, Linux, or WSL2, you run curl -fsSL https://open-jarvis.github.io/OpenJarvis/install.sh | bash. On native Windows, you run irm https://open-jarvis.github.io/OpenJarvis/install.ps1 | iex. There is also a desktop GUI with installers for .exe, .dmg, .deb, .rpm, and .AppImage. The installer handles uv, the Python venv, Ollama, and a starter model, with the README claiming about 3 minutes on broadband. After installation, you start with jarvis, which defaults to the chat-simple preset. The jarvis doctor command shows the status of the background downloads for the Rust extension and larger models. That background download is a notable design choice. It means the initial install is fast, but you may not have full functionality until those downloads finish. The quick start also shows presets. For example, jarvis init --preset morning-digest-mac sets up a spoken daily briefing, and jarvis connect gdrive provides a single OAuth flow for Gmail, Calendar, and Tasks. The deep-research preset enables multi-hop research with citations, and the code-assistant preset gives an agent with code execution, file I/O, and shell access. The scheduled-monitor preset is a stateful agent on a schedule with memory. These presets are the fastest way to see what the framework can do, but they are starter configs, not production deployments.

The Skills System: A Catalog, Not a Monolith

The skills system is where OpenJarvis differs from a simple chatbot wrapper. Skills are tools that agents discover from a catalog and invoke on demand. You install skills from public sources using jarvis skill install hermes:arxiv or jarvis skill sync hermes --category research. The README mentions importing from Hermes Agent, which has about 150 skills, and OpenClaw, which has about 13,700 community skills. That is a large catalog, but the quality control is unclear. Skills follow the agentskills.io open standard, which is a plus for interoperability. You can also optimize skills from your trace history with jarvis optimize skills --policy dspy, and benchmark their impact with jarvis bench skills --max-samples 5 --seeds 42. That benchmarking command is a concrete feature that lets you measure whether a skill actually improves performance. The optimization loop is part of the project's stated goal of improving models using local trace data. This is a genuine mechanism, not just a promise. However, the README does not specify what the benchmark measures or how the optimization affects accuracy. That is a gap. If you are considering using the skills system in production, you will need to read the user guide to understand the evaluation metrics.

Limitations: Where Local-First Hits a Wall

The most obvious limitation is that OpenJarvis is a young project. The latest release is v1.0.0 from May 2026, and the desktop-v1.0.2 release came a few days later. That is not a sign of maturity. The README is clear that the installer handles the Rust extension and larger models in the background, which means the first run may not be fully functional until those downloads complete. That background download is a potential failure mode if you are on a slow connection or a restricted network. Another limitation is the dependence on Ollama as the model runtime. The installer sets up Ollama, which means OpenJarvis is tied to Ollama's model management and performance characteristics. If Ollama does not support a model you need, you may be stuck. The project also claims to call the cloud only when truly necessary, but the README does not describe how that decision is made. There is no mention of a fallback mechanism or a threshold for when cloud calls happen. That is a critical gap for anyone who needs to guarantee privacy or offline operation. Finally, the 88.7% figure for local model handling of queries is a research claim. It comes from the project's own Intelligence Per Watt research, and the README does not provide the methodology or the query distribution. You should treat it as a promising data point, not a proven fact.

Alternatives: How OpenJarvis Compares to Other Local AI Stacks

The most direct alternative is Ollama itself, which OpenJarvis uses under the hood. Ollama is a runtime for running large language models locally, but it does not provide an agent framework, a skills catalog, or an evaluation harness. OpenJarvis builds on Ollama to add those layers. If you only need to run a model locally and chat with it, Ollama alone is simpler and more mature. Another alternative is a cloud-based agent framework like LangChain, which provides tools, agents, and integrations, but it is not local-first by default. LangChain routes through cloud APIs unless you explicitly configure local models, and it does not treat energy or FLOPs as evaluation constraints. OpenJarvis's differentiator is its evaluation harness that includes energy, FLOPs, latency, and dollar cost. That is a real difference in approach. LangChain focuses on flexibility and integrations, while OpenJarvis focuses on local efficiency and measurable resource use. If your priority is minimizing cloud dependence and tracking energy consumption, OpenJarvis is closer to that goal. If you need a mature ecosystem with extensive integrations, LangChain has a larger community and more documentation.

Maintenance, Licensing, and What to Verify First

OpenJarvis is licensed under Apache-2.0, which is permissive and allows commercial use, modification, and distribution without copyleft obligations. That is a positive for adoption. The project is not archived, and the last push was in May 2026, so it is actively maintained. However, the release cadence is unclear from the provided material. There is a v1.0.0 release and a desktop-v1.0.2, but no indication of how frequently updates arrive. The documentation is hosted on GitHub Pages, and the project has a roadmap, but the README does not detail upgrade procedures or backward compatibility. The background download of the Rust extension suggests that updates may require re-downloading components. Before you adopt OpenJarvis, verify that the installer works on your specific OS, especially if you are on native Windows or WSL2. Check that the background downloads complete successfully, and confirm that the models you need are available through Ollama. Also, review the evaluation leaderboard to see how the built-in agents perform on the metrics that matter to you. The project's value depends on the strength of its evaluation harness, so confirm that harness covers your use case.

Editorial conclusion

Adopt OpenJarvis if you are a developer or researcher who wants a local-first agent stack that treats energy and cost as measurable constraints, and you are comfortable with a young project that relies on a one-command installer and background model downloads. Do not adopt it if you need a mature, enterprise-grade agent platform with extensive documentation and a stable API, or if your workloads require cloud-scale models that local hardware cannot handle. Before committing, verify the installer works on your exact OS (especially native Windows or WSL2), check the background download behavior for the Rust extension and models, and review the actual evaluation results on the leaderboard to confirm the 88.7% figure applies to your query types. The project's value depends on the strength of its evaluation harness, so confirm that harness covers your use case.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes