late-cli

Outperforming Claude Code and Codex for Local LLM Workflows — Agent Native

"You solved local AI coding for me." — Reddit

"Late-CLI is mindblowing... it's a true hidden gem." — GitHub Discussions

"The same model feels smarter with Late." — Reddit

Built with Late: Late is primarily developed inside Late itself.

10-Second Quickstart

A single, statically compiled binary. Zero dependencies. No Python venvs, no Node.js.

# Linux / macOS (Homebrew)
brew tap mlhher/late && brew install late

# Universal Fallback (Linux / macOS / Windows WSL)
curl -sfL https://raw.githubusercontent.com/mlhher/late-cli/main/install.sh | bash

# Launch interactively in any project
cd your-project
late

Manual Binaries: Linux, macOS, native Windows

Pre-release Notice: This README documents features in v2.0.0-rc.1 (pre-release). The latest stable release is v1.5.1. Binaries for both versions are available on GitHub Releases.

One binary. Zero configuration. If llama-server is already running, Late finds it automatically.

The Architectural Bottleneck

The Problem: Standard coding agents still let the primary agent directly absorb codebase scans, compiler errors, file reads, failed diffs, and retries into one growing trajectory. As that execution noise accumulates in the KV cache, model reasoning quality degrades severely. You blame the model, but it's an architectural failure.

1. The 40% Collapse: Long-context LLMs suffer up to a ~45% collapse in reasoning accuracy once context utilization crosses 40–50%, even when all tokens are technically relevant (Weiwei Wang et al., arXiv 2026: Intelligence Degradation in Long-Context LLMs).

2. The Overthinking Tax: Reasoning models waste 27%–51% of their trajectory on redundant self-reflection loops ("Wait...", "Hmm") without accuracy gains (Chenlong Wang et al., EMNLP 2025: Wait, We Don't Need to "Wait"! Removing Thinking Tokens Improves Reasoning Efficiency).

The Late Solution: Late splits the brain and treats central context as the scarce resource:

1. Architecturally Enforced Isolation: The Lead Orchestrator strictly plans and verifies. It spawns ephemeral Coder and Researcher subagents into isolated contexts. Once a subagent finishes its atomic task, its noisy scratchpad is wiped. Only structured, high-signal diagnostics return to the Lead Architect.
2. Disposable Test-Time Compute: Workers can spend far more aggregate inference than would ever fit cleanly into one useful reasoning trajectory. Late trades cheap compute for a bounded, high-signal orchestrator context.
3. Empirical Logit Biasing: Late implements real-time logit biasing for llama.cpp/llama-server. It suppresses redundant thinking tokens on the fly, reclaiming wasted CoT compute while leaving room for useful reasoning (varies by model).
4. Physical Tool Registry Pruning: The Orchestrator has no file-writing tools, has repo-mutating bash commands blocked, and cannot bypass delegation. Subagents have no orchestration tools and cannot recursively spawn agents.

See the Feature Matrix and FAQ for a direct comparison and real world examples.

The orchestrator’s context grows primarily from what actually matters: your instructions, plans, and verifiable results—not every grep, compiler trace, failed edit, and discarded hypothesis used to get there.

A model with a 64k context window is no longer limited to a 64k task. The cumulative job can grow into hundreds of thousands of tokens while the orchestrator stays inside its useful context budget, delegating fresh work instead of carrying the entire execution history forward.

The same model feels smarter in Late because the architecture protects the context in which its important decisions are made.

The Feature Matrix

FAQ

Why not conventional agents that can just edit the repository directly?

Because optional delegation is not the same thing as an architectural boundary. If the primary agent can keep reading files, executing commands, editing code, retrying patches, and absorbing tool output directly, its central trajectory still grows with the work.

Late makes that impossible. The orchestrator plans and verifies; isolated workers execute. This structural discipline ensures the model doesn't get dragged down in execution noise and converge on a partial solution. Late keeps decomposing the task in clean environments until all objectives are closed.

Don't other tools already have subagents?

Many modern tools have subagents. The distinction is enforcement: in Late, workers are not an optional side-path that the primary agent may bypass. Late architecturally enforces isolation:

• Forced Plan-First Decomposition: Tasks are decomposed into atomic, verifiable steps before code is touched.
• Actionable Diagnostic Reporting: Subagents return structured, high-signal reports rather than lossy summaries, letting the orchestrator do what it's best at: Planning (and nothing else).
• Tool Registry Pruning: The Orchestrator literally has no file-writing tools and cannot make hasty edits. Subagents have no orchestration tools and cannot spawn recursive agents.

Can this workflow not just be rebuilt with plugins?

The underlying orchestration loop of agents not written with the specific architecture in mind isn't built to enforce isolation, even if you write plugins or extensions to try and add it. Instead of just offering subagents, Late architecturally enforces them. The orchestrator is physically incapable of making file edits (whether through tools or Bash), and workers are architecturally separated from orchestration. You can't replicate that structural discipline with a third-party plugin.

Can small or quantized local models actually handle complex, real-world tasks?

Yes. This is specifically what Late was made for.

Repeated local testing with 35B-A3B models at 3-bit quantization running via llama-server has shown a consistent qualitative pattern: Late can spend far more aggregate inference than the orchestrator itself ever has to retain.

In one representative run, the agents collectively executed 200,000+ tokens while the orchestrator stayed below 64k tokens. The model autonomously resolved an interwoven 6-file merge conflict with cross-file refactors, duplicated logic, and subtle regressions, compiled cleanly, and passed all tests inside a disposable late-podman contai