Agentic Coding Overview

The single most-asked question about self-hosted AI in 2026: "can I get a Cursor or Claude Code experience on my own hardware?" The honest answer: yes for some workflows, with the right model, on Tier 2+ hardware (hardware tier guide). For diff-based pair programming with Aider + Qwen2.5-Coder 32B, the local experience is genuinely productive. For fully autonomous "give it a task" agents, local models still trail their closed-frontier counterparts meaningfully.

This page is the survey. Deep dives: Aider, Cline / Roo Code, Continue.dev, OpenHands / SWE-agent, MCP servers, Claude Code companion. For the underlying models see coding models.

The four shapes of agentic coding in 2026

1. Diff-based pair programming (terminal)

★ ★ Aider is the dominant FOSS pick. You describe a change in the terminal; Aider sends a search/replace edit to the model; you review the diff. Repo-aware via a code map; works with Ollama, OpenRouter, Anthropic, OpenAI. Architect mode separates planning (big reasoning model) from editing (faster code model).

2. IDE chat + edit (VS Code / JetBrains)

★ ★ Cline (formerly Claude Dev) and Roo Code (Cline fork). VS Code extensions; iterate with the model in a side panel; the model can read files, edit, run terminal commands. Continue.dev is the more conservative alternative — chat + tab completion, less autonomous, broader model support.

3. Tab completion (the GitHub Copilot shape)

Continue.dev does this with local models. TabbyML is a self-hosted Copilot. Sourcegraph Cody has a self-host tier. Quality is acceptable on Qwen2.5-Coder 7B / 14B for FIM (fill-in-middle) on most languages.

4. Autonomous task agents

OpenHands (formerly OpenDevin), SWE-agent, Plandex — "here's a task, go fix it." Sandbox-based; the agent plans, edits, runs tests, iterates. Works with frontier APIs; noticeably less reliable with local 30B–70B models.

The honest May-2026 ranking for local

• ★ ★ Aider with Qwen2.5-Coder 32B (Tier 2+) — works very well. Diff-based; human-in-the-loop; the diff format is forgiving enough that local models keep up.
• ★ ★ Continue.dev with Qwen2.5-Coder 7B (FIM) and Qwen2.5-Coder 32B (chat) — works well; less autonomous; predictable.
• ★ Cline with Qwen 3 32B or Llama 4 — works for short tasks; struggles with long agentic loops on local models; great with API.
• ★ TabbyML for self-hosted Copilot — focused on FIM; reliable.
• OpenHands / SWE-agent / Plandex with local models — ambitious; works in demos; unreliable enough that human-in-loop with Aider is more productive in practice.

Why local trails closed-frontier on agentic loops

• Reliability over many turns. Closed frontier models drop fewer tool calls, malform less JSON, recover better from errors.
• Speed. A frontier API at 80–100 tok/s makes a 50-step agent loop tolerable; a local 70B at 12 tok/s makes it tedious.
• Long-context retrieval. Local models cap at 32K–64K usable context for most workflows; agentic tasks across a 1M-line monorepo benefit from frontier APIs' 200K+ context.

Why local wins for diff-based pair programming

• Human-in-the-loop forgiveness. You catch the model's mistakes when reviewing each diff. Speed and "perfect tool call reliability" matter less.
• Privacy. Source code stays local. For proprietary / regulated codebases this is the dominant reason.
• No rate limits. Iterate as much as you want.
• Free at the margin. Power costs are real but trivial vs. metered API usage at heavy levels.

Recommended stacks

Free / fully-local (Tier 2+)

• ★ ★ Aider + Ollama + Qwen2.5-Coder 32B-Instruct Q4_K_M.
• Architect mode: DeepSeek-R1-Distill-Llama-70B (architect) + Qwen2.5-Coder 32B (editor).
• IDE FIM: Continue.dev + Qwen2.5-Coder 7B for autocomplete.

Hybrid local / API (best of both)

• ★ ★ Aider with Claude Sonnet 4.7 for hard tasks via OpenRouter or direct API.
• Local Qwen2.5-Coder 32B for routine work, Claude for architecture / hard refactors.
• Route via LiteLLM for budgets and logs.

Pure API (if budget allows)

• Claude Code — paid; the May-2026 gold standard for agentic coding by some margin.
• Cursor — paid IDE; closed source; many love it.
• These remain better than local on the hardest tasks; honest framing.

What MCP changes

The Model Context Protocol (Anthropic, late 2024 → community standard 2025–26) — see ai-selfhost-mcp-servers — gave us a portable tool-server protocol. Aider, Cline, Continue, Claude Code, Cursor all consume MCP. You write a tool server once; it plugs into every client. This is changing how the ecosystem composes — local + remote tools without per-tool integration work.

Hardware reality check

• Tier 0–1 (guide) — tab completion with Qwen2.5-Coder 7B; chat with 7B/14B for short questions; aider on a 7B is rough.
• Tier 2 (RTX 3090 24GB) — the sweet spot. Aider + Qwen2.5-Coder 32B at usable speed.
• Tier 3 (5090 32GB / 2× 3090) — comfortable; can run R1-distill 70B as architect alongside 32B editor.
• Mac Studio M3 Max / Ultra — works but prompt processing on long context is the rough edge.

Common honest pitfalls

• Trying to use a 7B model for agentic editing. It will malform diffs. Use 32B+ for serious edits.
• Setting context too small. Aider / Cline send the repo map plus relevant files; bump num_ctx in your Ollama model.
• Ignoring the OLLAMA_NUM_PARALLEL=1 reality. Default Ollama config serves one request at a time; an agent that fires parallel tool calls will queue.
• Forgetting cost-of-time. Local 12 tok/s on a 70B is fine for typing-pace pair programming; punishing for "10 sequential agent steps."
• Expecting Claude-Code-grade autonomy from a local 30B. It's not there yet. Use diff workflows, not autonomous-agent workflows.

Pick this if…

• One pick for serious local agentic coding: ★ ★ Aider + Qwen2.5-Coder 32B.
• IDE-side agent in VS Code: Cline.
• Tab completion only: Continue.dev or TabbyML.
• Autonomous task agents (with API): OpenHands.
• Honest hybrid: Aider routing to local Qwen for routine work + Claude Sonnet 4.7 for hard tasks via LiteLLM.
• Budget-no-object production: Claude Code.