blerg

One place to run all your coding agents.

Free, open-source. Blerg runs Claude Code, Codex, and Hermes on local models like NVIDIA Nemotron, side by side, on any machine you own. Agents hand work to each other with your approval, you watch every one of them live, and a board gives them the work. Local and cloud, one crew.

Get the code on GitHub Install in one command

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

A real session. NVIDIA Nemotron 3.5 Super VL, running on a desk-side DGX Spark, started Claude and Codex as its crew; the panel lists every session it started.

See it work

MORE POWER 1:13 NVIDIA Nemotron on a DGX Spark takes a launch-night ticket, then calls in Claude and Codex as its crew. An AI agent made this 2:09 A tour of Blerg: boards, sessions that start sessions, review, and charts, recorded and voiced by AI.

Real footage of Blerg, made by AI agents inside it. Videos play here from YouTube.

Isn't this just another AI chat app?

It looks like a chat because a chat is the easiest way to steer an agent. Underneath is everything it takes to run real agents safely, side by side, at scale:

  • The real agent CLIs. Claude Code, Codex, Hermes and OpenClaw run as themselves, with their own logins, tools, skills and plugins. Blerg drives them; it doesn't wrap one API.
  • Real sandboxes. Each session gets its own Docker container or Kubernetes pod. It sees the repository and its own login, nothing else of your machine.
  • Sessions that survive. Daemon restarts, a sleeping laptop, a usage limit that resets: sessions recover and carry on by themselves.
  • Agents that start agents. Across engines and models, with approval cards, standing rules, and awareness of each provider's remaining budget.
  • A board, not a to-do list. Agents draft cards, an admission step rejects duplicates and vague work, and a card becomes a session.
  • Credentials stay yours. One login, a per-person credential vault, and an MCP gateway that never shows the agent your token; risky write tools can wait for your approval.
  • Review for everything. Code, documents, PDFs and images, with anchored requests the agent answers one by one.
  • Numbers you can trust. Tokens, cost and usage limits per session and per provider, plus Prometheus metrics.

It doesn't look like a lot. It's a lot.

You have probably been here.

  1. One terminal

    One agent, one prompt, and you watching it.

  2. Several terminals

    Tabs everywhere. Which one just asked you a question?

  3. tmux, or the harness's own sub-agents

    More in flight, still tied to one machine and one screen. Close the lid and it is gone.

  4. Blerg

    Every session on every machine in one list, from any device, back after a reboot. And a board for when prompts stop scaling.

Two ways to work. One platform.

Keep prompting the way you do today, only with fewer limits. When a project outgrows a single prompt, move to tickets. Both run on the same install.

Prompt-driven sessions

What you do now, made more useful.

  • Any harness, any model, local or cloud
  • Resume a session on another machine, or after a reboot
  • Watch and answer from your phone
  • One laptop today, a cluster when you need it

Ticket-driven engineering

For when the work outgrows one prompt.

  • An agent-first kanban board, shipped in the box
  • Tickets designed for agents to write and read, not just humans
  • An admission gate that rejects duplicates and vague cards
  • Dispatch a card straight into a session, review the result on the card

Runner

Launches sessions in the harness you pick, keeps them alive, shows them in any browser, and brings them back after a restart.

Board

The agent-first kanban board. Agents file cards over MCP or a CLI, the gate curates, humans review and dispatch.

Core

A small control plane: identity, projects, discovery, audit. Every service publishes its docs at /agents.

Any scale. Same three services.

The runner, board, and core are the same binaries whether one person runs them on a laptop or a team runs them across a cluster. Start small, move up a tier when you outgrow it, keep your sessions.

  1. A few sessions

    Desktop

    Docker Compose and a host daemon, on the machine you already work on.

    • Windows
    • Linux
    • macOS

  2. Dozens of sessions

    All your computers

    A daemon on the desktop, the laptop, and the box under the desk. Each one dials in, and every session lands in the same list no matter where it runs.

  3. Isolated sessions

    Containers

    A throwaway container per session, with only that repo mounted and only that project's secrets injected.

  4. Hundreds of sessions

    Kubernetes

    One pod per session on any cluster: MicroK8s, k3s, kubeadm, or the one your team already runs.

Why it works this way

Choices that survived running agents on a real homelab, not a demo.

Works while you are away
Over Tailscale or any VPN, nothing exposed. Watch a session, answer its question, or dispatch a card from your phone.
Your accounts, hardware, and model
Your existing harness logins. Models on your own GPUs or any cloud provider. No proxy in the middle.
Volume without noise
Agents file hundreds of cards a day. The gate rejects duplicates and vague ones, so humans only curate.
Harness-agnostic on purpose
Harness choice is per project. A new harness is a driver, not a rewrite. No GPU required.
Agent-first docs
Every service publishes its docs at /agents, written for an agent to act on. Onboarding is a URL.
Isolation when you want it
On the host, in a throwaway container, or in a pod. Only that repo mounted, only that project's secrets.

Supported today

Harnesses

  • Claude Code
  • OpenAI Codex
  • Hermes Agentlocal models, e.g. NVIDIA Nemotron
  • OpenClawhost sessions

Runtimes and infrastructure

  • tmuxhost sessions
  • Dockerlocal sandbox
  • Kubernetescluster pods
  • Postgres

Integrations

  • GitHub
  • MCPagent access to the board
  • Tailscalereach it from anywhere

More harnesses (OpenCode, NemoClaw) and forges are on the way. A harness is a driver, not a rewrite.

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-ai.git
cd blerg-ai/install/desktop
./blerg-up.sh

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

When it finishes, your browser opens at localhost:8081 and asks you to create your account; no password to dig out of a log. Then 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

Put your whole crew to work.

Local models and cloud agents, side by side, on hardware you own. Free and open source.

Get Blerg on GitHub Watch MORE POWER