hax
A minimalist, terminal-native coding agent written in C that works with local and cloud LLMs inside your existing terminal.
Tests prove hax executes bash tool calls directly with no per-command permission prompt; the README explicitly disclaims per-command permission prompts, deferring to docs/philosophy.md, which is not in the evidence — so least_privilege, user_confirmation, external_effects, and rollback score 1. Data-flow transparency is decent: transcript view, optional wire trace, hermetic e2e envs (score 2), but the boundary of data sent to remote providers is not documented. Sensitive-data handling only shows 'set env var' with no redaction/storage policy (1). Small dependency set, pinned lint range, asan/tsan, sha256 checksums justify dependency_security 2. MIT LICENSE present but the 2026 copyright year is anomalous, so source_attribution 2.
The CI matrix (multi-platform, asan/tsan, lint) and carefully explained environment pinning show strong self-consistency (2). Dependencies declared per-distro in install_deps.sh (2). The e2e harness dumps stdout/stderr on failure with precise assertions; SIGINT handling has defined exit code 130 and resumable semantics (failure_messages 2), though end-user error text itself is not visible in evidence.
The README names its audience explicitly and states deliberate omissions, audience_and_scenarios 3. Capability boundaries are promised via the (unseen) philosophy doc, so 2. Trigger precision of the agent's tool selection has no source in the evidence, 1. Broad platform coverage (Linux/macOS/BSD/WSL) but the actual C implementation is absent, so environment_fit 2.
Docs are well tiered (usage/configuration/sessions/debugging/providers/philosophy): information_architecture 3. Install instructions cover brew/AUR/static binaries/source exhaustively: 3. Rich examples and provider table (examples 2, no FAQ). Known limitations promised but not visible (2). Complete LICENSE (3). Tag/version consistency checks and release-notes scripting but no CHANGELOG file (2). Maintenance responsibility rests on one individual with no governance or response commitments (1).
Output usability has concrete design evidence (clean stdout in -p mode, JSONL -- stream, stderr-only hints, streaming Markdown, preserved scrollback): 2. Clear marginal value (single binary, first-class local models, minimal deps): 2. Reasonable cost/benefit (few MB RAM, static binaries): 2. None reach 3 because no execution validates the claims.
CI details (tag/version grep, meson dist validating the shipped artifact, SHA256SUMS) make key claims traceable: 2. README claims are corroborated by tests and CI (bash tool execution, -- stream): 2. Fact and design-intent separation in comments/docs is clear: 2. Not 3 because the core C sources are not in the evidence, so behavioral claims cannot be fully settled.
- hax deliberately omits per-command permission prompts: the agent can execute bash commands directly. Run it in controlled directories or sandboxes and review the transcript afterwards.
- Without confirmation, one prompt can trigger chained file writes or subprocesses (including hax spawning itself as a subagent); avoid running it in directories containing sensitive credentials.
- API keys are passed via environment variables; beware shell-history and process-environment leakage. No key redaction or secure-storage mechanism is visible in the evidence.
- The publisher is an unverified individual with no governance or maintenance-response commitments; evaluate the automated update chain (brew/AUR PAT/SSH key) before relying on it.
- The LICENSE copyright year is 2026 (a future date) — a minor anomaly worth checking.
What does this agent do, and when should you use it?
hax is a coding agent shipped as a single native C binary, built for developers who live in the terminal. It offers an interactive REPL and a one-shot `-p` mode, with streaming Markdown output, live tool output rendering, and a Ctrl+T transcript view — all without hijacking the terminal's native scrollback. On the model side it is multi-provider: OpenAI, Anthropic, Codex (via a ChatGPT subscription), OpenRouter, OpenCode Zen/Go, llama.cpp, Ollama, and custom endpoints, with local llama.cpp models auto-discovered. It behaves like a well-mannered Unix tool: XDG paths, plain-text config and session files, clean stdout in one-shot mode, and composition via subprocesses rather than a plugin runtime. It runs on Linux, macOS, FreeBSD, and OpenBSD (Windows via WSL), with static prebuilt binaries plus Homebrew and AUR install channels.
Started in a project directory, hax sends user prompts to the selected model provider (llama.cpp's llama-server, OpenAI, Anthropic, etc.), streams the Markdown reply, and performs agentic tool calls whose output is reflowed and displayed live in the terminal. Interactive mode provides slash commands like /provider (choose provider and model), /login (for Codex), and /help. One-shot mode (-p) takes the prompt from an argument or stdin and prints the final answer; -c continues the latest session for the current directory, and --resume lets you pick or resume a session by ID. Sessions are plain-text files; -- emits a stream, and Ctrl+T opens a transcript view showing exactly what was sent and received, with an optional detailed wire-protocol trace for debugging. @file completion uses fzf when available.
- Developers running local models on resource-constrained machines: load a .gguf model with llama-server and hax auto-discovers it, using only a few MB of memory itself.
- Engineers who audit what their tools do: verify every request and reply via the Ctrl+T transcript view and an optional wire-protocol trace.
- Distro packagers: a single native C binary under MIT, easy to package for AUR, Homebrew, or static-binary distribution.
- Terminal-centric developers: hold a continuous conversation in the REPL, or script one-shot queries like
hax -p "list TODOs". - Users who switch between providers: move among OpenAI, Anthropic, OpenRouter, and local models within one tool via environment variables or /provider.
What are this agent's strengths and limitations?
- Extremely lightweight: one native C binary, a small dependency set, instant startup, leaving more RAM for local models.
- Local models are first-class: llama.cpp works with zero provider configuration, with auto-discovery of model and runtime capabilities.
- Respectful terminal behavior: only redraws the streaming line and input area, preserves native scrollback, and offers an inspectable transcript plus wire traces.
- Broad provider coverage: OpenAI, Anthropic, Codex, OpenRouter, OpenCode Zen/Go, llama.cpp, Ollama, and custom endpoints.
- Well-behaved Unix tool: XDG paths, plain-text config and sessions, clean stdout in one-shot mode, subprocess-based composition instead of a plugin runtime.
- Deliberately omits MCP marketplaces, plugin runtimes, IDE panels, and per-command permission prompts — teams needing those must pick another agent.
- BSDs are source-build only and Windows requires WSL; there is no native Windows support.
- Building from source requires a set of dependencies (C compiler, libcurl, jansson, meson, ninja, pkg-config), a higher bar than interpreted CLI tools.
- The Codex provider depends on a ChatGPT subscription and /login, excluding users without one.
How do you install or deploy this agent?
macOS/Linux via Homebrew: brew install oleksandrchekhovskyi/hax/hax. Arch Linux: install the AUR package hax. Any Linux distro: download the prebuilt static binary (x86_64 or aarch64) from the latest GitHub release and unpack it into a directory on PATH. From source: git clone https://github.com/OleksandrChekhovskyi/hax.git && cd hax && scripts/install_deps.sh && make (optionally make install). Dependencies: a C compiler, libcurl, jansson, meson, ninja, pkg-config, plus optional fzf for @file completion. BSDs build from source only; on Windows, use WSL.
How do you use this agent?
1) Connect a provider: set OPENAI_API_KEY, ANTHROPIC_API_KEY, OPENROUTER_API_KEY, or OPENCODE_API_KEY; for local models, start llama-server -m [model].gguf or ollama serve. 2) Run hax in your project directory to enter the interactive REPL; use /provider on first run to pick a provider and model (selections are remembered). 3) One-shot mode: hax -p "list TODOs", or printf "explain x" | hax -p. 4) Sessions: hax -c continues the latest session; hax --resume picks a past one; hax --resume=ID -p "next" resumes a specific session in one-shot mode. 5) Run hax --help for CLI usage and type /help in the REPL for slash commands.