DeV Code docs

DeV Code is a coding agent for your terminal. Start it with devcode in your project folder.

Install

On Linux or macOS:

curl -fsSL https://trydev.work/install | sh

On Windows, in PowerShell:

irm https://trydev.work/install.ps1 | iex

With npm:

npm i -g @devcodeagent/cli

With pnpm:

pnpm add -g @devcodeagent/cli

With bun:

bun add -g @devcodeagent/cli

Every method checks the download against the release's SHA-256 checksums before installing anything. To update, run devcode upgrade, or your package manager's install command again.

Connect a model

Start devcode in a project folder and type /connect. Pick a provider, paste its key, and you're ready. DeV saves the key in its own private store, so you don't need env variables or a .env file.

If a provider's key is already in your shell, /connect offers to use it. It's never picked up silently.

Scripts and CI have nobody to answer that question, so devcode run does read keys from the environment.

Free models

DeV Code costs nothing, and you can run it on free models. The list in /connect puts providers with a free tier first, with the best starting point at the top. Local models on your machine are found automatically.

The default model is auto/free. For each request it tries the free models you've connected, moves to the next when one is busy, and remembers which ones answer well for you. It never uses a paid model unless you choose one.

Each provider sets its own free limits and terms. When every model is rate limited, DeV waits if the limit clears soon and tells you what it's doing. If it can't, it ends with a clear error. Connecting a second provider gives you more room.

Some free tiers allow only a small amount per minute. DeV sends those a smaller request, so they suit short tasks. /connect marks them.

Modes

DeV chooses how to work and shows you in the prompt. Press Shift+Tab to change it yourself.

Mode	What happens
Build	The default. DeV edits files, and asks before anything risky.
Plan	For larger or unclear work. DeV reads the code and writes a plan, and changes nothing until you approve it.
Goal	For "keep going until the tests pass". DeV checks the goal each time it stops, and a separate reviewer confirms it. Control it with `/goal pause`, `/goal resume` and `/goal clear`.
Accept edits	File edits are approved; everything else asks as usual.
Auto	Everything that isn't denied is approved, including leaving the sandbox. Turn it on with `--auto`.

DeV decides from how you word the request, so unusual wording may just start in Build. You can switch at any time, or say "without planning" to skip a plan. Plan approval still asks you in Auto, because it is your decision and not a permission.

Commands

Command	What it does
`/connect`	Add a provider
`/models`	Pin a model instead of `auto/free`
`/goal <objective>`	Keep working until something is true
`/init`	Write a `DEV.md` for this project
`/voice`	Talk instead of typing: hold Space while you speak. Runs on your computer (free, private, offline), or with Groq or OpenAI if you choose cloud
`/memory`	Edit the project's memory
`/rewind`	Go back to an earlier message, files included
`/plugins`	Manage skills, plugins and MCP servers
`# note`	Add a note to the project's memory
`@file`	Mention a file

To run one prompt from a script:

devcode run "explain this repo"

To get the result as JSON:

devcode -p "fix the failing test" --output-format json

Configuration

Settings live in dev.json, either in your project or in ~/.config/dev/. Project memory lives in DEV.md. DeV also reads AGENTS.md.

{
  "sandbox": {
    "network": { "allow": ["npm.mycompany.com"] },
    "filesystem": { "allowWrite": ["~/shared"], "allowRead": ["~/.npmrc"] }
  },
  "hooks": {}
}

Hooks: PreToolUse, PostToolUse, UserPromptSubmit, Stop and SessionStart run as shell commands that get JSON on stdin. Exit code 2 blocks the action.

Security

DeV treats the model as untrusted, because text it reads can try to steer it.

On Linux and macOS, shell commands run in an OS sandbox. They can write only to your project, temp folders and package caches.
They can't read ~/.ssh, ~/.aws, other credential stores or DeV's key store.
Network access goes through an allowlist of package registries and git hosts.
Leaving the sandbox always asks you, unless you turned on Auto.
File edits and web fetches ask by default. Deny rules win in every mode.
Web pages and MCP results reach the model marked as untrusted.
Web search goes to Exa or Parallel, free services that need no key, and only the search words are sent. A page that only shows its content after JavaScript runs is read through Jina Reader, which receives just the page address. Deny websearch or webfetch in your settings to turn either off.

Limits: Windows has no sandbox yet, PowerShell commands are never sandboxed, and local MCP servers run outside the sandbox. Read the full security policy.

Benchmarks

DeV Code passes 27 of 30 benchmark tasks on free models, at no cost, with one run of each task. The tasks use hidden tests, and a do-nothing agent fails all of them. The tasks and results are in the bench folder.

FAQ

Is it really free?

Yes. DeV Code is free and open source, with every feature included. Model providers set their own limits on their free tiers.

Can I use it for commercial work?

Yes. DeV Code is MIT licensed. Check the terms of the model provider you connect, especially for free tiers and sensitive code.

Can I use my own paid model?

Yes. Connect any provider with /connect and pick a model with /models.

Does it send my code anywhere?

Only to the model provider you connect, or nowhere if you use a local model.

Why did a long task stop on a free model?

Some free tiers limit how much you can send per minute. Connect another provider with /connect.