Rust + Python -- active development -- 2026

Three-repo architecture: a Rust orchestration core dispatching persona-based agents, a knowledge-graph memory server built on Graphiti MCP, and a structured reference corpus. Agents assume specialized roles, pull context from the graph over MCP, and evaluate inputs against a codified rule framework -- the reasoning is grounded in retrieved structure, not model recall.

• Rust orchestration core with a Python tooling layer
• Persona-based agent dispatch with domain specialization
• Temporal knowledge-graph memory tier served over the MCP protocol
• Corpus ingestion pipeline with structured retrieval

Python -- active development -- 2026

Document pipeline built on one doctrine: the LLM reads, deterministic code writes. Models do the fuzzy work -- extracting facts from hostile scanned sources -- while checkable code owns assembly, templating, and consistency. A contamination gate fails closed on any generated fact it cannot trace to a source page, and no model asserts a fact from memory: everything checkable lives in an MCP tool server, not the model. A human reviewer signs off on every output.

• Every generated fact carries a page-level citation to its source
• Contamination block-gate: unsourced assertions fail closed
• Deterministic core proven by 213 tests; validated end-to-end on real source material, locally, air-gapped
• MCP tool server owns document assembly, templating, and consistency checks

TypeScript + Postgres -- production

Engagement on the ingest and read paths of a production data platform. Sustained ingestion throughput was capped by an over-aggressive pre-filter that discarded records upstream of the work that needed them; removing it and re-architecting the pipeline around batched writes lifted throughput roughly tenfold. On the read side, an endpoint the clients poll every two seconds had regressed to roughly eleven seconds under load -- resolved with a date-equality partial index, cached aggregates, and a read replica carrying the hot path.

• Re-architected a high-volume ingestion pipeline for roughly 10x throughput
• Root-caused the ceiling to an over-aggressive pre-filter and removed it
• Cleared an ~11s query regression on an endpoint polled every 2 seconds
• Date-equality partial index, cached aggregates, and a read replica on the hot path

Python + TypeScript -- active development -- 2026

Research pipeline that normalizes source data into a structured store, tracks probabilities as time series, and feeds two clients off the same data layer: a terminal TUI for live monitoring and a web dashboard for visualization. The methodology is the point: sixteen-plus alternative-data adapters behind one normalization interface, Kelly-criterion position sizing, and a backtester built so that no future information can reach a past decision.

• Built solo -- ~57K LOC Python across 93 commits
• 16+ alternative-data adapters behind a single normalization interface
• Look-ahead-bias-safe backtester: no future information reaches a past decision
• Kelly-criterion position sizing over time-series probability tracking
• Terminal TUI and web dashboard reading one shared data layer

TypeScript -- working prototype -- 2026

Candidate code runs in hardware-isolated E2B Firecracker microVMs -- untrusted submissions never execute on the host, and the pipeline treats everything it grades as hostile. Inside that boundary, submissions are scored against rubric criteria by an analysis pipeline that returns structured feedback. A working prototype rather than a battle-tested production system: the isolation model is proven out, the surrounding platform is not yet hardened by real traffic.

• Candidate code executes in hardware-isolated E2B Firecracker microVMs
• Untrusted submissions never touch the host
• Rubric-criteria scoring with structured feedback generation
• Built solo -- 46 of 46 commits; prototype stage, not production-hardened