>_Local-first · All major models

Let major AI models truly run in your codebase

LetCode is an AI coding agent: it understands your project, edits code, runs commands, and passes tests — turning "fix this bug" into a replayable, resumable, reusable workflow. Built on a deeply re-engineered agent kernel, with models, tools and capabilities composed entirely through plugins.

Local-First · Private by default Multi-Model · Claude / GPT / Gemini / DeepSeek / Qwen Cross-Platform · macOS / Windows / Linux
LetCode — letcode-site
1dsh fix the token-expiry bug on the login page
2● read src/auth/session.ts (142 lines)
3● located refreshToken logic — issue is in expiry check
4✓ edit src/auth/session.ts +12 -4
5● run test suite: auth/session.test.ts
6✓ 5 passed · 0 failed (2.4s)
7✓ change applied, session trajectory saved
8─ task done · 14 tool calls total
4+
Run modes: Standard / Code / Minimal / Creator
100%
Session trajectories replayable, resumable, forkable
0
core changes needed — every capability is a plugin
1s
double-click to launch the Mac app and start
CAPABILITIES

A complete coding agent, not a chat box

LetCode runs as an independent agent process: it reads files, runs commands and calls tools on its own — every step is auditable.

Full Agent Loop

Read files, edit code, run commands, search and call tools — one closed loop from start to finish. No need to babysit it step by step.

loop · tools · files

Everything is a plugin

Models, tools, sandbox, sessions, storage and UI — all swappable and composable. A plugin-based kernel means you can extend anything without touching core source.

plugin · composable

Full trajectory replay

System prompts, reasoning, tool calls and results are all written to an append-only session log. Resume, fork, search and replay — all supported.

trajectory · resume

Sandbox with tiered permissions

Read, write and command execution are approved tier by tier; critical actions always ask you first. Persistent permission whitelists balance safety and speed.

sandbox · permission

All major models supported

Claude, GPT, Gemini, DeepSeek, Qwen, Kimi and GLM all integrated — local models too. Hard reasoning and routine edits are auto-routed to the best model per task.

multi-model · router

Parallel sub-agent collaboration

Large tasks are decomposed automatically and multiple sub-agents work in parallel: one edits code, one runs tests, one researches — then results are consolidated.

subagent · workflow

Memory and context

Full-text search across session history; @file / @symbol inject context anytime. Resume, fork and replay — pick up where you left off.

memory · context

MCP and skills

Skills teach the model workflows, MCP plugs in the external tool ecosystem, /commands define custom shortcuts. Capabilities are plug-and-play.

mcp · skills · commands

Developer-extensible

One plugin = one new capability. The SDK exposes every extension point — models, tools, UI — so deep customization is never a black box.

sdk · plugin
MISSION

Our mission: never locked in by any vendor

An AI coding agent should be local and composable — owned by developers, not by any single vendor.

Composable first

Swappable models, tools and sandbox. The agent is never locked into one vendor's cloud.

Local first

Runs fully local by default — your code never leaves your machine. You decide which model and what context to send.

Composable

Everything is a plugin: swap models, tools, UI or sandbox without touching the core. Your workflow, your rules.

SECURITY

Security and privacy, designed in

Not a patch bolted on later — tiered permissions and isolation are built into the kernel.

Runs locally

Sessions and logs are stored locally in ~/.dsh/sessions by default — no forced cloud sync.

Tiered permissions

File reads, writes and command execution are approved tier by tier; critical actions ask you first, and whitelists persist.

Sandbox isolation

Commands and scripts run in a controlled environment; out-of-bounds actions are blocked before they can touch your system.

Auditable trajectory

Append-only session logs capture every step — prompts, reasoning, tool calls, results — inspectable anytime.

LIVE DEMO

From one sentence to shipped code

Three real scenarios showing how LetCode completes the full "understand → edit → verify" loop on its own. Click to switch.

Scenario: fix the token-expiry bug on the login page. LetCode reads files, locates logic, edits code and runs tests — 14 tool calls in total, fully replayable.
LetCode — workflow demo
ARCHITECTURE

Deeply re-engineered, fully composable

A purpose-built agent core with deep engineering: the core keeps only the Agent Loop; everything else is composed from plugins — swap models, tools or sandbox without touching the core.

01
Access layerHow you use LetCode
macOS AppWeb WorkbenchCLI / Headless
▼
02
Product capability layerThe differentiated dev experience
Diff previewPermission approvalsGit / TestSession management
▼
03
Agent RuntimeThe re-engineered agent core
Agent LoopSessionSandboxPlugin KernelSubagent
▼
04
Tool plugin layerCapabilities come from plugin combinations
fsbashgrepwebMCPSkills
▼
05
Model layerMainstream coding models routed per task
ClaudeGPTGeminiDeepSeekQwenKimiGLMLocal models
MODES

Four run modes, pick per scenario

One kernel, different ways to work: from a full-featured workbench to a minimal baseline — choose per task.

Standard

Full toolset: file editing, shell, search, skills, sub-agents and workflows. The default for daily development.

Code

Inherits everything from Standard; the model can orchestrate multi-step tool calls directly in TypeScript for complex pipelines in one pass.

Minimal

Keeps only the persistent shell and file editor, for model benchmarking and minimal-environment verification with reproducible results.

Creator

Runtime checks + a plugin test bench: craft your own presets and package them into new modes to share with your team.

QUICK START

Get your first AI coding agent running in 3 minutes

No environment variables, no builds. Install Node.js, run one command and you're off.

Install Node.js 18+

The only runtime dependency. Grab the LTS build from nodejs.org or install via Homebrew.

$ brew install node

Start with one command

npx pulls the agent kernel, boots the Web workbench and opens your browser.

$ npx @deepseek-ai/dsh web

Configure a model API key

In Settings, paste an API key for any supported model (Claude / GPT / DeepSeek / Qwen etc.), pick a working directory, and just talk.

$ echo 'ANTHROPIC_API_KEY=sk-ant-…' > ~/.dsh/.env
Read the full user manual →
CHEAT SHEET

Common operations at a glance

Conversational input is the default; slash commands and reference symbols are your speed boosters.

npx @deepseek-ai/dsh webStart the Web workbench — opens in your browser
dsh --profile headless "task description"One-shot task mode, exits when done — great for CI & automation
@file src/app.tsReference a project file in chat for precise context
@symbol fetchUserReference a code symbol — jump to definitions & call sites
/skillsLoad skill packs that teach the model your workflows
/mcpConnect external tools: databases, browsers, internal systems, SaaS
/agentsOrchestrate parallel sub-agent tasks — big jobs decompose automatically
/shareShare a session with your team for seamless handoff
COMPARISON

How we differ from Cursor and Codex CLI

Also a coding agent — but LetCode stands on the side of composability: swappable models, extensible kernel, auditable trajectories.

LetCode

Composable · multi-model

Deeply re-engineered, plugin-composed core
  • Runs locally; no code sent to third parties
  • Everything is a plugin: models / tools / sandbox / UI all swappable
  • All major models: Claude / GPT / Gemini / DeepSeek / Qwen / local models
  • Full trajectory replay: every tool call auditable, resumable, forkable
  • Terminal + Web + desktop, zero subscription cost
Form: CLI / Web / macOS App · Price: free tier + subscription

Cursor

Commercial IDE
  • Code indexing runs through its own service
  • Extensions limited by product boundaries; kernel not replaceable
  • Mature IDE experience: smooth Diff, @mention, multi-model switching
  • Subscription, priced per seat
Form: standalone IDE · Price: subscription

Codex CLI

OpenAI's official terminal agent
  • Clean terminal-first CLI experience
  • Locked to OpenAI models; no free integration of others
  • Extension is command-centric; a thin plugin system
  • Good for CI and one-shot tasks
Form: CLI · Price: pay per model usage
PRICING

Pricing, plain and simple: buy what you need, scale as you go

Core local capabilities are free. Need hosted sessions and more task quota? Four tiers scale with usage — pay for what you use. Bring-your-own-key users pay model vendors directly; we never take a cut.

Free · forever free

Every core capability is free to use: four run modes, bring-your-own-key for major models, local execution, full trajectory replay. Want hosting and more quota? Check the four tiers below.

Download Free
Starter
Starter
$29 / mo
1× base quota · ~40-60 tasks/mo

Daily development for individuals — about 40-60 full tasks, ideal for getting started with heavy use.

  • Cloud session hosting, sync across devices
  • Base task quota (1×)
  • All major models (Claude / GPT / Gemini / DeepSeek / Qwen)
  • Parallel sub-agent tasks
  • Community support (GitHub Discussions)
Most popular
Plus
$49 / mo
3× advanced quota · ~120-180 tasks/mo

Power users and small teams starting out — three times Starter's quota, with early access to new models.

  • Everything in Starter
  • Quota scaled up to 3×
  • New models adapted first
  • Higher sub-agent parallelism
  • Priority email support
Team
Pro
$99 / mo
7× team quota · ~300-400 tasks/mo

The workhorse for small teams (≤5 seats): shared context, collaboration and audit out of the box.

  • Everything in Plus
  • Team task quota (7×)
  • Shared sessions & context (≤5 seats)
  • Unified admin console & member permissions
  • Audit logs & compliance trail
Flagship
Max
$139 / mo
15× shared team pool · ~600+ tasks/mo

Growing teams (≤10 seats): a shared quota pool with transparent, controllable usage.

  • Everything in Pro
  • Shared team quota pool (15×)
  • Custom model routing & usage reports
  • Priority access to new models
  • Dedicated support channel

Enterprise · private deployment

On-prem deployment, SSO integration, SLA guarantees and a dedicated customer success team. Built for mid-to-large teams with strict data boundaries.

Bring your own key
Free users pay whoever they get the key from — no cut, no resale
No hidden fees
Upgrade, downgrade or cancel anytime; step back to local mode whenever
Your data, yours
Even if you cancel, your local data and trajectories are fully yours
USE CASES

One agent, three ways to use it

Whether you're building a personal project, iterating with a team or automating pipelines, LetCode has a place for you.

Individual developers

Hand the repetitive work to the agent: fix bugs, add tests, write docs, refactor legacy code.

  • Locate and fix issues from a single sentence
  • Full trajectory replay — fork and restart anytime
  • Runs locally; code never leaves your machine

Team collaboration

Sessions are saved per project with shared context; sub-agents work in parallel so review and development advance together.

  • Parallel sub-agents: code / tests / research
  • Tiered approvals with audit trails on critical actions
  • Exportable, reviewable, handoff-ready sessions

CI and automation

Headless mode runs and exits, plugging into pipelines: auto-fix tests, auto-open PRs, auto-write changelogs.

  • One-shot task mode with parseable output
  • Integrates with GitHub Actions / scheduled tasks
  • Sandbox isolation with controllable permissions
FAQ

Frequently asked questions

Quick answers on models, privacy and environment.

Cursor and Copilot are IDE / in-editor assistants. LetCode is an independent agent process built on a deeply re-engineered kernel: the core keeps only the Agent Loop while models, tools and sandbox are fully plugin-based. Swap models, extend tools, even replace the whole runtime — and your code stays on your own machine by default.
All mainstream coding models are integrated: Claude (Anthropic), GPT (OpenAI), Gemini (Google), DeepSeek, Qwen, Kimi, GLM and more — plus local models (Ollama / LM Studio). Set one global default or route per task, so complex reasoning and routine edits each use the best-suited model.
LetCode runs fully local by default: code stays on your machine and session logs live only in local ~/.dsh/sessions. Only when you explicitly connect a remote model API is the relevant context sent to that model provider — the standard mechanism for all cloud models.
The only hard requirement is Node.js 18+. It runs on macOS, Windows and Linux. macOS users also get a double-click desktop app that handles environment checks, key setup and browser launch automatically.
Powered by the plugin-based kernel: Skills teach the model workflows, MCP connects external tools, /commands define custom shortcuts, and Subagent & Workflow split tasks in parallel. One new capability = one plugin — no core changes.
Yes. Deploy LetCode on your own servers or a team intranet — no seat fees, no hidden charges, and your data and trajectories are fully yours.
DESKTOP APP

One workbench for the entire dev loop

Sessions, agent activity, files, Git changes, terminal, plans — all in one window, no more context-switching between tools.

From conversation to patch, fully visible

The desktop app puts chat, execution and review in one interface: watch the agent work while reviewing every change it makes.

  • Sessions saved per project: switch repos and pick up anytime
  • Preview before apply: every diff is visible, confirm then commit
  • Live sync: terminal, tests and Git status update as the agent works
Download Client
LetCode — macOS desktop
Project sessions
letcode-site
legacy-api
docs-rewrite
pay-refactor
Tools
Terminal
Git changes
Test results
Fix the token-expiry bug on the login page
Located the expiry check in src/auth/session.ts, editing and adding tests…
✓ edit src/auth/session.ts +12 -4
✓ 5 passed · 0 failed (2.4s)
─ change applied, trajectory saved
Diff preview
+ if (now > exp) return refresh()
- if (now > exp) throw
+ await refreshSession()
+ // new expiry-guard test case
Tests
5 passed
DOWNLOAD

Choose how you use it

macOS / Windows clients: pick the build for your chip. Web needs zero install; CLI suits automation and CI.

macOS Desktop

Double-click to launch: auto environment check, key setup and browser opening.

macOS 13+ · Node.js 18+ required
Windows Client

Native Windows client, x64. Install and go on Windows 10/11.

Windows 10+ · x64 · Node.js 18+ required
Web Workbench

Zero install: one npx command starts a local service, open it in your browser. Cross-platform.

npx @deepseek-ai/dsh web Quick Start
CLI / Headless

One-shot task mode: runs, exits, prints to the terminal. Great for CI, scripts and automation.

dsh --profile headless "run the tests" Quick Start
ECOSYSTEM

An open ecosystem, not a walled garden

Plugins, MCP and community — every capability comes from an open ecosystem you can freely combine.

Plugin ecosystem

The community keeps shipping plugins — model adapters, tool integrations, UI themes. One plugin is one more capability.

MCP ecosystem

Connect databases, browsers, internal systems and third-party SaaS via MCP — your whole toolchain, at its disposal.

Developer community

GitHub discussions, issues and feature requests are all open. Report bugs, propose ideas.

Multi-platform

The same capabilities run on macOS, Windows, Linux and the browser — switch between terminal, desktop and Web freely.

Let mainstream AI write your first line of code

Local-first and free to start. Run it now and feel the efficiency of the full Agent Loop.