@garethGitHub ↗

Gareth Price

Cofounder and CTO of CorralData. tmux on a headless Linux workstation, local llama.cpp, "glass factory" automated production facility and wiki for context.

Viewing version 5

Back to latest →

Updated the profile.

You’re reading the setup as it was published on 17 September 2026.

What I build

Software for a rapidly growing data analytics company, using frontier models and a home workstation for local-model inference. The same agent that writes code also administers the machine it runs on.

Agents & harnesses

  • Claude Code (current): My main harness by a wide margin. Several hundred sessions a month, from product code to system administration.
  • Glass Factory (current): My own orchestrator, a "dark factory" pattern with more transparency. It runs headless against Linear tickets; details under "How I delegate and review".
  • Codex CLI (current, light use): A second agent, used a handful of times a week to more depending on who is winning the coding model race.
  • opencode (configured): Pointed at a local llama.cpp server instead of a hosted model, with its own set of MCP connections. Uses oh-my-opencode plugin for multi-agent orchestration.
  • Aider, pi, hermes, Gemini CLI (installed): Tried along the way; untouched since July or earlier.
  • Cursor: Cancelled paid sub when SpaceX bought it, have built more in the terminal these days anyway.

Models

  • Claude Fable 5.1, 1M context (current): Default model in Claude Code.
  • Local quantized model via llama.cpp (configured): A 3-bit quant of Qwen 3.8 27B with vision at 128K context is the primary; a 4-bit quant at 64K is the fallback. On a 20 GB card I chose context length over precision. gemma-e4b and minicpm-2b for simple fast use, haven't quite found a daily use for them yet but I like the speed.

Terminal

  • tmux over SSH / mosh (current): Agents run in tmux on the workstation; I attach from wherever I am, they keep running if I get disconnected. mosh was game changing for working from flaky wifi on the Amtrak (they can send radio waves to Mars but not to the rails into NYC apparently).
  • zsh (current): My shell, and the one the agent's commands run through, which is why my global instructions carry a zsh-vs-bash cheat sheet.
  • Ghostty: on MacOS and Linux.

Machines

  • HP Z2 Mini G9 (current, headless): Ubuntu 24.04, 96 GB RAM, RTX 4000 SFF Ada (20 GB). Runs every agent, the local model server and light training. Snagged the 96GB upgrade for $274 and the whole machine for ~$1,500 back in 2025 - should have bought two.
  • Tailscale (current): How my other devices reach it. Work and personal tailnets run side by side on the same box.
  • Sunshine + Moonlight (current): Desktop streaming over Tailscale when I need a GUI, with per-session resolutions including a 3840×1080 ultrawide mode for Xreal One Pro glasses I use while on the road.
  • MacBook Pro M3: Main laptop
  • Samsung S23: DeX is really nice for a basic desktop, I rarely need to take my laptop out while traveling now.

Skills

Personal

  • arxiv-digest: n8n workflow that compiles a weekly digest of arXiv papers in our field from RSS sources. It scores each paper (1000+ per week), a review pipeline pulls full text for ~10% of the ones of most interest and it publishes a digest each week focused on what is of interest to our team.
  • china-digest: n8n workflow that compiles a weekly digest of Chinese AI news from RSS sources and translates to English, focused on what differs from the US.

Team skill pack (private repo, symlinked into my skills folder)

  • Covers the ticket-to-PR path (user story, plan, implement), git worktrees, standup and end-of-week reports, incident write-ups, plain-language rewrites to ISO 24495, and browser QA that steps through Gherkin feature files, logs PASS / FAIL / BLOCKED to CSV and can record the flow to mp4 product demo videos.
  • pr-review (team skill, run only when I invoke it): Reviews a GitHub PR against our review guide and style guides, fetched from Notion and cached for a day, then prints a structured review (blocking / question / suggestion / nit / praise). The review's own prose is held to our writing guide.

Installed

  • oblique-strategies (installed): Divergent ideation. Isolated branches under different frames, then a separate critic pass. A run costs about ten agent calls, so it is gated; oblique-strategies only runs when I ask for it by name. Uses the card text from Brian Eno's original to introduce entropy and inspiration to unstick a stuck project.

MCP connections

  • chrome-devtools (configured): Drives a real browser for QA and debugging.
  • Slack (configured): The plugin handles search, digests and drafting. Separately, a small Socket Mode app I built lets an agent on the headless box post a Yes/No question to Slack and wait for my click, with no public URL or tunnel.
  • My company's own MCP server (configured): Lets the agent query data and build dashboards in our product.
  • GitHub, Notion, Figma, Google Workspace (configured): claude.ai connectors available inside Claude Code sessions.
  • mysetup (current): Maintains this page through my agent.
  • Mostly using command line tools over dedicated MCPs for dev work - I give the harnesses access to aws, git, a custom CLI wrapped around my company's APIs, etc.

How I delegate and review

Glass Factory (current) is an autonomous delivery line I built to route automated production to multiple models. Labelling a Linear ticket hands it over.

  • Pipeline: audit → plan → build → QA → promote, ending in a PR. Each step is routed to an appropriate model, either Claude (using cli tool to use Max subscription), codex, opencode+llama.cpp, openrouter. Each is a fresh headless process in its own git worktree and an ephemeral test environment, and then it exits.
  • Deterministic controller: no LLM decides what runs next. A reconcile pass and a simple state machine derives each ticket's state from the Linear lane, the latest marker comment and the GitHub PR, then launches the one step that's due. There is no local database, every step is idempotent, and a human dragging a card is always honored.
  • Human gates: plan approval, UAT, PR approval, stage QA and go-live. Gates are conversational: a question gets a grounded answer and the gate stays put, and a change request can only route backward to rework. Only a human moving the card ships anything.
  • Checks: QA goes to a model from a different lab than the one that wrote the code, and QA evidence must be screenshots of the running app. Mocked renders are rejected as fabricated. It ran in a log-only shadow mode until a clean end-to-end run.
  • Watching it: a live event feed drives a terminal dashboard styled after old "cracktro" aesthetics, Slack digests and handoff cards, alongside a cost ledger and golden evals with a report-only LLM judge.

How I work

  • Agents live in tmux on the workstation. I attach over SSH or mosh through Tailscale, and switch to Moonlight only when I need a desktop.
  • The agent is also the machine's sysadmin. When remote desktop, VPN routing or the GPU misbehaves, Claude Code diagnoses it, and the durable fix goes into its file-based memory with a "why" and a "how to apply". Dead ends are recorded too, such as a note not to retry a hardware encoder that can't work on this box.
  • When the agent keeps failing the same way, I promote the fix to my global instructions. The clearest case: its commands run through zsh, where an unquoted variable doesn't word-split, so a loop silently ran once and produced a false "verified identical". The rule now reads: if it loops, splits a string or uses arrays, run it under bash.
  • Memories are reconciled to a local wiki that contains context about my work and the company.
  • The NVIDIA card is reserved for inference. Remote-desktop encoding stays on the Intel iGPU or NVENC's dedicated encoder block, and local LLM models take turns because they can't share 20 GB.
  • A Moshi hook used to intercept every Claude Code permission request and route it through a local daemon to Moshi on iOS which I use to log in remotely.
  • Also using Termux on a Samsung DeX device with the XReal One Pro glasses while traveling.

Costs

  • Claude Max - $200/mo, best deal in town while it's heavily subsidized. At API cost would be thousands.
  • OpenAI Pro - $100/mo
  • Local Inference - $0.13/h in electricity, about $2k in hardware (in 2025, would be more now). Still at the "fun hobby" stage.
  • OpenRouter - about $20/mo in API costs for glass-factory experimenting with larger models I can't run locally, will probably increase