AI-nHancement  /  Developer Tooling

Structure
for vibe
coding.

The criticism leveled at vibe coding — "AI slop," fragile codebases, looks good on the surface but fractured underneath — is not anti-AI. It is anti-fragility. Anvil targets the older problem.

"The workflow that prevents failures, not the AI tool that hides them better."
Single Rust binary ratatui TUI Agentic coder Cross-provider Two human gates
See How It Works → Quick Start
Anvil
Public Beta · Apache-2.0
The Wedge

Not a better
AI coding agent.

Anvil is not competing with Codex, Claude Code, Cursor, or any other AI coding agent on the axis of "better AI coding agent." That is a losing race against the model providers.

Anvil competes on a different axis: AI coding done correctly. The competitive question reframes from "which AI tool is best?" to "which workflow produces shippable code?" On that axis, Anvil's competitors are not other AI tools — they are the absence of process.

The coder is a real agent — it reads, writes, and edits files and runs commands itself, the way Claude Code, Cursor, or Aider do. What Anvil adds is discipline at exactly two human gates, so a long vibe-coding session doesn't quietly drift off the rails. The human is the gate; the coder does the work.

$ anvil # launch the TUI
⚙ read_file src/llm.rs ↳ ok
coder> wrote plan.md — 4 phases
 
/lock-plan # the plan gate
→ reviewer-a (Anthropic) 3 findings
→ reviewer-b (OpenAI) 2 findings
→ REVIEW_plan_R1.md / REVIEW_plan_R2.md
 
/accept-plan
✓ plan locked — phase work unlocked
 
/accept-phase P0 # the phase gate
→ reviewer-a + reviewer-b critique git diff
→ REVIEW_P0_R1.md / REVIEW_P0_R2.md
/ship-phase P0 → shipped
Architecture

One Rust binary.
An agent and two reviewers.

Rebuilt from the ground up: a single Rust binary — no sidecar, no protobuf. A full ratatui TUI drives a real agentic coder that works directly in your repo, and two cross-family reviewers supply a genuine second opinion at each gate. (The previous multi-crate + Go sidecar + protobuf design is archived under archive/old-v1/.)

Surface
TUI + CLI anvil
A full interactive ratatui TUI by default — persistent chat, live status header, the two workflow gates as slash commands. A CLI is also available for headless and legacy/scripting use.
anvil anvil ui /lock-plan /accept-phase /status
drives the agent
The agent
Coder point it at your repo
A real agentic coder — it reads, writes, and edits files and runs commands itself, the way Claude Code, Cursor, or Aider do. Nothing to attach or copy-paste. Tools are scoped to the project root; paths that escape it are rejected.
read_file write_file edit_file list_dir grep run_command
second opinion at each gate
The review
Reviewers reviewer-a / reviewer-b
Two different model families. At the plan gate they critique plan.md; at the phase gate they critique the actual git diff. Findings appear in chat and are written to REVIEW_*.md. No R3+.
reviewer-a (R1) reviewer-b (R2) plan.md git diff REVIEW_*.md
any provider, local or hosted
External
Model Providers
Cross-provider by design, with live model enumeration where the provider exposes /v1/models or Ollama's /api/tags. Local-first or hosted frontier — any model with tool-calling can be the coder.
Ollama / local OpenAI xAI · Groq Anthropic · Google Azure · Bedrock · Vertex + more
Workflow

Free-form chat.
Structure at two gates.

Everything between the gates is ordinary agentic chat — the coder reads, edits, and runs commands directly in your repo. Discipline kicks in at exactly two human gates: the plan gate and the phase gate. You approve at each; two cross-family reviewers supply the second opinion.

1
Chat
Discuss goals and constraints; the coder works directly in the repo
Discuss Build Iterate
2
Plan gate
Coder writes plan.md; reviewer-a + reviewer-b critique it; you approve
/lock-plan /accept-plan
3
Build phase
Coder implements a phase: reads, edits, runs tests. You confirm each shell command
/y · /n run tests
4
Phase gate
reviewer-a + reviewer-b critique the git diff; fix what they raise, then ship
/accept-phase /ship-phase
The Invariant
1
The human is the gate
Nothing advances without your approval. The coder does the creative work and makes the file changes; you approve the locked artifact at the plan gate and at each phase gate. /accept-plan records the plan hash and unlocks phase work.
2
The reviewers are a genuine cross-vendor second opinion
reviewer-a and reviewer-b are two different model families critiquing the same locked artifact — the plan, then each phase's diff. No R3+: two diverse opinions, not a committee.
3
The agent is scoped to the project root
File reads, writes, and edits run automatically — that's the point. But run_command waits for your /y or /n, and any path that escapes the project root is rejected.
Core Features

Every mechanism exists
to prevent a real failure mode.

No speculative infrastructure. Each feature is traceable to a specific class of fragility in AI-assisted development.

⌨️
Real Agentic Coder
Not a chat box you paste into. The coder reads, writes, and edits files and runs commands itself — the way Claude Code, Cursor, or Aider do. Point it at your repo and tell it what to build. Nothing to attach.
read / write / edit run_command Project-scoped
🚦
Two Human Gates
A plan gate and a phase gate. The coder writes plan.md itself, then builds phase by phase. You approve each gate. Everything between is ordinary agentic chat — so a long session doesn't quietly drift off the rails.
Plan gate Phase gate No drift
⚔️
Cross-Vendor Review
Two different model families — reviewer-a and reviewer-b — critique the plan, then each phase's git diff. A genuine second opinion, not the coder grading itself. Findings land in REVIEW_*.md. No R3+.
Two reviewers Cross-family REVIEW_*.md
🔌
Cross-Provider by Design
Ollama, LM Studio, Groq, OpenAI, xAI, Anthropic, Google, Together, Fireworks, OpenRouter, Mistral, DeepSeek, Azure OpenAI, AWS Bedrock, Google Vertex, custom gateways — all supported, with live model enumeration. Run fully local or on hosted frontier models.
15+ providers Live model lists Local-first
🖥️
Full ratatui TUI
Streaming responses with live tool activity, a header showing workflow stage, per-GPU utilization + VRAM (NVIDIA via nvidia-smi) and loaded Ollama models, a / command palette, focused review cards, and per-session JSONL logs. A CLI covers headless use.
TUI default Live GPU / VRAM JSONL logs
🔑
Secrets That Just Work
Paste a key during setup and Anvil captures it as the conventional *_API_KEY env var and writes it to a project-local .anvil/.env — auto-loaded on every future run, no shell-profile changes on any platform. OS keyring is supported as a secondary option.
.anvil/.env Env vars Keyring optional
Quick Start

Only Rust required.
Build, init, run.

Install with Cargo, create the project files, and launch the TUI. On the first bare anvil a fast interactive wizard walks you through providers and role assignment — or picks live local Ollama models in a single step.

# build or install
$ cargo build --release
# or: cargo install --path .
 
# create project files (anvil.toml + .anvil/)
$ anvil init
 
# launch the TUI — wizard auto-starts first run
$ anvil
✓ Quick local Ollama, or add a provider
then just type to chat with your coder
# the gates
/lock-plan run R1 + R2 on plan.md
/accept-plan approve & lock the plan
/accept-phase review the phase git diff
/ship-phase mark the phase shipped
 
# everything else
/y /n approve / deny a run_command
/config providers, models, roles, keys
/status roles, gate progress, GPU, Ollama
/view-plan /view-reviews popups
Files Anvil writes at the repo root
anvil.toml  providers · model bindings · roles .anvil/.env  auto-loaded secrets plan.md REVIEW_plan_R1.md · REVIEW_plan_R2.md REVIEW_P*_R1.md · REVIEW_P*_R2.md
Technology

Rust, top to bottom.
No sidecar. No protobuf.

One binary you build with Cargo. The interactive surface is a ratatui TUI; providers are reached directly over their own HTTP APIs with live model enumeration. The previous multi-crate + Go + gRPC design is archived.

🦀
Core · the binary
Rust + Cargo
A single binary — only Rust is required to build it. The agentic coder drives project-root-scoped tools (read_file, write_file, edit_file, list_dir, grep, run_command). Build with cargo build --release.
Cargo Single binary Agent tools Apache-2.0
🖥️
Interface · the daily driver
ratatui TUI
Streaming responses with live tool activity, a header for workflow stage + per-GPU VRAM (NVIDIA via nvidia-smi) + loaded Ollama models, a / command palette, multiline input, review cards, and per-session JSONL logs in .anvil/. A CLI covers headless and scripting use.
ratatui Live status JSONL logs CLI fallback
🔌
Providers · direct HTTP
Cross-provider
Reached directly over their own APIs, with live model enumeration where the provider exposes /v1/models or Ollama's /api/tags. The agent needs a model with tool/function calling — all hosted frontier models qualify; many small local models don't.
/v1/models /api/tags 15+ providers Tool-calling
🔐
Secrets · credentials
Env + .anvil/.env
Paste a key once: it's captured as the conventional *_API_KEY env var and written to a project-local .anvil/.env that future runs auto-load — no shell-profile edits on bash, zsh, fish, PowerShell, WSL, Docker, or CI. OS keyring is a secondary option.
.anvil/.env Env vars Keyring optional Cross-platform
Public Beta — Apache-2.0

Public beta.
Point it at your repo.

Anvil has been rebuilt from the ground up: a single Rust binary, a real agentic coder, a full ratatui TUI, and two cross-vendor human review gates — cross-provider, local or hosted. The old multi-crate + Go sidecar + protobuf design is archived. Apache-2.0, building in the open.

GitHub Organization → ← All Products