Mlyn

A local AI coding agent for VS Code, powered by your own Ollama models.

Mlyn adds a chat panel that can read, search and edit your workspace and run commands, with your approval at each step. The model runs on your machine: no cloud, no API keys, no telemetry, and no per-token bill.

Mlyn (млин) is Ukrainian for "mill": it grinds through your code locally.

Requirements

VS Code 1.85 or newer.
Ollama running locally (default http://127.0.0.1:11434).
Linux or macOS. The agent runs commands through bash, so on Windows use VS Code with WSL.

At least one model that supports tool calling:

ollama pull qwen3:8b          # about 5 GB, a good starting point
ollama pull qwen3-coder:30b   # about 18 GB, noticeably better at editing code

Mlyn picks the best installed model that supports tools and fits in your memory. You can change it at any time with the picker under the input box. Models without tool support are marked "chat only": they can answer questions but cannot touch your files.

What it does

Chat panel in the activity bar. Drag it to the secondary side bar if you prefer it on the right. Answers stream in with markdown, code blocks with a Copy button, and clickable file references such as src/app.py:42.

Agent tools, through Ollama's native function calling:

Tool	Purpose
`read_file`	Read a file with line numbers, paged for large files
`list_dir`	List a directory
`find_files`	Find files by glob, for example `.py` or `src//.ts`
`search_text`	Regular-expression search in file contents
`edit_file`	Replace an exact, unique string in a file
`write_file`	Create or overwrite a file
`run_command`	Run a bash command in the workspace root, with a timeout

Approvals. Choose a mode under the input box: Ask before edits (default), Auto-accept edits, or Auto. Each proposed edit shows an inline diff, and View diff opens VS Code's diff editor.
Editor context. The active file and selection are attached to your message. Click the chip above the input to leave them out. Ctrl+Alt+L adds the current selection as a quoted snippet.
Stop (or Esc) aborts generation and kills any command the agent started.
Project instructions. Mlyn reads AGENTS.md or CLAUDE.md from the workspace root, if present.
Chats are saved per workspace. /clear starts a new one. Ctrl+Alt+O opens the panel.

Security

Mlyn lets a language model act on your computer, so read this section.

Files: every tool is confined to the open workspace folder. Paths outside it, including through symbolic links, are refused.
Commands: run_command executes real shell commands with your user's permissions. In the default mode every command waits for your approval. "Always allow" applies to the current chat only, is tied to the program and subcommand (for example git status), and is never offered for compound commands, sudo, or rm.
Auto mode removes all approvals. Small local models make mistakes. Use Auto only in a disposable or version-controlled workspace.
Model output is rendered with an HTML-escaping markdown renderer under a strict content security policy.

Privacy

Mlyn talks only to the Ollama server you configure. It sends no telemetry and makes no other network requests. Session logs stay on your machine.

Logs

Output panel: run Mlyn: Show Log to see model turns, tool calls, approvals and errors. Use VS Code's "Developer: Set Log Level" to see debug detail.
Session files: one JSON-lines file per chat, with token counts and timings for every step. Run Mlyn: Open Log Folder to find them. The newest 30 are kept. Turn them off with mlyn.sessionLogs.

Attach the relevant session file when you report a problem. It contains the first 300 characters of your messages and short previews of tool output, so check it before sharing.

Settings

Setting	Default	Meaning
`mlyn.baseUrl`	`http://127.0.0.1:11434`	Ollama server
`mlyn.model`	empty	Model to use. Empty means automatic selection
`mlyn.numCtx`	`16384`	Context window. Ollama's own default of 4096 is too small for agent work
`mlyn.temperature`	`0.2`	Low values make tool use more reliable
`mlyn.think`	`false`	Let thinking-capable models reason first. Better on hard problems, slower
`mlyn.keepAlive`	`30m`	How long Ollama keeps the model loaded
`mlyn.maxIterations`	`25`	Model turns per request before the agent pauses
`mlyn.commandTimeoutSeconds`	`120`	Default timeout for commands
`mlyn.permissionMode`	`ask`	Default permission mode for new chats
`mlyn.sessionLogs`	`true`	Write a log file per chat

What to expect

Mlyn is as capable as the model you give it, and as fast as your hardware.

On a GPU, steps take seconds. On a CPU, expect 20 to 90 seconds per step, plus a minute or two the first time a model loads. The status line shows what is happening.
Mixture-of-experts models such as qwen3-coder:30b run surprisingly well on CPUs with enough memory, often faster than smaller dense models.
Local models do well on focused tasks: explain this file, find where something is used, fix this function, write a test and run it. They struggle with vague requests and large multi-file refactors. Be specific, and name the files when you can.
Keep chats short. Every step re-reads the conversation, so /clear between unrelated tasks keeps things fast.

Development

git clone https://github.com/melnykai/mlyn && cd mlyn
npm test            # tools, agent loop, markdown, extension host (mocked vscode), webview DOM
npm run test:live   # real run against Ollama: the model must fix a bug and verify the fix
npm run package     # builds mlyn-<version>.vsix
code --install-extension mlyn-0.1.0.vsix --force

The webview test needs jsdom (npm i --no-save jsdom) and is skipped without it. There are no runtime dependencies. Layout: extension.js (VS Code glue), src/agent.js (agent loop), src/tools.js (sandboxed tools), src/ollama.js (HTTP client), src/models.js (model selection), src/logger.js, media/ (webview), test/.

License

MIT