Askimo: a Kotlin desktop client that puts chat, local RAG, MCP tools and agent CLIs in one window
AI Client for chat, RAG, Skills, MCP tools, and agents. Support multiple LLMs (Anthropic, OpenAI, VertexAI, vLLM, Nvidia NIM, Gemini, OpenRouter)
At a glance
- What is it?
- Askimo is a native desktop AI client written in Kotlin and licensed AGPL-3.0. It aggregates providers, keeps a local retrieval index, and delegates goals to installed agent CLIs. The judgement: the local-first storage model is the reason to consider it, and the AGPL licence plus the fast release cadence are the reasons to check your constraints first.
- Who is it for?
- Adopt Askimo if you want a single desktop binary that talks to cloud and local models, indexes your own folders without shipping them anywhere, and can hand a goal to an agent CLI you already have installed. Do not adopt it if AGPL-3.0 is incompatible with how you distribute software, or if you need a headless service that runs on a server rather than a workstation.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly Kotlin, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The friction Askimo is aimed at: model sprawl plus data you cannot upload
Two problems get bundled together here. The first is provider sprawl. An engineer who wants to compare an OpenAI model against Claude, then against a local Ollama instance, normally ends up with several browser tabs, several API keys, and a copy-paste loop between them. Askimo's README frames the pitch as switching models in seconds without leaving the app, and the provider list is wide: OpenAI, Claude, Gemini, Grok, Ollama, LM Studio, Docker AI, OpenRouter, NVIDIA NIM, Together AI, vLLM Server, plus any OpenAI-compatible endpoint. The second problem is the one that actually decides adoption for a lot of teams. Retrieval over internal files usually means uploading those files to a hosted index. Askimo's README states that files, the RAG index, conversation history and telemetry stay on the machine, with local SQLite storage, and that the only network calls are the ones you configure. That claim is the product's centre of gravity. Everything else (chat, vision, speech) is table stakes in this category; the local index is not. The audience is therefore fairly narrow and fairly specific: developers and technical users on macOS, Windows or Linux who want one desktop application for both hosted and self-hosted models, and who have documents they are not willing to send to a third party.
What actually runs: a Kotlin desktop app with a local store and a retrieval classifier
The repository's primary language is Kotlin, and the README is explicit that this is a native desktop application rather than a web wrapper, citing fast startup and stability across long conversations as the reason for that choice. The stated memory footprint is 50 to 300 MB, with the caveat that AI models require additional memory depending on the provider, and 250 MB of disk. Those numbers describe the app itself, not a locally hosted model. The data flow implied by the documentation is: you configure a provider, conversations and usage/cost tracking are written to a local SQLite database, and a separate local index is built from folders, files and web URLs you point it at. Retrieval is described as hybrid BM25 plus vector search, with an AI classifier that decides whether a query needs retrieval at all and skips it when it does not. That classifier is the most interesting design decision in the README, because it is a latency and cost trade-off rather than a feature. A classifier pass adds a model call before retrieval; the payoff is that conversational turns which clearly do not need your file index do not pay for a vector search. Whether that trade is worth it depends on your query mix, and the README does not publish accuracy figures for the classifier, so treat the skip behaviour as a design intent rather than a measured guarantee. On top of this sit two extension surfaces: MCP servers, which the README shows connecting from the same app, and agent CLIs, where you select an installed CLI and delegate a goal.
Installation is a download, not a build, and the docs live off-repo
Askimo is distributed as a signed desktop download rather than a package you compile. The README's Quick Start is three steps: install and open Askimo, add a provider by pasting an API key for OpenAI, Claude or Gemini, or by pointing it at a running Ollama instance, then start chatting. There is no install command in the repository material, no Homebrew formula, no Docker image and no pip or npm package referenced. The homepage points at https://askimo.chat/download/ and the documentation at https://askimo.chat/docs/, with a provider setup guide at https://askimo.chat/docs/desktop/ai-providers/. That matters for evaluation: the repository README is a product page, and the operational detail (provider configuration fields, RAG indexing options, MCP server configuration, plan YAML schema) sits on the external docs site, which is not included in the material available here. One concrete configuration surface is named in the README: Plans are defined in YAML or generated, and each step builds on the previous one with live progress, exportable as PDF or Word. Web search is also configurable by backend, with DuckDuckGo requiring no API key and Brave Search API, Tavily, or a self-hosted SearxNG instance as alternatives. Beyond those names, the exact config keys are not visible in the supplied material, so anyone evaluating this should read the docs site directly rather than infer settings from the README.
The AGPL-3.0 licence and the release cadence are the real adoption costs
The licence is AGPL-3.0, and that is a stronger constraint than the word "open source" usually signals to a buyer. AGPL obligations attach to network use, which is why it appears on server-side projects, but it also applies to distributed desktop software. If your organisation ships a modified Askimo to customers, or exposes a modified version over a network, the licence terms are the thing to read before you build on it. This is not a legal opinion and it is not a reason to avoid the project; it is a reason to route the decision through whoever handles licence compliance at your company, particularly if you were hoping to embed the client in a commercial product. The second cost is cadence. The release history shows v1.4.17 on 2026-08-20, v1.4.18 on 2026-08-24, and v1.5.0 on 2026-09-09, with the last push to main on the same day as v1.5.0. A four-day gap followed by a minor version bump two weeks later is a fast, active rhythm. Fast releases are good for fixes and bad for stability expectations: if you standardise a team on a specific build, you are signing up to re-verify provider behaviour and index compatibility on a roughly fortnightly basis. The README does not describe a long-term support branch or a stable channel, so pinning a version is the practical mitigation, not a documented policy.
Where Askimo is the wrong tool: headless pipelines and shared team indexes
The local-first design is also the limitation. Askimo is a desktop application with local SQLite storage and a local index, which means the retrieval corpus lives on one machine and is not shared. A team that wants a single index over a shared document store, queryable by a backend service, is looking at the wrong category of tool; Askimo's model is one person, one workstation, one index. The README's privacy claim cuts the same way: because nothing is uploaded, there is no server-side component to point a CI job or a scheduled batch process at. The second limitation is the dependency on things you install yourself. Agent delegation requires an agent CLI to be present on the machine; the README names Claude Code, Codex and Antigravity as examples. MCP tooling requires an MCP-compatible server. Neither ships with Askimo in the material shown, so the "delegate a goal to an agent" workflow is only as available as your local toolchain. Third, the memory and disk figures (50 to 300 MB, 250 MB disk) describe the client, and the README states plainly that AI models require additional memory depending on provider. Anyone planning to run a local model through Ollama should budget for the model, not the app. Finally, the README leans on qualitative claims about long conversations and responsiveness without publishing measurements, so those specific claims are unverified from the material here.
How it differs from a browser-based multi-model front end
The obvious alternative is a hosted multi-model chat front end, of which there are many, and the difference is architectural rather than feature-level. A hosted front end runs in a browser, keeps your conversation history on someone else's infrastructure, and reaches local models only if you expose them through a tunnel or a public endpoint. Askimo is the inverse: a native binary that talks to whatever endpoints you configure, stores history in local SQLite, and reaches a local Ollama or LM Studio instance on the loopback interface without any exposure. If your documents are the sensitive part, that inversion is the whole argument. If your documents are not sensitive and your priority is zero installation and shared access across a team, the hosted front end wins on both counts, because Askimo has no multi-user story at all. The second alternative worth naming is a command-line agent harness such as Claude Code, which the README itself lists as something Askimo can delegate to. That is not really a competitor; it is a component. The difference in approach is that a CLI harness assumes one provider and a terminal, while Askimo assumes a graphical window, several providers, and an index. If you already live in a terminal and only use one model, adding a desktop client on top buys you the RAG index and the provider switcher, and little else.
Verdict: a workstation tool with a licence to check first
Askimo is a reasonable fit for an individual engineer or a small technical team that wants one desktop application covering hosted providers and local models, with a file index that never leaves the machine and the option to hand work to an agent CLI already installed on the same box. The combination of local SQLite storage, hybrid BM25 plus vector retrieval, and a classifier that can skip retrieval is a coherent design, and the multi-provider list is broader than most clients in this category. It is a poor fit for anyone who needs a server-side service, a shared index, or a component to embed in a closed-source product, because the architecture is single-workstation and the licence is AGPL-3.0. The two facts to verify before committing are the ones the README cannot settle: the exact provider and RAG configuration keys, which live at https://askimo.chat/docs/ and are not reproduced in the repository, and whether AGPL-3.0 terms are acceptable for your distribution model. The release history (v1.4.17, v1.4.18, v1.5.0 within three weeks) suggests you should pin a version and treat upgrades as a deliberate step rather than an automatic one.
Editorial conclusion
Adopt Askimo if you want a single desktop binary that talks to cloud and local models, indexes your own folders without shipping them anywhere, and can hand a goal to an agent CLI you already have installed. Do not adopt it if AGPL-3.0 is incompatible with how you distribute software, or if you need a headless service that runs on a server rather than a workstation. Before installing, verify three things: that your OS meets the stated floor (macOS 11+, Windows 10+, or Ubuntu 20.04+/Debian 11+/Fedora 35+), that the agent CLI you intend to delegate to is already on your PATH, and that your chosen provider endpoint is reachable from the machine, because the README states the only network calls are the ones you configure.
Community notes