Your agent workbench.

chimaera keeps Claude Code, Codex, and other coding agents running as persistent sessions on the machine your code already lives on, from your laptop to an HPC login node. Run several in parallel and it tells you which one needs you; drive each from a rich chat UI or its real terminal, with the files they produce rendered right beside them. Close your laptop mid-run and nothing dies — reconnect and every session is exactly where you left it.

Download Read the docs

macOS & Linux one static binary no root, no containers runs on old-glibc HPC

rnaseq-pipeline · ssh://gpu-node

claude

> volcano plot uses the wrong contrast, fix it
 
⏺ Switching the DESeq2 contrast to treated vs
  control and regenerating the figure.
 
⏺ Update(scripts/deseq2.R)
  ⎿ Updated · 1 addition, 1 removal
    - res <- results(dds)
    + res <- results(dds, contrast =
      c("cond","treated","control"))
 
⏺ Bash(Rscript scripts/deseq2.R)
  ⎿ figures/volcano.png · 2,214 DE genes
 
⏺ Write(results/deseq2_report.md)
 
⏺ Done. Using treated vs control now.

> run the QC summary next

⏵⏵ accept edits onclaude-opus-4.8

volcano.png

deseq2_report.md

Differential expression

treated vs control · 2,214 genes at padj < 0.05

gene	log₂FC	padj
IL6	+3.1	2e-11
MMP9	+2.7	8e-10
CXCL8	+2.4	4e-09
SOD2	−1.9	1e-06

fix DESeq2 refactor · needs you 3 sessions · daemon healthy

why it exists

One tool instead of two half-fits

Running agents on a remote machine usually takes two tools: code-server in a browser tab to look at files, and tmux over SSH to keep the agents alive. Browser terminals die on reload, tmux shows no file output, and the files an agent produces (reports, plots, tables) end up nowhere near the session that produced them. chimaera does both jobs in one window, on the machine that owns the work.

features

What's in it

Sessions survive disconnect

The daemon holds every PTY with full server-side terminal state. Reload, reconnect, or reattach from another machine and you get the same screen back, with no lost scrollback and no broken reconnect.

One launcher for your agents

Claude Code, Codex, Gemini CLI, and Antigravity, each detected if installed, resumable per workspace, and installable from official sources. Binaries live under ~/.chimaera, and your credentials stay yours.

Chat mode or the real TUI

Every agent runs two ways on one session, a toggle apart. Chat mode, the default, is a rich structured UI: tool cards, permission prompts, rewind, and inline previews of what each turn made. Flip to the real claude or codex TUI and it looks, behaves, and bills exactly like your terminal.

Previews that replace code-server

Images, Markdown, CSV/TSV (gzip included), PDF, notebooks, and sandboxed HTML reports, the MultiQC and FastQC class of output. The server extracts and the client renders, so whole files never load.

Git, built in

A source-control panel with side-by-side diffs, worktree create and remove, a branch per agent, and a session-scoped view of exactly what an agent changed. The review side of git, without leaving the workbench.

A real workbench layout

Split panes, tabs, drag-and-drop, focus mode, and a session strip that says where you are. Terminals and file previews are the same kind of surface, so you arrange them however the work wants.

Linked terminals

Hand an agent a leash to a live shell, the one with your modules and conda environment already loaded, instead of paying setup cost on every command. It stays scoped, user-granted, and audited in the shell's own scrollback.

how it works

The daemon owns the sessions. Windows are views.

local or remote

Connect over your own SSH

chimaera connect <host> shells out to your system ssh, so ProxyJump, ControlMaster, and 2FA from ~/.ssh/config all work as-is. The daemon installs into ~/.chimaera on the host, with no root and no containers.

Install-if-missing. Detects the target with uname and drops in the right static binary.
Start-or-attach. Reuses a running daemon, tunnels the port, opens the UI.
Self-updating. An outdated remote daemon is replaced on connect. An idle shell holding an environment is never killed without asking.

zsh · your laptop

# run it locally
$ chimaera serve
  → workbench on http://127.0.0.1:9700

# or drive a remote host: HPC login node, dev box, anything
$ chimaera connect gpu-node
  → installing daemon in ~/.chimaera … ok
  → tunnelling :9700 … ok
  → opening workbench

built for shared machines

One static binary. Old glibc. No root.

The daemon cross-compiles to fully static musl binaries (x86_64 and aarch64) that run on old HPC systems, verified on a cluster running glibc 2.17 with no root. It is built to live on a shared login node: bounded allocations, hard ceilings on preview extraction, and about 150 MB RSS at steady state.

NFS-safe state. Append-only, size-capped JSONL under ~/.chimaera, so there is no SQLite near Lustre.
Good citizen. No busy loops, no unbounded buffers.
Native app included. A Tauri shell wraps the same UI with a home screen of workspaces and one-click connect. It auto-updates; quitting kills nothing.

$ ldd ./chimaera
  not a dynamic executable

$ ./chimaera serve --port 9700
  chimaera 0.1 · build a1b9f3c
  workspaces: 2 · sessions: 5 (3 live)
  listening on 127.0.0.1:9700

download

Get chimaera

The native app bundles the daemon and auto-updates itself. The standalone daemon binaries are for remote hosts, and chimaera connect installs them for you.

Native app

The workbench in real windows: a home screen of workspaces and remote hosts, one-click connect, and signature-verified auto-update on launch.

latest release · macOS (Apple Silicon)

Download for macOS

Apple Silicon · .dmg · auto-updates after install

daemon binaries

Linux · x86_64

static musl

Linux · aarch64

static musl

macOS · aarch64

daemon binary

All releases are on GitHub.

build from source · needs Rust + Node

$ git clone https://github.com/martinappberg/chimaera
$ cd chimaera
$ npm --prefix web-ui install && npm --prefix web-ui run build
$ cargo build --release -p chimaera
$ ./target/release/chimaera serve

faq

Good to know

How do my agents run and bill?

Two ways, a toggle apart. In the real TUI, an agent runs as the actual claude or codex terminal in a normal PTY, spawned through your login shell with your environment, so it behaves and bills exactly as it does in any terminal. In chat mode (the default), chimaera drives the same CLI over its structured JSON protocol to render the rich chat UI; that path bills like the CLI's structured/headless mode rather than the interactive TUI. Either way, chimaera never touches your credentials, it just owns the process. One setting (agents.defaultView) picks which mode new sessions open in, and any session flips between the two.

Do my credentials go through chimaera?

No. Credentials stay yours. They live in your HOME and login-shell environment, independent of who installed the agent binary. chimaera can install and update agent CLIs from official sources, but never touches your auth.

Is it only for HPC?

No. It is a general tool for running agents wherever the work lives. HPC login nodes are the founding stress test (old glibc, no root, shared machines), which is why it also behaves well on a laptop or a plain dev server.

What platforms are supported?

macOS and Linux. The daemon ships as static musl binaries for x86_64 and aarch64 Linux plus an aarch64 macOS build; the native app is macOS (Apple Silicon). Windows is untested. See the docs.

What's the license?

GNU AGPL-3.0, free to use, self-host, and modify. For a closed-source product or service built on chimaera, a commercial license is available: get in touch. Contributions require a CLA.