buildwithnexus

Overview

buildwithnexus is a fast, agentic coding assistant that lives in your terminal. It plans a change, reads and edits your files, and runs commands — asking before each change. It ships as a single static binary written in Rust: about 2.3 MB, four runtime dependencies, no Python, no async runtime, no Docker, no background server.

npm install -g buildwithnexus
buildwithnexus            # or: bwn
~2.3 MB
Static binary
4
Runtime deps
8
Model providers
3
Working modes

How it works

buildwithnexus is a native ReAct loop written in plain Rust control flow — the model reasons, calls a tool, sees the result, and repeats until the task is finished. There is no graph runtime and no orchestration backend; the loop, the tools, and the permission checks are all just the binary.

You: a task in natural language
        |
        v
Model reasons about the next step
        |
        v
Tool call  ──►  read_file · list_dir · write_file
   ▲            edit_file · run_command · finish
   │                    |
   └──── result ◄───────┘   (gated by permissions; you confirm changes)
        |
        v
finish  ──►  result returned to you

The same loop powers every mode. The only difference is which tools are available and how much planning happens up front.

Three modes

Plan
Decompose, then execute
The model breaks the task into discrete steps you review and approve, then carries them out.
Build
Agentic tool loop
A full ReAct loop over the tools — read, list, write, edit, run, finish — to make changes directly.
Brainstorm
Free-form chat
Talk through ideas and approaches with no tools and nothing touching your files.

See the Modes page for details. Subagents extend the loop: spawn_subagent delegates a sub-task to a fresh context window, optionally isolated in its own git worktree.

Local or remote models

Point buildwithnexus at a hosted API or at a model running on your own machine. Eight built-in providers span two wire protocols — the Anthropic Messages API and OpenAI chat-completions (which also covers every OpenAI-compatible endpoint). Local models are auto-detected at setup by probing the Ollama API and scanning your GGUF folder.

Remote · API key
AnthropicOpenAIOpenRouterGroqHugging Face
Local · on your machine
Ollamallama.cpp serverLM Studio

Why it is fast

Performance is the primary design lever. Because it is a native binary doing direct Rust control flow, there is nothing to interpret and no runtime to spin up.

Native binary
No interpreter, no async runtime
The agent loop is compiled Rust, not a graph engine on top of a language VM.
Prompt caching
Reuse stable context
Caching cuts repeated work across turns so each step pays for less.
Pooled TLS
Pre-warmed connection
A pooled, pre-warmed TLS connection removes handshake latency from each request.
Auto-compaction
Stays inside the window
Context auto-compacts as it nears the model's window, so long runs keep flowing.

Sessions that continue

Every run's transcript is saved under ~/.buildwithnexus/sessions. Pick up where you left off with continue, resume <id>, or sessions to list them — and /resume inside the REPL.

continue
Resume the most recent session
resume <id>
Restore a specific session
sessions
List saved transcripts

Safe by default

Every mutating tool is gated. The default permission mode is ask; you can switch to auto or readonly. Even under auto, sensitive paths (~/.ssh, .env, *.pem, the key store) and catastrophic commands still require confirmation. File tools stay confined to the working directory, API keys are never sent to a non-HTTPS endpoint, and key-like tokens are redacted from surfaced errors. See Security for the full model.

Interactive and headless

The REPL renders inline on the normal terminal screen — native scroll, select, and copy — with colored diffs for edits, token streaming, multi-line input, Tab completion for / commands and @ file paths, Ctrl+R history search, and ! shell mode. Key slash commands: /model to hot-swap the AI model mid-session, /compact to compress context, /review / /commit / /pr for git shortcuts, /schedule and /loop to run background workflows without blocking the UI, /workflows to manage them, /btw to inject silent context, and /config / /memory / /skills for configuration. For automation, drive it from scripts:

buildwithnexus run "add a --verbose flag to the CLI"
buildwithnexus run "summarize recent changes" --json   # one event per line

run also accepts plan, brainstorm, continue, and resume. Lifecycle hooks (Claude-Code-compatible: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd) live in ~/.buildwithnexus/settings.json and .buildwithnexus/settings.json. Project hooks run only after you trust the folder and may deny a tool, but never grant one.

At a glance

Install
npm install -g buildwithnexus
Run
buildwithnexus · bwn
Config
~/.buildwithnexus/
License
MIT

Source at github.com/Garretts-Apps/buildwithnexus. Next: Install · Modes · Configuration.