A coding agent for the models you run.

DGC lives in your terminal and drives your model — Ollama, llama.cpp, LM Studio, vLLM, or any OpenAI-compatible cloud. Permission modes, plan mode, thinking levels, memory and skills. Your machine, your model, your data.

$ curl -fsSL https://dagucchicode.com/install.sh | bash
pure python, 3 deps no root needed MIT licensed
dgc — ~/my-project
Providers

One command to connect anything.

dgc setup walks you through provider, key, model and context size. Switch any time inside the session with /connect.

Ollama·local llama.cpp·local LM Studio·local vLLM·local OpenAI·cloud OpenRouter·100s of models Groq·cloud DeepSeek·cloud Together·cloud Mistral·cloud
Permissions

You decide how much rope it gets.

Four permission modes, switched live with /mode — from ask-first to fully unattended.

default

Reads and known-safe commands run free. Writes and other shell commands ask first — allow once, always, or never.

acceptEdits

File edits are auto-approved so flow isn't interrupted; shell commands still ask for a yes.

plan

Read-only. The agent researches your codebase and presents a concrete plan — approve it into any mode, or send it back to revise.

auto

Full-auto. Everything is approved — the agent builds, tests and verifies unattended until the task is done. Deny rules still fire.

Fine-grained rules on top.

Claude Code-style rules, evaluated deny → ask → allow. Compound shell commands are split and matched per subcommand; wrappers like timeout are stripped; read-only commands (ls, git status, …) never prompt.

Rules persist globally in ~/.dgc/config.json or per project in .dgc/permissions.json.

permission rules
# in the REPL
/permissions allow Bash(npm run *)
/permissions allow Edit(src/**)
/permissions ask   Bash(git push *)
/permissions deny  Bash(rm -rf *)
/permissions deny  Read(**/.env)
Features

A real harness, not a chat wrapper.

The machinery the big agents have — pointed at whatever model you choose.

Plan mode

Read-only research → a concrete step-by-step plan → approve into auto, acceptEdits or default. Reject with feedback and it revises.

Thinking modes

/think off|low|medium|high, with think / think hard / ultrathink keywords bumping a single turn. Reasoning streams dimmed.

Memory

DGC.md in your project and ~/.dgc/DGC.md for you load into every session. #a fact quick-adds; /init writes the project guide.

Skills

Drop a SKILL.md into .dgc/skills/<name>/ — the model invokes it when the description matches, or call it directly with /skill.

Runs tiny local models

No native tool-calling on the endpoint? DGC auto-falls back to a text tool-call protocol and parses it, so small quantized models still work.

Context compaction

Long sessions summarize older turns automatically near your model's context limit. /compact forces it, /clear resets.

TOOLS THE AGENT CAN CALL

read_filewrite_fileedit_file bashglobgrep web_fetchtodoskill save_memorypresent_plan
Quickstart

Coding in under a minute.

1

Install

curl -fsSL https://dagucchicode.com/install.sh | bash Self-contained venv, nothing needs root.

2

Connect a model

dgc setup picks a provider and model interactively; dgc doctor verifies the endpoint.

3

Start coding

dgc -p "task" --mode auto dgc opens the agent in your project; the line above runs one-shot, unattended.