A little presence. A lasting conversation.
Give the work you come back to a home of its own.
A conversation, a model, and a clear job to do.
CLI, extension and SDK · Your computer · Your models
Meet the team
Choose a name. Get to know one Pip at a time.
Start with a conversation
Describe what you need. Review the scope. Your Pip gives the work a place to continue.
Your life, your way
A quieter morning. A thoughtful reply. A plan for the weekend. Tell your Pip what matters, then review what it can do.
Illustrative playback. Nothing is scheduled, sent or changed.
“Find room for a walk, a book, and a slow breakfast.”
A two-hour plan, with room to do nothing.
saturday-plan.md ↗Company, with boundaries
Every created Pip has its own conversation and rolling context. Come back to the work without starting from nothing.
Inherit the main chat’s model or choose a separate one. Context and thinking controls stay close to the conversation.
A reviewer can propose a fix for Patch or a check for Pulse. Scope and permissions need your review before execution.
One job can lead to another
Rook finds a possible issue. Patch prepares an isolated change. Pulse runs the checks you approved. Each handoff stays visible; no unreviewed chain of permissions.
A few useful details
In the CLI with dgc pips, in the Pips view of the VS Code extension, and from the SDK through session.pips in Python and TypeScript.
Linux, macOS, and Windows with DGC inside WSL 2. Chats, reviews, drafts and Personal tasks run on all three. Patch and Pulse commands run under bubblewrap on Linux and in WSL 2, and under Seatbelt on macOS, which DGC tells you is weaker. A live-data Pip’s commands run in a read-only box: bubblewrap on Linux and in WSL 2, and Seatbelt on macOS, which is a little weaker. A Pip’s own computer runs on Linux, in WSL 2, and on Apple-silicon Macs with macOS 26 or later; on a Mac it works in its browser, not yet the whole desktop.
Yes. Pips run on your computer, with no Pips account and no hosted runner. With Keep Pips running on (DGC turns it on the first time a Pip gets a schedule or a routine), they carry on with the editor closed: a systemd user service on Linux, a LaunchAgent on macOS, and on Windows the runner starts when you sign in. Not while the computer is off or asleep.
Source reviews are read-only. Patch prepares changes in an isolated copy after you approve the scope. Review its result before applying anything to your working project. Ask DGC to fix on a report fixes it in a copy and applies the change when it’s done, with Review and Undo.
Only as far as you let it. Each Personal Pip has a level you set on its page. At Ask, every send waits for you. At Approve for me, where new Pips start, an email to someone you named or already wrote to, or an event with no guests, goes by itself; sending to someone new, posting, deleting and ordering still ask. At Full access, sends go by themselves. Always allow lets one exact kind of action through, and each plugin has its own level, from Always ask to Never ask. A payment always asks.
When you ask. “Pay these bills” with photos of them: it finds each bill on its site and fills in everything but the card. Card numbers are like passwords: a Pip never asks for one or types one, and a card number sent in its chat isn’t sent. You type the card on its screen and press Pay; that is your approval.
Yes. Use DGC’s model by default or choose one for each Pip, with its own context window and thinking. A Personal Pip can also think with the Claude Code or Codex you’re signed in to, on your own plan. Model quality and supported context sizes vary.
Pause one Pip, or stop them all at once with dgc pips stop, which also cancels queued and running work. Archive a Pip you no longer need; its history stays for review.
Beyond the project
Personal Pips help with errands, plans and replies. Ask the main chat for one, or meet Core, the first Pip DGC introduces.
Every new Personal Pip gets its own computer: a browser and files in a sandbox, apart from yours. It reads the web freely; what a page would send goes only as far as you let it, and a payment always waits for you.
Every weekday at eight, when a bank alert arrives, fifteen minutes before an event. It suggests a routine; nothing runs until you add it. A routine can also run a read-only troupe over a project.
Connect Gmail or a calendar from its chat, and every plugin you turned on in Settings is its to use. For each plugin you choose what it may do without asking, from Always ask to Never ask; one that can move money always asks.
It keeps short working notes on how the job goes, which you can edit, and DGC writes a daily log of its runs for you. What you tell it about yourself shows as Remembered, with Forget. /learn turns what it just did into a skill you save.
What your Pips can do
All of it runs on your computer, under the rules you set for each Pip.
A Pip whose model can see uses its whole computer: the browser, Files, a Terminal, an image editor, Documents and a PDF viewer. It looks, clicks, types and drags, and you watch its cursor. On a Mac, in its browser.
Save a site’s login once, with its authenticator key if it has one. DGC types it in, the one-time code too, and the Pip never sees it.
You set each Pip’s level. New Pips start at Approve for me: searches, carts and drafts go by themselves; orders, posts and new recipients ask. Payments ask at every level.
Allow an exact action once, or always for the same account, tool or site. Its page lists what it may do without asking, with Stop allowing. A payment never offers it.
When a task needs a site you’re signed in to, it asks. Allow once and it works in a tab of its own, on the card’s sites only, then gives your Chrome back. It asks every time.
A Personal Pip can think with the Claude Code or Codex you’re signed in to, on your own plan. Their own tools stay off: its tools and its rules come from DGC.
Each finished run is a message from the Pip in its chat, made from the run’s report alone, so every number is the report’s. Ask it about it there. All-clear runs fold into one message.
A project reviewer’s finished run shows as a card in the chat it reports to: what it found, the worst of it, and the report a click away. A card never starts a turn.
It starts a helper in your chat’s session without starting a turn, in one fix copy DGC keeps for the project, with the project’s own install. The report card is its live status: Watch, Stop, and any question asked right on the card. A Pip fixes chip sits on the chip line.
When it’s done, the card says what changed and whether the tests ran in the fix copy, with Review and Undo. A file you edited on the same lines meanwhile is held back, and the card says which.
Its job is up to six exact read-only commands you approve: a query, a disk check, a health URL. Only those lines ever run. Its model writes a short summary whose numbers must come from what they print. It posts in its chat, and your Work chat gets a report: all clear, or needs you.
The lines run in a read-only box that reaches only the local addresses they name. An obvious write is refused when you approve the list and again before a run, and changing the list is a reviewed change. It recommends a read-only database account. It runs on Linux, on a Mac (a little weaker there, as its card says) and in WSL 2 on Windows.
Keep Pips running starts the runner when you log in, so a morning routine still runs after a restart. Up to four Pips work at once, with no daily token limit.
Send it photos (iPhone ones too) and documents as in the main chat. Dictate, have a reply read aloud, or talk with voice mode, on models that run on your computer.
It fills in everything but the card, then asks you to type it on its screen and press Pay. A card number never goes in its chat.
On Windows, Pips run in DGC inside WSL 2: Windows starts the runner when you sign in, notifications are Windows’ own, and your signed-in Chrome is the one on Windows.
DGC Pips
Start in the conversation you already have.
Explore the workflowIn the CLI, the VS Code extension and the SDK
