Local-first · Ollama-native · Open source

An infinite AI coding canvas
local-first, private by default

Terminals, editors, chats, git, and a crew of models — floating windows on a pannable, zoomable canvas. Run entirely on local Ollama models and nothing leaves your machine, or opt in to frontier models — Claude, GPT, Gemini — per task, through your own account, never a middleman.

C++20 / Qt6 · Linux · free and open source · no account, no telemetry, no credits

An infinite canvas, not a grid of boxes

Terminals, editors, chats, the crew, git — floating windows on a pannable, zoomable canvas. Put things where they make sense and leave them there.

The OllamaDev canvas: the crew's brain pane, a chat pane, a terminal, and the overview map

The Brain pane (the whole crew pipeline), a chat pane, a terminal — and the overview map, bottom left.

The crew

One command. A Director decomposes the task, coders build the pieces in parallel, an Auditor reviews every changeset, and clean work lands in your folder. Contested work waits for you.

# plan it, build it in parallel, audit it, land it
$ ollamadev crew "add rate limiting to the API and document it"

▸ plan: director is decomposing the task
    coder #1 [coder] ollama:gpt-oss:120b-cloud · hard
    coder #2 [docs]  ollama:gpt-oss:20b-cloud  · moderate
▸ build: 2 coders working
▸ audit: reviewing every changeset
▸ land: applying clean work
    applied #1 (2 files)
    held    #2 — audit flagged: adds code beyond the docs-only subtask
▸ done: 1 applied · 1 held
Isolated

A git worktree per coder

Real worktrees sharing the object store — not copies of your repo. Each coder gets a real git repo it can read the history of, and your working tree is never touched until you accept.

Reviewed

An Auditor that says no

Every changeset is read before it lands. Wrong, unsafe, or outside the subtask it was given — it gets held for you instead of applied.

Gated

A secret never lands

A credential in a diff blocks the landing and blocks the commit. Findings are redacted, so the secret is never echoed into a log or a model's context.

Resumable

Interrupted is not lost

crew resume keeps every coder that finished — landing their work from disk with zero model calls — and the Director re-plans only what is left.

Steerable

Talk to a running coder

crew steer 2 "use the existing logger" — it arrives between iterations and changes what that coder does next.

Guarded

First writer wins

Two coders touching the same file is caught, not merged blindly. The second one is held for you to look at.

The brain

Difficulty is a property of the subtask, not the role. With --route, each piece of work is classified and given a model that fits it — so "rename a variable" doesn't cost what "design the parser" costs.

$ ollamadev route "rename a variable"
→ simple    ollama:qwen3.5:9b        (short lookup-style question)

$ ollamadev route "design a lock-free queue"
→ hard      ollama:gpt-oss:120b-cloud

All opt-in. With none of these set, the crew is exactly as it was.

FlagWhat it does
--routePick each subtask's model by difficulty.
--amplify NN independent Director plans, keep the consensus shape — and an N-reviewer audit panel where a strict majority is needed to land anything. A 2–2 split holds the change.
--debateAdvocate vs skeptic vs judge, per changeset. A contested change has to survive an argument.
--dedupeHold a coder whose work duplicates another's.
--securityA read-only vulnerability hunt. The crew writes a report and changes nothing.
--learnDistil what this run taught into memory and a reusable skill, and load it back on the next run.
--swarm NRaise the coder cap for a wider fan-out.

Git, properly

A real git client on the canvas: the commit graph, staged and unstaged changes, an inline diff — and an interactive rebase where the model proposes the plan and you approve every line of it.

The git pane: commit graph with lanes, branches, stashes, tags, staged and unstaged changes
Tidy history

AI interactive rebase

The model reads your commits and proposes which to fold together and which to reword. You see every line before anything is rewritten, and a backup ref is taken first — so it is always undoable.

Commit

Messages that say why

A Conventional Commit written from the staged diff — on a dedicated git.model, because a commit message is a small job that shouldn't cost what chat costs.

Safety

It tells you before it eats your work

Every destructive action names what it will destroy. Force-push is always --force-with-lease. Unstage never means "delete my edit".

Everything else

Agent

47 built-in tools

Read, write, edit, patch, glob, grep, bash, background shells, semantic code search, the web — and 17 git_* tools. Native Ollama function calling, no text-scraping fallback.

Editors

ACP + LSP

An Agent Client Protocol server, so an editor can drive it as an agent — permission prompts and all. And a language server: hover, completion, go-to-definition, rename, real compiler-backed diagnostics.

Providers

Ollama, and every coding CLI

Ollama local and cloud, plus Claude Code, Codex, Gemini, cursor-agent, opencode, qwen. Mix providers inside one crew — a different backend per coder.

Vision

Show it a screenshot

@shot.png in any prompt. Works in the CLI, the one-shot, and the desktop chat.

Extend

Skills, memory, MCP, plugins

Progressive-disclosure skills, wiki-linked memory, MCP servers, and plugins that contribute skills, commands, hooks and MCP servers — installed disabled, and enabling shows you the exact commands first.

Voice

Say it instead

Local speech-to-text. Steer the crew without typing.

Install

Qt6 is the only dependency. There is no account, no key, and nothing to sign up for.

# Debian / Ubuntu
$ sudo apt install build-essential cmake ninja-build qt6-base-dev \
      qt6-webengine-dev libqt6svg6-dev

$ git clone https://github.com/kennethyork/OllamaDev-Qt.git
$ cd OllamaDev-Qt
$ ./install.sh          # builds, tests, installs the CLI + desktop app

$ ollamadev setup       # picks and pulls a model for your hardware
$ ollamadev doctor      # check it over

You need Ollama running. Cloud models work through your own ollama signin — there are no API keys in this app, and nothing is routed through anyone else's account.

The commands you'll actually use

Command
ollamadevInteractive agent. -c resumes this folder's session.
ollamadev "…"One-shot. It reads, edits, runs — then stops.
ollamadev crew "…"The parallel bench: plan → build → audit → land.
ollamadev crew resumeFinish an interrupted run. Keeps what's done.
ollamadev boardHeld work, waiting on you. crew accept 2 / crew discard 2.
ollamadev commit -aAI commit message. A leaked secret blocks it.
ollamadev shipStage → scan → commit → ask → push.
ollamadev tidy 10AI interactive rebase over the last 10 commits.
ollamadev scanHunt the tree for leaked credentials.
ollamadev route "…"Which model would the brain pick, and why.
ollamadev code-search "…"Search the repo by meaning, not by string.
ollamadev evalA fixed task suite → a pass rate you can compare models with.
ollamadev acp / lspServe an editor over ACP, or as a language server.
ollamadev-adeThe desktop app.

What it is, and what it isn't

Being straight with you. This is a real tool that does real work, but it is early and it is one person's project.

  • Linux only today. The code is Qt6 and should port to macOS and Windows, but neither is built or tested. Do not assume it works there.
  • Build from source. No signed installers yet.
  • 205 assertions in the self-test suite, all passing — install.sh runs them on every build. Every feature on this page was driven end-to-end against a live model before it was written down. But it has one user.
  • Not a hosted product. No account, no telemetry, no credits, nothing to bill you for — and equally, nobody on call if it breaks.
  • AGPL-3.0. Use it, change it, share it. But if you modify it and offer it to others — including as a hosted service — you owe them your source too. Running it on your own machine carries no obligation.