Galda

Hand off the work. Judge the result.

Galda turns your Claude Code subscription into a team you direct: you describe a goal in chat, Galda decomposes it into tasks, Claude Code workers implement each one (writing and running tests), an independent verifier exercises the result in a headless browser, and you get evidence — video, screenshots, changed files, optionally a pull request with the proof committed to the branch. You only step in when a decision needs a human.

The problem it attacks: today humans micromanage AI — checking every three minutes, re-explaining context, getting "done" claims that are not done. Galda does the task on your machine, tests its own output, and only says "done" with proof.

Principles

• Proof-first. "Done" is granted by an independent check (a real browser clicking the real UI, recorded), never by the worker's self-report.
• Runs on your subscription. The engine is your existing Claude Code — no extra metered API. Verification is deterministic (no LLM at verify time). This is a hard requirement, not a preference.
• Everything stays on your machine. Galda runs locally; your files never leave. Git operations happen in temporary worktrees, and workers have no git access at all — your working tree is sacred.
• Failure is a first-class outcome. Tasks can end as needs-human or blocked, not just pass/fail. (In progress.)

Quickstart

Requirements:

• The claude CLI, logged into a Claude subscription — required (this is the engine).
• Node 20+.
• Google Chrome — recommended (enables the headless video/screenshot proof).
• ffmpeg — optional (turns proof videos into mp4/gif; without it they stay .webm).
• macOS is best-supported; Linux/Windows are experimental.

One line — it checks your environment, starts the local server, and opens your browser. State lives in ~/.manager-for-ai (never in the npx cache); the directory you launch from becomes your first project:

npx @galda/cli

Then pick a project (a directory on your machine), type a goal in Japanese or English, and press Enter. Include an explicit pass condition ("clicking #save shows a toast containing Saved") and Galda verifies it independently and attaches video proof. Add "make a pull request" (or プルリク) and it opens a PR with the proof committed.

Pricing

Free to try — up to 5 queued tasks and 1 project. When you outgrow it, subscribe for unlimited tasks and projects and get your license key at galda.app. Because Galda runs on your own Claude Code subscription, there's no metered API bill on top.

Connect over MCP

Click "Connect MCP" in the top bar and run the generated one-line command. From then on, any Claude Code session can drive Galda:

• manager_create_goal — hand over a goal (project, text, deliverable, model)
• manager_status — goals, tasks, proof and PR links
• manager_reply — reply in a goal's thread (resumes that goal's worker session)

How it works

goal (chat / MCP)
  → planner: decompose into tasks + extract pass conditions   (1 LLM call)
  → worker: claude -p per task, tests written and run          (your subscription)
  → verifier: authored once, then run deterministically in
    headless Chrome — video (mp4 + auto-playing GIF) + screenshot
  → fail? worker retries with the failure evidence (max 3)
  → all done? optional PR from a temp worktree, proof committed

State lives in an append-only ledger, not in the conversation — the server restarts without losing pending work. Each goal keeps its own Claude Code session, so thread replies carry full context.

From a repo checkout (development)

npm install
node engine/server.mjs   # prints the keyed URL; state stays in engine/
npm test                 # unit tests (pure helpers)

A repo checkout keeps its state in engine/ (detected by the .git dir); the installed package uses ~/.manager-for-ai. The repo dogfoods itself: open the app, pick this project, and hand it a goal — a worker implements it here under the rules in CLAUDE.md (tests are mandatory).

Layout

app/        browser UI (single file, no build step)
engine/     server.mjs (chat/queue/SSE) · manager.mjs (verify-proof loop)
            verify.mjs (deterministic verification core) · pr.mjs (worktree PRs)
            mcp.mjs (MCP server) · lib.mjs (pure helpers) · test/
examples/   demo fixture app + a task definition for the verify-proof loop
CLAUDE.md   rules that every worker in this repo loads (tests are mandatory)

Status

Working, changing fast. Verified end to end: goal decomposition, live activity streaming, independent verification with video proof, proof-carrying PRs, thread replies with session resume, MCP access, per-goal model selection.