Everything No Reason

Building reliable tools for code intelligence and agent workflows.

I build the connective tissue between software systems and language models: structured context, reliable tools, and interfaces that help agents make better decisions.

My work sits at the intersection of code intelligence, agent-facing infrastructure, and production-minded open source. I care about systems that are fast enough to use interactively, explicit about what they do not know, and shaped around the next decision a developer or an agent needs to make.

┌─ DESIGN PRINCIPLES ───────────────────────────────────────────────────────┐
│  structured context  →  give the agent the right graph, not a raw dump    │
│  honest unknowns     →  expose uncertainty instead of inventing edges    │
│  low-friction tools  →  stateless, composable, easy to invoke             │
│  measurable systems  →  benchmark the claim, document the conditions     │
└───────────────────────────────────────────────────────────────────────────┘

A structural code graph built for AI agents, not humans.

A Rust-based code intelligence system for structural queries, impact analysis, route maps, cross-repository contracts, and agent-oriented code navigation. It uses compact TOON／JSON output, zero-copy graph access, incremental indexing, and explicit BlindSpot records when static analysis cannot establish an edge.

Rust Tree-sitter rkyv mmap Tantivy Graph Analysis MCP

Turning real-world web data into a composable tool for AI workflows.

A FastMCP server that compares products across 14 Taiwan e-commerce platforms. The interface is intentionally small—one compare_prices tool with expressive filters—while the implementation handles asynchronous retrieval, platform differences, test fixtures, CI gates, and token-efficient TOON responses.

Python FastMCP Async I/O msgspec TOON Data Integration

Two smaller projects exploring the same theme from different angles: moving performance-sensitive paths into Rust while keeping Python interfaces practical, and making CI／hook feedback fast enough to become part of the normal development loop.

• Agent systems with an operational core: scenario-driven orchestration, multi-agent isolation, and workflows that can grow from a single tool call into a reliable product surface.
• Reliable runtime foundations: durable execution, explicit state, cache-aware retrieval, and infrastructure that keeps agent behavior observable and recoverable.
• Composable agent interfaces: MCP servers, compact tool outputs, context shaping, and interfaces that are easy for both models and developers to invoke.
• Systems engineering: Rust／Python boundaries, concurrency, incremental computation, performance-aware storage, and CI that verifies the intended contract.

_{Rank methodology ↗}

How can developer tools expose more useful structure to an agent while remaining honest, composable, and cheap to run? The answer usually lives somewhere between the parser, the protocol, and the shape of the output.