strand Download

A Git client for the agent era

Agents write the code.
Someone has to review it.

Strand is a fast, keyboard-first Git client built around one workflow: watch an AI coding agent change your working tree, review every line with whole-file context, and send feedback straight back to the agent. Free for individuals.

Download Strand 1.0 Release notes

macOS · Windows · Linux · free for individuals

Make it yours
acme/api + 0 3 Stash feature/auth-retry Quick Launch⌘K
acme/api›Review· 8 unstaged files
Unstaged changes 4/8 reviewed Discard unreviewed (4) Pin baseline at HEAD
Unstaged8 Stage all Staged0
▾src
▾auth
TSsession.ts✎1M
TSretry.tsA
TSerrors.ts✓M
▾api
TSclient.tsM
TStypes.ts✓M
▾tests
TSretry.test.tsA
TSsession.test.ts✓A
▾docs
M↓auth.md✓M
src/auth/session.ts -2+6 Note Stage Discard ✓Mark reviewed
✎ L13surface the retry count in the error message×
11import { getToken, refreshToken } from './token'
2import { withRetry } from './retry'
23
34const SESSION_MAX_AGE = 15 * 60 * 1000
45
56export async function getSession(url: string) {
67 const token = await getToken()
78 const headers = { Authorization: `Bearer ${token}` }
8 const res = await fetch(url, { headers })
9 if (!res.ok) throw new Error('auth failed')
9 const res = await withRetry(() => fetch(url, { headers }), {
10 attempts: 3,
11 backoff: 'exponential',
12 })
13 if (!res.ok) throw new AuthError(res.status)
1014 return res.json()
1115}
1export interface RetryOptions {
2 attempts: number
3 backoff?: 'linear' | 'exponential'
4}
5
6export async function withRetry<T>(fn: () => Promise<T>, opts: RetryOptions) {
7 let delay = 250
8 for (let i = 0; i < opts.attempts; i++) {
9 try { return await fn() } catch { await sleep(delay); delay *= 2 }
10 }
11 throw new RetryExhausted(opts.attempts)
11import { request } from './request'
22
33export class ApiClient {
44 constructor(private base: string) {}
55
6 get(path: string) {
7 return request(this.base + path)
6 get(path: string, signal?: AbortSignal) {
7 return request(this.base + path, { signal })
88 }
99}
11# Auth
22
3Requests fail hard on transient network errors.
3Requests retry up to 3 times with exponential backoff.
4See `withRetry` in `src/auth/retry.ts`.
45
56## Tokens
1import { withRetry } from '../src/auth/retry'
2
3test('retries transient failures', async () => {
4 let calls = 0
5 const flaky = async () => { if (++calls < 3) throw new Error('ECONNRESET'); return 'ok' }
6 await expect(withRetry(flaky, { attempts: 3 })).resolves.toBe('ok')
7})
stash@{0}WIP on feature/auth-retry you2mf31c0aa
feature/auth-retryHEADaifeat(auth): retry transient session failures you5m9c4e7a1
aitest: cover retry exhaustion + backoff timing you12m41d2c9f
aifeat(auth): add withRetry helper you18mb7a31e2
mainfix: invalidate stale token cache dana2he91f44a
chore(deps): bump tokio to 1.44 you3h77ab210
v0.4.0release: v0.4.0 you1d3d8e6b4
perf(log): incremental git log walk dana2d5376c21
init: scaffold you3wa1b9c04
Commit⌘↵
↑↓ j k files space reviewed m note n p blocks s stage d d discard c commit ⌘F search
feature/auth-retry 3↑ 0↓ · Up to date 8 modified · 0 staged · UTF-8 · LF

This one works — click around, press j / k to step the queue, space to mark reviewed, ⌘K for the palette.

01 — The loop

Built around the agent loop, not bolted onto it.

Claude Code in one pane, Strand in the other. Most Git clients were designed for changes you made and already understand. Strand assumes the opposite: the diff is new to you, it's big, and it keeps moving.

  1. Watch it happen

    A native file watcher streams every change into Strand as the agent works — no refresh button, no window-focus dance. Running agents in parallel? Worktrees get grouped tabs and an overview dashboard: branch, dirty count, ahead/behind, one click to review.

    repo://changed · debounced 400ms

  2. Pin a baseline

    “Review everything since this commit.” Committed, staged, and unstaged agent work since the fork point shows as one diff — agents commit as they go, and your review shouldn't care. Per-worktree sessions pin themselves at the merge-base automatically.

    since 4f2c91d · committed + staged + unstaged

  3. Review with whole-file context

    Every changed file renders in its entirety with the edits inline — you judge changes in context, not through a 3-line keyhole. j/k through the queue, space to mark reviewed. If the agent touches a reviewed file again, it flips back to unreviewed on its own.

    highlighting off the main thread · 60fps on lockfiles

  4. Send feedback back

    Drop notes on lines as you read. “Copy feedback” builds one markdown prompt — quoted diff excerpts included — ready to paste into the agent. Stage what's good; discard the rest behind an automatic safety stash with a restore window.

    ✎ Copy feedback (3) → paste into your agent

git blame says it was you

The commits carry
your signature.

The agent writes the code, but it ships under your name — your sign-off, your repo, your pager at 2 a.m. A Co-Authored-By trailer won't save you in the postmortem. Read it before it merges.

Don't ship shit to prod.

commit 9c4e7a14b2f08d3
Author: you <you@acme.dev>← signed by you
Date: Fri Jun 12 16:32:08 2026
 
feat(auth): retry transient failures ai
 
Co-Authored-By: Claude <noreply@anthropic.com>← written by the agent

Strand tags agent commits in the graph — the ai chip — and “select commits since baseline” rounds up the whole session for review.

02 — Performance

Fast is the feature.

Strand's prime directive — written into the repo, enforced in review: stable, fast, performance-first. A Rust engine, your OS's native webview, and a standing rule that no change ships if it regresses a hot path.

47ms
to open a 100k-commit repo
discover + first 5,000 commits
42ms
status refresh, 10k-file tree
the path every agent edit touches
15MB
installer, whole app
Windows MSI · Linux deb/rpm · macOS universal ~31 MB
0 
bytes of Electron
Rust + Tauri + native webview

Engine benchmarks on an M1 Pro against synthetic 100k-commit / 10k-file fixtures — methodology in docs/perf-baseline.md.

03 — Keyboard

Hands on home row.

Keyboard-first, never keyboard-only. Every surface in Strand has a focus model — lists, trees, dialogs, menus — so reviewing an agent session never makes you reach for the mouse. And when you forget a key, ⌘K finds everything: branches, files, commits, actions, fuzzy-matched.

Menus open with ⇧F10, dialogs trap focus, screen readers get announced toasts. Accessibility isn't a mode.

  • jkstep through the review queue
  • spacemark reviewed — and stay put
  • npjump between change blocks
  • sstage the file
  • dddiscard — safety-stashed first
  • mleave a note on the line
  • cjump to the commit form
  • ⌘Keverything else, fuzzy

04 — Everything else

A whole Git client.
Not just a review pane.

The review workflow sits on top of a complete, fast Git client — so accepting the agent's work and shipping it never leaves the app.

Interactive rebase

Reorder, reword, squash, fixup, drop — no editor in the loop. fixup! commits auto-arrange like --autosquash.

Three-way conflicts

Theirs and ours side-by-side, the assembled result below. Pick per conflict or per side; resolve writes and stages.

Worktrees, first-class

One worktree per agent, grouped as tabs, with a dashboard, one-click review from the fork point, side-by-side Compare of parallel attempts, and Merge & clean up to land the winner — removals snapshot-archived, always restorable.

Stashes on the graph

Stashes render as nodes hanging off their base commit — apply, pop, or drop them right where they live.

Time travel

Blame with commit jump, a reflog browser with recovery actions, file history that follows renames. Nothing is ever lost.

Sees more than text

Before/after image diffs, markdown and SVG previews that re-render live as the agent edits the docs.

Light, dark, yours

Light and dark themes, eight accent hues, three densities — one OKLCH hue rotation recolors the whole app live.

Honest git

Network and signing shell out to your git — credentials, SSH agent, GPG, and LFS work on day one. No re-implementation surprises.

Workspaces

Group the repos behind one product. Open a workspace to focus the rail on just those repos, review changes across all of them in one merged queue, and import straight from a VS Code .code-workspace.

AI commit messages

Suggest subject + body from your staged changes via the ChatGPT subscription you already have (Codex CLI) or Claude Code — no API key, sign in once in Settings → AI.

05 — Pricing

Free for people.
Honor system for companies.

No feature gates. No license keys. No nag dialogs. The same full app for everyone — the only question is whether a company is making money with it.

For individuals

$0

Free. Forever. All of it.

  • Every feature — nothing held back
  • No account, no trial clock
  • No product telemetry
  • Auto-updates included
Download

For companies — coming soon

Pay once

A one-time commercial license.

  • Same app, same features — it's support, not an upsell
  • Honor system: no keys, no activation, no phoning home
  • A proper commercial license for your lawyers
  • Keeps the project funded and independent
Coming soon

free for personal use · one-time commercial license for companies · no keys, no activation, no phoning home

Your agent is already typing.

Be ready to review it. Download Strand 1.0 — it opens your biggest repo in well under a second.

Download for macOS ⊞ Download for Windows 🐧 Download for Linux

Strand 1.0 · signed stable updates · free for individuals