The Five Whys

Why? Because every AI agent framework today ships a 200-package dependency tree and a 200 MB Python venv. odek is an ~8 MB static binary with minimal dependencies — everything else is Go stdlib.
Why? Because you shouldn't need a PhD in Python packaging just to run go test. odek installs in 5 seconds with a single go install command — no Docker, no venv, no npm, no sagas.
Why? Because locking into one LLM provider is a strategic mistake. odek is provider-agnostic — Deepseek, OpenAI, Anthropic, Ollama, vLLM, Groq, Together, Fireworks. Any OpenAI-compatible endpoint.
Why? Because agents need real tools, not abstractions on top of abstractions. odek gives you read_file, write_file, patch, search_files, shell, and browser — all gated by a unified security layer. No plugins. No SDKs. No class hierarchies.
Why? Because the agent ecosystem has split into two worlds — tools that serve MCP (Claude Code, Cursor) and tools that consume MCP. odek does both in one binary. Serve your tools to any MCP client, or connect to external MCP servers for Playwright, Fetch, databases, and more.

See it in action

Real terminal output from real runs. Click through the examples.

odek — agent loop

# Quick file query
$ odek run "How many lines in go.mod?"
═══ Iter 1/15 ═══ [456 in · 21 out · 0.8s]
The go.mod file has 3 lines:
module github.com/BackendStack21/kode
go 1.24
require ( ... )
✅ Done in 0.8s

# Multi-turn session
$ odek run --session "Refactor the auth module"
═══ Iter 1/8 ═══ [521 in · 342 out · 3.2s]
I'll refactor the auth module. Let me start by reading the current code:
🔧 shell read_file auth.go
📄 auth.go (142 lines) loaded
The module uses basic JWT without refresh tokens.
I'll add: refresh token rotation,
rate-limited login, session revocation.
✅ Session saved: 20260520-a1b2c3

# Sandbox mode
$ odek run --sandbox "Check if curl is installed"
🔒 Sandbox: ephemeral container started
═══ Iter 1/4 ═══ [389 in · 156 out · 2.1s]
Running inside a fresh Docker container:
$ which curl
/usr/bin/curl
$ curl --version
curl 8.5.0 (x86_64-pc-linux-musl)
🔒 Container destroyed

# Parallel sub-agents
$ odek run "Audit all Go files for security issues"
🔄 Delegating 3 sub-agents...
└─ agent-1: scan imports (os/exec, crypto, net)
└─ agent-2: check error handling
└─ agent-3: inspect file permissions
═══ Parallel · 3 children · 4.7s
Results:
• 2 missing defer file.Close()
• 1 hardcoded secret in config.go
• All permissions: 0644 ✓

# MCP server mode
$ odek mcp
odek mcp ⚡ MCP server starting (v0.14.3)
Connected by Claude Code. Exposing 8 tools:
• read_file — read files with line numbers
• write_file — write files safely
• search_files — ripgrep-backed search
• shell — execute commands
• patch — find-and-replace edits
— MCP stdio —

# Web UI with token stats
$ odek serve --addr :8080
odek serve ⚡ http://[::]:8080
Open in browser. @-completion for files.
┌─ Session: 20260520-xyz ───────────────────────┐
│ ∑ ⌂ 1,248 context · ⎇ 342 output │
├───────────────────────────────────────────────┤
│ User: What's in src/? │
│ ⚡ Thinking... │
│ Agent: Let me check the source directory. │
│ ⚡ 2.1s · ⌂ 456 · ⎇ 89 │
└───────────────────────────────────────────────┘

What you get

🔒

Sandboxed Execution

odek run --sandbox — every session spawns an isolated Docker container. No network, no host mounts beyond the working directory, zero capabilities, destroyed on exit.

🧩

Sub-Agent Delegation

Parallel OS-process sub-agents via delegate_tasks. True isolation — each sub-agent is a fresh process with its own config, tools, and timeout. Up to 3 concurrent workers.

🧠

Self-Learning Skills

Detects multi-step procedures, error recoveries, and corrections during your sessions. Saves them as reusable SKILL.md files. On by default — --no-learn to disable.

💾

Persistent Memory

Three tiers: facts (markdown on disk), session buffer, and searchable episodes. Merge-on-write via go-vector cosine similarity saves ~80% LLM calls. go-vector RP is ephemeral — rebuilt from text on every write, no embedding state to persist.

🔗

MCP Two-Way

Server: odek mcp exposes native tools to Claude Code, Cursor, any MCP client. Client: odek connects to external MCP servers and makes their tools available to the agent.

🌐

Web UI

odek serve — browser-based agent with @ resource completion, WebSocket streaming, token economics, inline loading, drag-and-drop file attachments, and a full IDE-style console. Built from Go's embed — zero npm.

📎

File Attachments

Attach files to any prompt with --ctx / -c (CLI), @file inline references (REPL), or drag-and-drop (Web UI). File content is injected as context blocks — no tool calls needed.

🏗️

Layerable Config

Four-layer priority chain: global → project → ODEK_* env vars → CLI flags. ${VAR} substitution in config files. Sensible defaults at every layer.

🔍

Native Tools

Built-in read_file, write_file, search_files, patch, shell, and browser. All gated by a unified security layer — classify operations as allow / deny / prompt per risk class.

odek vs the rest

	odek	Python agents
Direct dependencies	Minimal — stdlib + 4 focused pkgs	200+ packages
Binary size	~8 MB static	50–200 MB (venv)
Startup	Instant	2–10 seconds
Sandbox	`--sandbox` flag	Manual Docker setup
Tool interface	One interface, one method	Class hierarchies + decorators
MCP	Bidirectional (server + client)	Client-only or adapter needed
Language	Go — native binary	Python — interpreter required

Install in 5 seconds

1 Have Go 1.25+ installed. If not: brew install go or download.
2 Install:
go install github.com/BackendStack21/kode/cmd/odek@latest
3 Set your API key: export ODEK_API_KEY=sk-... (or DEEPSEEK_API_KEY / OPENAI_API_KEY)
4 Run your first task: odek run "How many lines in go.mod?"

One-line binary install

No Go toolchain? Auto-detects your OS and architecture:

# Download to /usr/local/bin (may need sudo)
curl -sfLo /usr/local/bin/odek https://github.com/BackendStack21/kode/releases/latest/download/odek-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/') && chmod +x /usr/local/bin/odek

# Or to current directory
curl -sfLO https://github.com/BackendStack21/kode/releases/latest/download/odek-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/') && chmod +x odek-* && ./odek-* version

auto-detect OS/arch ✓ static binary ✓ no runtime deps ✓ works offline ✓

# Results instantly
$ odek run "How many lines in go.mod?"
3 lines

# With session persistence
$ odek run --session "Refactor the auth module"
$ odek continue "Now add error handling"

# Different provider, same binary
$ odek run --model gpt-4o --base-url https://api.openai.com/v1 "Explain this"

# Attach files for context
$ odek run --ctx data.csv "analyze trends"
$ odek run "@README.md summarize this project"





  Cheatsheet

  Commands
  
    odek run <task>Single-shot task
    odek run --sandbox <task>Run in Docker sandbox
    odek replInteractive multi-turn REPL
    odek repl --id <uuid>Resume a saved session
    odek serveStart Web UI (http://127.0.0.1:8080)
    odek serve --sandboxWeb UI with Docker sandbox
    odek subagent --goal <s>Run a focused sub-task
    odek mcpStart MCP server (stdio)
    odek mcp --sse-addr :8081Start MCP server (SSE)
    odek init [--global]Create config file
  

  Key Flags
  
    --model <name>LLM model (deepseek-v4-flash, gpt-4o, etc.)
    --base-url <url>API endpoint URL
    --sandboxRun in Docker sandbox
    --thinking <level>Reasoning depth (enabled/disabled/low/medium/high)
    --learnEnable skill learning (on by default)
    --no-learnDisable skill learning
    --max-iter <n>Max think→act cycles (default 90)
    --ctx <files> / -cAttach files as context blocks (comma-separated)
    --system <prompt>Override system prompt
    --no-colorDisable colored output
  




  Everything else is documented
  Deep-dive docs for every subsystem. Real detail, no fluff.

  
    CLI ReferenceAll commands, subcommands, flags, examples
    Cheat SheetQuick reference: commands, config, memory, subagents, env vars
    Go SDK GuideImport, Agent, Tools, memory, multi-turn sessions, examples
    ConfigurationConfig files, env vars, priority chain
    Providers & ModelsDeepseek, OpenAI, Anthropic, Ollama, vLLM, more
    MCP (Two-Way)Serve tools + connect to external MCP servers
    Memory SystemThree-tier facts, buffer, episodes
    Multi-Turn SessionsSave, resume, list, trim, cleanup
    SandboxingDocker isolation, config, security model
    SecurityPrompt injection defense, threat model
    Sub-AgentsTask decomposition, delegation protocol
    Self-LearningSkill detection, LLM enhancement, curation
    Web UIodek serve, WebSocket protocol, @ resources
    DevelopmentBuilding, testing, contributing
  




  Ship it
  
    One binary. One loop. Zero frameworks.

    Go install and go.
  
  
    go install github.com/BackendStack21/kode/cmd/odek@latest
    
    GitHub →