Multi-session GUI
Project explorer, streaming chat, agent activity timeline, diff viewer. Open parallel sessions with different models; a busy session keeps working while you use another.
Open-source · local-first · model-agnostic
One open harness that understands your repository, edits code, runs your tests, and manages git — on your machine, with any model you choose: DeepSeek, Qwen, Kimi, GLM, MiniMax, Cloudflare Workers AI, or weights running on your own GPU. No subscription. No lock-in. No code leaving your disk unless you say so.
The future of development is local.
The environment belongs to the developer. The model is replaceable.
$ silkcode --model auto ~/apps/ridelink Silk Code v0.1 | model: ollama/qwen2.5-coder (local) | mode: ask | ~/apps/ridelink silk> Fix the login redirect bug and run the tests. ⚙ grep {"pattern": "redirect", "path": "src/auth"} ⚙ read_file {"path": "src/auth/session.ts"} ⚙ edit_file {"path": "src/auth/session.ts", "old_string": "…", "new_string": "…"} ? Allow modifying file: src/auth/session.ts [y]es / [n]o / [a]lways: y ⚙ run_tests {} → $ npm test … exit code: 0 Fixed the redirect target in session.ts and verified it: 24 tests passed. ✓ 0 bytes sent to the cloud — model, code, and session all local.
Why Silk Code exists
AI coding tools today rent you back your own workflow: your code flows through someone else's servers, into someone else's model, under someone else's rules. Silk Code inverts that. The harness is open source, runs where your code lives, and treats every model — cloud or local — as a swappable component.
The runtime, the sessions, the checkpoints, and the project memory live on your disk. Pull the plug on the internet and keep coding. Local models work offline, start to finish.
Any OpenAI-compatible endpoint, native Ollama, vLLM, LM Studio. Switch mid-session. When a better model ships tomorrow, you keep your entire setup and swap one line of config.
Permissions, approvals, project conventions in SILKCODE.md, sandboxing —
the agent operates under your governance. MIT-licensed, single runtime
dependency, auditable end to end.
The shift
The rented way
The Silk Code way
The loom
Silk Code sits between you and any model, giving it the tools, context, and guardrails to do real engineering — not just autocomplete.
Stage 01
Every session opens with a repo map, your SILKCODE.md rules, project
memory, and installed skills. The model knows your codebase before its first tool call.
Stage 02
Search, read, and edit files; run commands; call MCP tools. Writes and risky commands
are approval-gated — rm -rf, push, and merge always ask first.
Stage 03
run_tests auto-detects pytest, npm, cargo, go, and flutter. The agent runs
your suite and reads the failures before claiming success.
Stage 04
Checkpoints snapshot every file before it's touched — one /revert undoes a
turn. Commits carry co-author and model provenance. Push when you say so.
Any model, cloud or local
One provider layer speaks to every OpenAI-compatible endpoint, with native Ollama support and local-model discovery. Run parallel sessions on different models and compare — the harness doesn't care which brain you plug in.
Gold, dashed = runs on your own hardware. --model auto picks whatever
you have: a running local server first, then any cloud provider with a key. Onboard anything else
with silkcode models add — or pull local models Ollama-style with
silkcode models pull qwen2.5-coder.
Quick start
Requires Python 3.10 or newer (macOS ships 3.9 — grab a current Python from
python.org first) and git. Keep Silk Code in its own virtual environment, then add a shell alias
so the silkcode command is available from every project without activating the
environment first.
# install or update Silk Code if [ -d "$HOME/SilkCode/.git" ]; then git -C "$HOME/SilkCode" pull else git clone https://github.com/RupertCloud/SilkCode.git "$HOME/SilkCode" fi cd "$HOME/SilkCode" # create the virtual environment if needed [ -d .venv ] || python3 -m venv .venv # install or update Silk Code .venv/bin/python -m pip install -e . # add the global command if it is not already configured grep -q 'alias silkcode=' ~/.zshrc 2>/dev/null || \ echo 'alias silkcode="$HOME/SilkCode/.venv/bin/silkcode"' >> ~/.zshrc source ~/.zshrc silkcode --help
This command block is safe to rerun: it updates an existing checkout, reuses its virtual
environment, and avoids adding duplicate aliases. The alias invokes Silk Code directly
inside its environment, so you do not need to activate .venv to use it.
# cloud: DeepSeek (or qwen / kimi / glm / minimax / openrouter) export DEEPSEEK_API_KEY=[redacted] # or local & private: install Ollama from ollama.com, then silkcode models pull qwen2.5-coder
Pick a model with tool-calling support — the agent works by calling tools.
qwen2.5-coder is the reliable local choice.
cd ~/Projects/my-project silkcode gui . # browser GUI at 127.0.0.1:8377 silkcode gui ~/Projects/my-project # or pass the project path directly silkcode ~/Projects/my-project # terminal REPL
silkcode gui ~/SilkCode opens the Silk Code source repository itself.
To work on another codebase, pass that project's directory instead.
Then just ask: "Build a small Flask API with tests, and make sure the tests
pass." Approve its actions as prompts appear; switch to
--mode agent once you trust it.
The harness
Project explorer, streaming chat, agent activity timeline, diff viewer. Open parallel sessions with different models; a busy session keeps working while you use another.
Every session starts with a repo map, your SILKCODE.md project rules,
accumulated project memory, and installed skills — the model knows the codebase
before its first tool call.
Commands are risk-classified. Reads run free, writes and installs ask,
rm -rf / push / merge always require approval — unless you explicitly
grant them for the session.
Files are snapshotted before the agent touches them. One click (or
/revert) undoes a whole turn.
run_tests auto-detects pytest, npm, cargo, go, and flutter — the agent
runs your suite and reads the failures before claiming success.
Context compaction trims old tool output and turns as you approach the model's window — sessions roll on instead of dying, and are resumable from GUI or CLI.
Connect any Model Context Protocol server — its tools become agent tools, approval-gated like everything else.
Run the agent's commands in a disposable container instead of your machine: self-hosted with one command, or on Cloudflare Sandboxes via the bundled Worker.
silkcode benchmark runs real coding tasks end-to-end per model —
with an A/B mode that isolates what the harness itself contributes.
GitHub
Sign in with GitHub — install the Silk Code app, approve a code in your browser, done. No tokens to create or paste; short-lived credentials, scoped to the repos you chose, refreshed automatically.
| silkcode connect github | sign in (or verify a $GITHUB_TOKEN) |
| /push · ⇧ Push | push when you say so |
| --auto-push | push automatically after each turn |
| github_create_pr | agent opens draft PRs, reads issues, merges on approval |
And the harness signs its work. Agent-made commits register Silk Code as co-author — you stay the author, the record stays honest:
Fix login redirect after session refresh Co-Authored-By: Silk Code <agent@silkcode.dev> X-Silk-Model: deepseek/deepseek-chat X-Silk-Session: 42
git log --grep=X-Silk-Model
forever answers "which commits did the agent write, with which model?"
Command line
| silkcode [path] | interactive REPL — /model, /mode, /diff, /revert, /push, /usage |
| silkcode -p "…" | one-shot, scriptable: run a single request and exit |
| silkcode review | AI review of your uncommitted changes |
| silkcode test | run the project's tests, framework auto-detected |
| silkcode models | list, add, pull, or set default models |
| silkcode sessions · resume | continue any session — including ones started in the GUI |
| silkcode mcp · sandbox · benchmark | tool servers, remote execution, model evals |
The contract