vibrate_

Your AI coding agent, in a throwaway container. One binary. Zero hassle.

A single Go binary that runs Claude Code — or Codex, OpenCode, Pi — in an isolated Docker container per project. A declarative .vb file pins your setup; a wizard fills the gaps. Cloud keys or local models via Ollama / LM Studio. As easy as vibrate.

Terminal
$ cd ~/my-project && vibrate
[vibrate] No .vb found — starting wizard…
✓ harness claude-code   profile full   shell zsh
[vibrate] Detected runtime: OrbStack · building vb-claude-code-full-a1b2c3d4…
✓ docker client, just & toolchain baked in · .vb written
$ claude "analyze this codebase"
Analyzing project structure...

The recommended path. just install compiles the binary, drops it on your $PATH, adds a short vb alias, and registers shell completion for your shell. Needs Go and just.

Clone & install 
git clone https://github.com/wlame/vibrator.git
cd vibrator
just install                 # → /usr/local/bin (sudo) + `vb` alias + completion
# or: just install ~/.local/bin   # user-local, no sudo

Then just:

cd ~/my-project
vibrate

First run builds a per-project image; every run after that jumps straight in.

No Go toolchain? Grab a static binary from the Releases page — built for Linux and macOS on amd64/arm64. Drop it anywhere on your $PATH as vibrate. (Windows runs via WSL2 with the linux/amd64 binary.)

Install a release binary 
# Pick the asset for your OS/arch (e.g. vibrate_0.3.0_darwin_arm64):
chmod +x vibrate_*_*_*
sudo mv vibrate_*_*_* /usr/local/bin/vibrate
vibrate --version

Then just:

cd ~/my-project
vibrate

The first vibrate in a project runs the wizard and builds the image; later runs reuse it.

Authenticate Claude Code (once) 
# Already logged in on the host? Do nothing — your ~/.claude.json
# is merged into the container automatically on every start.

# Option A: browser login, captured & written back to the host
vibrate --login

# Option B: long-lived token, read automatically on every run
claude setup-token
echo "eyJhbG..." > ~/.claude-docker-token

# Option C: pass an API key from the host
ANTHROPIC_API_KEY=sk-ant-... vibrate
Other harnesses bring their own keys — e.g. OPENAI_API_KEY for Codex, GEMINI_API_KEY / OPENROUTER_API_KEY & friends for OpenCode and Pi. Vibrator forwards the right host env vars per harness and mounts each agent's host config so logins persist — or skip keys entirely and pick a local Ollama / LM Studio model in the wizard.

Why Vibrator?

📦

One static binary

A single self-contained Go binary — nothing to install on the host but Docker. just install adds a vb alias and shell completion.

📌

Declarative .vb

Your choices land in a TOML .vb at the project root — harness, profile, extensions, mounts, LLM provider. Auto-gitignored, replayed on every run.

🪄

Wizard fills the gaps

First run with anything unset? An interactive wizard walks you through it — and prints the equivalent command. vibrate reconfigure re-runs it anytime, keeping your credentials.

🚀

Runtime auto-detection

Finds Docker Desktop, OrbStack, Colima, Rancher Desktop, Podman, or native Docker — and the right socket — with zero configuration.

🦙

Local LLMs & BYO provider

Point Codex, OpenCode, or Pi at Anthropic, OpenAI, any OpenAI-compatible endpoint — or a local Ollama / LM Studio model. Vibrator starts the server and pulls the model for you.

🤖

Four harnesses

Claude Code is first-class and the most exercised. Codex, OpenCode, and Pi are wired in (experimental) — one flag switches agents.

🔌

Curated extensions

Per-harness MCP servers, skills, and agents — Serena, Context7, Playwright, claude-mem, plus the ECC bundle — added with --extensions.

⚡

YOLO, safely

Inside the sandbox the agent skips its permission prompts by default — that's the point of the container. Want the prompts back? --no-yolo, persisted to .vb.

🔒

Isolated by default

One throwaway container per workspace, matching your host UID/GID. Host config is mounted read-only; Docker-in-Docker is opt-in via --dind — and never forces a rebuild.

What's inside

A lean always-on base image, plus everything else on demand — profiles bundle the toolchains, --extensions adds the MCP servers, skills, and agents your harness understands.

🤖

Harnesses

  • Claude Code — Anthropic's agentic CLI · primary, fully exercised
  • Codex — OpenAI's coding CLI experimental
  • OpenCode — BYO-provider agent (75+ models) experimental
  • Pi — provider-agnostic coding agent experimental
🎚️

Profiles

  • minimal — just the harness on the base image (~150 MB)
  • backend — Python, Go, gh, Postgres client
  • frontend — Node + Bun, Playwright + Chromium, gh
  • full — the lot + audit toolkit & Codex CLI (default) · tune with --with/--no
🔌

Extensions & MCP

  • Serena — semantic code analysis via LSP
  • Context7 — up-to-date library docs
  • Playwright — browser automation MCP
  • claude-mem — persistent cross-session memory
  • + GitHub, Postgres, Slack, Notion… — dozens more per harness --extensions
🧰

ECC bundle

  • Everything Claude Code — cross-harness agents, skills, rules & hooks
  • ecc-developer — the recommended engineering preset
  • minimal · core · security · research · full — pick your context budget --extensions
🧠

LLM providers

  • anthropic · openai — cloud, key from a host env var or pasted once
  • Ollama, LM Studio — local, keyless; started & model-pulled for you
  • openai-compat — any compatible endpoint, your URL
  • for Codex, OpenCode & Pi — picked in the wizard, pinned under [llm] in .vb
🔗

Host integrations

  • claude-mem server — Postgres-backed memory shared across containers
  • Serena host server — one LSP-backed MCP serving every workspace
  • your own, in TOML — user-defined integrations join the registry
  • vibrate integrations — interactive setup, status & management
🔋

Always-on base

  • ripgrep, fd, fzf — fast search & navigation
  • jq, just, sqlite3, tree, vim — data, tasks & inspection
  • htop, the docker client — baked into every image; --dind wires the socket
  • git, gpg, ssh, curl — the usual essentials
💻

Runtimes & shells

  • Python + uv, Go, Node + Bun — via profiles or --with
  • GitHub CLI, Postgres client — opt-in features
  • bash · zsh · fish — your choice, with completion

The base image (docker client, ripgrep, fd, fzf, jq, just, htop, git, …) is always present. Toolchains come from your profile or --with; MCP servers, skills, and agents come from --extensions. Everything you pick is recorded in .vb and rebuilt deterministically — while each agent's config and session history live in sidecar mounts, so they survive container recreation.

Usage

First run & every run

vibrate

Wizard fills the gaps, builds the image, drops you into the agent. Instant on every run after.

Pick your agent & stack

vibrate --harness=codex --profile=backend

Choose a harness and a profile; the rest defaults sensibly.

Docker-in-Docker

vibrate --dind

Mount the host Docker socket. The client is always baked in, so toggling never rebuilds the image.

Add a curated bundle

vibrate --extensions=ecc-developer

Layer in MCP servers, skills, and agents — here the ECC developer preset.

Drop into a shell

vibrate shell

Same container, but a plain shell instead of the agent — for poking around.

Preview without building

vibrate wizard

Run the wizard standalone to see the resolved spec — no image, no container.

Update the agent in place

vibrate update

New Claude Code out? Update the harness CLI inside the container or image — no full rebuild.

Change your mind

vibrate reconfigure

Re-run the wizard for an existing workspace — new harness, profile, or extensions. Credentials in .vb are preserved.

Bring the prompts back

vibrate --no-yolo

Agents skip permission prompts by default — it's a sandbox. This restores them, and sticks via .vb.

The vb shortcut

just install already wires up a vb alias and shell completion for you. Installed a prebuilt binary by hand? Add the alias yourself:

For Bash: 
echo 'alias vb=vibrate' >> ~/.bashrc && source ~/.bashrc
For Zsh: 
echo 'alias vb=vibrate' >> ~/.zshrc && source ~/.zshrc

Then just run vb in any project directory!