Kob AI

An AI coding assistant for VS Code — just enter the URL and API key of a server you already have and start working. A sidebar chat shows what the AI is doing (reading files / searching / editing files / running commands), in the style of Claude Code, and you pick the model from a Copilot-style dropdown below the input box.

Getting started

1. Click the Kob AI icon in the Activity Bar (far-left strip).
2. Click the settings button (the sliders icon, top right) and enter your URL and API key (optional — most local servers don't need one).
3. Click Connect & save — the extension detects the server type automatically and fetches the list of available models. The server is kept in the list.
4. Choose a model from the dropdown below the input box (type to search, ↑↓ + Enter to select), then type your prompt. Picking a model from another server switches the chat to that server in the same step.

Example URLs: http://localhost:11434 · 192.168.1.20:11434 · https://openrouter.ai/api/v1 · http://localhost:1234/v1 A bare hostname works too (http:///https:// and /v1 are added when needed), and you can also paste a full endpoint URL (e.g. …/v1/chat/completions).

Works with servers that expose an Ollama API or an OpenAI-compatible API (e.g. OpenRouter, LM Studio, vLLM, LiteLLM, llama.cpp server, Ollama /v1, and more).

Your API key is stored in VS Code SecretStorage — one key per server, never written to settings.json and never sent back to the webview.

Upgrading: your current URL, key and model list are carried over to the first entry of the server list automatically (0.1.x setups with a single URL are migrated the same way).

Modes

Agent mode needs a model that supports tool calling. The model picker shows a no tools badge for models that don't, and switches to Chat automatically.

What the Agent can do

Revert a reply's changes

Every reply that changed files ends with an N files changed box. Revert (click twice to confirm) puts every file that reply touched back the way it was before it — files it created are deleted. If a file changed again afterwards (by you or a later reply), you are asked first, because those later changes go too. The model is told about the revert with your next message. The "before" versions are saved with the workspace, so Revert keeps working after VS Code restarts (for 30 days; replies that changed more than about 8 MB of text only until the restart).

Long chats are summarized automatically

When the next request would fill 80% of the model's context window (or pass the context budget, see below) and clearing old tool output is not enough, Kob AI asks the model for a summary of the chat so far and the Agent carries on from it — also in the middle of a task. The summary is shown in the chat (Show summary). If the server refuses a request as too long, the same happens once and the step is retried. For servers that do not report a model's window, the summary happens ahead of time only if you set Context window yourself. Turn it off with kobAi.autoCompact.

Fewer tokens per step

Every step of the Agent resends the whole conversation, and tool output (files read, command output, page snapshots) is most of it. So once the Agent has moved on, the output of its older tool calls is replaced with a one-line note naming the call, and the long text it sent in them (file content, old_string/new_string) goes too; the newest 6 stay whole and the Agent reads a file again when it needs it. Output is cleared in batches of about 20k tokens, so servers that cache the start of a prompt (DeepSeek, GLM, OpenAI, Claude through OpenRouter) keep their cache most of the time. On top of that, a request should stay under kobAi.agent.contextBudget tokens (100k by default) whatever the model's window: past it — or past 80% of a smaller window — older output is cleared down to the newest 2, and only then is the chat summarized. Replayed on real chats, this cut the input tokens of long Agent tasks by about half. The usage dashboard's Agent health table counts, per model, what clearing costs (files read again), calls the model wrote wrong, failed edits and summaries, so you can see whether a model copes. It also shows how much of the input the server read from its cache, when it says. Turn clearing off with kobAi.agent.clearOldToolOutput.

Goals: give it a goal and walk away

/goal make npm test pass (or /goal add a dark mode toggle to the settings page) switches to Agent mode and tells the model to keep working, without stopping to ask, until the goal is met, and to check it (build, tests) before calling it done. When the model stops without saying the goal is met, for example because it asked "shall I go on?", Kob AI sends the goal back and it carries on, up to 8 extra rounds and 3× the usual step limit (kobAi.agent.maxSteps). The model lists the assumptions it made in its final message.

You get a VS Code notification when it is done, when it needs something only you can give (a password, a decision that would lose data), or when it gives up. To leave it running unattended, keep the Agent checkboxes in the settings panel ticked. Otherwise it waits for you at each approval, and a notification tells you it is waiting. Stop ends the goal at any time, and Revert undoes everything it changed.

Specs: agree on what to build first

/spec add a login page with Google sign-in switches to Agent mode. The model looks around the project, then writes three files in .kob/specs/<name>/ without touching any code:

• requirements.md: user stories with acceptance criteria ("WHEN … THE SYSTEM SHALL …"), what is out of scope, open questions
• design.md: the files to add or change, data shapes, error handling, how it will be tested
• tasks.md: a checklist of small steps in order

Then it stops. Read the files, edit them if you like, and reply to approve or say what to change. The Agent then works through tasks.md one task at a time and ticks each task as it goes. /spec alone lists the project's specs with how many tasks are done; picking one carries on with its unticked tasks, in a new chat too. Commit .kob/specs so the team can see them.

Explore agents: keep the chat's context small

Turn on Let the Agent send helper agents to explore the code in ⚙ → Agent (kobAi.agent.subagents, off by default because every helper step is one more request — see Fewer requests) to give the Agent the explore tool. For a question that needs many files read, it sends a helper agent that starts with an empty context, reads and searches on its own, and hands back a short report with path:line references. The files the helper read never enter the chat, so the chat's context window fills up much more slowly — which matters most with local models and their smaller windows.

• Read-only: the helper gets only the tools that look (list, find, search, read, symbols and references, Problems, semantic search). It cannot edit files, run commands, browse or use MCP servers, so it never asks for approval.
• Which model: Auto Model's Easy model when one is set that can use tools, so exploring runs on a small, cheap model while your main model decides; otherwise the model of the reply. kobAi.agent.subagentModel = same always uses the model of the reply.
• Several at once: independent questions asked in the same step go out together, up to 4 helpers at a time. (Ollama answers them one by one unless it runs with OLLAMA_NUM_PARALLEL above 1; the panel then shows the others waiting.)
• The team panel: while a reply runs, a panel above the input box shows how many agents are working — the Lead (your model, shown even when it works alone, with its own steps, tokens and time) and each Explorer as a little robot, with what it is looking into, what it is doing right now (Read src/auth/login.ts, Thinking…), its steps, tokens and time. The robots read, think and write in their own way, and cheer with a tick when their report is handed over. Motion is turned off when your system asks for reduced motion.
• Each helper also leaves an Explored card in the chat; click it to read the report. Its tokens count toward the reply, and in the usage dashboard they are listed under the helper's model.
• A helper cannot send helpers of its own. At most 30 steps, then it is asked for its report.

Fewer requests

Every step of the Agent is one request to the model: it answers, the tools it asked for run, their results go back in the next request. Many servers bill per request, so Kob AI keeps them few on its own, with nothing to set:

• The Agent is told to put every call that does not need an earlier one's result into the same step: read all the files it needs at once, edit several files together, then run the check — and not to re-read what is still in view.
• The checklist never costs a request of its own: it goes with the other calls, and is never held back for or sent back to be ticked off.
• The helpers that buy quality with extra requests are off by default: the separate reviewer (kobAi.agent.reviewer, up to 20 requests per reply) and the explore agents (kobAi.agent.subagents). Turn them on if you pay per token and want them.

The project's checks, the security check and the check of claimed test runs still hand real failures back. Approving a call never costs a request — the Agent waits on your machine. The usage dashboard's Model calls tile counts the requests, per turn too.

Type while it works

Press Enter while a reply is running to queue a message. The Agent reads it at its next step; if it finishes first, the message is sent as your next prompt. Stopping the reply puts queued messages back in the input box.

Git: commit messages and reviews

In the Source Control view, the ✨ button writes a commit message for the staged changes (or all changes when nothing is staged) into the message box, in the style of the repository's recent commits. The ☑ button opens a chat tab that reviews your uncommitted changes: bugs, risky changes, missing tests and smaller issues, each with path:line. Both use the model selected in the chat.

Slash commands

Type / in the input box for the command menu (Enter runs the highlighted one, Tab fills it in so you can add text after it).

Your own commands are Markdown files: .kob/commands/<name>.md in the project (commit them to share with the team), ~/.kob/commands/<name>.md for yourself. .claude/commands/*.md files work too, so commands written for Claude Code can be reused. A file may start with front matter (description: …, shown in the menu); in the prompt, $ARGUMENTS is replaced by whatever follows the command (without it, that text is added at the end). Sub-folders become namespaces: git/pr.md is /git:pr.

---
description: Review a file for security problems
---
Review $ARGUMENTS for security problems: injection, secrets in code, unsafe input handling. List each with path:line.

Hooks: checks that run by themselves

Hooks are commands Kob AI runs on its own while the Agent works, so a team's rules hold without anyone asking:

• afterEdit — after the Agent writes a file matching files, e.g. a formatter. {file} is the file (paths with spaces or shell characters are skipped rather than put into a command line; the path is also in the KOB_FILE / KOB_FILE_REL environment variables). The result goes into the edit's tool result, so the model knows the file was reformatted.
• afterTurn — when a reply that changed files is done: lint, typecheck, tests. The result is shown in the chat. With "feedback": true, a failure is handed back to the Agent to fix (at most twice per reply).
• beforeTool — before a tool call matching tools (a tool name or kind as a glob: run_command, {edit_file,write_file}, edit) and files: a team's own guard. Exit code 2 blocks the call, and what the command printed is the reason the Agent gets (the same convention as Claude Code's PreToolUse); any other result lets the call go on (a hook that crashes is reported, not obeyed). The call is in KOB_TOOL, KOB_TOOL_KIND, KOB_TOOL_ARGS (JSON), KOB_FILES (one per line) and KOB_COMMAND.

// .kob/hooks.json — create it with /hooks
{
  "afterEdit": [{ "files": "**/*.{ts,tsx}", "run": "npx prettier --write {file}" }],
  "afterTurn": [{ "run": "npx tsc --noEmit", "feedback": true, "timeout": 120 }],
  "beforeTool": [{ "tools": "run_command", "run": "node .kob/check-command.js" }]
}

Your own hooks, for every project, go in the kobAi.hooks setting (same shape). A project's .kob/hooks.json runs commands the repository chose, so Kob AI asks before running it — and again whenever the file changes. Hooks run in Agent mode only.

Without afterTurn hooks, the project's own typecheck / lint / test scripts run instead (kobAi.agent.autoVerify). They are the repository's code too, so Kob AI first shows what they run (pre-scripts included) and asks once per project — and again whenever those scripts change; never in a folder VS Code does not trust. When the test script is just vitest, vitest run or jest, only the tests that touch the changed files run (vitest related, jest --findRelatedTests) — all of them when a config file, package.json or more than 30 files changed. A TypeScript project without a typecheck script gets its own node_modules/typescript (tsc --noEmit), and only errors in the files the reply changed are handed back — errors that were in other files before are counted, not blamed on the Agent. (VS Code itself checks only TS/JS files open in a tab.)

Guardrails and the security check

Some calls always wait for your click, even with every …without asking box ticked — the card says why, and offers no Allow for this chat or Always allow (kobAi.agent.guardrails, on by default, user settings only):

• Commands that destroy or publish: rm -rf, git push --force, git reset --hard, git clean -f, DROP TABLE, npm publish, terraform apply, kubectl apply, deploys, sudo, curl … | sh, uploading a local file with curl -d @….
• Secrets in code: a write that adds a real-looking API key, token, private key or password in a connection string to any file but a local .env (where it belongs). The card shows only the start of the value.
• Files that run code by themselves or hold keys: CI workflows, git hooks (.husky/…), .vscode/tasks.json / settings.json, .devcontainer/, .npmrc, key files, and an install script (postinstall…) added to package.json.
• Packages: installing one that does not exist on npm / PyPI (a typo, or a name the model made up — attackers register those) is refused; one with fewer than 100 downloads last week asks. After an npm install, npm audit runs and serious vulnerabilities are reported.

When a reply changed code and its checks passed, the lines the Agent added are checked once for common security mistakes — SQL or shell commands built from strings, innerHTML / eval / dangerouslySetInnerHTML, TLS checks turned off, Math.random() for tokens, file paths or redirects taken from the request, pickle / yaml.load — and anything found is handed back to the Agent to fix or confirm (kobAi.agent.securityCheck). It is a pattern check, not a full analyzer.

The …without asking settings themselves are user settings only now, so a repository's .vscode/settings.json cannot turn them on.

Permission rules: what the Agent may never do

Rules for what the Agent may never do (deny), must ask about first (ask), or may do without asking (allow), whatever the auto-approve boxes say. deny beats ask, ask beats allow, and guardrails still ask.

// .kob/permissions.json — create it with /permissions (deny and ask only)
{
  "deny": ["Read(.env*)", "Edit(.env*)", "Edit(src/migrations/**)", "Command(git push --force*)"],
  "ask": ["Command(npm publish)", "Mcp(chrome)"]
}

Your own rules, allow included, go in the kobAi.agent.permissions setting (user settings only). A project's file can only tighten what the Agent may do: its allow rules are ignored, so a repository can never let the Agent skip your approval. A blocked call never runs and the Agent is told which rule stopped it. Read rules cover read_file, not commands — deny Command(cat .env*) too if that matters. Rules hold in Plan mode as well.

Checked work: proof, baseline, reviewer

Four things keep the Agent honest about its own work:

• Claims need proof (kobAi.agent.verifyClaims). When the final answer says a check passed — "all tests pass", "the build is clean", "no type errors", "lint passes", in English or Thai — but nothing in the reply ran that check after its last change (or the last run failed), the answer goes back once: run it and report what it really shows, or say plainly it was not checked. Only commands whose exit code is the check's own count (npm test | tail does not); the project's checks that ran after the reply count too. Hedged or negative sentences ("should pass", "I did not run the tests") are not claims.
• Baseline (kobAi.agent.baseline). Right before the reply's first file edit, the checks that will run after it (your afterTurn hooks, or the project's own once you have allowed them) run once, to see how the project stood. A check that still fails the same way at the end is not handed back — it was failing before — and when there are new failures, only the new lines are pointed out. Lines are compared with their line numbers, counts and timings taken out, so an old error that moved down a few lines is still old. Skipped when nothing changed since the previous reply's checks all passed (git repositories), and for test runs limited to the changed files.
• A separate reviewer (kobAi.agent.reviewer). Once a reply that changed 15 or more lines passed its checks, a helper agent looks at the diff with fresh eyes: it sees only your request and the changes — not the conversation, so it does not share the Agent's assumptions — and may read the code around them (callers, types), but change nothing. Real bugs, security holes or parts of the task not done ([high] / [medium]) go back to the Agent once to fix or answer; style and nits do not. same runs it on the reply's model, easy on Auto Model's Easy one (cheaper), off (the default — it costs a helper run of requests) turns it off. It shows in the team panel like an explore agent.
• /fix <bug>: test-first. The Agent first writes a test that fails because of the bug and runs it, then fixes the code, then shows the test passing. If it changed code without a failing test before the fix, or without a passing run after it, it is sent back once. When a bug truly cannot be shown with a test, it ends with NOT REPRODUCED: <why> and says how it checked instead.

The usage dashboard's Agent health table counts the unproven claims per model; hover a model for how often the reviewer found something and how often an old failure was not handed back.

Memory

Say "remember that we use pnpm" (or state a lasting preference like "always answer in Thai") and the Agent saves it with the remember tool — facts about the project or about you (every project). Every later chat starts with them. /memory opens them to read or edit; they are kept in VS Code's storage for the extension, not in your repository. Saving a memory asks for approval like a file edit does (when Apply file edits without asking is off).

Web search

Run Kob AI: Set Up Web Search (or Set up… under Web search in the settings panel) and enter your own Brave Search or Tavily API key. The Agent then gets a web_search tool for current information (versions, error messages) and reads the best results with web_fetch. The key is kept in VS Code's secret storage. Without a key there is no search, only web_fetch of a URL.

Semantic search: find code by meaning

Pull an embedding model on your Ollama server — ollama pull bge-m3 (understands Thai questions too) or ollama pull nomic-embed-text — and refresh the model list. The Agent then gets a semantic_search tool: "where is the password checked?" or "ส่วนที่คำนวณภาษี" finds verifyCredentials() or computeVat() even though the words differ. It works next to the other search tools, not instead of them:

• Results are ranked by meaning and by words together, so a function name you type still comes first.
• It answers "no confident match" instead of the nearest guess when nothing clearly stands out — the bar rises with the size of the project, as chance matches do.
• The Agent is told results are pointers: it reads the lines before relying on them.

The index is built in the background the first time (progress in the status bar), then only files that changed are indexed again. It stays on your machine, in VS Code's storage for the workspace — not in your repository — and code is only sent to the server the embedding model runs on (with Ollama, your own). Any OpenAI-compatible server with an /embeddings endpoint works as well. Pick the model with kobAi.index.embeddingModel, rebuild with Kob AI: Rebuild Code Index, or switch it off with kobAi.index.enabled. Dependencies, build output, lock files, minified bundles and files over 256 KB are skipped.

AI Voice (talk with the AI, Windows)

Press AI Voice (the headset button next to Send) and just talk: Kob AI listens, answers out loud, types your command and sends it once you say "ยืนยัน". Leave it on and you can work all day without touching the PC — or set kobAi.handsFree.autoStart and it comes on with VS Code.

Your speech is turned into text by the service you pick on the AI Voice card in ⚙ (the first press of AI Voice opens it, and so does Kob AI: Set Up AI Voice):

• Groq (whisper-large-v3) — free, no credit card. Get a key ↗ opens console.groq.com/keys.
• OpenAI (gpt-4o-transcribe) — paid (about $0.006 a minute of speech), often a little more accurate in Thai.
• Gemini (gemini-2.5-flash) — a key from aistudio.google.com/apikey; free tier with daily limits, then paid. Gemini has no speech-to-text endpoint, so the recording goes to the model in a chat message with instructions to write the words down — good with Thai mixed with English terms, usually a little slower than Groq.

Each has its own key box and its own Model menu (e.g. whisper-large-v3-turbo for speed, gemini-2.5-flash-lite for price, or Other model… to type any id; models the service lists show up there after its key is checked). Paste the key and press Check & save — Kob AI asks the service whether the key works before keeping it in VS Code's secret storage (never in settings.json), and switches AI Voice to that service. Keep keys for all of them and switch with one click. Sentences that are not built-in words are understood by a small model at the same service (Groq llama-3.3-70b-versatile, OpenAI gpt-4o-mini, Gemini gemini-2.5-flash-lite). If you already added Groq as a chat server, its key is used and you can leave the box empty. Language, microphone, Mali's face and "turn on when VS Code opens" are on the same card.

• What you say goes to that service; nothing else from the chat does. Silence and very short sounds are not sent at all.
• kobAi.voice.language (default th) tells the service which language you speak. Kob AI also sends a short hint — common coding words and the names at the top of your workspace — so terms like commit, deploy or package.json in Thai speech are more likely to come out in English.
• The microphone is Windows' default recording device (Settings → System → Sound → Input) — unless that is Stereo Mix, which only hears the speakers; then the first real microphone is used. To pick one yourself, put part of its name in kobAi.voice.microphone (e.g. HyperX).

When it comes on it checks the speech-to-text key, the internet and the chat server. All fine: "ระบบเอไอพร้อมทำงานแล้วครับ" and it listens for your first command straight away, no wake words needed. Something wrong: a low tone and it says what, e.g. "คีย์ของบริการถอดเสียงใช้ไม่ได้ครับ". A Thai "เฮ้ มะลิ" the offline English recognizer misses is double-checked by the speech-to-text service (at most 90 short checks an hour).

While it is on, Mali's face sits above the input box: it looks at you while listening, glances up while thinking, dozes when resting, and its lips move with the loudness of the voice as it speaks, with the words in a speech bubble beside it (kobAi.handsFree.face turns it off).

1. Say "เฮ้ มะลิ" → a rising tone and "พร้อมรับคำสั่งครับ".
2. Say what you want, as long as you like, and stop talking. After 3 seconds of quiet (a falling tone) it says "รับทราบครับ", types the command into the input box, reads it back — "คุณสั่งว่า … ยืนยันคำสั่งไหมครับ" — and waits for your answer. Need to think in the middle? End with "เดี๋ยวนะ" or "เอ่อ" and it waits longer.
3. Answer in your own words — a small model works out what you meant:
   • send it ("ยืนยัน", "โอเค", "ส่งเลย", "เอาเลย") — "รับทราบคำสั่งครับ", then it presses Enter for you (while the Agent works, the command is added to the running task). "ส่งเลย แต่บอกมันด้วยว่าอย่าแก้ test" adds the words first.
   • drop it ("ยกเลิก", "ไม่เอาแล้ว", "ช่างมัน") — the box is cleared, "ยกเลิกเรียบร้อยครับ พร้อมรับคำสั่งต่อไป", and it listens for the next command at once, without "เฮ้ มะลิ".
   • say it again ("แก้ใหม่", "พูดผิด"), or add to it ("เพิ่มว่า ให้รันเทสต์ด้วย").
4. When the reply is done: "เสร็จแล้วครับเจ้านาย" (or right away a short summary, with kobAi.handsFree.onDone: summary), and for 8 seconds you can go on talking without the wake words.

While the Agent works, or after it, say (in any words — these are examples):

Approvals by voice. When the Agent asks to run a command or edit a file, you hear "ขอรันคำสั่ง npm test อนุญาตไหมครับ" — answer "อนุญาต" / "ทำไปเลย" or "ไม่อนุญาต" / "อย่า". No answer: it waits on screen and asks again the next time you say "เฮ้ มะลิ". Destructive commands (rm -rf, git push --force, git reset --hard, npm publish, DROP TABLE …) are never allowed by voice: it tells you and waits for a click. Anyone in the room can say "อนุญาต" — keep that in mind.

When it is not sure what you meant it asks back ("หมายถึงให้หยุดงาน ใช่ไหมครับ"); the riskier the action (allow, send, new chat), the surer it must be. Kob AI: Show Voice Command History lists every sentence it heard and how it understood it.

• Nothing leaves your PC while it waits. The wake words are heard by Windows' offline English speech recognizer, which hears a Thai "เฮ้ มะลิ" as "hey mali" / "hey molly" — say it in one breath for the best result. After them your speech goes to the voice input service (the same key), and a sentence that is not one of the built-in words goes, as text only, to a small model at the same service (Groq llama-3.3-70b-versatile, OpenAI gpt-4o-mini, Gemini gemini-2.5-flash-lite) to be understood. Turn that off with kobAi.handsFree.understand: then only the built-in words work. If the service cannot be reached, it tells you so out loud.
• Several VS Code windows: only the window you used last listens; the others stand by (🎧 in the status bar shows which).
• All day: while it is on, Windows does not go to sleep (the screen may still turn off) — kobAi.handsFree.keepAwake. A long task you gave by voice (e.g. a /goal) reports its progress every 10 minutes (progressMinutes). If the chat tab is hidden, it comes forward when a command is typed into it.
• The replies use Windows' own voice for kobAi.voice.language — for Thai that is Microsoft Pattara (a male voice, so the replies end in "ครับ"). While it speaks it does not listen, so it does not hear itself — with headphones, kobAi.handsFree.bargeIn lets you talk over a long answer to stop it.
• Settings (kobAi.handsFree.*): wakeWords (English), wakeConfidence (raise it if it wakes by itself; Kob AI: Show Log shows how sure it was), silenceSeconds, followUpSeconds, confirmWords / cancelWords (your own extra words), endPhrases, replies (everything it says), onDone, progressMinutes, speechRate, sounds, keepAwake, bargeIn, autoStart, understand, intentModel.

Mention files with @

Type @ in the input box (or click the @ button) to pick a file or folder of the workspace. A mentioned file is sent to the model with its contents (with line numbers), a folder with its listing, so the model does not have to look for them. Paths with spaces are written as @"my folder/file.txt".

Commands that never ask

With Run terminal commands without asking off, the approval card offers Always allow npm test: commands starting with that prefix (whole words, so npm test -- --watch=false but not npm testx) then run without asking. The list is in the settings panel (Commands that never ask) and in kobAi.agent.allowedCommands. A command that chains, pipes or redirects (;, &, |, <, >, backticks, $() always asks, whatever it starts with.

Auto Model

Pick Auto at the top of the model menu, and Kob AI chooses the model for each message by how hard the task is. It only ever uses the models you set in ⚙ → Auto Model:

• Models can come from different servers, e.g. Easy on Ollama on your machine and Hard in the cloud. Use suggested fills the empty slots from the models you have: small ones for Easy, big ones for Hard. A model that cannot use tools is flagged for Medium and Hard.
• Chat mode always counts as Easy, with no analyzer call. If the analyzer fails or takes longer than 20 seconds, the task goes to Medium.
• A slot left empty falls back to a cheaper one first (Hard → Medium → Easy; Medium → Easy → Hard). A model that cannot take the images you attached, or whose window is smaller than the chat, is skipped.
• Ask before a task goes to the Hard model (on by default) asks each time. Cancel sends the task to Medium instead.
• The analyzer also says whether a message needs your project at all. A general question (travel, maths, a programming concept that names nothing in your code) is answered without the project's tools — nothing in it is searched, only the web tools stay, and every request is smaller. Never for a goal, files you @-mention or code you have selected; when the analyzer is unsure, the tools stay. A line in the chat says so; if it was about your code after all, say so and ask again.
• The model is chosen once per message and kept for the whole reply. The first row of the steps under the chat says which one and why.
• Auto Model is optional: picking Auto before it is set up opens the card, and until then messages go to the model picked in the menu. Picking one model in the menu turns Auto off.

Browser and other MCP tools

The Agent can use any MCP server — for example chrome-devtools-mcp, which lets it open pages, read them, click, fill in forms and read the console/network log, so it can test what it wrote or click through a console to deploy. Servers are configured in your user settings (kobAi.mcp.servers); they start the first time the Agent runs and stop when VS Code closes. Needs Node.js (npx) on your PATH.

The easy way: ⚙ → MCP servers (or Kob AI: Connect an MCP Server). Every server below has an on/off switch — switch on what the Agent may use, switch it off when you don't need it (a sign-in or token is kept while it is off):

The first time you switch on one with a browser sign-in, the browser opens once; after that the sign-in is reused. Each server shows whether it is connected and how many tools it gives the Agent; Supabase has Options (read-only, one project), LINE OA has Options (your user ID), and Sign out forgets a sign-in or token. Tokens go to VS Code's secret storage, not settings.json.

Chat and shop platforms: what the Agent may do

These act on real customers and real money, so Kob AI fixes what the Agent may do there. The limits cannot be switched off in settings.json. A server counts as one of these platforms by its URL, its command line or its name in kobAi.mcp.servers (e.g. "shopee": { … }), so a server you add yourself gets the same limits.

Read-only means the Agent is offered only tools whose name starts with a look word (get_, list_, search_, find_, read_, fetch_, query_, describe_, count_, check_, lookup_, view_, show_, download_, export_) and has no action word after it (get_or_create_… is out). Kob AI goes by the tool's name, not by what the server says about the tool. Everything else is hidden from the Agent, and a call that gets through anyway is refused. The Output log (View → Output → Kob AI) lists the tools that were held back. On LINE OA a message with any userId other than yours is refused. The Agent tells you to do the rest yourself in the platform's own seller or business center (LINE Official Account Manager, Meta Business Suite, TikTok Shop Seller Center, Shopee Seller Centre, Lazada Seller Center).

Facebook Page: getting a token

Kob AI needs a Page access token with pages_show_list, pages_read_engagement and read_insights. You get it from your own Meta app. The app can stay in Development mode (no review by Meta), because it only reads Pages you manage yourself.

1. At developers.facebook.com → Create app, pick the use case for managing a Page, and finish the steps.
2. Open the Graph API Explorer, pick your app, add the three permissions above and press Generate Access Token. Allow your Page when Facebook asks.
3. That token expires in about an hour. To get one that does not expire, open the Access Token Debugger, paste it, and press Extend Access Token. Back in the Explorer, with the extended token, run me/accounts?fields=name,access_token: the access_token next to your Page is a Page token that does not expire.
4. ⚙ → MCP servers → switch on Facebook Page → paste that token. It goes to VS Code's secret storage, and to the server as FB_PAGE_TOKEN.

If the token stops working (you changed your password, or removed the app), the Agent says so. Paste a new one in the card. Insights use page_media_view, page_post_engagements and page_daily_follows_unique by default, since Meta retired page_impressions and page_fans in November 2025. Ask for other metric names and the Agent passes them on.

Before you add a community server for Instagram, TikTok, Shopee or Lazada: it runs on your machine and holds your shop's keys, so read its code or use one you trust. Kob AI limits what the Agent asks it to do, not what the server itself does with your keys.

Supabase and Neon never delete tables or databases. DROP TABLE / DATABASE / SCHEMA, TRUNCATE, DELETE without WHERE, and deleting or resetting a branch or project are refused by Kob AI before they reach the server — also inside migrations and DO blocks, and with read-only off. The Agent tells you to do it yourself in the Supabase dashboard or the Neon Console. Other servers (e.g. a Postgres one) can opt in with "protectData": true. Railway starts with it on too (it hosts databases): besides the SQL and tool checks, an instruction in words such as "remove the postgres service" or "ลบฐานข้อมูล" is refused; unlike Supabase and Neon you can switch it off in settings.json.

"kobAi.mcp.servers": {
  "chrome": {
    "command": "npx",
    "args": ["-y", "chrome-devtools-mcp@latest", "--browser-url=http://127.0.0.1:9222"],
    "allowTools": ["list_pages", "select_page", "new_page", "navigate_page", "take_snapshot",
                   "click", "fill", "wait_for", "list_console_messages", "list_network_requests"],
    "readOnlyTools": ["take_snapshot"]
  }
}

readOnlyTools lists tools that only look and never change anything, so they don't ask for approval. Servers don't always mark such tools themselves (chrome-devtools-mcp does not for take_snapshot), and without this every look at the page would need a click on Allow.

• Use your own logged-in Chrome: start Chrome with a dedicated profile folder and a debugging port, sign in to the sites you need once, and leave it open: chrome.exe --remote-debugging-port=9222 --user-data-dir="%LOCALAPPDATA%\kob-chrome-profile" (recent Chrome versions refuse the debugging port on the default profile). Leave out --browser-url and the server opens its own empty Chrome instead (nothing is logged in there). Newer Chrome versions can also be attached with --autoConnect instead of --browser-url (you allow remote debugging in chrome://inspect) — see the chrome-devtools-mcp README for the versions it needs.
• Approvals: read-only tools (e.g. taking a page snapshot) always run freely. Anything else (click, fill, navigate…) also runs freely by default (kobAi.agent.autoApproveMcp); untick it to see the exact arguments and wait for Allow each time (or "Allow for this chat", per server).
• Web pages are untrusted input. A page can contain text that tries to steer the model. Kob AI tells the model to ignore instructions found in tool output, but that is not a guarantee: if you don't trust the pages you visit, turn off autoApproveMcp and review each action before you click Allow, and don't combine it with autoApproveCommands.
• Give it a big enough context. A page snapshot is long; use a model with a large window (on Ollama, Auto kobAi.numCtx gives it as much as fits in memory, or set e.g. 32768 yourself). Output over maxOutputChars (default 20000) is cut off.
• Keep the tool list short (allowTools): every tool description is sent with each request, and small models get worse with many tools.
• When the browser is offered: only when your message asks for it (browser, Chrome, screenshot, open the page…), or — for a model marked image — when you ask for a visual change in web work, so it can take one screenshot and check the result. Otherwise Chrome is never started. If Chrome cannot be reached, the Agent finishes without it and says the page was not checked.
• Screenshots are sent to models marked image (only the latest few stay in the chat); other models work from the text snapshot.
• Per-server options: command, args, env, allowTools, readOnlyTools, maxOutputChars, disabled, and secretToken with secretTokenEnv (a program gets the token from the ⚙ card in that env variable, e.g. LINE's CHANNEL_ACCESS_TOKEN). The setting is machine-scoped on purpose, so a repository's .vscode/settings.json can't make the extension run programs.
• Problems starting a server are shown in the chat once and written to Kob AI: Show Log (the server's own stderr is included).

More features

• Keep several servers at once (local Ollama, a remote OpenRouter key…): the settings list shows one row per server with its own URL, key, model list and status. Use switches the chat to it, Edit changes its URL/key, Models expands what it offers (and lets you pick a model of that server), Delete removes it together with its saved key. The model dropdown groups every server's models under its own heading, so you can switch server and model in one click. Each model shows its context window (e.g. 1M) when the server reports it; the list is fetched again each time VS Code starts
• Attach images for models that can see them: click the 🖼 button, paste a screenshot, or drop image files into the input box. Models marked image in the model menu accept them (read from Ollama's capabilities and OpenRouter's model info); large images are scaled down to 2048 px before sending
• A bar under the input box shows how full the model's context window of the chat actually is (it turns amber, then red, as the chat fills it). Hover it to see which window the number comes from
• Automatically attaches the active file / highlighted selection as context (a chip above the input box — click ✕ to leave it out)
• An elapsed-time counter, token counts and a Stop button (or press Esc). While a thinking model reasons, the status line says Thinking…; its reasoning itself is not shown. When the chat is summarized to free up the context window, the summary streams into a Summarizing box in the reply. Fold it while it streams and later ones start folded too; unfold one to bring them back
• Servers & API keys… (the ⚙ item in the model dropdown and at the top of settings) is where the list lives
• Markdown, code blocks with a Copy button, and tables
• Press ↑ in an empty input box to recall your previous message
• Chat tabs come back with their chats after a reload or restart of VS Code; if none was open, opening Kob AI brings up the most recent chat so you can carry on (kobAi.reopenLastChat)
• New chat opens the chat as another editor tab in the same group — it never splits the editor into a second column (Kob AI: Open Chat in Editor Tab does the same); the chat you came from keeps running and stays in History, and old chats are never removed automatically

Commands (Ctrl+Shift+P)

Kob AI: Open Chat · Open Chat in Editor Tab · New Chat · Open Settings (Server URL / API Key) · Refresh Model List · Show Log · Stop Background Processes Started by the Agent · Check for Updates · Generate Commit Message · Review Uncommitted Changes · Set Up Web Search · Rebuild Code Index · Set Up AI Voice · Show Voice Command History

The URL and API key are set only from the ⚙ button (kept in the extension's secret storage, not in settings.json). If something goes wrong, check the log with Kob AI: Show Log.

Settings (kobAi.*)

Known limitations

• The Agent's file tools (read/search/edit) only operate in the first workspace folder and never write to .git.
• The diffs of a reply (not Revert) only open until VS Code restarts; after that the current file opens instead.
• get_diagnostics and the errors after an edit come from the language servers, which mostly check open files. VS Code's TypeScript/JavaScript support only checks files open in an editor tab, so for other TS/JS files the Agent is told to run the typecheck (e.g. npx tsc --noEmit) instead.
• Web search needs your own Brave or Tavily API key; without one the Agent can only web_fetch a URL it already knows.
• run_command is not sandboxed — it runs real commands on your machine (with the workspace as the working directory). Review each command carefully before clicking Allow, and turn off autoApproveCommands if you use a model you don't trust.

For developers

npm install
npm run compile        # build with esbuild -> dist/extension.js
npm run typecheck
npm test               # unit + e2e against a mock server (no VS Code/Ollama needed)
npm run test:vscode    # run inside real VS Code (separate Extension Host profile) — Windows
npm run package        # build the .vsix file
node scripts/harness.js  # open the UI in a browser with a simulated VS Code theme: http://localhost:5599/
npm run eval -- --url http://localhost:11434 --model qwen2.5-coder:7b [--tools both]
                       # how well a real model does real tasks with the Agent's tools (key in KOB_EVAL_KEY if needed)

Press F5 in VS Code (.vscode/launch.json is included) to launch an Extension Development Host.

Install from a .vsix file: code --install-extension versions/kob-ai-0.11.0.vsix (packaged .vsix files live in versions/; the one npm run package just built is in the repo root until moved there).