The Landscape: Terminal, Editor and Autonomous Agents

A coding agent is a loop with a shell in it. By the end of this lesson you will be able to name the tools worth knowing in 2026, say for each one whether it is open source and whether its own documentation describes a route to a server you own, and — more useful than any individual answer — work out which question to ask about a tool you meet next year that is not on this list.

The list below was compiled on 2026-09-09 from each project’s own documentation. It will start going stale immediately. Two of the projects here moved their documentation to a new domain in the months before that date, one changed its parent organisation, one was archived outright, and one now describes itself as a fork of a project it did not fork a year ago. Treat every row as a claim with a date on it and re-check the ones you depend on.

The only question that decides everything

Strip the branding away and an agent is a program that sends messages to an HTTP endpoint and acts on what comes back. Whether it can talk to your machine reduces to one question: which wire format does it speak, and can it be told where to send it?

Where an agent attaches to a stack you own

a request travels down; only the top two layers differ between tools

1. The agentTerminal, editor extension or autonomous runner. Owns the loop, the prompts, the tool definitions and the permission modelthe thing you install
2. Wire formatOpenAI Chat Completions, OpenAI Responses, or Anthropic Messages. This is the compatibility questionthe thing that breaks
3. Base URL and keyAn environment variable or a config file entry. If the tool has no way to set this, nothing below matters
4. Your gatewayThe Part 9 LiteLLM proxy: stable aliases, one key, usage records, both API shapes
5. Enginesllama-server, vLLM, an MLX server, whatever is behind the alias today
6. Weights on your diskNever leave the machinethe point of all this

Every tool in this lesson occupies the top layer. The three questions worth asking about a new one are: which wire format, can I set the base URL, and does it need tool calling to be useful.

Most tools speak OpenAI Chat Completions, which is why “OpenAI-compatible” has become the lingua franca of local serving. A few speak the Anthropic Messages format. One speaks the OpenAI Responses API and, as of the date above, documents no other option. That single fact does more to decide which tools you can use than any feature list.

The second question is subtler and Part 24 already answered it: an agent without tool calling is a chatbot. Goose’s provider documentation states it plainly — “goose extensively uses tool calling, so models without it can only do chat completion”. A tool may connect to your endpoint perfectly and still be useless, because the model behind the endpoint cannot emit a tool call the tool can parse. That is the next lesson’s subject.

Terminal agents

These run in a shell, in your repository, and they are where local models work best, because there is no proprietary index, no cloud-side embedding service and no editor telemetry in the path.

Aider is the smallest thing that works and the easiest to point anywhere. Its repository ships the Apache-2.0 licence text, and its documentation has a page titled for exactly this purpose: “Aider can connect to any LLM which is accessible via an OpenAI compatible API endpoint.” Two environment variables and a model name with an openai/ prefix and you are running. It is Aider 0.86.0 · verified 2026-09-08 in this course. It also ships the polyglot benchmark, which makes it the one tool in this list that comes with its own measurement, and the third lesson uses that.

OpenAI Codex CLI is Apache-2.0 — its README says “This repository is licensed under the Apache-2.0 License” — and has a first-class local mode. Passing --oss runs it “against a local ‘open source’ provider such as Ollama or LM Studio”, with oss_provider in config.toml choosing which. Arbitrary endpoints go in a model_providers table. There is a catch about the wire format that the fourth lesson deals with in detail, and it matters.

OpenCode is MIT-licensed and configured with a single opencode.json in which a provider is described by an npm package, a base URL and a model map. Its provider documentation gives worked examples for Ollama, for llama.cpp’s llama-server and for LM Studio, which makes it the tool in this list whose documentation is most directly about local serving. It is OpenCode 1.18.29 · verified 2026-09-08 here. Its repository moved during 2026: github.com/sst/opencode redirects to a new organisation, which is worth knowing when a link in an old blog post fails.

Goose, from Block, is Apache-2.0 and has moved twice in the recent past: its documentation now lives at goose-docs.ai rather than the GitHub Pages address most links point at, and the project site states it is “now governed by the Agentic AI Foundation at the Linux Foundation”. It reaches an OpenAI-compatible server through OPENAI_HOST, with OPENAI_BASE_PATH for servers that mount the chat endpoint somewhere unusual, and Ollama through OLLAMA_HOST. It is Goose 1.50.0 · verified 2026-09-08 here and the seventh lesson covers it.

Claude Code is the outlier: proprietary, and the only tool here whose vendor documentation explicitly declines to support what this part is doing. Its “Other LLM gateways” page says that Anthropic “doesn’t support routing Claude Code to non-Claude models through any gateway”. The mechanism nonetheless exists, llama.cpp publishes an Anthropic-compatible endpoint, and the fifth lesson works through what happens when you use them together, including the parts that do not work.

Qwen Code is Apache-2.0 and documents the local path directly. Its model-provider page has a section headed “Local Self-Hosted Models (via OpenAI-compatible API)” and says “Most local inference servers (vLLM, Ollama, LM Studio, etc.) provide an OpenAI-compatible API endpoint”, with OPENAI_API_KEY, OPENAI_BASE_URL and OPENAI_MODEL as the environment variables. It is not pinned in this course’s version table, so treat its flags as unverified until you read its help output.

Crush, from Charm, carries the Functional Source License (FSL-1.1-MIT, an MIT Future License), which is source-available rather than open source under the usual definitions — worth knowing before you build on it. Its README documents local models explicitly, including provider types named llamacpp, omlx, lmstudio, litellm and ollama, which is the most local-serving vocabulary of any tool here.

Gemini CLI is Apache-2.0 — “🛡️ Open source: Apache 2.0 licensed” — but its authentication documentation describes three routes and none of them is a local endpoint: browser sign-in, a Gemini API key, or Vertex AI. A search of its README and its authentication, settings and model documentation on 2026-09-09 found no base-URL override and no OpenAI-compatible provider. Open source and locally usable are different properties, and this is the cleanest example of the difference.

Mistral Vibe lives at github.com/mistralai/mistral-vibe and is Apache-2.0. Its README documents “Custom Domains” for enterprise deployments, but is specific that “The credential is still a Mistral API key”. No generic OpenAI-compatible or Ollama path appears anywhere in it. Do not confuse a vendor-endpoint override with local-model support; they look similar in a feature list and are not the same thing.

Editor agents

Cline is Apache-2.0 and documents Ollama, LM Studio and a generic “OpenAI Compatible” provider whose configuration page is emphatic about the one field that matters: “Base URL: Enter the base URL provided by your chosen provider. This is a crucial step.” Its Plan and Act modes and its auto-approve list are the permission model, and the sandbox lab returns to them.

Kilo Code is MIT-licensed. Its lineage is worth stating carefully because it has changed: the project was widely described as a fork of Roo Code, which was itself a fork of Cline, but as of 2026-09-09 its own README describes something different — “Kilo CLI is a fork of OpenCode, enhanced to work within the Kilo agentic engineering platform”. Its documentation site moved from kilocode.ai to kilo.ai in the same period. Ollama and a custom OpenAI-compatible provider are both documented.

Continue is Apache-2.0 and remains the cross-editor option, covered in Part 10 for completion and chat. For this part the important field is a capability rather than a provider: its configuration reference lists tool_use as “Enables function/tool calling support (required for Agent mode)”. A local model in Continue without that capability declared gives you chat and edit, not an agent.

GitHub Copilot now documents bring-your-own-key models, and the supported list includes Ollama, LM Studio and “Any OpenAI-compatible HTTP endpoint”. Two caveats travel with it. On Copilot Business or Enterprise plans “the ability to use local BYOK in IDEs can be disabled by an enterprise or organization policy”. And Visual Studio Code’s own documentation states the agent-mode condition bluntly: “For a model to be available when using agents in chat, it must support tool calling. If the model doesn’t support tool calling, it won’t be shown in the model picker.”

Cursor is the negative result. Its API-keys page lists four bring-your-own-key providers — OpenAI, Anthropic, Google and Azure — and no custom base URL, Ollama or OpenAI-compatible option appeared on any page read on 2026-09-09. It also states a limit that applies to the keys it does accept: “Custom API keys only work with chat models. Tab completion continues using Cursor’s built-in models.” This is an absence rather than a published refusal, so record it as “not documented” rather than “impossible”.

Zed is dual-licensed, primarily GPL-3.0-or-later with Apache-2.0 components, and has the cleanest local configuration of any editor here: language_models blocks keyed ollama, llama.cpp and openai_compatible, each with an api_url and an available_models array in which a model declares max_tokens and supports_tools. The sixth lesson quotes the file.

JetBrains AI Assistant states that it “supports a selection of models that can run locally on your machine through Ollama and LM Studio”, configured under Settings, Tools, AI Assistant, Providers and API keys, and that the third-party route needs no JetBrains AI subscription. It also carries a general caveat worth reading before you plan around it: “Not all features may be available when using models from third-party providers.” A feature-by-feature breakdown for local models specifically was not found on 2026-09-09.

Autonomous agents

OpenHands is MIT-licensed and is the one tool in this list built to run unattended for a long time. Its local-model documentation is unusually direct about requirements, including that “OpenHands requires a large context size to work properly” and that “even with a large context window, some local models may struggle with reliable tool use”. It runs its work inside a container it starts itself, which is the right architecture and also the reason it is the tool whose sandbox you must read carefully rather than assume. It is OpenHands 1.16.0 · verified 2026-09-08 here.

Goose belongs in this category as well as the terminal one: with GOOSE_MAX_TURNS defaulting to 1000 it is perfectly capable of running for an hour on its own, which is the seventh lesson’s subject and the reason the sandbox lab exists.

Tools that ended, and what replaced them

Roo Code is gone. Its GitHub repository carries the banner “This repository was archived by the owner on May 15, 2026. It is now read-only”, and its README says “The Roo Code Extension was shut down on May 15th”, pointing readers at a community fork and at Cline, “from where Roo Code originated”. Its old documentation domain redirects, and roocode.com now serves a different product from the same people.

⌚Version note

This course’s research notes recorded the Roo Code shutdown as April 2026. The repository’s own archive banner and README both say 15 May 2026, checked on 2026-09-09, and the repository wins. If you find the April date repeated elsewhere, including in older notes of your own, it is wrong. This is what dated sourcing is for: a claim you can correct is better than a claim you cannot check.

The wider lesson is about churn rather than about one extension. In the eighteen months before this page was written, one major editor agent was archived, one changed its declared lineage, two moved their documentation to new domains and one changed its governing organisation. Anything you build on top of a specific agent inherits that churn. Anything you build on top of the gateway does not, which is the architectural reason Part 9 came before this part rather than after it.

The matrix

Read this as a snapshot dated 2026-09-09, not as a specification. “Documented” means the project’s own documentation describes the route; “not confirmed” means the pages read on that date did not describe it, which is weaker than saying it is impossible.

Tool	Kind	Licence	Local endpoint documented	How
Aider	Terminal	Apache-2.0	Yes	OPENAI_API_BASE, or Ollama with OLLAMA_API_BASE
Codex CLI	Terminal	Apache-2.0	Yes	--oss with oss_provider; model_providers in config.toml
OpenCode	Terminal	MIT	Yes	opencode.json provider with options.baseURL
Goose	Terminal	Apache-2.0	Yes	OPENAI_HOST and OPENAI_BASE_PATH, or OLLAMA_HOST
Claude Code	Terminal	Proprietary	Mechanism exists; vendor declines to support it	ANTHROPIC_BASE_URL against an Anthropic Messages endpoint
Qwen Code	Terminal	Apache-2.0	Yes	OPENAI_BASE_URL with the openai auth type
Crush	Terminal	FSL-1.1-MIT (source-available)	Yes	provider types llamacpp, ollama, lmstudio, omlx, litellm
Gemini CLI	Terminal	Apache-2.0	Not confirmed	No base-URL override found in the docs read
Mistral Vibe	Terminal	Apache-2.0	Not confirmed	Custom domain overrides still require a Mistral key
Cline	Editor	Apache-2.0	Yes	Ollama, LM Studio, or the OpenAI Compatible provider
Kilo Code	Editor and CLI	MIT	Yes	Ollama, or a custom OpenAI-compatible provider
Continue	Editor	Apache-2.0	Yes	apiBase plus the tool_use capability for agent mode
GitHub Copilot	Editor	Proprietary	Yes, with conditions	BYOK: Ollama, LM Studio, any OpenAI-compatible endpoint
Cursor	Editor	Proprietary	Not confirmed	Four cloud providers only; chat models only
Zed	Editor	GPL-3.0-or-later with Apache-2.0 parts	Yes	language_models keys ollama, llama.cpp, openai_compatible
JetBrains AI Assistant	Editor	Proprietary	Yes, partially	Ollama and LM Studio; feature coverage not itemised
OpenHands	Autonomous	MIT	Yes	openai/-prefixed model with a local base URL
Roo Code	Editor	Apache-2.0	Archived 2026-05-15	Shut down; see Cline or the community fork

⛨Security

Two rows in that table are proprietary editors that can be pointed at a local model. Doing so changes where the tokens go and changes nothing else. The extension still has its own account system, its own update channel and its own telemetry, exactly as Part 10 said about editor completion. “The model is local” and “the tool is offline” are separate claims needing separate evidence, and only the first one is what a base-URL setting buys you.

Compare a complete workflow instead of a feature list

Choose a small code change with an independent test and a clearly bounded repository. Compare how each tool obtains context, proposes edits, runs checks, handles failures and presents a diff for review. Keep model, starting commit, task prompt and resource budget fixed wherever the tools permit.

Record compatibility differences explicitly. One client may need a different API shape or parser, and another may add a repository map or hidden system instructions. If these cannot be held constant, the experiment compares complete workflows rather than the client shell alone.

Evaluate the final artefact independently of the agent’s own report. Check that the code solves the task, avoids unrelated changes and can be reproduced from the recorded starting point. Also record approval interruptions and operator intervention. A tool can be productive for interactive work while unsuitable for unattended tasks. The decision should follow your desired workflow and local model’s measured capability, rather than the number of features listed by the project.

Recap

An agent is a loop with a shell in it, and whether it can use your hardware comes down to the wire format it speaks and whether it lets you set a base URL. Most speak OpenAI Chat Completions; Claude Code speaks Anthropic Messages; Codex CLI’s documented wire format is the Responses API. Open source and locally usable are independent properties, and Gemini CLI is the example that proves it. Editor agents mostly support a local endpoint now, with GitHub Copilot’s bring-your-own-key list including any OpenAI-compatible endpoint and Cursor being the notable absence. Tool calling is the capability that separates an agent from a chat window, which is why the next lesson is about models rather than tools. And the whole list churns: check the date on any survey, including this one, before you plan around it.

Check your understanding

Question 1. What single property of a coding agent most determines whether it can be pointed at a server you own?

• Whether it is open source
• The wire format it speaks and whether the base URL can be set
• Whether it runs in a terminal rather than an editor
• The programming language it is written in

Show the answer and why

Answer: The wire format it speaks and whether the base URL can be set

Gemini CLI is Apache-2.0 and documents no base-URL override; GitHub Copilot is proprietary and documents any OpenAI-compatible endpoint. Licence and location predict very little. The wire format plus a settable base URL predicts almost everything.

Question 2. Which of these statements about Claude Code and local models is accurate as of 2026-09-09?

• Anthropic documents and supports routing it to local models
• There is no environment variable for changing the endpoint
• The base-URL mechanism exists, and the documentation states that routing to non-Claude models through a gateway is not supported
• It only works with Amazon Bedrock

Show the answer and why

Answer: The base-URL mechanism exists, and the documentation states that routing to non-Claude models through a gateway is not supported

The "Other LLM gateways" page states that Anthropic "doesn't support routing Claude Code to non-Claude models through any gateway". The variables are documented for gateways in front of Claude models. The fifth lesson works through what that means in practice.

Question 3. A model connects to your agent, answers questions, but never edits a file or runs a test. What is the most likely cause?

• The base URL is wrong
• The model cannot produce tool calls the agent can parse, so the loop degrades to chat
• The agent needs a licence key
• The context window is too large

Show the answer and why

Answer: The model cannot produce tool calls the agent can parse, so the loop degrades to chat

Goose's documentation states it directly: "goose extensively uses tool calling, so models without it can only do chat completion". A wrong base URL produces a connection error, not a polite conversation.

Question 4. Which of these are reasons to record a date beside every row of a tool survey? Select all that apply.

• A widely used editor agent was archived in May 2026
• Documentation domains move, so old links stop resolving
• A project can change how it describes its own lineage
• Licences are chosen at random and change weekly

Show the answer and why

Answer: A widely used editor agent was archived in May 2026, Documentation domains move, so old links stop resolving, A project can change how it describes its own lineage

All three of the first happened to tools in this lesson within a year. Licences do change, but rarely and deliberately; the churn that catches people out is archival, relocation and re-parenting.

Question 5. Crush is licensed FSL-1.1-MIT. What does that mean for a reader deciding whether to build on it?

• It is public domain
• It is the MIT licence with a different name
• It is a source-available licence with an MIT future licence, so the usual open-source permissions do not apply immediately and the terms need reading
• It cannot be used at all

Show the answer and why

Answer: It is a source-available licence with an MIT future licence, so the usual open-source permissions do not apply immediately and the terms need reading

The Functional Source License is source-available with a delayed conversion to MIT. That is a real distinction from the Apache-2.0 and MIT tools in the same table, and it is the kind of thing to establish before rather than after you depend on a tool.

Check my answersClear