Software engineer, systems design first.

It started with an auto-eater for an idle game. Then a scraper for baseball stats. Then a model to predict the stats, then a script to babysit the model. Somewhere in there I stopped writing the thing and started writing the thing that writes the thing, and I haven't really stopped since — about three years of pouring most of my waking hours into it.

Generating code got cheap. Knowing which of it to trust didn't.

So that's what I build now: harnesses that agents do the real work inside, and the verification underneath that makes the output worth keeping. Provenance that traces a claim back to the exact bytes it came from. Judges that run in clean rooms so my own wishful thinking can't leak into the score. Promotion gates somebody has to pull by hand.

(Also a manga reader. And a speech server in Go. And a wheel spinner. You'll see.)

Nothing here needs an account, and most of it doesn't need a GPU or a network:

make demo                 # symphony, running agents against a fake tracker — no credentials, no network
npm install -g ralph-cli  # scaffold and guard a repo your agents are about to churn through

Symphony's demo boots a simulator that speaks the Codex wire protocol, opens a dashboard on 127.0.0.1:8420, and lets you drag a ticket to Done and watch the run stop and clean up after itself. That's the whole pitch in about ninety seconds.

I keep circling the same problem from different sides: an agent can produce more than you can check, so the checking has to be part of the machine. Each of these is one answer to that.

Click any box to open its repo.

flowchart TD
    pn["📄 <b>paper notes</b><br/>ten studies, every claim<br/>checked against the source"]
    dv["🪵 <b>dovetail</b><br/>skills that compose agents,<br/>judges and clean-room evals"]
    tr(["🌿 <b>trellis</b><br/>agentic runtime over corpora<br/>way bigger than context"])
    sy(["🎻 <b>symphony</b><br/>tickets become isolated,<br/>autonomous agent runs"])
    rc["🧹 <b>ralph-cli</b><br/>keeps a repo navigable<br/>while agents churn it"]

    pn -->|"what the research<br/>actually licenses"| dv
    dv -->|"built with"| tr
    dv -->|"built with"| sy
    rc -->|"keeps them honest"| tr
    rc -->|"keeps them honest"| sy
    tr -.->|"contests a note when<br/>the evidence under it dies"| pn

    click pn "https://github.com/OpenCnid/llm-research-inspirations"
    click dv "https://github.com/OpenCnid/dovetail"
    click tr "https://github.com/OpenCnid/trellis"
    click sy "https://github.com/OpenCnid/symphony"
    click rc "https://github.com/OpenCnid/ralph-cli"

    classDef engine fill:#1f6feb,stroke:#1158c7,color:#ffffff;
    classDef tooling fill:#8957e5,stroke:#6e40c9,color:#ffffff;
    class tr,sy engine;
    class dv,rc,pn tooling;

An agentic runtime for corpora far too big to read into context. Instead of stuffing everything in and watching it rot, the model writes code in a persistent Python REPL and calls itself over slices.

The part I actually care about is what happens to what it learns. Source bytes live in Postgres as immutable content-addressed blocks. Derived beliefs live in Neo4j carrying the exact hashes they came from, so every claim traces back to bytes. Change a source and a Merkle diff walks the graph marking anything downstream contested — quarantined and auditable instead of quietly wrong. Nothing gets promoted to trusted without a human running the command.

Then it turns the same rule on itself: Trellis writes its own extensions as modules, and each one lands the way a belief does. Two are active, one's retired, one's contested. A capability gets held to the standard its knowledge is.

Twenty-query benchmark: F1 1.000 on every query, twice over in independent runs, $0.81–$0.87 a run. TypeScript + Python, Express API, Next.js, ~250 commits.

A Rust implementation of the OpenAI Symphony spec. It watches an issue tracker, opens a workspace per issue, runs a coding agent in it, and keeps watching — move the ticket to Done and the run stops and the workspace disappears.

Most of the work went into the boring guarantees, which is usually where the real work is. One authority mutates scheduling state, so an issue can't be dispatched twice. Agents run only inside their own sanitized path. Tracker credentials never touch the agent's process environment. Config is one file in the repo, reloaded live — and if you save something invalid it keeps the last known good instead of taking the service down.

Tokio multithreaded, two agent backends, Apache-2.0.

Author prompts without contaminating them. Compose isolated sub-agents and judge panels. Verify a result in a clean room without fooling yourself. Close a session so the next one starts from what actually happened rather than from vibes.

Agents write fast and leave a mess behind: duplicated patterns, drifting architecture, docs that stopped being true three commits ago. This is the countermeasure — scaffolding and architectural guardrails that keep a repo navigable while agents iterate on it. On npm, 477 commits.

Ten papers read end to end and written up as three-tier chain-of-density notes, every claim locator-verified against the source. Not summaries — notes about what a paper actually gives you permission to build. llm-research-inspirations is the map from the research to what came out of it, with receipts.

I'm looking for a team building agent systems for real — where the harness, the inference layer, and the product are all the same problem, and somebody has to hold all three at once. That's the work I'd do for free, and mostly have been.

If you're building on agents and hit the part where you can't tell good output from confident output, I'd genuinely like to talk about it. Open an issue on anything here.