Late: Zero-Config AI Coding Agent for Any LLM
/late-cli
Late is a zero-config CLI coding agent written in Go that splits work between a planning orchestrator and disposable subagents whose context is wiped after each job, so compile errors and lint noise never pile up in the main context. Reach for Late if you run local models via llama.cpp and want that split without YAML config; skip it if you need a mature, proven tool — it remains early and narrow.
What is Late?
Late is a command-line AI coding agent, shipped as a single statically compiled Go binary with no Python or Node.js dependencies. A main orchestrator plans inside a roughly 1,000-token system prompt, then spawns ephemeral subagents — one for coding, one for research — that do the work and get destroyed afterward, so their context never reaches the orchestrator. It targets llama.cpp locally by default, or DeepSeek and Claude via env vars.
Addressing LLM Context Degradation
Most CLI coding agents run everything — planning, edits, lint output, file writes — through one shared context window. The README's framing is blunt: every compile error and lint failure piles into the KV cache, and as that context fills with noise, the model's own reasoning degrades, even though it looks like the model got dumber. Late's answer is architectural rather than a bigger context window or a smarter prompt: it enforces a hard boundary between the orchestrator that plans and the subagents that execute, so the noise a subagent generates while fixing a lint error never becomes part of what the orchestrator has to reason over.
Core Features and Architecture
- ✓Orchestrator/subagent split: a main orchestrator holds a roughly 1,000-token, always-planning system prompt, and spawns ephemeral coding and research subagents that get destroyed once they return results, per the README.
- ✓Exact-match diffs: edits go through strict search/replace blocks with self-healing retries on mismatch, so a bad edit fails loudly instead of silently corrupting a file.
- ✓Zero-config local LLM support: Late targets llama.cpp on port 8080 (the default llama-server port) out of the box, with no setup required.
- ✓Cloud provider connectivity: setting OPENAI_BASE_URL, OPENAI_API_KEY, and OPENAI_MODEL env vars points Late at DeepSeek, Claude, GPT, Kimi, GLM, or OpenRouter.
- ✓Hybrid model routing: the README describes planning with a larger reasoning model (its examples: GPT 5.6, Kimi K3, GLM 5.2) while subagents execute on a faster, cheaper local model (its example: Gemma 4).
- ✓MCP integration and Agent Skills: external MCP servers map into Late over standard I/O, and third-party Agent Skills extend it without additional configuration, per the README.
- ✓Context-aware search that respects .gitignore and .llmignore, so irrelevant files don't flood the context window.
- ✓Human-in-the-loop trust scopes: read-only commands auto-approve, mutating commands hard-stop for a [y/N] prompt, and the README describes Session, Project, and Global trust scopes with TTL decay.
Quickstart: Installing Late
Late installs as a single statically compiled binary with no Python virtual environments or Node.js required, per the README. On Linux or macOS, the README's Homebrew path is `brew tap mlhher/late && brew install late`. A universal fallback for Linux, macOS, and Windows WSL is `curl -sfL https://raw.githubusercontent.com/mlhher/late-cli/main/install.sh | bash`. Arch Linux users can run `yay -S late-cli-bin`, and native Windows binaries are listed on the project's GitHub Releases page. Once installed, `cd` into a project directory and run `late` to start it — no setup step is required before that first run.
Configuring and Running Late
Out of the box, Late looks for a local `llama-server` on port 8080 and needs no configuration to start working against it, according to the README. To point Late at a cloud provider instead, you export three OpenAI-compatible environment variables before running it: `OPENAI_BASE_URL`, `OPENAI_API_KEY`, and `OPENAI_MODEL`, which the README says works with DeepSeek, Claude, GPT, Kimi, GLM, or OpenRouter. The README defers persisting these settings, MCP server setup, Agent Skills, Git worktree usage, and keybindings to a separate quickstart guide at `docs/quickstart.md`, so exact syntax for those isn't part of the facts here.
Practical Applications and Workflows
- •Running a coding agent entirely against a local model through llama.cpp, for developers who want to keep code and prompts off a cloud API.
- •Splitting planning from execution on a budget: the README's hybrid-routing example uses a larger model like GPT 5.6, Kimi K3, or GLM 5.2 to plan, and a smaller local model like Gemma 4 to execute the edits subagents produce.
- •Working across multiple branches at once with Git worktree support, running independent agent instances without one branch's context bleeding into another's.
- •Resuming a long agent session after closing the terminal or rebooting, since the orchestrator keeps session history on disk rather than only in memory.
- •Wiring in existing MCP servers or third-party Agent Skills to extend what Late's agents can do without extra configuration, per the README.
Strengths
- ✓Ships as a single statically compiled Go binary — no Python venv, no Node.js, no dependency chain to debug before you can run it.
- ✓The orchestrator/subagent split is a real architectural choice, not a marketing label: subagents are destroyed after each job, so lint noise and failed diffs don't accumulate in the main context.
- ✓Zero-config local model support — it targets llama-server on port 8080 out of the box, so trying Late with a local model doesn't require writing a config file first.
- ✓Model-agnostic: the same install works with local llama.cpp models or cloud providers (DeepSeek, Claude, GPT, Kimi, GLM, OpenRouter) by swapping three env vars.
- ✓Exact-match diff edits fail loudly on a mismatch instead of silently corrupting a file, and self-heal by retrying rather than leaving a broken patch applied.
- ✓Free to use for commercial code output under its own README's terms — you don't owe anything for code Late helps you write, only if you resell Late's engine itself.
Considerations for Using Late
- △License isn't a standard open-source license: the README's own terms say you can use Late freely to write code (including commercial code), but you may not monetize Late itself without a commercial agreement, and the terms convert to GPLv2 only on Feb 21, 2030.
- △Late is a small project; there's no adoption data beyond a Medium post, a GitHub Discussions comment, and a Reddit comment quoted in the README, so real-world track record is thin.
- △Go is the only language listed for the repo, and the README doesn't document a plugin API or extension language beyond MCP servers and Agent Skills, so deeper customization options aren't clear from the facts here.
- △The Feature Matrix comparing Late to Claude Code, OpenCode, and unnamed clones is the README's own framing, not an independent benchmark — none of those comparisons are independently verified.
- △Persisting cloud-provider settings, MCP setup, Agent Skills details, and keybindings are all deferred to a separate docs/quickstart.md file rather than documented in the README itself, so getting past the zero-config local path takes extra reading.
Late Compared to Other Agents
Frequently Asked Questions
Late's README states it's free to use for writing code in any project, including commercial ones, and your generated output is yours. Monetizing Late itself — its orchestration engine being provided as a paid service — requires a commercial agreement, and those terms convert to GPLv2 on Feb 21, 2030.
Late's own README says yes: you can use Late freely to write code for any project, commercial included, and the code you generate with it is yours. What you can't do without a separate commercial agreement is repackage Late's orchestration engine into a paid product.
Late targets llama.cpp on port 8080, the default port for llama-server, with zero configuration required — it's the model path Late is built around by default, according to the README.
Late keeps a main orchestrator on a roughly 1,000-token planning prompt and spawns ephemeral coding and research subagents to absorb compile errors, lint output, and raw data; those subagents are destroyed after returning results, so their noise never reaches the orchestrator's context.
Setting OPENAI_BASE_URL, OPENAI_API_KEY, and OPENAI_MODEL lets Late connect to DeepSeek, Claude, GPT, Kimi, GLM, or OpenRouter, per the README's Model Connectivity section.
Late offers human-in-the-loop control: read-only commands auto-approve for speed, but mutating commands hard-stop for a [y/N] confirmation, and the README describes Session, Project, and Global trust scopes with TTL decay controlling how long an approval lasts.
Who should try it — and who should skip
Try Late if you already run models locally through llama.cpp and want an agent that treats context as a scarce resource — the orchestrator/subagent split and zero-config local path are built for exactly that workflow, and the single Go binary means no dependency setup first. It's also worth a look if you're paying per-token for a cloud model and want to test whether stripping noise out of the context window cuts your bill, since the README's own Reddit quote claims the same model feels smarter under Late. Skip it if you need a mature, heavily-adopted tool with a large plugin ecosystem and long track record — Late is a 402-star project with terms that aren't a standard open-source license, and its comparison claims against Claude Code, Codex, and OpenCode come from its own README rather than an independent benchmark.
Related repositories
Want a second opinion on late-cli?
Ask an AI that can read this page — one click and you get its take on late-cli.