All Projects

CKB is a native code intelligence system that ships as a single self-contained binary. It builds a deep semantic index of your codebase locally — no cloud, no LLM costs, no latency penalty. Via both a CLI and an MCP server, it exposes semantic search, call-graph traversal, impact analysis, architecture mapping, and hotspot detection directly inside your editor or agent workflow.

The design goal was explicit: full code understanding at zero marginal cost per query. SCIP (Sourcegraph Code Intelligence Protocol) drives the indexing layer, making cross-language analysis both precise and fast. CKB is the backbone of my broader developer tooling ecosystem.

Cartographer is a structural intelligence engine that maps a codebase's architecture, monitors its health, and predicts the ripple effects of changes before they're made. Where CKB handles deep semantic analysis at the symbol level, Cartographer operates at the module and dependency graph level — answering questions like "what are the architectural bottlenecks?" and "what breaks if I change this?"

The dependency graph maps files and modules as nodes with import relationships as edges, annotated with language, complexity estimates, and bridge flags. Bridge detection uses Bridgeness Centrality (betweenness centrality filtered to exclude noisy utility hubs) to find files that genuinely connect disparate subsystems — the ones where a change propagates furthest. Layer enforcement is config-driven via `layers.toml`, detecting back-calls and skip-calls before they land in main. Health scoring runs on a 0–100 formula accounting for cycles, bridges, god modules, and violations.

The predictive simulation feature is the most useful part in practice: before writing a single line, you run `cartographer simulate` to see whether a proposed signature change will create a cycle, which modules will be affected, what layer rules it violates, and what the net health impact is. Historical evolution tracking surfaces architectural debt trends over time. Ships as a Rust binary with an MCP server for AI tool integration and BM25 search over the codebase map.

LIP is a language-agnostic open protocol for streaming, incremental code intelligence. The core design problem it solves: LSP is great for real-time editor queries but ephemeral — it knows nothing between sessions. SCIP produces rich static snapshots but they go stale the moment you touch a file. LIP bridges both models: a lazy query graph that answers LSP-style queries in real time while persisting a SCIP-style index that updates incrementally as code changes.

On top of that base, LIP adds two things most code intelligence systems lack: blast-radius indexing (given a symbol change, what is the complete set of affected call sites and transitive dependents?) and a content-addressed dependency registry that lets you fetch a precise "slice" of a dependency's index rather than re-indexing the whole thing locally.

The reference implementation is in Rust and covers the full stack: a tree-sitter indexer for Tier 1 analysis, a Salsa-inspired incremental query database, a Unix-socket IPC daemon, an LSP bridge via tower-lsp so any standard editor just works, and a CLI for indexing, querying, and daemon control. Dart/Flutter bindings ship in the same repo. Wire format is JSON for v0.1; FlatBuffers IPC is planned for v0.2.

ArchReview integrates architecture audits directly into CI/CD pipelines. It statically analyzes your codebase on every pull request and flags pattern violations, circular dependencies, forbidden module boundaries, and structural drift — before they land in main.

The core insight: architecture problems are cheap to fix at the PR stage and expensive to fix six months later. ArchReview makes enforcement automatic rather than relying on code review attention. Rules are defined in a config file, so teams can encode and evolve their own conventions without touching the engine.

Onboarding Tutor is an interactive system that dramatically shortens time-to-productivity for developers joining an existing project. Instead of reading docs that are always slightly out of date, new engineers engage in a structured dialogue with a tutor that knows the actual codebase — its conventions, architecture decisions, and gotchas.

The tutor is built on top of CKB's code intelligence and exposed via MCP, so it works inside any MCP-capable editor or agent. The goal is not generic "how does React work" explanations, but project-specific knowledge transfer at scale.

Ingestible is a high-efficiency RAG pipeline that handles the messy reality of multi-format input. PDFs, audio, video, Markdown, HTML, spreadsheets — 25+ formats — get transformed into token-optimized, semantically chunked knowledge stores tuned for retrieval precision rather than brute-force coverage.

The emphasis is on reducing context load rather than maximizing it. Most RAG systems are bloated; Ingestible was designed to put the right tokens in front of the model, not all of them. Retrieval quality improves because noise is structurally excluded, not filtered after the fact.

Cognitive Vault solves a real problem in AI-assisted development: institutional memory evaporates. When a context window resets, or a developer leaves the team, the tacit knowledge they carried — why a decision was made, what was tried and failed, what the current state of a complex investigation is — disappears.

Cognitive Vault captures that knowledge explicitly: structured, queryable, and persistent. It ships as a CLI and MCP server backed by PostgreSQL and Prisma. Teams can vault decisions, findings, and open questions, and surface them inside any LLM workflow. Designed for the reality that LLMs forget by default.

ContextCompressionEngine is a TypeScript library for reducing token usage in LLM pipelines without sacrificing semantic fidelity. The core challenge: naively truncating or summarizing context degrades quality in unpredictable ways. CCE applies structured compression strategies — relevance scoring, semantic deduplication, and hierarchical summarization — to produce a smaller context that actually answers the question better.

Particularly useful in long multi-turn conversations and document analysis pipelines where context accumulates faster than it decays.

FormatConverter is a zero-dependency TypeScript library that splits structured documents at the right semantic seam: the parts that must survive verbatim (tags, keys, schema) versus the parts that can be compressed or summarized (prose values, verbose comments, paragraph content).

The problem it solves is real in any LLM pipeline that ingests documents. Treating a YAML config or XML manifest as plain prose destroys its structure and wastes tokens on noise. Treating it as fully opaque prevents any compression at all. FormatConverter draws the line correctly for each format — JSON keys and short values are preserved, long prose string values are compressible; XML tags and attributes are preserved, verbose text nodes are compressible; Markdown headings and tables are preserved, paragraph bodies are compressible.

The logic was originally part of ContextCompressionEngine and extracted here as a standalone package so it can be reused independently. Ships as ESM, works in Node 18+, Deno, Bun, and edge runtimes. Published on npm as `@lisa/format-converters`. 87 tests, zero dependencies.

SwarmWire is an orchestration framework for complex multi-agent systems and swarm intelligence workflows. Building reliable pipelines where dozens of agents coordinate — passing state, dividing work, recovering from failure — requires infrastructure that most agent frameworks don't provide out of the box.

SwarmWire provides typed message passing, agent lifecycle management, and workflow composition primitives designed for knowledge processing at scale. It underpins several of my other pipeline-heavy projects.

DeviceRouter is an adaptive serving layer that detects hardware capabilities in real time — CPU class, available RAM, GPU presence — and routes requests accordingly. The practical use case: serve a lightweight experience to a low-end mobile device and a full-fat experience to a desktop, without requiring the client to self-report its capabilities.

Detection happens at the server layer on the first request, making the behavior transparent to the application. MIT licensed and built for Node.js environments.

FrugalRoute is a capability-centric, local-first LLM routing layer. The premise: your AI bill is a routing problem. Every prompt goes to the same expensive cloud model — whether it's a trivial FAQ or a complex reasoning task — because wiring up local models, fallback logic, cost tracking, and caching is a month of engineering nobody approves.

FrugalRoute is one line of config between your app and your models. It classifies each incoming prompt, matches it to the cheapest capable option — including local models running on-device — and falls back gracefully when needed. Cost is tracked per request. Repeated patterns are cached. The router learns from your traffic over time, improving routing decisions without manual tuning.

Ships as an npm package and as `npx frugalroute` for zero-install use. 445 tests.

PIXL is an LLM-native pixel art toolchain built around .pax — a TOML-based format designed specifically for how language models reason about visual content. The insight behind it: existing sprite/tileset formats were designed for human editors and tools, not for LLMs that think in structured text.

The ecosystem includes a Rust parser and validator, a WFC (Wave Function Collapse) tileset generator, an MCP server for agent-driven pixel art generation, an HTTP API, and a Flutter desktop studio for human editing. The full stack covers both AI-generated and human-authored pixel art with the same underlying format.

OpenLab is an open bioinformatics platform focused on cancer research. The core capability: autonomous AI agents that read the scientific literature, pull variant databases, and produce cited gene dossiers with variant interpretation — the kind of synthesis work that currently takes researchers days.

The stack is Python/FastAPI on the backend with a React/TypeScript frontend. The agent layer is designed to produce auditable outputs: every claim traces back to a citation. This is research tooling, not a black box — the goal is to augment researchers, not replace them.

BioLab extends the OpenLab platform with whole-cell simulation via CellForge and a deeper focus on genome analysis pipelines. LLM-powered evidence synthesis sits alongside standard bioinformatics tooling — variant calling, pathway analysis, expression data — so researchers can move between computational and knowledge tasks in a single environment.

The Rust components handle performance-critical simulation workloads while Python drives the analysis and agent orchestration layers.

Morphon is the reference implementation of Morphogenic Intelligence — a biologically-inspired adaptive intelligence engine where computational units (morphons) grow, differentiate, and restructure at runtime without backpropagation. Credit assignment happens via eligibility traces and neuromodulatory broadcast rather than gradient flow; the network structure itself is a learned component, not a fixed topology.

Morphons live in Poincaré ball space with learnable curvature per-point. Structural plasticity handles synaptogenesis, pruning, migration, division, differentiation, fusion, and apoptosis across four temporal scales via a dual-clock scheduler. Four neuromodulatory broadcast channels (reward, novelty, arousal, homeostasis) gate local plasticity. A triple memory system covers working, episodic, and procedural memory on separate timescales.

Results: solves CartPole-v1 (avg 195.2), achieves 87.7% stateless MNIST accuracy, and recovers to near-intact performance after 30% associative morphon damage — forced developmental restart after damage consistently outperforms the original trajectory. Ships with Python bindings via PyO3 and a WebAssembly build with an in-browser 3D visualizer of the Poincaré ball embedding.

This is the implementation artifact for the paper "Morphogenic Intelligence: Runtime Neural Development Beyond Static Architectures" (v2, April 2026).

Cytopia is a free, open-source city building simulation game with a custom isometric rendering engine written in C++ and SDL2. I was lead developer for several years on a project that grew to over 2,100 GitHub stars and an active contributor community.

The engine handles isometric tile rendering, pathfinding, building placement, and a mod-focused architecture designed to make community contributions straightforward. CMake build system, OpenAL audio integration, and cross-platform support (Linux, macOS, Windows). Working on a large-scale open-source game with a real player base is a completely different discipline than building developer tools — scope, backward compatibility, and community expectations all matter in ways they don't in internal tooling.

JewelFall is a pixel-art puzzle game for iOS. Swipe-based controls, progressive difficulty that scales with player skill, and an original soundtrack composed specifically for the game. The design philosophy was clean, tactile controls and a visual style that holds up on Retina displays without looking like it was made in a game jam.

Shipped solo: design, development, art, and music all handled in-house.

This paper introduces Morphogenic Intelligence (MI), a neural architecture where computational units called morphons dynamically grow, differentiate, and restructure during runtime. Unlike conventional architectures with fixed topologies, MI treats network structure itself as a learned component — guided by chemical gradients in hyperbolic embedding space and neuromodulatory signals controlling local plasticity.

Key technical contributions: spike-timing inhibitory STDP, Pulse Kernel Lite arrays (4.3× speedup), and a stateless training methodology (V3-SL) that lifts MNIST accuracy from ~82% to 87.7% by decoupling representation learning from sequential context. The paper documents a failure mode taxonomy with six characteristic modes and their biological parallels, and establishes that the system operates as a Liquid State Machine with reservoir computing properties.

The system self-heals after damage: losing 30% of associative morphons triggers a forced developmental restart that consistently produces better-specialized morphons than the original trajectory (mean +14.8pp recovery over damaged baseline). The Morphon repository is the reference implementation.

This paper addresses semantic staleness in LLM memory systems — the failure mode where source material updates but stored embeddings continue serving outdated information with unwarranted confidence. TruthKeeper combines classical Truth Maintenance Systems with modern vector retrieval to build a memory layer that tracks justification dependencies, cascades invalidations when upstream sources change, and escalates contested claims to human review.

Core contributions: a four-state truth model (SUPPORTED, OUTDATED, CONTESTED, HYPOTHESIS) that captures nuance beyond binary true/false; a Memory CI paradigm that treats memories as verifiable assertions triggered by source changes, analogous to continuous integration; claim decontextualization that rewrites anaphoric references into self-contained assertions before fact-checking; a conflict detection pipeline combining topic gating, negation analysis, and pattern matching with confidence-scored automated resolution; and a PR-style human review workflow for changes exceeding automation confidence thresholds.

The dependency tracking network monitors justification chains for each memory item, enabling automatic cascading invalidation when any upstream source changes — so knowledge that depends on outdated facts is flagged, not silently served.

TasteHub is a recipe management app for iOS and Android, co-founded with Martyna and built under TasteHub GmbH. The product solves a genuinely annoying problem: recipes live scattered across bookmarks, screenshots, and browser tabs, and none of the existing apps are particularly good at importing from the real web.

Architecture is offline-first with Firebase sync — recipes are always available, updates propagate in the background. A web scraping importer handles the messy reality of recipe sites (structured data when it's there, DOM parsing when it's not). Collaborative sharing lets households and friend groups maintain shared recipe collections.