Work

Surge XT has hundreds of parameters across oscillators, filters, FX, and modulation—impossible to keep in working memory during a session.

Asking an AI for help with sound design means the model is guessing from training data, not reading the actual parameter documentation.

Built an MCP server that ingests and chunks the official Surge XT docs, exposing search, section fetch, and parameter lookup as tools AI models can call directly.

AI assistants can now look up exact knob behaviour and guide patch recreation with authoritative documentation.

Adding semantic search to a small project means standing up Pinecone, Weaviate, or a Postgres extension—infra for something that should be trivial.

Hosted vector databases are overkill for local tools; rolling your own HNSW index is a week of work that has nothing to do with the actual project.

Built an embedded Rust vector store with a single-file persistence model—same mental model as SQLite, but for approximate nearest-neighbour search.

Drop-in semantic search with no server, no daemon, no connection pool.

Running multi-agent AI systems is chaotic without clear orchestration and shared state.

Agents need task scheduling, shared memory, and a single control plane—otherwise you're gluing scripts and hoping they don't collide.

Built a distributed AI worker runtime with an orchestrator, shared memory, and DAG-based scheduling so multi-agent runs stay predictable at scale.

Autonomous workflows: research summaries, parallel analysis, and agent collaboration across engineering, finance, and legal operations.

Note-taking tools optimise for writing, not retrieval. Months later, the note you need is buried and keyword search returns 40 results.

Semantic search requires a vector store and embedding pipeline; RAG synthesis requires an LLM—both are heavy to wire up just for personal notes.

Built a Rust CLI and TUI that embeds notes locally, retrieves by meaning, and synthesises answers from your own knowledge base—nothing leaves your machine.

Ask questions in plain English. Get answers drawn from your own notes.

LLM pipelines stitch together inference servers, vector stores, and orchestration layers across multiple process boundaries.

The model is fast; the glue is slow. Every HTTP hop and subprocess call adds latency the user feels but the benchmark doesn't capture.

Built a C++ execution runtime that compiles LLM and ML pipelines into static graphs—embed, retrieve, and generate as typed first-class operations with no interpreter overhead.

Single binary, no orchestration daemons. Pipelines run as compiled programs.

Working on a proprietary photonics platform that bridges simulation and design workflows.

Most photonics tools are either opaque GUIs or low-level solvers that are hard to integrate into modern research and product stacks.

Designing Eigenwave as a focused, proprietary environment that pairs high-fidelity simulation with opinionated, ergonomic workflows.

In active development—aimed at making advanced photonics exploration feel closer to modern software engineering.

Document extraction is often brittle, lossy with images, or prohibitively expensive at scale.

Generic OCR ignores structure; most "AI study tools" quietly fail on diagrams, equations, and screenshot-heavy slides.

Built an opinionated document intelligence CLI that uses vision LLMs and config-driven RAG to turn arbitrary slides, papers, and textbooks into clean, full-context markdown.

Static PDFs become queryable, refinable knowledge—ready for RAG, notes, flashcards, and assessment pipelines.

Writing Rust extensions for Python means maintaining a C FFI layer, a Python wrapper, and keeping both in sync with the Rust API.

Every type change requires updates in three places. The binding layer is always a commit behind the implementation.

Built a compiler that reads Rust source, reflects the public type surface, and emits the FFI layer, native extension, and .pyi stubs automatically.

Bindings become a compiler output. Change the Rust signature, run ferryx, done.