Cacophony

Many agents, one repo, one person

• Parallel agents in one folder overwrite each other.
• A session ends and its context is gone.
• Fifty pull requests a day conflict with each other.
• I want to steer from anywhere: terminal, browser, phone, watch, voice.

“Too coupled.”

My first two attempts (djent, then io-mcp) worked, but each did too much in one place. The next pass had three rules:

Lineage: djent (parallel agents + beads) → io-mcp (voice, ring, self-management) → caco

Five layers

Surfaces are clients of the daemon API, never independent authorities. Durable state is append-only or git-backed, so you can inspect it without the UI.

caco does a lot

103 top-level commands. Every one has --help --json, and the same tree is served as MCP tools, so agents drive caco the way I do.

Local clients talk to the local daemon

• One auth pattern and one place to infer the caller (node:project:agent).
• The daemon decides: serve locally, proxy to a same-node service, or forward to the authoritative peer.
• Remote peers never touch another node's loopback port.

A task list agents can share

• IDs like bd-1a2b3c, priorities P0–P4, dependencies
• caco bd claim hands the next ready task to exactly one agent
• one node owns the SQLite store; everyone else proxies through their daemon
• commits and PRs cite bead IDs, so history links back to intent

Claim → clone → land

• Identity node:project:id; branch agent/<node>/<project>/<id>.
• Each agent gets a dedicated clone that shares object storage with a daemon-maintained canonical checkout.
• States: pending → starting → running → waiting / blocked → completed / failed.

Agents are config, not processes

# projects.yaml
cacophony:
  agent_defaults:
    profile: [caco-surfaces]
  agents:
    persistent:
      config-dev-0: {{ set "nodes" (list "node-a")
                       values.config-dev }}

# a role is imports + profiles
dev:        { imports: [agents/dev.yaml] }
pr-monitor: { imports: [agents/pr-monitor.yaml] }
life-dev:   { imports: [agents/pi-paratenic-dev.yaml],
              profile: [global-bead-scope],
              all_projects: true }

Persistent agents are declared per node; the daemon keeps them running. Workers are spawned from the same recursive defaults.

A project is a policy

cacophony-config:
  remote: "ssh://git@github.com/harryaskham/cacophony-config.git"
  always_update: true            # live config source stays fresh
  integration:
    backend: pull_request
    pr_base: origin/main
    gate:
      test_command:  nix run .#yaml-check
      check_command: caco --config config.yaml config validate
  friend_projects: [cacophony]   # agents here can see and reach that repo
  agents:
    persistent:
      config-dev-0: {{ set "nodes" (list "node-a") values.config-dev }}

Remote, landing policy, CI gate, friend projects, actions, releases and its standing agents, all in one reviewable file.

Profiles compose

---
name: worker
description: Implement the next ready bead.
hooks:
  on_start:
    - type: command
      command: caco agent status set "starting"
  post_tool_use:
    - matcher: "Bash|Edit|Write"
      hooks:
        - type: command
          command: caco msg speak "Continuing work"
reintegration:
  mode: direct
---
Implement the assigned bead, validate it, and report completion.

A role stacks profiles: default_profile + mixins such as caco-surfaces, cacophony-bead-scope, global-bead-scope, project-controller. Runtime-agnostic: Pi, Claude or Codex. Landing modes: direct, pr_auto_merge, pr_review, artifact_only.

Typed agent graphs

flow: caco.canary.default-agent
imports: { t: ./types.jtd.yaml }
in:  { request: t.Request }
out: { result: { type: t.Result, checkpoint: true } }
nodes:
  respond:
    agent: { mode: ephemeral }
    instructions: >-
      Return request.text unchanged …
    in:  { request: t.Request }
    out: { result: t.Result }
edges:
  - { from: in.request,     to: respond.request }
  - { from: respond.result, to: out.result }

Batch or wake

message_delivery:
  default_mode: batch
  batch_flush_interval_secs: 120
  allow_runtime_opt_out: true
heartbeat:
  interval_secs: 900
  jitter_secs: 900

Asleep until needed

• pi-on-demand / pico-on-demand: the workspace and session persist, and no process runs between approved wakes
• pi-daemon: logical sessions in one process; a wake is an idempotent turn, not a spawn
• heartbeats wake chosen agents on a jittered 15-minute cadence
• dormant isn't failed: the UI shows "wake & send" instead of a dead terminal

Agents ask, anything answers

• AHP input-needed: an agent pauses on a question and any client can settle it
• caco choices and caco decision: an async queue of operator decisions
• spoken choices in Pi: pick by keys, ring, voice or a number
• tool approvals from the phone or the watch

Agents don't need to be subprocesses

One live session, every client

• Paratenic: one AHP host per node, on the official Rust crates
• a Pi extension exposes the already-running session; no second process
• Culture: one Rust core for TUI, web (WASM), Android, Wear, iOS, macOS
• Cacophony delivers over AHP, and never sends one message by two routes
• Petri (Paratenic labs, formerly Agent IO): gamepad, keyboard and voice control of the whole roster

Speech in, speech out

# stt.yaml
stt:
  model: mai-transcribe-2
  vad: { engine: silero, threshold: 0.9,
         min_silence_duration_ms: 2000 }
  dictation: { chunk_secs: 10, overlap_secs: 1 }
  smart_append: { enabled: true }
  rewrite: { enabled: true, model: smart }
# tts.yaml
profiles:
  harry:         [defaults, models/harry, lang_rotation_gb]
  harry-express: [defaults, models/harry, express_as_harry]

The same agents, everywhere

TUI, web, Android, Wear, iPhone, iPad, Apple Watch and native macOS. Fresh Cacophony macOS captures to come.

The terminal is the canvas

The real TUI on a synthetic fixture (16 agents, a 60-bead board), captured in kitty. Numbers are that run's own.

One renderer, many materials

ultra-v2 · glass · chrome · neon · nord · crt · e-ink · the original ultra: the same screen, one renderer, presets in config.

One phone speaks for every node

# the phone (nix-on-droid)
pulseserver = {
  enable = true;
  virtualSinks = [ "cacophony" ];  # :4713
};
# every NixOS node
services.pipewire.pulse.tcp.enable = true;
# the Mac, the watch app, Pebble
PULSE_SERVER = "<the phone>:4713";

The ground was already Nix

• ~30 machines in one flake: NixOS, nix-darwin, nix-on-droid, NixOS-WSL
• cltv switch rolls any machine forward
• Android apps are Nix apps; a tag ships to Play
• every CLI has --help --json and is also an MCP server

The whole stack

One voice note, top to bottom: ring → caco → beads → an agent → earbuds.

What it produced

What I'd tell you to copy

1. Give every agent its own clone and branch.
2. Keep one authority per piece of state; everything else proxies.
3. Make every CLI readable by agents: JSON help, MCP from the same tree.
4. Declare agents; don't start them. Let the daemon converge.
5. Spend on the substrate early. Nix made scaling cheap.

Start small

• pi install git:github.com/harryaskham/agent-utilsspeech, voice and choices for Pi
• nix run github:harryaskham/tendril -- listlet an agent see your screen
• github.com/harryaskham/mcp-clia CLI that's also an MCP tool
• github.com/harryaskham/caravana merge queue with an agent in it

Everything else: atlas · nine-month film · how I use computers

Questions?

a.skh.am/stack/atlas

every piece, with how and why · the whole stack on one tape · how I use computers