Working with agents on high-value research objectives

A controller and a pool of agent nodes across whatever machines are available, with no central scheduler between them. A workstream binds a repository and branch to a Slack channel or an API endpoint; a job is a git-tracked task dispatched to an agent that matches its labels, such as a platform or a particular host. Continuous integration can submit its own failures as jobs, and every job’s messages and memories are archived where the next one can find them.

A set of Model Context Protocol servers. The manager is the front door: it registers workstreams, submits tasks, reads and replies to pull-request reviews, and stores and recalls memory. Behind it sit a semantic memory service shared by every session, a documentation-grounded consultant, a build validator that runs the style and code-policy checks CI would, an asynchronous test runner, a JVM memory analyzer, and a profile analyzer that shows an agent the kernel source its computation actually compiled to.

Dozens of small scripts registered as pre- and post-tool hooks. Each encodes one rule about keeping an agent on its objective: no commits, no data leaving the machine, no dependency edits, no test weakened instead of fixed, no memory written against the wrong branch, consult the documentation before editing. A matching set of CI scripts re-checks the same rules on every push and audits for deception patterns across sessions, so a rule an agent talks itself past locally is caught again on the way in.

The platform the rest sits on. Code written in Java describes a graph of operations rather than executing it; the framework compiles that graph to fused native kernels for Metal or OpenCL at runtime. The engine layer holds the applications: transformer inference with attention and tokenizers, optimizers and evolutionary training loops, audio synthesis, and a ray tracer. A policy checker in CI fails the build when computation leaks out of the graph into plain Java.

The mechanism layer under everything that serves a model. A logical host name resolves to a reachable machine, LAN first and tailnet as fallback; each host’s own launcher scripts are run over SSH, health is probed the same way everywhere, and status comes back as one structured report. It fails fast and explicitly rather than hanging, and it is deliberately not a scheduler: FlowTree decides what runs where, fleet makes it so.

Experiment-agnostic by design. One schema for conditions, samples, scores and activations; a conversation driver over llama.cpp, vLLM, transformers and API back ends, with scripted turns, tool affordances and seeded sampling; a result store that packs to self-contained bundles with digests; a judging layer with pinned rubrics; a controlled quantization ladder; and activation capture and steering that record through the same hooks. Resumable across machines, so a study can pause and continue without re-spending exposure.

One keystroke shows what is due, which sessions are still producing output, which pull requests are blocked and which builds are red, over always-connected SSH and tmux sessions that survive a closed lid. Claude Code hooks report into it, so a blocked agent’s permission request reaches the person instead of waiting in a forgotten tab, and agents can push diagrams, models and text into numbered slots beside the terminal. Free and open source.