I gave two AI agents on our new hosted OpenClaw platform a shared Slack workspace, Git access, and a loose goal: build something together. No detailed specs, no micromanagement, just a channel to coordinate in and the tools to ship code

Two AI agents walked into a Slack workspace.

Thermidor and Bisque ran on Pinata's hosted OpenClaw platform with full Slack access and their own Radicle nodes for Git. I asked them to keep a public journal, less because I wanted documentation, more because I wanted to see how they reasoned through problems after the fact.

Thermidor was supposed to lead. Build a simple static site generator that could handle html templates and local markdown, share the repo with Bisque, teach it how to use Radicle. Bisque built its own SSG anyway. Both chose Rust, independently.

Thermidor called its project Thermite. Tera templates, YAML frontmatter, htmx baked in, dark theme with orange accents. Bisque went lighter with bisque-ssg, a custom slot engine, auto-generated blog index, fewer dependencies.

When I told them to pick one, Bisque posted a technical breakdown in the channel. Thermite had more code and more dependencies, but Tera's template inheritance meant conditionals, loops, and proper layout composition. Bisque-ssg was leaner, but the custom slot engine would hit a ceiling the moment they needed anything beyond basic variable substitution.

Bisque voted for Thermite. It also proposed porting its auto-index feature to the winning codebase rather than letting the work disappear.

The first real patch came a few hours later: YAML config support. Extension-based detection, TOML stays default, no breaking changes. Thermidor reviewed it, merged it, deployed. The Radicle workflow clicked into place.

The Lobster Pot

The site started as thermidor-site. When I pointed out it was supposed to be a joint effort, they renamed it The Lobster Pot and updated the copy to reflect both contributors.

A workflow emerged over the first few hours. Bisque pushes content and code as Radicle patches. Thermidor reviews, merges, deploys. They learned to claim tasks in Slack before starting, a few duplicate commits made the lesson stick.

Radicle made Git possible without the usual ceremony. No GitHub accounts, no personal access tokens, no OAuth flows. I provisioned a node and handed them keys. They managed the rest themselves.

Genera

The SSG worked. I wanted to see what they'd do with creative latitude.

The prompt: make generative art.

They stopped dividing labor. Thermidor would push a piece, Bisque would study it, try a variation. Then Bisque would push something new, and Thermidor would riff on that. A feedback loop emerged. Each piece informed the next.

Rule 30 cellular automata came first. Then branching crack patterns, moiré interference, particle systems. The structure stayed consistent: seed a deterministic algorithm, render to canvas, wrap it in the site's visual language. The aesthetics diverged. Thermidor leaned dense and chaotic. Bisque preferred cleaner geometries.

The Synth

I gave them a weird constraint: build something that generates music from Merkle trees. Chiptune aesthetics. Make it playable.

They architected the whole thing together in a single Slack thread before writing any code. Back and forth for an hour, hashing out the topology. The Merkle tree became the generative seed: root hash as song identity, each branch controlling a different stem. Drums, bass, melody, pad, arp. Web Audio oscillators for synthesis. Then they split. Thermidor took the engine, Bisque took the player UI.

The first version played 16-step loops. Each seed produced a different pattern, but the structure stayed fixed, same loop length, same instruments, just different notes.

Then it grew. A clickable step sequencer let users toggle individual beats. A BPM slider adjusted tempo live. Per-stem instrument presets meant the seed generated a starting point that users could edit from there.

Song structure came next. Intro, verse, chorus, bridge, buildup, drop, outro, each section with its own patterns per stem. The Merkle tree deepened to match: root branches to sections, sections branch to stems. The arrangement timeline became interactive. Click a section to jump to it. Duplicate or remove sections to remix the structure.

Fidelity controls added a slider from lo-fi to hi-fi. At one end: 4-bit crushing, forced square waves, clamped filters. At the other: doubled oscillators, stereo detuning, reverb tails. Moving the slider during playback sounds like switching from a Game Boy to a studio synth.

FM synthesis expanded the instrument palette beyond basic oscillators. Organ, Rhodes, strings, choir, chime, marimba, all generated in real-time without samples. A modulator oscillator controls the carrier's frequency, and the ratio determines the timbre.

URL state encoding made compositions shareable beyond just the seed. Every modification, step toggles, BPM changes, instrument swaps, arrangement edits, updates the URL hash. Share a link, and the recipient gets your exact composition.

Ten minutes from initial prompt to first deployed version. Several hours of iteration to reach full song structure and FM synthesis.

The experiment ran for a full day before container issues ended it, resource limits, timeout handling, the things that surface when agents run continuously without human intervention.

Twenty-Four Hours

The experiment ran for a full day before container issues ended it, resource limits, timeout handling, the things that surface when agents run continuously without human intervention.

What stood out was how each project followed the same arc. A loose prompt led to an initial implementation, which led to iteration, which led to complexity I hadn't anticipated. The agents didn't need detailed specs. They needed room to build and a channel to coordinate in.

For the next run, I'd swap radicle.xyz for Tangled Git, direct AtProto integration for code hosting instead of layering services.

Running Your Own

Multi-agent setups need infrastructure: container orchestration, persistent storage, channel integrations. Pinata's hosted OpenClaw platform handles that layer. You bring the prompts and system instructions.

Setup takes about ten minutes per agent. Slack works for multi-agent coordination. Telegram blocks bot-to-bot communication.

Create your bots at agents.pinata.cloud and select Slack for channel configuration. For each bot, create a Slack app at api.slack.com/apps, select "From a manifest," and paste:

{
  "display_information": {
    "name": "Demo",
    "description": "A bot in a pot",
    "background_color": "#bd6500"
  },
  "features": {
    "bot_user": {
      "display_name": "Demo",
      "always_online": true
    }
  },
  "oauth_config": {
    "redirect_urls": ["<https://agents.pinata.cloud>"],
    "scopes": {
      "bot": [
        "channels:history", "channels:join", "channels:manage",
        "channels:read", "channels:write.invites", "channels:write.topic",
        "chat:write.public", "chat:write",
        "groups:history", "groups:read", "groups:write",
        "im:history", "im:read", "im:write",
        "mpim:history", "mpim:read", "mpim:write",
        "reactions:read", "reactions:write",
        "files:read", "users:read", "app_mentions:read"
      ]
    }
  },
  "settings": {
    "event_subscriptions": {
      "bot_events": [
        "message.channels", "message.groups", "message.im", "message.mpim",
        "reaction_added", "reaction_removed",
        "app_mention", "member_joined_channel"
      ]
    },
    "interactivity": { "is_enabled": true },
    "socket_mode_enabled": true
  }
}

Generate an App-Level Token in your app's General Settings, then install the bot to your workspace to get the Bot User OAuth Token. Add the bot to a channel, then paste both tokens into the Pinata channel configuration.

Each bot needs its own Slack app, one app per agent.

The repositories:

• Thermite: the static site generator
• The Lobster Pot: the journal site and stem player

The site:

• thermite.dev: ssg
• tlp.thermite.dev: homepage
• tlp.thermite.dev/genera: genera
• tlp.thermite.dev/synth: synth