Abacus Coder

Abacus Coder by Abacus IT BD. Formerly named Abacus AI. Same extension and same settings; only the name changed, to stop it being confused with the unrelated company Abacus.AI).

A free, local-first AI coding agent for VS Code. Chat, edit files, run terminal commands, and get real work done, autonomously. Works entirely offline with a local Ollama model, or with any OpenAI-compatible cloud API you already have a key for (OpenAI, Groq, OpenRouter, DeepSeek, Together, or a self-hosted server). No subscription, no vendor lock-in, no account required.

Why Abacus Coder

• Actually free. No subscription, no usage caps imposed by this extension, no account to create. Use Ollama for zero cost, or bring your own cloud API key and pay only that provider directly.
• Local-first by design. Runs fully offline with Ollama. Optional telemetry is off by default and, even when on, only ever sends anonymous usage counts, never your code, chat content, or API keys.
• A real coding agent, not just a chatbot. Reads and writes files, runs terminal commands (in a visible integrated terminal, so interactive prompts work), searches your codebase, fetches URLs, and reads PDFs/spreadsheets, chained across multiple steps in one turn.
• See exactly what it changes. Every file edit shows a real diff before you approve it, and once applied, the change is highlighted directly in your editor with a one-click Undo, not just in the chat panel.

Features

• Chat with streaming responses, markdown rendering, and syntax-highlighted code blocks
• Attach files — an Attach button under the message box takes images, PDF, Excel, CSV and video. Images go to the model as pictures, documents as extracted text, and a video as sampled still frames (frames only, no audio — it tells you so rather than pretending otherwise)
• Tools: read/write/edit files, apply multi-file diffs in one reviewable step, run terminal commands, search the codebase by text or by meaning (semantic search), run git, read live compiler errors, fetch a URL, drive a real browser, read PDF/Excel/CSV, and a live step-by-step plan for multi-part tasks
• Finishes long jobs on its own instead of stopping every few steps to ask you to type "continue", with a token budget so a big job can't quietly run away
• Readable chat — a turn that touched a dozen files collapses to one "Worked for 12.4s · 7 steps" line you can expand, not a wall of boxes
• Clear approval prompts — "Run a terminal command" with the actual command, not a tool name and a block of JSON. Enter approves, Esc denies
• Ready-made provider list — 48 endpoints grouped into model providers (OpenAI, Claude, Gemini, xAI, DeepSeek, Mistral, Kimi, GLM, Qwen and more), routers and hosted inference (OpenRouter, Together, Fireworks, Groq, DeepInfra, Novita, NVIDIA NIM, SiliconFlow and more) and local servers (Ollama, LM Studio, llama.cpp, vLLM, Jan, LiteLLM). Pick one and the URL fills itself in; Custom is always there for anything else
• Inline autocomplete: gray ghost-text suggestions as you type, Tab to accept (off by default; enable abacusAI.autocomplete.enabled)
• Next-edit suggestions (experimental): after you pause, the model looks at the edits you just made and proposes the one most likely to come next, even when it's somewhere else in the file (the other uses of a renamed variable, a call site after a signature change). On the cursor line it shows as ghost text; elsewhere a gutter arrow marks it: Tab jumps there, Tab again applies it, Esc dismisses. Uses your autocomplete/chat model; off by default (enable abacusAI.nextEdit.enabled, tune abacusAI.nextEdit.debounceMs). Secret-looking files are never tracked; Abacus Coder: Show Next Edit Log shows every request
• Inline help/edit right in the editor: select code and press Ctrl+Shift+I
• MCP support: connect any Model Context Protocol server and its tools join the agent (see below)
• Background tasks: run agent tasks detached while you keep coding. In a git repo each task works in its own isolated git worktree (branch abacus/task-<id>), so parallel tasks never touch your files; when it finishes you review the multi-file diff and apply it (git apply --3way), discard it, or keep the branch. Outside a repo (or with abacusAI.backgroundTasks.isolation: none) edits are checkpointed so Restore Checkpoint undoes the run. Up to abacusAI.backgroundTasks.maxConcurrent (3) run at once, the rest queue; interrupted tasks and leftover worktrees are reported after a reload
• Slash commands (/review, /explain, /tests, /fix, /refactor, /commit, plus your own, plus every skill as /<skill-name>)
• Rules, memory & skills in the same formats Claude Code, Codex, Cursor and Copilot use: AGENTS.md / CLAUDE.md / .cursorrules / Copilot instructions, path-scoped rule folders (.cursor/rules, .claude/rules, .github/instructions), nested AGENTS.md in monorepo packages, persistent agent memory, and Agent Skills (SKILL.md) — see below
• Command approval rules: allowlist safe commands, always-ask for destructive ones
• Real-time in-editor diff highlighting + Undo for every AI-made edit
• Local Ollama (auto-detected) or any OpenAI-compatible cloud endpoint, with saved provider profiles for quick switching
• API keys remembered per provider, so switching back and forth never loses one — and an optional (off by default) setting to sync them across your computers
• Guided setup wizard with live model lists and tool-calling capability detection
• Multiple persistent chat sessions with history; Open Chat in Tab starts a second, independent conversation (its own history, queue and Stop) beside the sidebar
• Agent / Plan / Ask modes next to the send button (Shift+Tab cycles): Plan investigates read-only and shows a plan card to Approve / Revise / Reject; Ask is read-only Q&A
• Steer while it works — messages typed during a turn are queued and handed to the agent at its next step (or start the next turn); Stop clears the queue
• Edit & rewind / Fork on any of your messages: rewind restores the files changed since then and puts the message back in the input; fork opens the conversation up to that turn in a new tab
• Questions, plans and subagents in the chat: the agent can ask you a multiple-choice question, and task subagents show live progress in a collapsible card
• /compact summarises older turns into one message, with a context meter in the status row that warns at 80% of the model's context length
• Usage analytics with per-model token costs, including the discounted rate for cached tokens
• Opt-in, anonymous-only telemetry (off by default)

Connect MCP servers

MCP (Model Context Protocol) lets you plug external tools into the agent: GitHub, databases, filesystems, anything with an MCP server. Three ways to connect one:

1. Guided: Command Palette → Abacus Coder: MCP Servers → Create workspace .abacus/mcp.json. A template opens with a working example; edit it and send any chat message. Servers start on the next turn. The same command shows each server's status and restarts them.
2. Personal (all projects): add servers to the abacusAI.mcp.servers setting:

   "abacusAI.mcp.servers": {
     "github": {
       "command": "npx",
       "args": ["-y", "@modelcontextprotocol/server-github"],
       "env": { "GITHUB_TOKEN": "..." }
     }
   }
   

3. Team-shared: commit .abacus/mcp.json to your repo (the same mcpServers format Claude Desktop uses, so you can paste a server's README config nearly as-is).

Already set up for another tool? Abacus Coder also reads .mcp.json (Claude Code), .vscode/mcp.json (VS Code / Copilot, root key servers) and .cursor/mcp.json (Cursor). When the same server name appears in several places, the winner is .abacus/mcp.json > .mcp.json > .vscode/mcp.json > .cursor/mcp.json > your user setting. Editing any of these files takes effect on the next chat message. Strings may use ${workspaceFolder}, ${env:NAME} (or ${NAME} / ${NAME:-default}), so secrets can stay in your environment instead of the file.

Remote servers and sign-in

Hosted MCP servers are configured with a url instead of a command:

{
  "mcpServers": {
    "linear": { "url": "https://mcp.linear.app/mcp" },
    "internal": {
      "url": "https://mcp.example.com/mcp",
      "headers": { "Authorization": "Bearer ${env:INTERNAL_MCP_TOKEN}" }
    },
    "legacy": { "type": "sse", "url": "https://old.example.com/sse" }
  }
}

Both the current Streamable HTTP transport and the older HTTP+SSE transport are supported; leave type out and Abacus Coder detects which one the server speaks ("type": "http" or "sse" forces one). If a server requires OAuth sign-in, you get a notification "MCP server X needs sign-in" — click Sign in, approve in your browser, and the server starts. Nothing opens in your browser unless you click. Tokens are kept in VS Code's secret storage and refreshed automatically; sign in or out any time from Abacus Coder: MCP Servers. Most servers register Abacus Coder automatically; if yours needs a pre-registered OAuth app, add "oauth": { "clientId": "...", "scopes": ["..."] } (plus "callbackPort": 33418 if the app requires a fixed redirect URI http://127.0.0.1:<port>/callback). A server with its own Authorization header, or "oauth": false, never prompts.

Connected tools appear to the agent as mcp_<server>_<tool> (very long names are shortened) and always ask your approval before running. Servers that publish resources also get one mcp_<server>__read_resource tool. You can also just ask Abacus Coder in the chat: "how do I connect an MCP server?"

Rules, memory & skills

Your existing setup for other agents works here unchanged.

• Rules are merged into the agent's instructions from every workspace folder: AGENTS.md, .abacusrules, CLAUDE.md, .cursorrules, .github/copilot-instructions.md, plus your personal ~/.abacus/AGENTS.md. Rule folders with frontmatter are read too: .abacus/rules/*.md, .cursor/rules/*.mdc, .claude/rules/*.md, .github/instructions/*.instructions.md. A rule with alwaysApply: true (or no globs) is always on; one with globs: / applyTo: / paths: (e.g. src/**/*.tsx) applies once the agent works on a matching file. A nested AGENTS.md or CLAUDE.md (e.g. packages/web/AGENTS.md) applies when the agent touches files under it. Rules are capped at about 24KB, with a note to the agent when something was left out.
• Memory: the agent saves short, durable facts with its memory tool (your preferences, project facts that aren't in the code) and sees them at the start of every chat. Ask it to "remember …" or "forget …". It is stored in the extension's private storage, never in your repo, and it refuses anything that looks like a secret. Review, edit or clear it with Abacus Coder: Memory; turn it off with abacusAI.memory.enabled.
• Skills: folders with a SKILL.md (name + description frontmatter, then instructions) under .abacus/skills/, .claude/skills/, .agents/skills/, .github/skills/, .cursor/skills/, or ~/.abacus/skills/, ~/.claude/skills/, ~/.agents/skills/. The agent sees each skill's name and description and loads the full instructions when a request matches; you can run one directly as /<skill-name> ($ARGUMENTS in the skill is replaced with what you type after it). disable-model-invocation: true makes a skill user-only. List them with Abacus Coder: Skills; turn them off with abacusAI.skills.enabled.

Install

1. Open the Extensions view in VS Code (Ctrl+Shift+X).
2. Search for Abacus Coder and click Install.
3. Click the Abacus Coder icon in the activity bar to open the chat.

Set up a model

• Local (free, private): install Ollama, pull a model (e.g. ollama pull llama3.2), then run Abacus Coder: Provider & Model from the Command Palette. Abacus Coder auto-detects whether Ollama is running and shows it in the chat header.
• Cloud (your own API key): run Abacus Coder: Provider & Model, choose Cloud, and paste in a base URL + API key. Works with OpenAI, Groq, OpenRouter, DeepSeek, Together, or any self-hosted OpenAI-compatible server. Your key is stored in VS Code's encrypted SecretStorage, never in plain settings.

Privacy

Abacus Coder is local-first: it never sends your chat content, file contents, or API keys anywhere. Optional telemetry (off by default, toggle in Settings) sends only the extension version, which provider/model you use, and anonymous per-tool usage counts, enough to guide development, nothing that identifies you or your code.

Feedback & bugs

Found a bug or have a feature request? Open ai.abacusitbd.com and use the feedback form.

License & author

Abacus Coder is free to use but not open source. See the LICENSE file (included with this extension) for the full terms, and NOTICE for third-party attributions.

Developed by Abacus IT BD, founded by Riad Ahmed.

• LinkedIn: linkedin.com/company/abacus-it-bd
• Web: abacusitbd.com

Also reachable from inside VS Code via the Abacus Coder: About command.