A coding agent for the models you run

Own your coding agent.

DGC runs a real agentic coding loop against a local model, any OpenAI-compatible endpoint, or your own Claude / Codex / Qwen / Kimi / Copilot subscription — in the terminal and in VS Code. Your models, your machine, your data.

Get started →See the benchmark
$curl -fsSL vibedgc.com/install.sh | bash
94.4%
DGC · Aider polyglot (27B)
61.3%*
SWE-bench Lite · provisional
11
Providers in /connect
5
Subscriptions
100%
Local · on your machine
The CLI.

A real agentic loop, in your terminal.

Reads, edits, runs tests, and self-corrects — permission modes, plans, skills, hooks, and a multi-agent fleet, in one focused terminal UI.
FIG.1 — AGENTIC LOOPSELF-CORRECTING
DGC agentic coding loopA clockwise loop connects read, edit, run and verify, returning to read when verification finds another issue. READread · grep EDITmulti_edit RUNrun tests VERIFYself-correct DGC COREUNTIL VERIFIED
FIG.2 — PERMISSION LADDERYOU SET THE ROPE
planread-only — research & propose
defaultask before every shell command
accept-editsauto-apply edits · gate the shell
autofull autonomy — nothing gated
less autonomy⇧⇥ cycles livemore
dgc — ~/acme-api
Vibe DGC v0.25.0
a coding agent for the models you run
[ New session ] or just start typing
New sessionCtrl+N/new
Switch modeShift+Tab/mode
Commandstype //help
QuitCtrl+Q/quit
❯Ask DGC to build, fix or explain…qwen3.8:27b · default
permission modes/planskillslifecycle hooksmulti-agent fleetrewind/goalMCP
The extension.

The same harness, native to your editor.

Real tool calls, readable diffs, standing goals, permission decisions, and plan feedback — without reducing the agent to a chat bubble.
FIG.3 — EDITOR SURFACEVS CODE · CURSOR · PROTOCOL V4
structured tool cardsinline diffsgoal timerpause + cancelplan reviewMCP + skills
Localhost artifacts.

The part no local-model harness does.

When the agent proposes a plan, DGC renders it as a clean page on one localhost port — the steps, the files it’ll touch, the approach — not raw markdown scrolling past the terminal. Approve in the terminal, or keep planning. Every proposal shares one port behind a dropdown.
127.0.0.1:45000/plan/refactor-authrefactor auth ▾
///   PROPOSED PLAN
Refactor auth into its own package
Move the token + verify helpers into an auth/ package and re-export them, so the app imports from one place.
  1. Create the auth/ package; move token.py and verify.py in.
  2. Re-export both from auth/__init__.py.
  3. Update the 7 imports, then run the suite.
Files it’ll touch
auth/__init__.pynew
token.pymoved
verify.pymoved
7 call-sitesedited
///   PROPOSED PLAN
Add an iat claim to the JWT
Stamp tokens with an issued-at time and cover it with a test — a two-line change.
  1. In sign(), add iat: now() to the payload.
  2. Add a test asserting the claim is present + valid.
  3. Run npm test to confirm both pass.
Files it’ll touch
auth/jwt.ts+2
tests/jwt.test.ts+1
///   PROPOSED PLAN
Cache the /profile route
Add a small in-memory TTL cache so repeat profile reads skip the DB.
  1. Wrap the handler with a 60s TTL cache keyed by user id.
  2. Invalidate on profile update.
  3. Add a test for hit / miss / invalidation.
Files it’ll touch
routes/profile.ts+cache
lib/ttl-cache.tsnew
tests/profile.test.ts+1
Approve in terminalor keep planning3 steps · saved · survives restart
Providers.

Point it at anything that serves a model.

Local inference, direct APIs, or your own first-party subscription — one harness and one /connect surface.
Local · on device
  • Ollamanative chat
  • llama.cppopenai /v1
  • vLLMopenai /v1
  • LM Studiolocal server
Model and data stay on your machine.
API · direct endpoint
  • OpenAIapi key
  • Anthropicapi key
  • OpenRouter100s of models
  • Groq · DeepSeek · moreopenai /v1
Native or OpenAI-compatible transport.
Subscription · official CLI
  • Claude Codepro / max
  • Codexchatgpt
  • Qwen · Kimicoding plan
  • GitHub Copilotgithub plan
Delegated to each vendor’s official CLI.

One /connect switches between all three. Subscriptions are covered below.

Bring your own subscription.

Already pay for Claude, ChatGPT, or Copilot? Run it here.

Pick your vendor in /connect and DGC drives each turn through the official CLI — your login, your plan, your terms, no extra API bill. DGC never handles the vendor’s tokens.
Claude CodePro / Max
Codex · ChatGPTChatGPT
Qwen Codecoding plan
Kimi for Codingcoding plan
GitHub CopilotGitHub
How it works
DGCspawns the vendor’s official binary as a subprocess
↓
Official CLIowns your sign-in · your plan · your terms · no API bill
↓
Your modelClaude · GPT · Qwen · Kimi · Copilot — steered by DGC, effort and all
Benchmark.

Proven on a model you run yourself.

The same Qwen3.8-27B endpoint for every harness, scored by real tests on a deterministic Aider polyglot slice — hardware-independent and reproducible.
FIG.4 — HARNESS EVALUATIONMEASURED · IDENTICAL ENDPOINT · RAW TRACES SAVED
Harness performance · Qwen3.8-27Bpass@2 · 600 s cap · bars 70–100%
01goose95.6%
02DGC this is us94.4%
03pi94.4%
04OpenCode88.9%
05Codex CLI87.8%
On an identical endpoint at a 600 s cap, DGC solves 85 of 90 — second, level with pi and one problem behind goose. It is the only harness here that never ran out of clock, and it reaches that on 25% fewer output tokens than the leader.
Cost of that scoremeasured, same endpoint
0
timeouts · only harness with none
122 s
avg per round · fastest of five
−25%
output tokens vs the leader
local modelQwen3.8-27B
scoringpass@2
suiteAider polyglot · 90
languagespy js java go c++ rs
endpointidentical
raw tracessaved
184 / 300*
SWE-bench Lite · 61.3% · provisional
1 endpoint
same weights · every harness
3 commands
re-run it yourself · raw traces saved
Run it yourself — same 27B, your machine
# the whole harness ships with DGC (DGC + the other agents + toolchains)
git clone https://github.com/OpenPeach-ai/dgc && cd dgc/bench
bash install_harnesses.sh

# score DGC on the deterministic 90-problem subset
python3 run_bench.py --engine dgc --model qwen3.8:27b-bf16 \
    --base-url http://localhost:11434/v1 --limit 15 --rounds 2
* Benchmark noteEvery harness ran the same model build on the same endpoint — identical digest, 600 s cap, 32,768-token window, pass@2 over the same 90 problems. Raw per-problem traces are saved. Aider is absent because it did not complete a valid run in this configuration; SWE-bench Lite remains provisional.
DGC’s bet is that the harness matters more than the model. We parse tool calls straight from the model’s text, so a local model with no function-calling API still runs the full read → edit → run → verify loop. The capability lives in the harness — not the weights.
Mohit KalraFounder & CEO · Vibe DGC
Power tools.

Built for real, long, autonomous work.

Optional power-modes for data-heavy tasks, unattended runs, and closing the loop back to your own model.
Code action · persistent state

A persistent Python REPL

Load a dataset into a variable once, then run functions over it across turns — instead of re-reading data into context. Token-efficient by design.

/code-action on
dataset → python variable · turn 08 → state retained
Autonomous gate · verifiable

Run until it passes

Bind an unattended run to a real check. DGC won’t stop the turn until your command exits 0 — feeding failures back and continuing.

dgc --autonomous-gate "npm run check"
attempt 01 · 3 failures → attempt 03 · exit 0 · gate open
Trace → training · owned

Your usage becomes data

Turn your real DGC sessions into scrubbed, training-ready JSONL — fine-tune your own local model on how you actually work.

dgc export-training --successful-only
secrets → scrubbed · output → training.jsonl
What’s inside.

A complete harness, not a wrapper.

FIG.5 — EXECUTION PIPELINETHE MODEL PROPOSES · DGC OWNS THE REST
DGC execution pipelineA request flows left to right through prompt, permission, tools and sandbox, your model, verification and reviewable output; a failed check loops back to the tools stage until the work is verified. 01PROMPTtask · repo · goal 02PERMISSIONplan · edit · auto 03TOOLS · SANDBOXread · edit · bash · MCP 04YOUR MODELlocal · API · subscription 05VERIFYrun the real tests 06OUTPUTdiffs · tests · traces ON FAILURE → PATCH → RERUN
Not a chat wrapper

The model proposes actions; DGC owns permission evaluation, workspace boundaries, execution, correlation, persistence, and convergence.

Evidence before completion

Diffs and tests stay first-class. Failed checks return to the loop instead of being polished into an unsupported “done.”

Control
Permission modesPlan modeThinking control
how you gate the loop
Execution
SandboxMCP serversArtifactsLifecycle hooks
what the agent may touch
Memory & state
MemoryStanding goalsRewind & checkpoints
what persists across turns
Scale
Multi-agent fleetSkillsSub-agents · task tool
how it runs in parallel