What is DeepAgents Code?

DeepAgents Code (the dcode binary) is LangChain's terminal-first coding agent, shipped as the deepagents-code PyPI package. It's a Textual TUI built around LangChain's deep-agents architecture — planning, subagents, skills, and AGENTS.md — and it's truly model-agnostic: you point it at any provider:model string (OpenRouter, Anthropic, OpenAI, Fireworks, Baseten, or a local model) instead of being locked to one lab.

Can I run DeepAgents Code on a server?

Yes. dcode is terminal-native, so an always-on box is its natural home. jurniti runs DeepAgents Code on a dedicated Firecracker microVM with an in-browser terminal and a persistent home — wire your model once, close your laptop, and the agent keeps your config, skills, and AGENTS.md across every restart.

Which models can I use with DeepAgents Code?

Any of them. dcode takes a provider:model string, so you can run open weights like GLM-5.2, DeepSeek, or Kimi through OpenRouter for cents — no $20/mo frontier subscription required — or point it straight at Anthropic, OpenAI, Fireworks, or a local endpoint. jurniti is bring-your-own-key: the credential lives in your VM, traffic goes straight to the provider, and we never see your tokens or mark up usage.

Why run DeepAgents Code on a microVM?

dcode runs real shell commands its planner decided on — code no human reviewed. On your laptop that has the run of your machine. On jurniti, dcode gets root inside its own Firecracker microVM with its own kernel and a KVM hardware boundary, one tenant per box. A runaway command or a poisoned dependency stays contained to one disposable VM you can reprovision in seconds.

How much does it cost to host DeepAgents Code?

Plans start at $25/mo ($250/year — two months free), and every plan has a 30-day money-back guarantee. dcode runs on Starter (1 vCPU / 2 GiB) for most work. Your model spend is separate and never marked up, because you bring your own key — and with open weights through OpenRouter that bill is often pocket change.

Is this an official LangChain product?

No. jurniti is independent managed hosting for DeepAgents Code. We install the upstream deepagents-code package at first boot — no fork — so you run the real dcode and authenticate with your own provider keys.

DeepAgents Code Hosting on a Real microVM

LangChain shipped DeepAgents Code with one decision that sets it apart: it doesn't pick your model for you. Point dcode at any provider:model string and go — GLM-5.2, DeepSeek, or Kimi through OpenRouter for cents, no $20/mo frontier subscription gating the door. The catch is the same one every terminal agent has: it runs real bash commands its planner decided on, and on your laptop that's your whole machine on the line. Here's the move: run DeepAgents Code on its own always-on Firecracker microVM. Bring whatever model you want, keep a persistent workspace, and let the agent run inside a box it can't escape — booting in about 124ms.

What DeepAgents Code is

DeepAgents Code (the dcode binary, shipped as deepagents-code) is LangChain's terminal-first coding agent, built on their deep-agents architecture. The headline isn't a model — it's the freedom to bring any model:

Truly model-agnostic. A provider:model string is the whole config: dcode --model openrouter:z-ai/glm-5.2. OpenRouter, Anthropic, OpenAI, Fireworks, Baseten, or local.
Open weights, no subscription. Run GLM-5.2, DeepSeek, or Kimi for a few cents a session instead of renting a frontier lab by the month.
Deep-agent planning + subagents + skills, with AGENTS.md and MCP — the cross-vendor conventions Claude Code and Codex use too.
A Textual TUI — terminal-native, no web UI to babysit.

That last part is the tell: dcode is built for a terminal that's always on, not a laptop you close.

Why a real microVM for DeepAgents Code

Here's the truth most "run an agent" guides skip. A coding agent runs bash, and dcode's planner runs whatever it decides — install this, rewrite that, fetch the other thing. On your laptop, that's the whole machine. A shared container shares the host kernel, with 200-plus known weaknesses in the stack — the wrong boundary for an agent acting on its own.

jurniti gives DeepAgents Code its own Firecracker microVM — its own kernel, a KVM hardware boundary, one tenant per box. The same isolation serverless platforms use. Give dcode root inside its own VM and a runaway command, a bad install, or a poisoned dependency all stay contained to that box. Reprovision and you're clean in seconds.

Your model relationship stays yours. jurniti's BYOK is architectural: drop an OPENROUTER_API_KEY (or any provider key) and the credential lives only in your VM. Traffic leaves straight for the provider, and jurniti is never in the path. No proxy, no token markup — so the cents-per-session math on open weights stays cents.

dcode runs on Starter (1 vCPU / 2 GiB) for most work. And it's reversible: a 30-day money-back guarantee, workspace kept 7 days after cancellation.

Run DeepAgents Code in 3 steps

By hand this is a VPS, the LangChain installer, Python plumbing, auth, a tmux setup for durable sessions, and patching for as long as you run it. jurniti runs the box; you keep the agent.

1. Pick a plan and pay

Starter is enough to start. Check out, and the provision chain runs automatically the moment payment confirms.

2. Your microVM boots with dcode ready

A fresh Ubuntu microVM boots with DeepAgents Code pre-installed and on your PATH. You get an in-browser terminal — nothing to SSH into. Wire a model and go:

export OPENROUTER_API_KEY=...
dcode --model openrouter:z-ai/glm-5.2    # open weights, cents per session
# or point it anywhere: dcode --model anthropic:claude-... / openai:gpt-...

3. Put it to work

Hand dcode a task and let it plan, spawn subagents, and run. Your AGENTS.md, skills, and config live on the persistent home, so they survive every restart.

Give DeepAgents Code its own microVM

What people run DeepAgents Code for

Cheap open-weight coding. GLM-5.2 or DeepSeek doing real work for cents, not a monthly seat.
Model bake-offs. Swap provider:model and run the same task across labs — same workspace, same agent.
Pinned environments. Your AGENTS.md, skills, and MCP servers — set up once, always there.
Walk-away runs. Plan it, close the laptop, come back to the result on a box that never sleeps.

Snapshot a configured workspace into a template and fork it for the next project — your model wiring, never your credentials (scrubbed on publish).

jurniti vs a laptop vs a DIY VPS

	jurniti	Your laptop	DIY VPS
Always on	Yes	No — it sleeps	Yes
Isolation for an autonomous agent	Firecracker microVM (KVM)	Your whole machine	Shared kernel
Model key	Yours, never leaves the VM	Yours	Yours
Blast radius of a bad command	One disposable microVM	Your whole machine	Your whole server
Setup	Automatic · 124ms boot	Local install	Manual
Refund	30-day money-back	n/a	None

Pricing

Starter is $25/mo ($250/year, two months free) and runs DeepAgents Code for most work. Pro is $49/mo and Max $99/mo give heavier runs more room or add a custom TLS subdomain. Every plan includes the 30-day money-back guarantee, and your model spend is separate and never marked up — which, on open weights through OpenRouter, is the cheapest serious coding agent you can run.

Running a different agent? See the guides for Claude Code, OpenAI Codex CLI, and OpenCode, or compare plans on the pricing page.