Present Link to heading
Conversational Document Intelligence Platform
A multi-tenant enterprise platform for conversational question-answering over an organization's documents, built for an enterprise client (proprietary, so unnamed here) and delivered in phases.
Phase 1: the RAG platform (delivered). The end-to-end pipeline, built in about three months: upload, ingest, index, retrieve, and a citation-backed answer streamed back over WebSockets. Users upload documents in nine supported formats; an ingestion pipeline parses them through a distributed worker fleet (with a Ray lane for bulk loads), extracts page-level citation provenance, and syncs content into a managed RAG knowledge base. The query path rewrites multi-turn conversations into standalone questions, performs semantic retrieval with metadata-aware filtering (workspace, classification, trust level), and streams LLM-generated answers with source citations. Tenancy follows an organization, team, and workspace hierarchy, and each user's clearance level is checked against document classification at retrieval time. Go services handle identity, API orchestration, and connector management over Protobuf contracts with code-generated ORM schemas; Python services handle parsing, retrieval, and notification dispatch; the frontend is React, TypeScript, and Tailwind. Both languages share a strict eight-layer architecture—core interfaces through transport—with decorator builders composing logging, metrics, tracing, retry, and circuit breaking at each boundary. A custom CLI replaces Makefiles as the sole task runner across code generation, testing, migrations, and deployment. It runs on Kubernetes behind an API gateway, with Helm charts, Kustomize overlays, Terraform-provisioned cloud resources, and full observability via Grafana, Prometheus, Loki, and Tempo.
Phase 2: AI operations and economics (in progress). Phase 2 makes the AI stack observable, measurable, affordable, and auditable: every production AI call is traced, sample-evaluated, budget-enforced, cache-eligible, and audited, and prompts and models are promoted only through evaluation gates. Its scope is an evaluation platform with graders, a versioned prompt registry, an AI audit trail that produces SOC 2 and HIPAA evidence, a token ledger with per-tenant budgets, a model gateway with semantic routing and cost controls, a semantic response cache, quality and drift monitoring, and an AI-operations console. It adds no new architectural layer: each capability is a new interface with a configuration-selected implementation and a no-op default, or a new decorator in the existing stacks, enabled per concern and per environment. LLM and agent tracing and the first AI-operations console and analytics screens have shipped.
Knowledge Engine Toolkit
An open-source (MIT) service substrate for building multi-language backend systems in Go and Python: the reusable “how we build services” library, carrying no product logic. I am its lead author, and I open-sourced it with Georgia Tech. Every service is assembled from eight layers—core interfaces, foundation, clients, repositories, services, pipelines, workflows, and transport—and imports only flow downward, enforced by lint rules rather than convention. Every swappable component is an interface with a Kind, a typed config, and a factory, selected by configuration and injected at one composition root, with a stub default so a service boots with zero infrastructure. Logging, metrics, tracing, retry, circuit breaking, and timeouts are decorators applied at that root, never inlined.
The library ships the parts every service rebuilds: layered config, structured logging, metrics and tracing, resilience, caching, and backpressured streams; clients for databases, caches, queues, object storage, locks, and cloud and deployment tooling; HTTP, gRPC, Connect, JSON:API, MCP, CLI, and cron front-ends; a batch fan-out execution engine; the typed list-query and chart-spec languages; and code generators and scaffolds. The Python half mirrors the Go half and is published to PyPI as techai-webutils. Integration tests run against real dependencies in throwaway containers—never fakes.
House Proceedings Corpus
A multi-service search and analysis platform for large-scale congressional text, indexing over 181 million tokens across 2,700+ U.S. House transcripts. A FastAPI gateway routes queries, Kafka decouples ingest pipelines, Elasticsearch powers full-text and faceted search, and Neo4j stores entity graphs linking speakers, bills, committees, and topics. A spaCy-based NLP pipeline extracts named entities, noun phrases, and dependency structures at ingest time. The system follows clean layered architecture with repository pattern, dependency injection, and full observability via Prometheus metrics, Grafana dashboards, and structured JSON logging.
Past Link to heading
Enterprise Search & Ingestion Platform
A large-scale semantic search and image ingestion platform built with iNaturalist and released as open source under the MIT license (iNatInq). I am its top contributor. It has two engines. The query engine embeds a text query with CLIP, checks a semantic cache, and runs dense nearest-neighbor retrieval in Qdrant (Weaviate is also supported) blended with keyword and metadata filters, delivering sub-200ms query latency. The ingestion engine lists images in S3, embeds them with CLIP on distributed Ray/GPU clusters (with Spark and Databricks pipelines alongside), and upserts the vectors to Qdrant, processing over 400 million images in under 24 hours.
Every external call is wrapped in retry with exponential backoff, circuit breakers, and rate limiting, so search degrades gracefully when a dependency fails. Ingestion is built to finish clean at scale: batch-level fault isolation, a dead-letter queue with reprocessing, checkpointing for resumable jobs, change data capture for incremental updates, and end-of-run reconciliation. Prometheus metrics cover clients, breakers, retries, cache, search, and ingestion, and all logs are structured.
Retrieval quality is measured, not assumed. A benchmark harness scores Precision@K, Recall@K, NDCG@K, MAP@K, and MRR, along with p50/p95 latency and throughput, against the INQUIRE text-to-image retrieval benchmark (Vendrow et al., NeurIPS 2024). INQUIRE pairs 250 expert-level natural-world queries with iNat24, a dataset of five million iNaturalist images. The same harness compares vector-database providers and four quantization profiles (float32, scalar, scalar with rescoring, and binary with rescoring).
PerceptivePanda
PerceptivePanda was an AI-native customer research platform that replaced traditional human-led interviews with AI-driven micro-interviews at scale. I co-founded the company and served as CTO. The core contribution was a deterministic control layer wrapping LLMs using a dialogue state framework grounded in discourse theory from my work at Stanford—particularly the Questions Under Discussion model. The system tracked addressed questions, identified threads for deeper probing, and orchestrated LLM calls through a structured state machine, ensuring coherent analytical conversations while preserving natural fluidity. PerceptivePanda was a StartX ’24 company, acquired by Zapier in January 2026.
ClearGraph / Tableau Ask Data
At ClearGraph, I architected the natural language querying technology that became Tableau Ask Data after Tableau’s 2017 acquisition. I led integration and scaling, growing the team to 30+ engineers and deploying to hundreds of thousands of users. The system—designed before BERT existed—used Montague Grammar and compositional semantics from my Stanford research. User utterances were parsed via context-free grammar rules into a formal intermediate representation, resolving ambiguity, underspecification, and implicit context at each derivation stage. The work produced 9 issued patents covering NLQ architecture, intent inference, cascading edits, table calculations, and incremental visual feedback:
- US-11550853-B2 — Table calculations via natural language
- US-11314817-B1 — Intent inference and context for NL expressions
- US-11301631-B1 — Visual correlation of NL terms to structured phrases
- US-11244114-B2 — Analyzing underspecified NL utterances
- US-11055489-B2 — Levels of detail via NL constructs
- US-11048871-B2 — Analyzing NL expressions in data visualization
- US-10902045-B2 — NL interface with cascading filter edits
- US-20220253481-A1 — Inferring intent for NL in data visualization
- US-20210319186-A1 — Using NL constructs for data visualizations
Partial Order Optimality Theory
Companion implementation to “A constructive solution to the ranking problem in Partial Order Optimality Theory” (Journal of Logic, Language & Information, 2017). Classical OT assumes grammars are strict total orders over constraints, making it impossible to model free variation. PoOT generalizes to arbitrary partial orders, but the ranking problem—finding all compatible grammars from observed data—was unsolved. The paper provides an exact set-theoretic construction exploiting the lattice structure of partial orders. The codebase generates the full lattice, computes grammar sets via winner/loser set intersection, identifies harmonically bounded candidates, and derives candidate entailments. Includes Finnish vowel coalescence and case datasets.
Doctoral Dissertation: On Adjectival Comparatives
The syntax and semantics of ordinary comparative constructions in English. PhD Dissertation, Stanford University, 2015. The dissertation argues that standard degree-based analyses of comparatives are fundamentally flawed—requiring abstract degrees as first-class objects and covert operators to handle scope. The alternative framework, grounded in Barker and Shan’s continuation semantics and Muskens’ simplified Montague logic, computes comparative meaning compositionally through continuation-passing without positing degrees or hidden structure. The account covers phrasal, clausal, sub-, and differential comparatives, and resolves long-standing puzzles around scope interactions between comparatives and quantifiers.