Structured tools
Native-loop intent, target and result stay scannable.
A native agentic loop for local and API models, plus delegated turns through supported coding subscriptions. In your terminal and your editor.
curl -fsSL https://vibedgc.com/install.sh | bashReads, edits, runs the tests and self-corrects. Permission modes, plans, skills, hooks and a multi-agent fleet in one focused TUI.
Drawn from a saved DGC run on go/alphametics: the first round failed its tests and the second passed. The in-session steps, their wording and their pacing are illustrative; the raw run output is not shown.
/mode setsactual contract| Mode | Read files | Edit files | Shell | Use it for |
|---|---|---|---|---|
| plan, read-only · proposes a plan | runs without asking | unavailable | unavailable | Understand a codebase and review the proposal before model-requested edits or shell commands. |
| default, asks before writes and shell | runs without asking | asks first | asks first | Everyday work on a repository you care about. |
| acceptEdits, edits apply · shell still asks | runs without asking | runs without asking | asks first | Long edit sessions where the diff is the review. |
| auto, model tool actions auto-approved | runs without asking | runs without asking | runs without asking | Unattended work in a sandbox or throwaway repo; some integration prompts remain user-gated. |
A small fix. A complete loop.
One checklist, updated as the work moves.
Review the approach before the edits begin.
Bring the exact lines into the conversation.
Project guidance, right where you work.
Pick up the context and the pending work.
On native local/API routes: structured tools, readable diffs, goal-aware turns, permission decisions, and plan feedback. Subscription routes retain DGC's local goal record and presentation while the vendor owns its turn. A finished turn folds its work into one Worked for row, so it reads as your prompt and the answer.
Actual extension surface · deterministic protocol fixture · real disposable-file edit and unittest run · not a live model session · real time, no speed adjustment.
Native-loop intent, target and result stay scannable.
Additions and removals remain first-class.
Local record, timer, progress, pause and cancel at hand.
Approve, revise, or keep researching on local/API routes.
Choose a provider per chat, route helpers to the computers you choose, make pictures and clips with your generators, and use a plugin’s own card in the conversation. Each step keeps DGC’s review controls.
You choose the systems and models. Router is off until you turn it on.
A paid image asks before it runs. Every clip shows its price first.
Pick a preset in the card. A change still uses your usual review flow.
Cards come from the plugin. DGC keeps the connection and permissions.
Use your other model computers for helpers and Pips. See workers, model context and hardware where available.
Explore Router →Bring local or cloud generators. Keep results with the chat and in Library; review paid work first.
Explore image generation →Use a plugin’s own interface in Work, ChatDGC or Pips, and fold it away when you are done.
Explore plugin cards →Bring Router, media generation, plugin cards and usage by system into your app.
Explore the SDK →Keep hosts and a signed-in Claude Code or Codex in one list. Each chat and Pip chooses its own and keeps it after a reload.
Connect your model →Replay what a reply did: each model round with its reported tokens, each tool with its own time. Nothing is guessed.
In your editor →A later message waits above the box to reorder, steer in or remove. Type @ to name a plugin, an Output, a Pip or a file.
The composer →Core proposes Personal Pips for your review. A workflow passes an exact result through two to four Pips, and grants none of them anything new.
Explore Pips →Explorer, researcher and critic are first-class task specialists. In the editor they land as coloured chips — the mark swirls while they work, stills when they finish. Click a chip for that agent’s own page: duration, answer, files. Child greps stay off the parent thread. A background task can outlive the turn; the composer stays free and DGC wakes a new turn when it lands.
Identity marks · live while working · click opens the agent page
Explorer maps. Researcher writes one findings file. Critic reviews it. Worker implements.
Eight identity marks. Same face for the same id. Animate only while the agent is working.
Back, duration, the child’s tools and a FILES card. Composer stays on the parent.
A detached specialist keeps going after the turn ends. The pill stays; DGC starts a new turn when it lands.
Give recurring reviews, focused fixes, test runs and the errands of your day a home of their own. Your Pips keep their own conversations, work with the models you choose, and bring decisions back to you. Review a team proposed by Core, then route results through a reviewed or bounded unattended workflow.
In the CLI, the VS Code extension and the SDK
Documents, slides, spreadsheets, dashboards and pages. Choose an artifact in Work or ChatDGC, edit what DGC makes, and find it again in that surface’s Library. Compare changes, restore an earlier version, or export a file to share.
ON YOUR COMPUTER · SAVED VERSIONS · REAL FILE EXPORTS
This plan is one example of a Page artifact. Plans open privately on this computer; approval stays in DGC.
Move token and verification helpers into one package and update the callers, without changing behavior.
2 files1 file7 importsThe proposed surface stays inside the auth package and its direct callers. No migration or public API change is planned.
movecreateupdateApproval starts the implementation. The proposed definition of done requires every listed check to return a real successful exit code.
npm test -- authnpm run typecheckgit diff --checkOpen, compare, restore or remove an artifact later.
Edit a document beside your chat or build a deck with layouts and speaker notes. Export Word, PowerPoint or PDF when it is ready.
Edit cells and formulas, filter the rows you see and chart a selection. Export Excel or CSV, with the rows you filtered out still kept.
Review each read-only source before it runs. Refresh locally without a model call, or ask a Pip to refresh after its run. Export HTML or PDF.
See who saved each version. Compare text, cells, slides or page files, then restore an earlier version without losing the newer one.
Small Python or TypeScript programs add status lines, panels, slash commands and guards. The same mod works in the terminal, Work, ChatDGC and the SDK. Review what it asks to read or do before you allow it.
52% used48% free
Guard asks before DGC continues. Your usual permission decision still applies.
See what fills the context window in a panel that follows each turn.
Count the steps DGC takes in this session, grouped by tool.
Hold a risky command for review and see why it needs your attention. A mod can stop an action or ask you; it cannot approve one for you.
Ask DGC to help write a mod, inspect its capabilities and try it in a development session. Each mod runs in its own sandbox.
When a status report or comparison needs more than prose, DGC can arrange verified facts into metrics, steps, charts and choices in your editor. The answer is still readable as text, and a choice sends a normal message through your existing permissions.
The tests pass. One review step remains.
Click a choice in step 2 to try this illustration. On the website, no model request or tool action runs.
See progress and test counts beside the familiar tool calls, agent map, Pip fixes and artifacts. DGC keeps their existing controls and motion.
Compare options, scan a table, then choose a follow-up with one click. Widgets and saved artifacts keep their own tabs and Library.
Read an audit or a short plan in your Pip’s own conversation. A choice sends a message; proposals and approvals stay in their usual review flow.
The Python and TypeScript SDKs can read the same bounded cards as data. Render them in your interface and route choices through the regular SDK send path.
Local inference, direct APIs, or a subscription you already pay for. Save several providers, choose a route for each Work session, and set a separate default for new sessions.
Native chat or an OpenAI-compatible local server.
DGC sends model-conversation context to the endpoint you configure. Optional integrations receive directed requests; language servers also receive queried document text.
The vendor’s binary keeps ownership of login and terms.
A model on your own machine is not a model with fewer tools. Install a plugin from Settings or connect a server, and its tools join the same list as the built-ins: one route, one permission prompt, one set of hooks and redaction. And through three of them, Zapier, Composio and n8n, thousands more apps.
Logos belong to their owners.
Every entry names its licence and, separately, what DGC actually verified — often less than “it works”.
GitHub, Notion, Linear, Sentry, Supabase, Stripe. Installed is not connected, and the model is told which.
Composio, Zapier, Arcade, Make, or n8n on your own instance. Several run the request in their own cloud — DGC says so before you connect.
Stdio or remote, the 2026 protocol or the legacy handshake. Bounded frames, consent before any URL opens.
Pick the vendor in /connect. DGC passes each turn to its official CLI using that vendor account route—without configuring a separate DGC API key. Vendor plan, usage, and fee terms still apply.
Pro, Max, ChatGPT, and other supported first-party subscriptions.
Each vendor binary owns authentication, account policy, and its model/tool turn.
DGC maps the mode, retains session history, runs SessionStart/Stop hooks, and presents the vendor’s result.
Ask anything that isn't code. It looks things up and cites every page, researches in depth, reads your files and draws the charts. Your own model answers, and your chats stay on your computer.
Meet ChatIn the DGC extension for VS Code and Cursor
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.
Optional modes for data-heavy tasks, verified unattended native-model runs, and turning your own sessions into scrubbed training data.
Load a dataset once, then operate on variables without repeating it into context.
Command: /code-action onOn local/API routes, failures return to the next turn and completion waits for a real exit code. Delegated vendor turns bypass this gate.
Command: dgc --autonomous-gate "npm run check"Export heuristic-filtered sessions as bounded, credential-scrubbed JSONL; review them before training.
Command: dgc export-training --successful-onlyEach turn DGC runs opens a recovery point—the exact conversation and the pre-edit bytes of every file the edit tools touch, saved before the tool runs. Rewind restores both, survives resume and compaction, and refuses a file-tool edit it cannot snapshot.
Command: /rewindA second surface under the transcript. Open the file explorer, browse and pick files for the next prompt, watch the model’s edits land—the agent never stops streaming above it. And a measured estimate of when the turn will finish, so you can walk away.
I’ll read the implementation and tests, then fix the bounds.
# Clamp example Keep a value within a range. Run the tests: python3 -m unittest -v
/files · a file explorer in the loopThree columns, previews, copy/cut/paste, rename, trash with undo. Enter drops @path into your prompt; files the model changed this turn carry a mark.
A range, not a promise: ~2–4 min left with the task count beside it, from this project’s own history and the turn’s task list. /eta stats reports how often it held.
/notify · walk awayA terminal notification, an editor toast, or your Stop hook when the turn ends. Your choice.
Writes follow the permission mode and stay inside the project; nothing enters the model’s context unless you insert it. No shell, ever.
/diff opens a live view of everything the model has changed—every file with its added and removed line counts, and the diff itself—under the transcript while the turn keeps running. Select the lines you want to talk about and press Enter: they land in your next prompt as a quoted diff, so “why did you change these two lines?” quotes exactly those two lines.
I’ll inspect the bounds and make the smallest fix.
No changes yet
Changes appear here as the agent edits.
def clamp(value, lower, upper): """Keep value within the bounds."""/diff · what changed, liveGit’s own answer, read-only: the working tree against HEAD, staged and untracked files, +12 −3 per file, the whole set summed in the header. Re-read every two seconds while it is open, so edits appear as they land.
Space starts a selection, Enter attaches it as a fenced diff block with the file and line range; a takes the whole hunk. Nothing else about the file enters the model’s context.
Wide terminals show the file list and the diff together; narrow ones swap between them with Tab. J / K step through files without leaving the diff.
It never writes, stages or runs a shell command. Approving or undoing a turn stays with /review and the editor’s Changes view; /diff is for looking and asking while the work is still moving.
On native local and API routes, the model proposes while DGC orchestrates boundaries, execution, persistence, verification, and the evidence you review. Subscription routes delegate the model-and-tool turn to the vendor CLI.
Permission modes, plan review and thinking control.
Sandbox, MCP, artifacts and lifecycle hooks.
Standing goals, sessions, rewind and project memory.
Fleet sessions, isolated sub-agents and reusable skills.
It started with a usage limit, and a machine under my desk doing nothing.