[ coding-agent harness ]

Frontier when it has to be. Cents when it doesn’t.

Grist is a complete coding-agent harness. A confidence gate routes every task to the cheapest capable rung, verified memory and a code map brief it on your codebase, and specialists do the work in your tree — inference billed to your own provider key.

$ npm install -g grist-ai Sign in with Google Download for macOS

one request, five moves — your key pays for inference, your source never leaves the machine

4cost-tiered rungs, cheapest first

0%markup on your provider key

100%of your source stays on your machine

402is what an over-cap request gets — never a surprise bill

[ how it works ]

One prompt in. A verified diff out.

You never pick a model. The harness reads the task, prices it, and spends only what the difficulty earns.

You prompt

CLI, TUI, or desktop. The client sends the task and names a rung — never a vendor model id.

Gateway admits

Your grist_sk_ key identifies the account. Spend caps are hard: over cap returns 402, not a bill.

Jev gate routes

A confidence gate scores difficulty once per run, picks the cheapest rung that can handle it, and dials exploratory effort — trivial tasks get a tight budget, ambiguous ones get room to investigate.

Ladder resolves

The rung becomes a model — the best in its cost band. Defaults are ours; your dashboard can override any rung.

Your key pays

The provider call rides your BYOK key. Inference bills to your provider account; Grist never holds your budget.

Memory compounds

Verified outcomes — tests passed, approved, corrected — are written to memory and the code map updates, so the next run starts briefed instead of blank.

Specialists delegate

The gate hands work to named specialists — explore, plan, review, verify — each running inside the assigned rung. Repeat calls resume warm, so context compounds within the session too.

[ the concepts ]

Everything in the harness, explained.

Ten ideas do the heavy lifting. Each one has a full page in the docs — what it is, why it exists, and how it behaves.

The Jev gate

A confidence gate that reads each task once and routes it to the cheapest rung that can actually do it — and dials the effort budget to match the ambiguity.

The ladder

Four cost-tiered rungs, each holding the best model in its band. You see rung names — never vendor model ids.

Specialists

Four named roles the gate can delegate to. Every sub-task re-gates with the parent’s rung as a ceiling — decomposed work can only get cheaper, never pricier.

Memory that learns your codebase

Grist remembers only what was verified — tests passed, you approved, you corrected. A nightly Dreaming pass curates it, so the next session starts briefed instead of blank.

Dreaming & calibration

Memory curates itself mechanically — no human in the loop, every change a Git commit on an audit trail. Calibration tunes the gate’s thresholds from real outcomes, one bounded step at a time.

The code map

A graph of your repository — files, symbols, routes, and how they connect — so the agent navigates by structure instead of grepping blind.

SoL-Pi: same quality, fewer tokens

Huge tool output gets packed to a handle plus an excerpt; an edit and its check fuse into one move. Spend goes to judgment, not log spam — and context compounds across a session instead of resetting.

The desktop app

Supervise every thread from one window: a worktree per thread, per-hunk review, automations, and a review queue for anything that needs your eyes.

Gateway & keys

One account, named keys you can revoke independently, per-key spend caps and attribution. Bring your own provider key — inference bills to it directly, and your source never leaves your machine.

Automations

Recurring jobs on a schedule — the failure digest and memory curation ship built in. Whatever an automation produces waits for your review; nothing merges itself.

[ local ]

The repo never leaves the machine.

Tools run in your working tree. The prompt goes out. The source does not. Your provider key stays yours. We never train on your code.

your diskstays

Source filesnever sent

Git historynever sent

Tool executionlocal

Testslocal

prompt only →

gatewaysees

Prompt tokenssent

ObservationPackhandle + excerpt

Meter + capenforced

Source ingestnone

a finished run looks like: 3 files · tests passed · $0.012

[ built on opencode ]

Rebuilt on OpenCode v2.

Grist moved from a surgical fork to a first-class OpenCode plugin, tracking upstream v2.0.32. The gate, the ladder, and the doctrine are unchanged — everything around them got better.

Zero-config plugin

The harness ships baked into the grist binary — every session loads the Jev gate, doctrine, and control plane with no setup. One additive upstream hook is the entire fork surface, so upstream releases land as plain tags.

The full CLI, inherited

grist auth · models · debug · service · upgrade · stats · session · mcp

v2’s command surface arrives as upstream features, not Grist code to maintain.

Managed background service

grist serve --service elects a single server; grist run is a thin client over it. No ad-hoc servers lingering after a reinstall.

Grist identity

Config discovery prefers grist.json and .grist/, and global state lives under ~/.grist — the harness has its own name on disk.

[ for teams ]

Your key. Your cloud. Your codebase.

Grist for enterprise is API-only: the harness runs in your VPC, inference bills to your provider account at zero markup, and the team shares one verified memory and code map. Per-key spend caps and attribution come built in.

How enterprise deployment works →

[ get started ]

Open to everyone.

Create an account with your name and email, or sign in with Google — your account is ready on the spot.

Install

npm install -g grist-ai

Or grab the desktop app above.

Sign in

grist auth login

Pick Grist and sign in — the account is created on the spot.

Bring your key

OpenRouter, Vercel AI Gateway, or any OpenAI-compatible endpoint — or use a dashboard grist_sk_ key.

Run

grist

Prompt. The gate handles the rest.

Already working with an AI agent?

Give it the Grist skill and it can delegate multi-step coding work to Grist itself:

$ npx skills add grist-ai/grist-skills

for Muse, OpenClaw, Hermes, or any agent with a shell — how skills work

✦ Or paste this into your AI agent

Use Grist for my coding tasks from now on. Grist is an agentic coding-harness CLI.
1. Install the Grist agent skill by running: npx skills add grist-ai/grist-skills (built for personal AI agents and agentic CLIs like Muse, OpenClaw, Hermes, and OpenCode). Read the installed skill file in full before doing anything else.
2. Install the CLI if it is missing: npm install -g grist-ai.
3. Ask me for my Grist API key if you do not have it (it starts with grist_sk_). Never print it, log it, or write it into any file — pass it via environment variable only.
4. For multi-step coding work (features, bug fixes, refactors across files), delegate to Grist exactly as the skill describes. Report back what changed, the branch name, test results, and cost.

[ faq ]

Fair questions.

Does my code leave my machine?

No. Tools run in your local working tree. The prompt goes out to the model; your source does not. We never train on your code.

What does Grist cost?

The harness is free for personal and noncommercial use; commercial use needs a license. Inference bills to your own provider key at your provider's prices, with zero markup from us — and hard spend caps mean an over-cap request returns 402, not a bill.

Which model does Grist use?

Whichever the task earns. The Jev gate routes across four cost-tiered rungs, each holding the best model in its band. You work with rung names, and your dashboard can override any rung's model.

How is this different from a plain agent CLI?

A plain CLI spends the same on every task and forgets everything between sessions. Grist prices each task, remembers what was verified, navigates by a code map, and delegates to specialists — the harness is the product.

Can my team use it?

Yes — the enterprise deployment runs the harness in your own VPC on your own provider key, with shared team memory, a team code map, and per-key spend attribution. See the enterprise docs.

Stop re-teaching the agent your codebase.

Open to everyone. Bring your own key. Your code stays on your machine.

$ npm install -g grist-ai