KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #ai-agent #developer-tools #codex #typescript #cli #deepseek-harness #claude-code #ai-agents #mcp #rust

Anvil

★ 17 Open GitHub ↗

Provider-agnostic AI dev pipeline: clarify → plan → build → review → PR across your repos, mixing LLM providers per stage with your own keys. No vendor lock-in, no markup.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<br />

# The provider-agnostic AI development pipeline

<h3>
  <i>Use your own keys. Mix providers per stage. Pay per token, not per seat.</i>
</h3>

<p>
  Anvil ships features end-to-end — clarify, plan, build, review, PR —<br />
  across every repo in your project, on whatever model is cheapest for each stage.<br />
  <b>No vendor lock-in. No markup. No hosted plan.</b>
</p>

<p>
  <sub>
  Anvil is an <b>open-source, self-hosted AI coding agent</b> — an end-to-end <b>LLM pipeline</b>
  (clarify → plan → build → review → PR) that runs on Claude, GPT, Gemini, and OpenRouter, or fully
  local via Ollama &amp; OpenCode. It speaks the <b>Model Context Protocol (MCP)</b> and uses your own
  API keys. Written in TypeScript.
  </sub>
</p>

<br />

<br />

[![Anvil pipeline builder showcase](https://raw.githubusercontent.com/esanmohammad/Anvil/main/assets/AI_Pipeline_Builder_Showcase.gif)](https://drive.google.com/file/d/1IHTQiLEQ4tulpdbUzI2iD5dmy82jBK-m/view?usp=sharing)

<sub><i>Dashboard preview &mdash; pipeline orchestration, live agent activity, knowledge graph, cost ledger.<br />
<b><a href="https://drive.google.com/file/d/1IHTQiLEQ4tulpdbUzI2iD5dmy82jBK-m/view?usp=sharing">Click the gif to watch the full demo</a></b></i></sub>

</div>

---

### **Plan on Claude. Build on Ollama. Review on GPT. Ship on a local model.**
### One pipeline. Eight providers. Whatever's cheapest for each stage.

</div>

---

## Why teams pick Anvil

#### Mix providers within a single pipeline
Routing is per-stage, not per-run. A single feature can flow through
three different providers without you lifting a finger. The pipeline
doesn't care which one ran which step.

</td>
<td width="50%" valign="top">

#### Cheap by design
Routing-by-stage means premium models only show up where premium
models actually matter. Read-only research and tight fix loops stay
on the free tier — *always*. Live cost ledger per call.

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### No vendor SDK lock-in
Every HTTP adapter is hand-rolled `fetch()`. No `@anthropic-ai/sdk`,
no `openai` package, no LangChain, no Vercel AI SDK. Drop a model —
your code keeps compiling.

</td>
<td width="50%" valign="top">

#### Bring your own keys, or don't
Ollama works fully offline. OpenCode's $10/mo Zen subscription
replaces the entire local tier — no GPU required. Cloud is for the
few stages that warrant it.

</td>
</tr>
</table>

---

## Quick start

```sh
# 1. Install
npm install -g @esankhan3/anvil-cli

# 2. Set up a project (interactive — answers a handful of questions)
anvil init

# 3. Open the dashboard and ship
anvil dashboard
```

That's the whole onboarding. `anvil init` creates `~/.anvil/`,
seeds `models.yaml`, scaffolds your project's `factory.yaml`, and
runs a health check. `anvil dashboard` boots the WebSocket
control plane and opens the UI.

> **First time?** The full walk-through — prerequisites, where to
> get provider keys, what `anvil init` will ask you, troubleshooting
> — lives in [`docs/getting-started.md`](docs/getting-started.md).

---

## Provider-agnostic by design

Eight providers ship in the box. One config file picks them per
stage. Each adapter speaks the same streaming format, the same
`UpstreamError` retry shape, the same per-call cost calculation.

| Provider | Tier slot | Best for |
|:---|:---:|:---|
| **OpenCode** (Zen) | `local` | Hosted open-coding models, $10/mo flat — replaces GPU-heavy Ollama |
| **Ollama** | `local` | Fully offline, your own GPU, embeddings + reranking |
| **Claude** (CLI) | `cheap` / `premium` | Best-in-class reasoning, native tool use |
| **OpenAI** | `cheap` / `premium` | GPT-5, o-series reasoning |
| **Gemini** | `cheap` / `premium` | Long context, Gemini 2.5 Pro |
| **OpenRouter** | any | Single key, hundreds of models |
| **Google ADK** | `premium` | When you need ADK's runner semantics |
| **Gemini CLI** | utility | Subprocess fallback |

</div>

### One run, three providers, fourteen cents

Routing is per-stage, not per-run. The same feature can flow
through three providers without you lifting a finger:

```
  clarify     →  Ollama / OpenCode   local           ~ $0.00
  plan        →  Claude Sonnet       deep analysis   ~ $0.05
  build       →  Ollama / OpenCode   local           ~ $0.00
  test        →  Ollama / OpenCode   local           ~ $0.00
  validate    →  Claude Haiku        cheap + fast    ~ $0.01
  review      →  Claude Sonnet       judgment-heavy  ~ $0.08
  ship        →  Ollama / OpenCode   local           ~ $0.00
                                                  ──────────
                                                    ~ $0.14
```

It's just YAML in `~/.anvil/stage-policy.yaml`. Premium models only
appear where premium models actually matter. **Read-only research
and the fix-retry loop are locked to free tier — they cannot
escalate, by design.** A typical run with Ollama or OpenCode burns
single-digit dollars on cloud calls.

### Auto-failover when a provider misbehaves

If a model 429s, 5xx's, hits a quota wall, or fails its liveness probe
mid-run, Anvil's chain-walker **burns it for the rest of the run** and
falls through to the next entry in the same tier — same provider or
different, your call. The pipeline doesn't pause, doesn't surface a
stack trace at the user, and doesn't double-charge by retrying the same
broken model. Every fallback hop emits a routing event so you can see
exactly which model was skipped and why.

```
clarify   →  adk:gemini-2.5-flash   ❌  (provider liveness fail)
          ↪  opencode/kimi-k2.6     ✅  (next in chain, same tier)
build     →  opencode/qwen3.5-plus  ❌  (429 — Alibaba upstream)
          ↪  opencode/glm-5.1       ✅  (model burned for run, fallback proceeds)
```

Two layers of detection: a **proactive** liveness probe at run start
(Ollama `/api/tags`, env-var presence for cloud) and a **reactive**
duck-typed `UpstreamError` check on every adapter call. Configurable
per-run cap on retry attempts in `models.yaml` (`walker.max_attempts`).

### One GPU, many models — exclusive slot serialization

Big local models can't all share a single GPU at the same time.
If your `clarify` and `build` stages both want a heavy Ollama
model, naive concurrency ends in an OOM. Anvil's
`exclusive_slot: true` flag puts those models behind a
**process-local FIFO queue** so only one exclusive model is ever
GPU-resident at a time.

The queue does the dance for you:

- **Hard eviction on switch.** Going from model A → model B
  explicitly tells Ollama to release A's weights, then polls until
  the GPU has actually freed them before letting B load. No GPU
  briefly holding both.
- **Intruder detection.** An out-of-band Ollama session on the host
  (e.g. you ran `ollama run` in another terminal) gets evicted
  before the next exclusive load — so two big models can't sneak
  in side by side.
- **Embeddings + rerankers bypass.** They're small enough to
  co-reside, so they never touch the queue.
- **Same-model calls are free.** Consecutive calls to the same id
  skip the eviction step entirely. A stage fanning out across repos
  pays the model-load cost once.

Mark a model exclusive in `~/.anvil/models.yaml`:

```yaml
- id: ollama/qwen2.5-coder:14b
  provider: ollama
  tier: local
  vram_gb: 9
  exclusive_slot: true        # mandatory for any VRAM-heavy local
```

Lets you mix multiple big local models on the same machine without
manual sequencing or OOM kills, regardless of how much VRAM you
actually have.

### Cost ledger, live

Every adapter call attaches a real `gen_ai.usage.cost` attribute
computed from a vendored LiteLLM pricing snapshot. The dashboard
shows you per-call, per-stage, per-run spend in real time. The
OpenTelemetry export carries the same numbers if you want them in
Langfuse, Tempo, or Honeycomb.

**No estimates. No surprises.**

---

## What you can do with Anvil

### Pipeline
Nine-stage feature pipeline — clarify, plan, build, test, validate,
ship — fanned out across every repo in your project. Per-stage
tool permissions, validate-fix retry loops, chain-fallback across
models when a provider 429s.