Codehamr
A minimal, local-first terminal coding agent: plug in any local model or API provider and let it read, edit and verify your code — no account or subscription required.
- Source repo
- plaxtoris/codehamr
- Stars
- ★ 222
- Last updated
- 1mo ago
- License
- MIT
- Primary language
- Go
- FA score
- 56/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platform
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- Privacy-conscious developers who want a coding agent on a local Ollama model so code and prompts never leave the machine
- Not a fit if
- Users who need sandboxed execution of untrusted code — the agent runs shell commands with your user's permissions and provides no sandbox
- Developers who want to run natively on Windows without WSL2 or a devcontainer
- Environments whose model server only exposes /v1/chat/completions without a Responses API
- Source review
- 56/100 · Major gaps 1 safety controls not found
What does this agent do, and when should you use it?
Codehamr is an MIT-licensed, standalone coding agent for the terminal, written in Go and shipped as binaries for Linux, macOS and Windows (amd64/arm64) via an install script. It works through four tools — bash, read_file, write_file and edit_file — reading your project, making changes, running checks and replying when finished. Model access is entirely your choice: the default configuration points at a local Ollama server on http://localhost:11434, and you can add API providers such as OpenRouter, with no project account or subscription required. Conversation state, prompt history and optional logging live in a .codehamr/ directory inside your project, and API requests go only to the endpoints you configure. There is no sandbox: shell commands run with your user's permissions, and on Windows the agent must run inside WSL2 or a Linux devcontainer.
Started in a project directory, codehamr reads .codehamr/config.yaml for model profiles (model ID, base URL, optional API key, context_size) and calls the selected model — e.g. qwen3.8:27b locally or anthropic/claude-opus-5.5 via OpenRouter — through the streaming Responses API with function tools. The agent loops over four tools: bash runs /bin/sh commands, read_file reads files, write_file writes files, and edit_file edits them; it reads your project, applies changes, runs build or test checks, and reports back. The embedded system prompt (compiled from internal/config/PROMPT_SYS.md) asks it to verify changes and mark checks it cannot run as unverified. /models lists or switches profiles, /clear resets the conversation, prompts are saved to .codehamr/history, and optional logging: true records prompts, responses and tool activity to .codehamr/log.txt.
- Privacy-conscious developers who want a coding agent on a local Ollama model so code and prompts never leave the machine
- Engineers with an OpenRouter or other Responses-API-compatible account who want to drive Claude-class models from the terminal
- Teams running the agent inside a devcontainer or VM to let it execute builds and tests automatically and report results
- Users who prefer a minimal toolchain — one binary, one config file, two slash commands — over heavyweight IDE plugins
- Evaluators experimenting with coding agents on self-hosted or low-resource inference servers
How do you install or deploy this agent?
On Linux or macOS:
curl -fsSL https://raw.githubusercontent.com/codehamr/codehamr/main/install.sh | bashOn Windows:
curl -fsSL https://raw.githubusercontent.com/codehamr/codehamr/main/install.cmd -o install.cmd && install.cmdBoth installers download binaries from the project's GitHub releases. First launch creates .codehamr/config.yaml with a default local profile in your current directory.
How do you use this agent?
Run codehamr in your project directory. To use OpenRouter:
export OPENROUTER_API_KEY='your API key'
codehamrThen enter /models openrouter to switch profiles. Example configuration:
active: local
models:
local:
llm: qwen3.8:27b
url: http://localhost:11434
key: ""
context_size: 262144
openrouter:
llm: anthropic/claude-opus-5.5
url: https://openrouter.ai/api/v1
key: ${OPENROUTER_API_KEY}
context_size: 1000000On Ollama, match context_size to OLLAMA_CONTEXT_LENGTH or the Modelfile num_ctx setting. Keys: Enter submits a prompt, Alt+Enter inserts a newline, Ctrl+C cancels the current turn (press again to quit), Ctrl+D quits on an empty prompt, Ctrl+L clears the screen while keeping the conversation, /clear resets the conversation and history.
What are this agent's strengths and limitations?
- Fully pluggable models and providers: local Ollama, OpenRouter, or any Responses-API-compatible server; keys can reference environment variables as ${VARIABLE}
- Minimal design: four tools, two slash commands, one config file; a single binary installed with one command
- Local-first: prompts and config stay in the project's .codehamr/ directory, API requests go only to endpoints you configure, and no project account is needed
- Built-in context management: the client reserves space for the system prompt, tool schemas and response, then packs recent history into the remaining window
- No sandbox: the bash tool executes commands with your user's permissions; isolation requires your own devcontainer or VM
- Windows cannot run the bash tool natively — WSL2 or a Linux devcontainer is required
- The system prompt is compiled from internal/config/PROMPT_SYS.md, so editing it requires rebuilding the binary
- Requires a backend supporting the Responses API with streaming and function tools; servers exposing only /v1/chat/completions need an adapter, and a passing /v1/models check proves connectivity only
- Profiles with a key send a small inference request at startup and activation, which may incur a small provider charge; token counts are estimates
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Codehamr This agent | 56 · Major gaps | CLIFree + model costs | ★ 222 | 1mo ago | Go | — |
| slash-agent | 47 · Major gaps | — | ★ 10 | 24d ago | Python | ChatGPT · Claude Code · OpenAI API |
| Nanocoder | 50 · Major gaps | CLIFree + model costs | ★ 2.6k | 1d ago | TypeScript | OpenAI API · Claude API |
| Distill Terminal Coding Agent | 47 · Major gaps | CLIFree + model costs | ★ 775 | today | Rust | ChatGPT · OpenAI API |
How does FollowAgents rate this agent?
Why each dimension lost points
README states plainly that the bash tool executes shell commands with the user's permissions and that codehamr provides no sandbox, but no command approval or confirmation mechanism is described — least privilege and user confirmation are thin; data flow disclosure is good (endpoints, logging, update check with opt-out); sensitive-data guidance exists (keep .codehamr out of VCS, env-var keys); dependencies are pinned but no vulnerability-audit evidence; no rollback (log is overwritten each start).
README is internally consistent and go.mod corroborates the CI Go version; dependencies are pinned; but failure-path documentation is scattered (Responses-unsupported servers, tool-parser issues) and error-message quality cannot be verified from the provided files.
The local/remote-model terminal-developer scenario is clearly framed; environment fit is well covered (WSL2, devcontainer, host.docker.internal); capability boundaries are honestly stated though partly model-dependent; trigger surface is small (two slash commands) but precisely described.
The README is well organized and the MIT LICENSE file is complete; however there is no CHANGELOG, the date-tag-overwrite release scheme hurts traceability, and install instructions use a curl|bash pattern documented only in prose; maintainer identity is absent.
Output usability is concretely described (streaming, Markdown rendering, keybindings); but as a deliberately minimal coding agent the README argues little differentiation from many peers; cost disclosure is decent (startup probe may incur small charges).
The README references PROMPT_SYS.md, tests, and media/README.md, none of which were provided for this review, so key claims cannot be traced; go.mod and the CI workflow do corroborate some facts; the README is honest about uncertainty (token estimates, model-dependent verification).
- Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
- The bash tool executes commands with full user permissions and there is no sandbox; run inside a devcontainer or VM.
- Installation uses curl | bash; install.sh content could not be verified in this static review — inspect it before executing.
- Startup model/credential probes may incur small API charges, and log.txt is overwritten on each startup, so history is unrecoverable.
- Publisher identity is unverified and the tool implementation source was not provided for this review, so safety claims rest on README self-description.
- No CHANGELOG and date-based overwrite tags make it hard to trace behavior changes across updates.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.