Editor Agents: Cline, Kilo Code, Continue and the Proprietary Editors

Part 10 put a model in your editor for completion and chat. This lesson puts an agent there: a thing that reads files you did not open, edits several at once and runs your tests, inside the window you already work in. By the end you will know which editors document a route to your own server, the one capability flag that separates a chat model from an agent model, and which editor is the notable absence.

Every claim here was read on 2026-09-09 and several of them changed within the preceding year.

Completion, chat, agent: three different asks

The distinction Part 10 drew between completion and chat needs a third term now.

Completion fires as you type, wants a fill-in-the-middle model and a latency budget measured in fractions of a second. Chat and edit fire when you ask, want the bigger model, and have a budget measured in seconds. Agent mode fires when you ask and then keeps going: it reads, writes, runs commands, reads the output and decides what to do next. Its budget is minutes, and its requirement is not size but tool calling.

Visual Studio Code’s own documentation states the condition without hedging: “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.” Continue expresses the same thing as a capability you declare: tool_use, “Enables function/tool calling support (required for Agent mode)”. Two different products, one requirement.

✕Common mistake

Declaring a capability the model does not have. Writing tool_use in a Continue model entry tells the extension to offer that model in agent mode. It does not teach the model to emit tool calls. If the model cannot, you get an agent that talks about the edit it would make and never makes it, which is the failure mode from the second lesson wearing a configuration file as a disguise. Measure first with Part 24’s reliability test, then declare.

The open-source extensions

Cline is Apache-2.0. Its documentation covers Ollama and LM Studio directly, and a generic “OpenAI Compatible” provider for everything else, which is the one that reaches the Part 9 gateway. The configuration fields it asks for are API Provider, Base URL, API Key, Model, and a Model Configuration block with Max Output Tokens, Context Window size, Image Support and Computer Use. Its own page is emphatic about the field that matters: “Base URL: Enter the base URL provided by your chosen provider. This is a crucial step.”

The Context Window size field in that block is worth dwelling on, because it is the same trap as everywhere else in this part, exposed as a form field. Set it larger than the engine behind your alias was started with and you get silent truncation; set it correctly and you get a tool that compacts when it should.

Cline’s permission model is two features. Plan and Act separates thinking from doing: “Plan mode is where you and Cline figure out what you’re building and how… cannot modify any files or execute commands”, then “Once you have a plan, switch to Act mode… can now modify files, run commands, and execute your strategy.” And auto-approve is a checklist with entries labelled “Read project files”, “Read all files”, “Edit project files”, “Edit all files”, “Execute safe commands”, “Execute all commands”, “Use the browser”, “Use MCP servers” and “Enable notifications”, plus a top-level setting the documentation calls “YOLO Mode” that auto-approves everything.

⛨Security

Read that auto-approve list again as a threat model rather than a settings screen. “Read all files” and “Edit all files” mean all files this editor’s process can reach, which is your home directory, your keys and every other repository on the machine. The narrow entries — read and edit project files — are the ones to leave on. The all-files entries and the mode named after a slogan belong inside the container from the next lab, or nowhere.

Kilo Code is MIT-licensed and has moved. Its documentation site went from kilocode.ai to kilo.ai during 2026. More surprisingly, its declared lineage changed: the project has long been described as a fork of Roo Code, which forked Cline, but on 2026-09-09 its own README says “Kilo CLI is a fork of OpenCode, enhanced to work within the Kilo agentic engineering platform”. Neither Cline nor Roo Code is mentioned anywhere in the current README. Record that as a dated finding rather than as settled history.

Ollama is documented with the model format ollama/<model_name>, no API key required “since Ollama runs locally”, and a Context Window Size setting whose documentation recommends “at least 32k”. Arbitrary endpoints go through a custom provider dialog taking a Provider ID, a display name, an API type of “OpenAI Compatible”, a Base URL, an optional API key, a model list and optional headers. Its CLI has the familiar dangerous switch, with the documentation’s own warning attached: “--auto disables all permission prompts and lets the agent execute any action without confirmation. Only use it in trusted environments.”

Continue is Apache-2.0 and is the cross-editor option, working in both VS Code and JetBrains. Part 10 configured it for completion and chat; this is the agent side of the same file.

RunnableAll tracks

continue-agent-config.yaml

# Purpose: a Continue configuration for agent work rather than completion - the coder model
#          declared with the tool_use capability that agent mode requires, a small model for
#          the cheap roles, and everything pointed at the Part 9 gateway.
# Platform: all (spark, strix, mac, nvidia)
# Minimum memory: 16 GB for the coder model behind the alias; 8 GB if you drop that entry
# Assumes: saved as ~/.continue/config.yaml, with the gateway from Part 9 running and a
#          virtual key from that project to paste into the three apiKey fields. Part 10's
#          configuration file covers the completion side; this one is about the agent side,
#          and the two can be merged into a single models list.
#
# The apiKey values below are the literal placeholder ${GATEWAY_KEY}. Replace each with the
# virtual key you generated on the gateway. Continue reads this file as written, so a real
# key here is a real key on disk: keep the file out of version control once you have edited
# it, or point apiBase at a server you started without --api-key and leave the field alone.
#
# Keys are from Continue's configuration reference read on 2026-09-09. The roles list there
# is chat, autocomplete, embed, rerank, edit, apply, summarize; capabilities include
# tool_use, documented as "Enables function/tool calling support (required for Agent mode)".

name: local-agent-workstation
version: 0.1.0
schema: v1

models:
  # The agent model. Without tool_use in capabilities, Continue's agent mode will not
  # offer this model, and the symptom is a model that is present in chat and absent in
  # the agent picker. Declaring it does not create the capability: the model must actually
  # emit tool calls, which is what Part 24's reliability test measures.
  - name: Local coder (agent)
    provider: openai
    model: local/coder
    apiBase: http://127.0.0.1:4000/v1
    apiKey: ${GATEWAY_KEY}
    roles:
      - chat
      - edit
      - apply
    capabilities:
      - tool_use

  # The cheap roles. Summarisation and apply-style edits do not need the large model, and
  # keeping them on a smaller alias means the coder model is not swapped out by a
  # background task in the middle of your work.
  - name: Local chat (small)
    provider: openai
    model: local/chat
    apiBase: http://127.0.0.1:4000/v1
    apiKey: ${GATEWAY_KEY}
    roles:
      - summarize

  # Retrieval, from Part 10. Included so that one file describes the whole editor setup.
  - name: Local embeddings
    provider: openai
    model: local/embed
    apiBase: http://127.0.0.1:4000/v1
    apiKey: ${GATEWAY_KEY}
    roles:
      - embed

Download continue-agent-config.yaml59 lines

The documented role values are chat, autocomplete, embed, rerank, edit, apply and summarize, and the documented capabilities include tool_use and image_input. Any OpenAI-compatible server is reached with provider: openai and an apiBase; the documentation notes “If you are using an OpenAI API compatible providers, you can change the apiBase” and names several local backends as examples. There is also a dedicated llama.cpp provider with an apiBase pointing at llama-server directly, which Part 10 used.

The proprietary editors

GitHub Copilot now documents bring-your-own-key models, and the list is more generous than people expect: OpenAI, Azure OpenAI, Microsoft Foundry, Anthropic, Ollama, Foundry Local, LM Studio and “Any OpenAI-compatible HTTP endpoint”. Adding one is a settings flow: open Model providers, add a provider, enter “the display name, base URL, and API key”.

Two conditions travel with it. The first is organisational: “For users on a Copilot Business or Copilot Enterprise plan, the ability to use local BYOK in IDEs can be disabled by an enterprise or organization policy.” If you are on a company plan, the setting may simply not be there, and that is by design. The second is the tool-calling requirement quoted at the top of this lesson, which is what decides whether your local model appears in the agent picker at all.

Visual Studio Code’s own page adds practical detail: the built-in Ollama provider is deprecated in favour of an official extension, custom endpoints are configured with id, name, url, toolCalling, vision, maxInputTokens and maxOutputTokens properties, the command is “Chat: Manage Language Models”, and the API type is chosen from Chat Completions, Responses or Messages — the same three wire formats that ran through the previous two lessons.

Cursor is the negative result of this survey and it is worth stating carefully, because an absence is weaker evidence than a refusal. Its API-keys page lists four bring-your-own-key providers: OpenAI, Anthropic, Google and Azure, the last described as “Models deployed in your Azure OpenAI Service instance.” No custom base URL, no Ollama and no generic OpenAI-compatible option appeared on any Cursor page read on 2026-09-09. The page also limits what the keys it does accept can do: “Custom API keys only work with chat models. Tab completion continues using Cursor’s built-in models.” Treat this as “not documented” and check again before concluding it is impossible.

Zed is dual-licensed, primarily GPL-3.0-or-later with Apache-2.0 components, and has the cleanest local configuration in this lesson.

RunnableAll tracks

zed-local-settings.json

{
  "_readme": [
    "Purpose: Zed's language-model settings for three local routes - Ollama, llama.cpp and",
    "the Part 9 gateway through the openai_compatible provider - with tool support declared",
    "per model so the agent panel will offer them. Platform: all (spark, strix, mac,",
    "nvidia). Minimum memory: 16 GB for the coder entries.",
    "Assumes: merged into your Zed settings.json rather than replacing it. Every key is",
    "from Zed's local-model and API-access documentation read on 2026-09-09.",
    "Delete this _readme key before use; Zed's settings file does not expect it."
  ],
  "language_models": {
    "ollama": {
      "api_url": "http://localhost:11434",
      "auto_discover": false,
      "available_models": [
        {
          "name": "qwen3-coder:30b",
          "display_name": "Qwen3-Coder 30B (Ollama)",
          "max_tokens": 32768,
          "supports_tools": true,
          "supports_images": false
        }
      ]
    },
    "llama.cpp": {
      "api_url": "http://localhost:8080",
      "available_models": [
        {
          "name": "local-agent-model",
          "display_name": "Qwen3-Coder 30B-A3B (llama-server)",
          "max_tokens": 65536,
          "supports_tools": true
        }
      ]
    },
    "openai_compatible": {
      "part-9-gateway": {
        "api_url": "http://127.0.0.1:4000/v1",
        "available_models": [
          {
            "name": "local/coder",
            "display_name": "Coder (gateway alias)",
            "max_tokens": 65536
          },
          {
            "name": "local/chat",
            "display_name": "Chat (gateway alias)",
            "max_tokens": 32768
          }
        ]
      }
    }
  }
}

Download zed-local-settings.json54 lines

Three provider keys matter: ollama, llama.cpp and openai_compatible, the last of which nests named providers underneath it. Each takes an api_url and an available_models array whose entries carry name, display_name, max_tokens and capability flags including supports_tools. For Ollama, Zed can discover models itself, and its documentation says it picks up “the served models with their context length and tool/vision capabilities” automatically.

The default capabilities for an OpenAI-compatible provider are documented and worth knowing, because they are not all what you would guess: “by default, OpenAI-compatible models inherit these capabilities: tools: true, images: false, parallel_tool_calls: false, prompt_cache_key: false, chat_completions: true, interleaved_reasoning: false, max_tokens_parameter: false.” Tools default on; parallel tool calls default off. Zed’s agent-panel documentation adds the caveat that applies to every editor here: “Tool calling needs to be individually supported by each model and model provider.”

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. The third-party provider route is documented as not requiring a JetBrains AI subscription, being billed instead by whatever provider you point it at, which for a local model is nobody. The caveat is general and unspecific: “Not all features may be available when using models from third-party providers.” A feature-by-feature breakdown for local models was not found on 2026-09-09, so if you depend on a particular feature, test it rather than assuming.

What an editor agent actually needs from you

four settings, in the order that they break

1. A base URL fieldIf the editor has none, nothing else matters. This is where Cursor stops.
2. A key fieldYour gateway virtual key, or nothing at all against a server started without --api-key
3. A tool-calling declarationContinue's tool_use capability, VS Code's toolCalling property, Zed's supports_tools. Without it the model is chat-only
4. A context-window numberMust not exceed what the engine behind the alias was started with, or you get silent truncation
5. A permission modelPlan and Act, auto-approve lists, YOLO switches. Set this before the first agent run, not after

Every editor in this lesson exposes the same five things under different names. When a new tool appears, look for these five and you have configured it; if the first is missing, close the tab.

What changed in 2026, and which tools ended

Roo Code was archived. The repository banner reads “This repository was archived by the owner on May 15, 2026. It is now read-only”, and the README says “The Roo Code Extension was shut down on May 15th”, directing readers to a community fork and to “Cline (from where Roo Code originated)”. The old documentation domain redirects and the product domain now serves something else entirely. If a tutorial you are following configures Roo Code, it is at least four months out of date and its other claims deserve the same suspicion.

Kilo Code’s documentation moved and its stated lineage changed, as above.

Continue, Cline and Zed were stable across the same period in the pages read, which is worth noting: churn is not uniform, and the tools with the clearest local-provider documentation happen also to be the ones that moved least.

⌚Version note

Everything in this lesson has a date because everything in this lesson needs one. Before you spend an afternoon on any row of it, open the linked page and check that it still says what is quoted here. That takes two minutes and it is the difference between a configuration that works and an afternoon spent debugging a setting that was renamed.

Completion and agent, together

One practical note to close on, because it is the arrangement most readers will actually want.

An editor with both features wants two models, for the reason Part 10 gave: completion needs a small fill-in-the-middle model with a latency budget of milliseconds, and an agent needs a large tool-calling model with a budget of minutes. Continue expresses this as roles in one file. Zed expresses it as separate provider entries. Cline and Kilo Code do not do completion at all, which is why many people run Continue for completion and Cline for agent work in the same editor.

Point every one of them at the Part 9 gateway rather than at ports. You get one key, one address, one usage log covering editor traffic as well as terminal traffic, and the ability to change the model behind an alias without touching a single editor setting.

Separate editor indexing from agent execution

An editor extension can maintain an index, supply inline completions, answer chat questions and execute tool-driven edits. These may use different providers and different permission settings. Review each configured path rather than assuming the chat provider controls the whole extension.

Start with a small disposable repository and inspect which files are indexed and sent. Exclude generated artefacts, credentials and irrelevant dependency trees according to the extension’s supported configuration. Then test a read-only question before an edit task. Keep the requested files, generated diff and test results in the experiment record.

Evaluate interaction as well as final correctness: stale suggestions, repeated permission prompts and indexing delays can dominate a local workflow. Compare the same task after the index is ready and label initial indexing separately. A larger context allocation may reduce truncation while increasing latency and memory pressure. Select a configuration based on retained correct edits and manageable resource use, with explicit control over indexing, execution and outbound providers.

Recap

Agent mode in an editor needs tool calling, and every product in this lesson says so in its own words: VS Code will not show a model without it, Continue requires a tool_use capability, Zed carries supports_tools per model. Cline, Kilo Code and Continue are open source and document local providers; GitHub Copilot’s bring-your-own-key list includes any OpenAI-compatible endpoint with an enterprise-policy caveat; Zed has the cleanest configuration of the lot; JetBrains supports Ollama and LM Studio without itemising which features survive; Cursor documents four cloud providers and no local route. Every editor exposes the same five settings under different names — base URL, key, tool-calling declaration, context window and permission model — and the context window is still the one that fails silently. Roo Code was archived in May 2026, Kilo Code moved domain and changed its stated lineage, and both are reminders to check the date on any survey including this one.

Check your understanding

Question 1. Your local model appears in the editor's chat picker but not in its agent picker. What is the most likely reason?

• The context window is too small
• The model or its configuration does not declare tool-calling support, which every editor here requires for agent mode
• The base URL is wrong
• The editor needs a paid subscription

Show the answer and why

Answer: The model or its configuration does not declare tool-calling support, which every editor here requires for agent mode

Visual Studio Code states that a model without tool calling "won't be shown in the model picker" for agents; Continue requires the tool_use capability; Zed uses supports_tools. A wrong base URL would break chat as well.

Question 2. What is the difference between declaring tool_use in a Continue model entry and the model actually supporting tool calls?

• There is none; the declaration enables the feature
• The declaration tells the extension to offer the model in agent mode; whether the model emits parseable tool calls is a property of the weights, measured separately
• The declaration downloads a tool-calling adapter
• The declaration only affects the autocomplete role

Show the answer and why

Answer: The declaration tells the extension to offer the model in agent mode; whether the model emits parseable tool calls is a property of the weights, measured separately

Configuration advertises a capability; it cannot create one. Declaring it on a model that cannot emit tool calls produces an agent that discusses edits and never makes them, which is why the reliability test comes before the configuration file.

Question 3. Cline's auto-approve list contains "Edit project files" and "Edit all files". Why does the distinction matter?

• It does not; they are synonyms
• "All files" means everything the editor process can reach, which includes your home directory, your credentials and every other repository on the machine
• "All files" only applies to files currently open
• "Project files" excludes source code

Show the answer and why

Answer: "All files" means everything the editor process can reach, which includes your home directory, your credentials and every other repository on the machine

The scope of "all" is the process's scope, not the project's. That is the whole reason the sandbox lab exists: the only reliable way to make "all files" mean "these files" is to give the process a filesystem that contains nothing else.

Question 4. Which statements about editor agents were true when checked on 2026-09-09? Select all that apply.

• GitHub Copilot documents bring-your-own-key support for any OpenAI-compatible HTTP endpoint
• Copilot Business and Enterprise administrators can disable local BYOK in IDEs by policy
• Cursor documents a custom OpenAI base URL for local servers
• Zed documents ollama, llama.cpp and openai_compatible provider keys

Show the answer and why

Answer: GitHub Copilot documents bring-your-own-key support for any OpenAI-compatible HTTP endpoint, Copilot Business and Enterprise administrators can disable local BYOK in IDEs by policy, Zed documents ollama, llama.cpp and openai_compatible provider keys

Cursor is the exception: its API-keys page lists four cloud providers and no custom base URL, and it limits custom keys to chat models. That is an absence in the documentation rather than a published refusal, which is how this course records it.

Question 5. Why does this lesson recommend pointing every editor at the Part 9 gateway rather than at engine ports?

• Because editors cannot reach ports directly
• Because one address and one key give you a single usage log across editor and terminal traffic, and let you change the model behind an alias without touching any editor setting
• Because the gateway makes models faster
• Because the gateway supplies tool calling

Show the answer and why

Answer: Because one address and one key give you a single usage log across editor and terminal traffic, and let you change the model behind an alias without touching any editor setting

It is the same argument the gateway project made. An alias is an interface; a port number is an implementation detail that you will have to update in six editor settings screens the day you change models.

Check my answersClear