An idea I'm actively developing. Agents write more of our code faster than anyone can read it, so I think understanding has to move up a level, to modules, dependencies, and what's safe to touch. The plan is a live visual map of the codebase that updates as agents work, with no LLM calls needed to keep it current, so the time between prompts becomes time spent understanding what just changed. A lightweight first draft exists, and the design is still moving while I brainstorm the right shape for it.

A research and build repo for a coding agent harness I fully own. It's custom TypeScript extensions on top of the open-source pi agent, never a fork, with versioned config and machine setup scripts so the same harness runs on both my Arch Linux and macOS machines. The architecture has to stay visible, so any change to the harness's shape updates a written source of truth and a living visual map in the same commit. The map is a mermaid diagram, with stock, custom, and planned parts in different colors.

A stdlib-only shim that turns a Claude subscription into an OpenAI-compatible API endpoint. shim.py serves /v1/chat/completions and /v1/models and writes each request to a file mailbox. A Claude Code agent you start in a normal session watches the mailbox and writes the answers back. No model in the repo, no API call anywhere, and structured output (json_schema) passes through, so tools that need it just work. I built it to run HackerRank's open-source hiring-agent resume scorer end to end on my subscription alone. Public and MIT.

It records and transcribes on-device, then runs a pipeline that writes the summary, pulls out action items, updates a per-project context doc, and syncs tasks to Todoist, Reminders, and Calendar. The files on disk are the source of truth, and the database is just an index rebuilt from them. External agents reach the knowledge base through a bundled MCP server, so there is nothing to subscribe to.

Push-to-talk dictation on my own Whisper server. Hold a key, talk, and the text lands wherever I am typing, cleaned up by a local model. It talks to the same self-hosted stack that serves the rest of my machines, so it stays private and works on every machine I type on. It even knows when my GPU box is busy gaming and offers to wake the server instead of hanging.

The framework that serves my local models to any machine I own. friday is the GPU box under my desk, and it doubles as a gaming rig, so the model server loads weights on demand, unloads them when idle, and shuts down entirely the moment a game launches. Everything talks to it through one OpenAI-compatible endpoint. Idle cost on the card is basically zero.

A bot I built with my Hermes agent to watch the used-hardware market for local-LLM rigs, like specific GPUs, high-memory Macs, and the integrated-memory mini PCs. It normalizes messy listing titles down to real products, keeps price history, and flags anything running well under its recent median so a good price reaches my phone. Adding a new source is a small, well-defined contract.

Turn any wallpaper into a full desktop theme. prism pulls a palette from the image, builds a complete color scheme, and expands it across fourteen app configs at once, checking contrast before it writes a single file so nothing comes out unreadable. It's also the wallpaper manager, with rotation and a built-in Wallhaven browser. Built for Omarchy. Public, MIT, and on my machine daily.

A dark Omarchy theme with a warm-pastel palette, frosted glass, and one accent color you can swap across everything at once. Hand-tuned down to the terminal gradient and the launcher animations. A small, finished thing. (prism is the grown-up version that generates themes instead of hand-writing them.)

Tasks live in one execution stream. Recurring ones spawn on schedule, a heartbeat loop drives them, and each agent routes its own notifications. An agent can draft outbound email, but nothing sends until I approve it.

A small Python wrapper I built for my research and still reach for whenever something touches local models. It wraps a local Ollama model with conversation memory, system instructions, and a hand-written tool-calling loop, in about 130 lines. It's deliberately minimal, just a reusable Agent class.

My first app. A grocery list, a kitchen inventory, and an AI chef in one. You check items off the list into your pantry, then ask what you can cook from what you actually have. The chat knows your inventory because it's built into the prompt. SwiftUI, a one-week build in 2024.

Describe a vibe, get a Spotify playlist, cover art and all. It's from early 2023. It asked text-davinci-003 for twenty songs, built the playlist, then generated the cover with DALL-E 2. Very early LLM days, and it shows. Kept for the timeline more than the code.

Point it at whatever's playing and it tells you the musical key. It doesn't analyze the audio at all. It Shazams the song, looks it up on Spotify, and reads the key from the metadata. A one-day build, made so I could jam along on guitar.

Play into the mic, get guitar tab back. Pure signal processing, nothing beyond numpy. It windows the audio, picks the fundamental frequency per frame, smooths the notes, and maps them to the lowest playable fret. Monophonic only, and a weekend of work, but the whole pipeline is hand-rolled.

A Raspberry Pi now-playing display for Spotify. The album cover spins like a vinyl record over a moving gradient, with floating lights colored from the art itself. There are two renderers, a CPU one and a GPU-shader one for the Pi's sake, and that rewrite was the real work. The name is aspirational. I pulled the lyrics out while chasing the visuals.

A research proposal I led. The idea is to give a population of small open-weight models, around 1B parameters each, a task none of them can do alone. They split it up and claim pieces off a shared board without anyone assigning roles. Each piece gets checked with a real test, and anything they can't handle gets escalated to a bigger model. The measure is how much of the work had to escalate. The question is whether the shape of the task and the mix of models can predict the point where the collection starts winning. I wrote it up as CORES and submitted it to the Schmidt Sciences call on scaling AI safety for a multi-agent world.

Two LLM agents split a set of tasks between them, each holding private preferences, talking in plain language but committing every offer as strict JSON. A scoring engine brute-forces the true optimal split, so I can measure how close the agents actually get. Research code, not a product.

My negotiation framework, generalized into a research platform with two negotiation domains behind one interface, one for splitting items and one for bargaining over a single price. It also generates training data from deterministic strategy agents and holds Janus, an experiment that conditions one frozen 7B model on a single continuous knob so it can span aggressive to conceding without retraining. Ongoing, unpublished work.

A clean extraction of just the price-bargaining domain, where a buyer and a seller negotiate one number inside a zone of agreement. It carries the whole pipeline, data generation through adapter training and benchmarks, with a lot of care spent keeping the training and inference prompts identical. The model has to work out whether it's buyer or seller from the control signal alone. Ongoing, unpublished.

The knowledge base behind this whole site. It's one source of truth for who I am and what I've built, and the copy, the project list, and the story on this site all come from it. My instance stays private, but the framework is public. You can fork the template and build a knowledge base of yourself through a built-in interview that an agent runs.

An original sliding-tile puzzle. You slide tiles until the center of the board matches a target pattern before the clock runs out, across three difficulty tiers. Built in Unity and released on itch.io. The one game here I designed from scratch instead of following from a book.

A top-down zombie wave-survival shooter in Unity. You aim with the mouse and hold off escalating waves for as long as you can. A four-person team project, and I was the busiest committer on it.

Conway's Game of Life with a JavaFX interface that has presets, a speed slider, and live generation and FPS counters. Under the hood it stores only the living cells in a hash set instead of a full grid. My oldest project here, from 2022.