divvy CLI
A coding agent for small, cheap LLMs: splits a goal into a task tree with contracts and verifies each leaf with builds and tests.
- 62 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The agent writes files and runs build and test commands in the working directory by itself.
- The API key is passed to an external model or local gateway through environment variables.
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add cli/divvyDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The agent writes files and runs build and test commands in the working directory by itself.
- The API key is passed to an external model or local gateway through environment variables.
This is third-party code. Review the repository files before installing.
What it does
divvy takes a large goal and splits it into a task tree. Each task has a contract and an acceptance command and runs in its own context: compilation and tests confirm the result instead of the memory of a long session. The idea targets weak models with few parameters. Any OpenAI-compatible API works: OpenAI, vLLM, Ollama and local gateways. `-plan` only builds the tree and stops, `-resume` continues a session, `-parallel` runs several leaves in isolated copies and `-solo` folds the tree into one context. There is a `-serve` web interface, a Tauri desktop app, cost estimation and hard `-max-cost` and `-budget-tokens` limits.
Who it is for. People who run local or cheap code models and want verifiable results without an expensive agent.
Good fit when
- A local model through Ollama handles a long session poorly and the task must be split into short verifiable leaves.
- You first want to review the task tree with `-plan` and approve it.
- A hard spending ceiling is needed: `-max-cost` and `-budget-tokens`.
- The goal fits one context and the tree is overkill: use `-solo`.
Not a fit when
- You need a ready agent with a strong model and no contract tuning.
- You need work outside the `-workdir` directory: tools read and write only there.
- You are not ready to tune parameters by hand for a specific weak model.
Example request
Build `divvy`, run `./divvy -plan -workdir ./ws` for the goal "an HTTP /health service with a test" and show the task tree before execution.Limitations
The documentation is written in Chinese. `-max-retries 0` by default means unlimited retries after a failed acceptance check, so set `-max-elapsed` and `-max-stall`. Acceptance commands are written by the model, and fallback checks are weaker than its explicit end-to-end commands. `-prune` deletes session files irreversibly, so run it with `-dry-run` first. Browser tools need Chrome or Chromium installed. Tuning for a weak model stays with you.
How to disable. Delete the `divvy` binary and the working directory with its `.divvy` session folder. Remove `OPENAI_API_KEY` from the environment.
FAQ
How do I install divvy?
With `go install github.com/esrrhs/divvy/cmd/divvy@latest` or by building in the repository: `go build -o divvy ./cmd/divvy`.
Which models work?
Any behind an OpenAI-compatible API: OpenAI, vLLM, Ollama, local gateways. For Ollama set `OPENAI_BASE_URL` to an address ending in `/v1`.
How do I review the plan first?
Run `./divvy -plan -workdir ./ws "goal"`: the tree is saved and work stops. Then `./divvy -resume -workdir ./ws` executes the plan.
How do I limit spending?
With `-max-cost` in dollars and `-budget-tokens` for tokens. These are hard session limits, and `-max-leaf-cost` and `-max-leaf-tokens` apply to a single leaf.
When is `-solo` better?
When the goal fits one context: the tree collapses into one leaf and a failed acceptance check goes back into the same dialog for fixing.
Discussion
No questions or reviews yet.
Related
CLI toolsiloom runs each Claude Code task in its own worktree and saves plans and decisions as comments in your issue tracker
A Rust agent for long tasks: background Runtime, subagents in Git worktrees, exit-code verification and a change audit export.
The /improve skill: a strong model audits a repository and writes self-contained fix plans, and you hand the execution to a cheaper model
A terminal coding agent in Go: GLM, DeepSeek and local Ollama models, 59 built-in tools and MCP
A 2.4 KB charter for CLAUDE.md and three on-demand skills: the agent stops guessing, verifies results and gates irreversible steps
A Claude Code and Codex plugin: the expensive model plans, a cheap one writes code under a test, and your plan lasts longer.
README in short
The document covers the quick start, a flag table, the runtime design, REPL and guided modes, the web interface and desktop app. It continues with cost estimation, the wave and aggregate loop, core principles, a weak-model benchmark and a known-limitations section.