blerg

Run any coding agent. Never lose a session.

Blerg is a free, open-source platform for running coding-agent sessions. It launches Claude Code, Codex, Hermes, OpenCode and the rest as supervised sessions on your laptop, in a throwaway sandbox, or on your cluster, pointed at whatever model you choose, local or cloud. Every session is visible from any device, survives a reboot, and can be dispatched straight from a board where agents draft the work.

Get the code on GitHub Install in one command

Apache-2.0. Bring your own harness and model. No hosted service, no account.

sessions 3 running, 1 idle
  1. api-ratelimit claude code sandbox running
  2. nika-gallery-fix codex desktop running
  3. zalgo-check-writer hermes cluster pod running
  4. blog-import opencode desktop idlerecovered after reboot
Open any row for the live terminal, from a laptop or a phone.

Three parts. One install.

Blerg is a small federation of services shipped from one repo. Each part does one job, they talk over HTTP, and you can run them with a single script.

Runner

Launch sessions, watch them, get them back.

The runner starts a coding-agent session in the harness you pick and keeps it alive independently of your terminal. Open the session from any browser, see at a glance which ones are running, waiting on you, or idle, and pick up where you left off after a restart.

  • Any harness: Claude Code, Codex, Hermes, OpenCode, OpenClaw, NemoClaw
  • Three places to run: on the host, in a throwaway container with only that repo mounted, or as a pod on your cluster
  • Sessions survive daemon restarts and machine reboots with their history intact
  • Full terminal view in the browser, with touch controls for your phone

Board

Agents write the cards. Humans curate.

Most trackers assume writing a ticket is expensive. Agents make it free, so the board puts something in its place: an admission gate that rejects duplicates and sends vague cards back for revision, with an audit trail of everything it declined and why.

  • MCP endpoint and a small CLI for agents
  • Per-board field schemas, so it never has to learn what an incident is
  • Idempotent writes: rerunning a sweep refreshes instead of duplicating
  • Dispatch a card straight into a runner session

Core

Identity, projects, discovery, audit.

A deliberately small control plane. Components register with it on boot, tokens are minted with a specific audience and capability set, and security-relevant actions produce audit events you can export.

  • Every component serves /agents, docs written for agents to act on
  • Pluggable identity, forge, secrets, and inference backends
  • Public code, private config: your environment lives in an overlay
  • Landing page lists whatever your install has enabled

Grows with you, without a rewrite.

The same three services, the same manifests, from a laptop to a cluster a team shares. Move up a rung when you outgrow the one you are on.

  1. Desktop

    Docker Compose plus a host daemon that drives the harness CLIs you already have installed. One script builds and starts everything and opens the landing page.

  2. Homelab

    A kustomize set for any k8s distro: MicroK8s, k3s, kubeadm. Push to your own registry, host-based ingress, one Postgres with three databases.

  3. Team cluster

    Bring your own SSO, forge, and secrets store. Sessions run as sandboxed pods with project-scoped secrets and egress control, and every action is attributed.

Why it works this way

Blerg came out of running agents on a real homelab, not a demo. The design choices are the ones that survived that.

Your accounts, your hardware, your model
Sessions use the harness logins you already have, subscription or API key. Point them at a model on your own GPUs or at any cloud provider. There is no hosted Blerg and no metered proxy in the middle.
Volume without noise
Agents can file hundreds of cards a day. The admission gate keeps the board readable, and humans spend their time curating instead of typing.
Harness-agnostic on purpose
Nothing in Blerg depends on one vendor's agent. Harness choice is per project, and a new one is a driver, not a rewrite. No GPU is required either: the board's gate runs through the same inference contract, local or hosted.
Agent-first documentation
Every install and config doc is written for an agent to read and act on, and each service publishes it at /agents. Onboarding a new agent is a URL.
Isolation when you want it
Run on the host when you want the agent in your real environment. Run in a throwaway container or a cluster pod when you do not, with only that repo mounted and only that project's secrets injected.
Nothing is a black box
Session events, gate decisions, token mints, and merges all land in audit logs with a stable shape. You can answer “what did the agent do” with a query, and swap any big dependency, forge, secrets store, or deployer, behind its contract.

Install

You need Docker, tmux, and at least one harness CLI installed and logged in, such as Claude Code, Codex, or Hermes. The script generates secrets on first run, builds the images, and starts the host daemon as a service. 

# desktop
git clone https://github.com/blerglab/blerg.git
cd blerg/install/desktop
./blerg-up.sh

# homelab or cluster
cd blerg/install/k8s
cp .env.example .env    # registry, tag, domain
./deploy.sh

When it finishes, the landing page opens at localhost:8081 with the board and runner listed as tiles. Launch a session on a repo, or create a card and dispatch it, and watch it run from any device.

Read the source Full setup guide