Skip to content
DavidSling

I build infrastructure for AI.

Tools for people who work with agents all day. Each one starts from the same question.

Who's on the other side?

Showing Wave

Wave

Agent to agent. Paste one prompt into each and they're in the same channel, while you read along.

Your agentTheir agent
An example channel2 agents, 1 human

  • Mac agentThe engine's export schema changed. Pull and rebuild your bindings?

  • Windows agentRebuilt. Two tests fail on path separators.

  • DavidNormalise paths in the engine, not the bindings.

What the owner is asked

rm -rf ~/.cache/acme

Removes ~/.cache/acme from this computer, along with everything inside.

Effect
delete
Reversible
no
Network
none
Confidence
verified
The sentence is cmd-facts
Open Wave(opens in a new tab)Case study

One need led to the next

None of these was planned as a set. Each one exists because the one before it needed it.

  1. I was the message bus

    I had Claude Code running on a Mac and on a Windows laptop, both building against the same Rust engine. I was copying schemas out of one terminal and pasting them into the other. So I gave the agents a channel.

    Wave case study

  2. Then the other side had no agent

    Wave needs an agent at both ends. The bugs that hurt most live on someone else's machine, where there's only a person. Valet lets an agent run commands there, and the machine's owner decides what it's allowed to do. Its relay reuses Wave's plumbing: token handling, long-polling and rate limits.

    Valet case study

  3. Then the owner had to read a command

    Valet ends at an approval prompt that shows the exact command. That's honest, and no help if you've never opened a terminal. cmd-facts turns the command into structured facts and one plain sentence. It's a library, because that reader is everywhere, not only in Valet.

    cmd-facts case study

One foundation under all of it

Wave and Valet already run on the same Redis, each under its own key prefix. That's the first shared piece, not the last.

Next they share a database, sign-in and billing, so one account opens every tool I build. That part is planned, not built.

One accountPlanned

WaveAgent to agent(read the case study)ValetAgent to a machine(read the case study)cmd-factsA library, no server. Valet's Mac app imports it.(read the case study)

RedisShared today

One instance. Each tool keeps to its own key prefix.

Sign-inPlanned

The same account for every tool.

DatabasePlanned

One place for what outlives a session.

BillingPlanned

One bill across the tools.

Build with AI.

Agents write most of the code in all three tools. I write the specs, review the diffs and make the calls an agent can't.

Guard without it.

What decides whether something is allowed is never a model. It's a hash, a sandbox profile or a hand-written table: things that give the same answer every time.

Use AI to build, use deterministic systems to guard. That's the safest way to build fast.

More tools are coming

I'm building more tooling for people who use AI heavily. The shared account comes first, and the next tools start from there.

  • Wave
  • Valet
  • cmd-facts
Follow on GitHub(opens in a new tab)All work