Meet Collie: A Local-First Coding Agent That Proves Its Own Work

I’ve been testing coding agents for a while now. Claude Code, Codex, the usual suspects. They’re powerful, but they all share a limitation I’ve been grinding my teeth over: they live in a cloud tab or an editor pane, and they can only touch the files you hand them. They can’t reach your browser. They can’t click through your actual app. They can’t see what you see.

Then I stumbled on Collie — and it’s different in a way that actually matters.

What Is Collie?

Collie is an open-source, local-first coding agent that lives on your machine and can run your environment. Not just read your files — open your logged-in browser, arrange your desktop, record your screen, take tasks from your phone, and prove its work by running actual tests before calling a task done.

It was built by the team at CollieHQ and landed on GitHub three days ago. Several things make it stand out from the crowd:

• Local and private. Nothing leaves your computer unless you send it somewhere. No account. No telemetry. Zero third-party dependencies in its core.
• Your real browser. A Chrome extension lets Collie operate inside your actual logged-in browser, much like the Prentis and Poke agents I covered recently that brought computer-using AI into the mainstream conversation — real sessions, real cookies. It can fill forms, check if a page loaded correctly, and interact with web apps without scraping.
• Self-verifying. When Collie fixes something, it writes a reproduction test that must fail on broken code, makes the smallest edit, and re-runs the assertion. A task isn’t “done” until it’s verified.
• Cross-platform. Linux, macOS, Windows, WSL2 — one Python codebase runs everywhere.
• MIT licensed. Free to use, modify, and distribute.

What got my attention most is the verification gate. Most coding agents check “did the test not error.” Collie’s gate is stronger, which is especially important after I documented how AI assistants hallucinate package names — the reproduction carries an assert actual == expected derived from the issue, so a plausible-but-wrong edit fails loudly and drives another repair round.

What Can Collie Actually Do?

The toolset is surprisingly broad for a project that’s only three days old:

The thing is, Collie isn’t a coding agent with unrelated features bolted on. The breadth above is there because Collie’s coding agent built all of it. The features are the benchmark — a harness strong enough to ship its own desktop app and iOS companion is strong enough for your bug.

How to Install Collie

Installation is refreshingly straightforward. The core is stdlib-only, so the base install is tiny:

On Linux or macOS

# Clone the repo
git clone https://github.com/colliehq/collie.git
cd collie

# Install with pip (editable mode recommended for now — PyPI publish is planned)
pip install -e ".[local,dev]"

# Run setup to configure optional deps and pick a provider
collie setup

# Start the terminal TUI
collie

First run walks you through picking an AI provider. It detects existing Claude, Codex, or Grok logins automatically. You can also paste an API key directly.

On Windows

One click. Download Collie-Setup.exe from the latest GitHub release and double-click it. The installer lays down a self-contained runtime (Python + Collie + semantic memory) and opens Collie in a native desktop window.

Optional Extras

# Full install with semantic memory, terminal UI, and keyless web search
pip install ".[local,tui,search]"

# For the browser bridge (managed Chromium with the extension preloaded)
pip install ".[browser]"

# For editor protocol support (ACP)
pip install ".[acp]"

The local extra pulls in semantic memory via granite-107m on onyxruntime (~55MB, multilingual, Apache licensed). The tui extra gives you the rich terminal interface. And search adds keyless web search — no API key required.

Quickstart: Your First Collie Session

Once installed, here’s how you actually use it:

Start the terminal chat

collie

This opens the TUI — a terminal chat interface. First run picks a provider if you haven’t configured one yet. Just type what you need done.

Fire a one-shot command

collie -p "fix the off-by-one in utils/timeparse.py"

Set your API key as an environment variable and Collie handles the rest. It finds the relevant code, writes a reproduction, edits the file, and verifies the fix — all in one shot.

Open the browser GUI

collie web

This opens the full browser interface — chat panel, live verification gate, diffs, star-map of your codebase, ambient desktop with clock and weather, and settings panel. It’s surprisingly polished for a v0.1 project.

Autonomous bug-fixing loop

collie loop --goal "get the suite passing" --until "pytest -q" --max 8

This is where Collie shines. It iterates toward the goal, stopping the first turn an executed check goes green. You can watch it fix things in real time.

Best-of-N execution

collie pack "fix the failing test" -n 3 --check "pytest -q" --apply

Runs N isolated attempts, keeps only what actually passes the check, and applies the best result. This eliminates the randomness of single-shot agent outputs.

The Verification Gate: Why It Matters

I want to call special attention to this because it’s the feature that made me actually trust Collie with real work.

Here’s how it looks in action:

locate   code_search "parse_duration compound units"   · 4 hits
         › utils/timeparse.py:42  _parse  ············· 0.91

repro    wrote repro.py · assert parse_duration("1h30m") == 5400
         ✗ FAILING  › got 1800, want 5400              ← gate armed

edit     utils/timeparse.py  ································· +1 −1
         43 │- total = SECONDS[unit] * int(val)
         43 │+ total += SECONDS[unit] * int(val)

verify   python repro.py
         ✓ PASSING  › parse_duration("1h30m") == 5400   ← gate green

✓ verified in 12.8s · Δ +1 −1 · 3,410 tok · $0.006

The agent first locates the relevant code, writes a failing reproduction (the gate arms), makes the edit, runs the repro again — and only when the assertion passes does it call the task complete. Wrong edit? It fails loudly, and the agent tries again. This assert-verify loop is the core differentiator. No other free agent harness does this out of the box.

Provider Support

Collie supports a wide range of AI providers, from fully local to cloud-based:

• Mock — testing with no API key, deterministic output
• Ollama — fully local models (qwen2.5-coder:7b, llama3.1, etc.)
• Anthropic — Claude (with first-party OAuth support for paid subscriptions)
• DeepSeek — cheap, fast API via OpenAI-compatible preset
• OpenAI — Codex, GPT-4o series
• OpenRouter — access to dozens of models through one API
• Qwen/DashScope, Groq, Zhipu, Moonshot — more OpenAI-compatible presets

This flexibility means you can start with a cloud API to test the harness, then switch to a local model once you’re comfortable, and pairing Collie with cheap providers is a great way to cut your LLM API costs significantly — all without changing your workflow.

How It Compares

I’ve been running Collie alongside Claude Code for the past two days. Here’s my honest take:

Where Collie wins: The verification gate is genuinely better than what any cloud coding agent offers. The local-first approach means no data leaves your machine. The browser bridge lets it test frontend changes in real browsers. And the price (free) beats every paid option.

Where Claude Code still leads: More mature model integration, broader context windows, and Anthropic’s models are still smarter for complex multi-file refactors. Collie with Ollama running a 7B model is impressive but doesn’t match Claude Opus on hard reasoning tasks.

Best use case: Pair Collie with a cheap model (DeepSeek or Ollama with qwen2.5-coder) for routine debugging, test writing, and small feature work. Reserve your expensive Claude credits for the heavy architectural decisions. This is the same pragmatic approach I took when trying Scriptc for native TypeScript compilation — use the right tool for each job rather than forcing one solution for everything.

Final Thoughts

Collie is the first coding agent that actually feels like it belongs on my machine rather than in a browser tab. The fact that it’s local, private, MIT-licensed, and self-verifying makes it a genuinely useful addition to any developer’s toolkit — not just another AI wrapper with a flashy demo.

It’s three days old on GitHub as of writing, so expect rough edges. But the architecture is solid, the verification gate is genuinely novel, and the cross-platform support means it works wherever you do. I’m keeping it installed and watching this project closely.

Give it a try. Clone the repo, run collie -p "fix something in your project" and see what happens when an agent has to prove its work before calling it done.