Jan is an open source local AI desktop client, officially positioned as an "open source ChatGPT replacement". It can run open source models such as Llama, Gemma, and Qwen locally and offline, and can also access cloud models such as GPT and Claude. It also provides local OpenAI compatible API and MCP capabilities, emphasizing the privacy-first experience of keeping data on the local machine.

Jan

Core parameters and statistics

Jan is an open source local AI desktop client. It is officially positioned as an “Open-source ChatGPT replacement” on GitHub and the official website, emphasizing that “it runs 100% offline on your own computer.” It integrates "download and run open source models locally", "access cloud commercial models", "local OpenAI compatible API" and "MCP agent capabilities" into the same desktop application.

Projects	Public Information
Official positioning	Open source ChatGPT alternative that can run offline
Operation method	Run open source model locally + connect to cloud model
Local models	Llama, Gemma, Qwen, GPT-oss and more (download from Hugging Face)
Cloud access	OpenAI, Anthropic (Claude), Mistral, Groq, MiniMax, etc.
Local API	OpenAI compatible, default localhost:1337
Agent capabilities	Support Model Context Protocol (MCP)
Open Source License	Apache 2.0
Community size	GitHub about 43,000 stars, 2,900 forks, 159 contributors
Downloads	The official website has been downloaded more than 5.7 million times
Latest version	v0.8.2 (2026-06-01, GitHub Releases, 102 releases in total)
Supported platforms	Windows, macOS, Linux

Deployment form: Jan is a desktop native application (built based on Tauri). Its core value lies in making "local reasoning" into a product form that can be used by ordinary users. For privacy-sensitive or network-restricted scenarios, the local model can be used completely offline; when stronger capabilities are needed, switch to the cloud model, and the two coexist in the same interface.

Interface Value: Jan exposes an OpenAI compatible API locally (localhost:1337), which means that existing scripts and applications written for the OpenAI interface can direct requests to the local model without changing the calling structure, reducing the cost of migrating from the cloud to the local.

Iteration rhythm: GitHub Releases shows that the project has accumulated 102 releases, and 0.8.0, 0.8.1, and 0.8.2 were released continuously in May 2026, indicating that it is still in the high-frequency delivery stage.

User and market recognition

Jan's recognition mainly comes from the popularity of the open source community and the actual download size, rather than public revenue figures (the latter is not officially disclosed).

Community and Downloads: GitHub repository janhq/jan publicly displays approximately 43,000 stars, 2,900 forks and 159 contributors; the official website homepage shows data of over 5.7 million cumulative downloads and over 15,000 community members. For a desktop tool whose selling point is “running large models locally”, this magnitude shows that it has passed the early experimental stage and formed a stable user group.

Word-of-mouth positioning: Public user feedback collected on the official website generally compares Jan with local inference tools such as Ollama and LM Studio, emphasizing its differences in "friendly interface and oriented to non-engineering users"; at the same time, models such as Jan-V1-4B self-developed by the project are also used by the community for local testing. This information comes from public sources, and specific performance varies based on machine configuration.

Prerequisites for implementation: The actual experience of running the model locally is highly dependent on the hardware. Official system requirements are publicly stated: 3B model under macOS 13.6+ requires approximately 8GB of memory, 7B requires 16GB, 13B requires 32GB, and Windows/Linux can be accelerated with NVIDIA/AMD/Intel Arc GPU. When the configuration is insufficient, it is more suitable to mainly use the cloud model for access.

Cost advantage

The cost advantage of Jan is not that "subscriptions are cheaper", but that it moves the inference process locally, structurally avoiding cloud API bills that are billed by call volume.

The software itself is free and open source: Jan adopts the Apache 2.0 license, the desktop client is free to download and use, and the official website is clearly marked "Free & Open source". This means there are no software subscription fees, and self-auditing and secondary development are also allowed.

Zero calling fee for local inference: When using a local model, inference is completed on your own device, and no cloud fees are charged based on tokens. In long-term high-frequency usage scenarios, the marginal cost is close to zero, and the cost is transferred to one-time hardware investment and electricity.

Cloud models are billed on a per-company basis: When users choose to access cloud models such as OpenAI, Anthropic, Mistral, Groq, etc., the relevant fees are charged by the corresponding service provider according to their pricing. Jan only serves as a unified client and does not increase the price itself.

True cost structure: For individuals and teams, what really affects the total cost is "whether local hardware can drive the target model scale." It is a more pragmatic cost combination to put tasks with high privacy requirements and large call volume locally and hand over occasional difficult tasks to the cloud model.

Main functions

Jan's capabilities are designed around "managing local models and cloud models simultaneously in one desktop application". The public functions can be summarized into the following categories:

• Local model running: Download and run Llama, Gemma, Qwen, GPT-oss and other open source models locally from Hugging Face, supporting pause/resume downloads.
• Cloud model access: Access cloud models such as OpenAI, Anthropic (Claude), Mistral, Groq, and MiniMax on the same interface, and switch as needed.
• Custom Assistants: Create special AI assistants for different tasks and solidify system prompts and parameters.
• OpenAI Compatible API: Start the localhost:1337 service locally for other applications to access the local model through standard OpenAI calling methods.
• MCP Integration: Expand tool calling and agent capabilities through Model Context Protocol.
• Privacy First: When using a local model, conversations and data are kept entirely on the machine.

The actual benefits of these capabilities depend on three key points: whether the target model size matches the local hardware, whether it is necessary to connect the local model to the existing OpenAI ecological application, and the strength of the rigid requirement that "data does not leave the local machine".

Model and version evolution

Jan is still in the high-frequency iteration stage. GitHub Releases publicly displays a total of 102 releases, and the main lines focus on local model management, cloud access API services and MCP capabilities.

Recent main version

• v0.8.2 (2026-06-01): The latest stable version, "v0.8.2 is now live on GitHub" is simultaneously marked on the homepage of the official website.
• v0.8.1 (2026-05-29): 0.8 series iterative repair version.
• v0.8.0 (2026-05-22): 0.8 major version node, promoting model hub, download and assistant capabilities.
• v0.7.9 (2026-03-23): Entering the 0.7.x late version before 0.8, reflecting the intensive release rhythm.

Self-developed model line

In addition to the desktop client, the team also publicly released models such as Jan-V1-4B (about 123 model entries hosted on Hugging Face), which the community used in conjunction with the Jan client for local actual testing. The model and client lines run in parallel, making Jan both a "runner" and a participant in the open source construction of the model itself.

Technical advantages

Jan's technical choices always serve the purpose of "turning large local models into products available to ordinary users."

• Local-first architecture: Build desktop applications based on Tauri (the warehouse languages ​​are mainly TypeScript and Rust). Compared with pure Electron solutions, they are lighter and easier to distribute on the three major desktop platforms.
• Mature inference backend: The official acknowledgment clearly states that it is based on open source inference engines such as llama.cpp, which enables it to run through mainstream open source models on consumer-grade hardware and supports GPU acceleration.
• Interface standardization: Locally expose OpenAI-compatible APIs, package "local models" into industry de facto standard interfaces, and reduce integration friction with existing tool chains.
• Extensible agent capabilities: Access external tools through MCP, so that the local model can not only talk, but also perform tasks with tool calls.

These designs jointly explain "why it is more economical and private": inference localization eliminates ongoing API fees, data localization meets privacy compliance, and standard interfaces reduce migration costs.

How to use

Jan provides a variety of entrances, covering pure local and mixed use:

Entrance	Applicable Scenarios	Description
Desktop client	Personal daily use	Download the Windows/macOS/Linux version from the official website or GitHub Releases
Local Model Hub	Offline Inference	Download the open source model from Hugging Face within the application and run it locally
Cloud model access	Requires stronger capabilities	Fill in the API Key of OpenAI, Anthropic and other service providers in the settings
Local API service	Secondary development/integration	Start localhost:1337 to call the local model in an OpenAI compatible manner

Typical steps to get started: Download and install the client for the corresponding platform → Download an open source model (such as 3B/7B) that matches the local memory in the Hub → Start a local conversation directly, or access the cloud model in the settings → If you need to integrate with other applications, open the local API server and point to localhost:1337.

Product Pricing

Jan's client itself is free and open source (Apache 2.0). The official website is clearly marked "Free & Open source" and there is no software subscription fee.

• Client & Local Model: Free. There are no pay-per-call charges when using the local model, and the cost is mainly local hardware and electricity.
• Cloud model call: When accessing OpenAI, Anthropic, Mistral, Groq, MiniMax and other services, the relevant fees are charged separately by each service provider according to their official pricing and have nothing to do with Jan.
• Enterprise/Business: The official business contact email address [email protected] is provided. The specific terms of enterprise cooperation are not disclosed and are subject to official communication.

Application scenarios

• Privacy-sensitive local Q&A: Use local models to process document Q&A, writing, and code assistance in environments that are not connected to the Internet or do not want data to be sent out.
• Developer local integration: Switch applications written for the OpenAI interface to the local localhost:1337, complete inference and debugging locally, and reduce API costs during the development period.
• Multi-model unified workbench: Compare the effects of local open source models and cloud commercial models in the same client, and flexibly switch according to task difficulty.
• Offline and network-limited scenarios: When on a business trip, on an intranet or with a weak network, rely on the downloaded local model to maintain basic AI capabilities.

Applicable people

• Privacy-focused individual users: For non-engineering users who want to keep conversations and data local and want a friendly interface, Jan is easier to use than similar tools that are more engineering-oriented.
• Developers and technical teams: Local OpenAI compatible APIs, MCPs and self-hosted solutions are required for local inference, prototype verification or to reduce the call cost during the development period.
• Boundaries for users with limited configuration: Local large models have clear thresholds for memory and GPU, and low-end devices have difficulty running large models smoothly; such users are more suitable to access cloud models or choose smaller local models.

Summary and Outlook

Jan's core competitiveness is to turn the engineering-oriented task of "running large models locally" into an open source, free, cross-platform and user-friendly desktop product, and to integrate local models into the existing ecosystem through OpenAI compatible APIs and MCP. Approximately 43,000 GitHub stars, over 5.7 million downloads, and 102 releases indicate that it has a stable community foundation and delivery rhythm.

The current limitations are also clear: the local inference experience is obviously restricted by hardware, and larger models have higher memory/GPU requirements; the cloud model still relies on the accounts and billing of each service provider. In the future, it is worth paying attention to the maturity of the MCP ecosystem through the collaboration between its self-developed model line (Jan-V1 series) and client capabilities, as well as its progress in the direction of enterprise self-hosting. For individuals and teams who want to pilot local AI at low cost, it is recommended to first use a mid-to-high-end device to run through the 7B model verification experience, and then decide whether to replace cloud calls with local inference in more scenarios; when enterprise-level privatized deployment is involved, license and support terms need to be confirmed in advance.

Related tools: Hugging Face, replicate

Technical advantages and capability boundaries

As an AI model and API product, Jan's core capabilities can be deeply understood through the following dimensions, which directly affect technology selection and implementation effects.

Inference Performance and Benchmark Performance The model’s reasoning performance is reflected in its performance on standard NLP tasks (text generation, code completion, semantic understanding, multi-turn dialogue, information extraction, etc.). It is recommended to conduct horizontal comparison through public benchmark test lists (such as MMLU, HumanEval, GSM8K, etc.), but please note that there may be a gap between benchmark test scores and actual business scenario performance. Key indicators that affect the actual user experience include: inference speed (Token/s or response delay, which directly determines the smoothness of the user experience), context window length (which determines the input size that can be processed at a time, affecting the complexity of the tasks that can be processed), and consistency of output quality (the stability of the results of multiple outputs of the same input, which affects the perception of reliability).

API Compatibility and Development Ecosystem The depth of API compatibility with mainstream development frameworks (LangChain, LlamaIndex, Semantic Kernel, etc.) directly affects the cost and cycle of integrated development. It is recommended to pay attention to the following integration dimensions: the coverage of language types supported by the SDK (whether mainstream languages ​​such as Python, JavaScript, Go, and Java have official SDKs), streaming output support (SSE/WebSocket protocol compatibility), function calling and tool usage capabilities (whether it supports mapping model output to structured function calls), the flexibility of structured output (JSON mode), and the ability to integrate with enterprise-level infrastructure (VPC deployment, Private Link, unified identity authentication). Complete API documentation and rich code examples can significantly lower the entry barrier to development and reduce integration time and costs.

Deployment Flexibility vs. Cost Tradeoff Depending on data privacy requirements, latency sensitivity, and usage scale, Jan can choose between cloud API calls or on-premises deployment options. The advantages of cloud deployment are zero operation and maintenance costs and elastic scalability, which is suitable for scenarios with large fluctuations in usage and rapid prototype development; local deployment provides complete data sovereignty and low latency (no network round-trip overhead), but you need to bear the cost of purchasing hardware such as GPUs and operation and maintenance manpower. It is recommended to use a monthly API call volume of 1 million times or a monthly fee of US$1,000 as a reference dividing line: below this threshold, cloud APIs have better cost-effectiveness and flexibility. After exceeding this threshold, the total cost of ownership of the self-deployment solution should be comprehensively evaluated, taking into account factors such as hardware depreciation, electricity, operation and maintenance manpower, etc.

Model selection and version strategy

For the selection of Jan series models, it is recommended to match the model capabilities of different versions according to specific usage scenarios. The large-parameter version performs better on complex reasoning and multi-step tasks, but has higher costs and longer delays; the small-parameter version can already provide satisfactory output quality in scenarios such as daily conversations and simple question and answer, and the cost is only a fraction of the large version. The recommended selection strategy is: use small and medium versions in standard scenarios to reduce costs, and only call large version models when complex inference tasks need to be processed. This hierarchical calling strategy can reduce the overall API cost by 40-60% without significantly affecting the output quality.

Version Info

• Jan v0.8.2 ：The latest stable version released by GitHub Releases continues to iterate along the main line of local model operation, cloud model access to OpenAI compatible API and MCP integration, and the desktop side covers Windows, macOS and Linux. （2026-06-01）
• Jan v0.8.1 ：The iterative version of the 0.8.x series continues to fix problems and improve the local model and dialogue experience after the 0.8.0 major version. （2026-05-29）
• Jan v0.8.0 ：The 0.8 major version node promotes the desktop client’s model management Hub download and assistant capabilities. （2026-05-22）
• Jan v0.7.9 ：The later versions of the 0.7.x series reflect the high-frequency release rhythm that the project maintained before entering 0.8 (GitHub has accumulated more than 100 releases). （2026-03-23）