Skip to content
Back to selected work

The full catalog.

Flagship products and research, each flagship broken out by repository so you can judge the architecture directly.

Flagship productsproduction agent systems, shipped

founder & sole engineer · live · 5,000+ users

VYNN AI — Production Agentic Financial Analyst

Equity research that takes an analyst a working day, delivered in about seven minutes. A LangGraph supervisor orchestrates seven specialized agents — fundamentals, news intelligence, valuation, and a validated recommendation — into a 35-page PDF, a 10-tab DCF, and a traceable rating for any ticker. Built end-to-end as a three-layer stack, piloted with ~500 users and now serving 5,000+, with reproducibility guarantees most research prototypes don't attempt. It's back online: the product runs at app.vynnai.com, the company at vynnai.com.

Three architectural commitments

Explicit state semantics. Intermediate artifacts are typed, inspectable state — not implicit prompt context. Every agent produces a structured slice of the supervisor state.

Strict symbolic–semantic separation. LLMs are restricted to intent recognition, relevance assessment, and event extraction. Valuation, recommendation logic, and numerical propagation are fully deterministic.

Cache-aware orchestration. Repeated or overlapping queries reuse validated artifacts. A 10-min semantic cache + daily report fan-out bounds redundant LLM work.

Production outcomes

  • Agent backend: ~15K of the ~50K total lines, across 40+ modules with 33 externalized prompt templates and a 3-layer recommendation engine (deterministic calculator → LLM narrative → regex validator enforcing ≥95% citation coverage).
  • Reproducibility validated across 9 production runs (NVDA, AAPL, MSFT), with a 72% latency reduction from parallel agent execution. A single-agent query answers in a median 98 seconds; a full multi-agent report lands in about six and a half minutes.
  • Deployed on Hetzner Cloud with zero-downtime multi-arch Docker; the ~500-user pilot has grown to 5,000+ users since relaunch.

3 repos, one system

stock-analyst · agent backendLangGraph supervisor coordinating 7 specialized agents with symbolic DCF valuation.

api-runner · control planeFastAPI + Docker-in-Docker ephemeral workers, SSE + dual WebSocket streaming.

vynnai-web · frontendReact 18 dashboard + AI chat with SSE streaming and subscriber-based WS.

app.vynnai.com — free (opens in new tab)·vynnai.com (opens in new tab)·Blog post·GitHub — all 3 repos (opens in new tab)

System architecture
React / TypeScript + ViteAI Chat (SSE streaming)Market DashboardPortfolio MgmtDaily ReportsNews FeedSSERESTWSS ×2Caddy (auto-HTTPS + reverse proxy)FastAPI BackendAuth (OAuth)Chat / SSE / JobsWS HubPrices + NewsDaily Scheduler8:30 AM ET cronPortfolio CRUDDocker SDK →spawns ephemeral containersEphemeral Docker Container (~975MB)Supervisor Agent (LangGraph Cyclical State Graph)Ticker Extraction → Intent Classification → Dependency-Aware RoutingCOMPREHENSIVE | MODEL_ONLY | QUICK_NEWS | CUSTOM (deterministic fallback)Financial Data Agentyfinance · fundamentalsDCF Model AgentGeneric · SaaS · REIT · Bank · Utility · EnergyFormula Evaluator (1,293L)News Intelligence AgentScrape → Filter → ScreenwaitsReport Generator Agent (HTML / PDF / XLSX)Recommendation Engine (3-Layer Validation)Deterministic Calculator → LLM Narrative → Regex Validator (≥95% citation coverage)Output ArtifactsXLSX (10-tab DCF)PDF Analyst ReportJSON APIFinancialState (Blackboard Pattern)33 externalized prompt templatesOpenAI + Anthropic (provider-agnostic)RedisQueues + Cache + SessionsMongoDBDocuments + NewsNginxSPA Static Serve

stock-analyst

Agent backend · Python

The brain of VYNN AI. ~15K LOC across 40+ modules. LangGraph supervisor orchestrates 7 specialized agents with a strict symbolic–semantic split: LLMs handle intent recognition, relevance, and event extraction only; valuation, recommendation logic, and numerical propagation are fully deterministic. Includes a custom 1,293-line Formula Evaluator that interprets Excel formulas programmatically, so downstream agents don't depend on Excel at runtime and Excel-JSON consistency is guaranteed.

Python · LangGraph · GPT-4o · Claude 3.5 Sonnet · MongoDB · Redis

Agentic-Analyst/stock-analyst·DeepWiki

api-runner

Control plane · FastAPI

10,598 LOC FastAPI control plane. Docker-in-Docker orchestration dispatches ephemeral worker containers per job; dual persistent WebSockets (news + real-time prices) with exponential backoff reconnection; SSE job streaming with log batching; pre-market scheduler at 8:30 AM ET with NYSE/NASDAQ holiday awareness (including algorithmic Good Friday via Anonymous Gregorian Easter). Graceful SIGTERM shutdown with 10s timeout and state preservation.

Python · FastAPI · Docker SDK · Motor · Redis · SSE · WebSocket · OAuth 2.0

Agentic-Analyst/api-runner·DeepWiki

vynnai-web

Frontend · React + TypeScript

23K LOC React/TypeScript SPA. Subscriber-based WebSocket context with debounced subscription updates (300ms) and delayed unsubscribe (1s) to handle React StrictMode double-mounts. Module-scoped singleton SSE refs survive component unmounts. User-scoped localStorage (`user_{email}_{key}`) prevents cross-account data leakage on shared devices. Holiday-aware market status hook computes NYSE state client-side with second-level precision, including 9 NYSE holidays with algorithmic floating-holiday computation.

React 18 · TypeScript · Vite · Tailwind · shadcn/ui · TanStack Query · Recharts

Agentic-Analyst/vynnai-web·DeepWiki

acquired by Sonar · 51.6% SWE-bench Verified · ISSTA 2024

AutoCodeRover — Autonomous Code Repair in the IDE

Autonomous coding agent that resolves GitHub issues end-to-end. My contribution is two-part: I built the JetBrains IDE plugin end-to-end in Kotlin, and enhanced the AutoCodeRover Agent with a Self-Fix Agent and interactive replay infrastructure that lifted SWE-bench Verified from 38.4% to 51.6%.

Contribution boundaries

JetBrains plugin — entirely mine. End-to-end Kotlin plugin: conversational UI, SSE streaming, PSI-based context enrichment, embedded SonarLint, build/test capture, GumTree 3-way AST merge for conflict-free patch application when local code has diverged from the agent's baseline.

Self-Fix Agent — mine. 4-step autonomous repair loop: collect failure reasons → diagnose which upstream agent produced the defective output → generate corrective feedback → selectively replay from that stage. Not a parallel peer to Write/Review — a recovery loop triggered on failure that routes corrective feedback back to the responsible upstream stage.

Interactive replay infrastructure — mine. Structured agent state with UUID-tagged LLM responses. Feedback at any stage replays only downstream agents; preserves upstream state; no full restart. The replay mechanism is the same substrate the Self-Fix Agent uses.

Production outcomes

  • AutoCodeRover moved from 38.4% (Jun 2024) to 51.6% (Jan 2025) on SWE-bench Verified during my contribution period. The Self-Fix Agent and interactive replay infrastructure are the mechanisms; the baseline agent architecture is group-authored.
  • 1.8× patch precision over the next-best open-source agent.
  • Published at ISSTA 2024 + arXiv (AutoCodeRover and SpecRover papers).

2 repos, one system

auto-code-rover · backendPython repair pipeline — Self-Fix Agent, interactive replay, UUID feedback.

jetbrains-ide-plugin · IDE integrationKotlin plugin — GumTree 3-way AST merge, SonarLint, conversational agent UI.

ACR paper (ISSTA '24) (opens in new tab)·SpecRover paper (arXiv) (opens in new tab)·Blog post

Repair pipeline architecture
JetBrains IDE (IntelliJ / PyCharm)PSI Traversal · Build/Test Listeners · Git4Idea · Editor APIACR Plugin (Kotlin)Chat UI + SSEStreaming chat, typewriter renderSonarLint EngineEmbedded Java/Python static analysisGumTree 3-Way MergeBaseline → Modified → Patched AST alignmentContext EnrichmentPSI refs + cursor history + open filesUser Feedback per Reasoning Step→ Guided Re-runcritique any agent stepAutoCodeRover Backend (Python · Docker)Meta-Agent OrchestratorHardcoded or LLM-drivenReproducer AgentContext Retrieval7-language tree-sitterPatching AgentReviewer AgentSelection AgentBest-of-N + regressionSelf-Fix AgentLLM-as-a-JudgeSWE-bench 51.6% VerifiedPatched Code + EvidenceSpecs + Reproducer + ReviewREST API (OkHttp)SSE Stream (real-time logs)replay loopFeedbackContext / FeedbackPatch

auto-code-rover

Repair backend · Python

Python agentic repair pipeline: Context Retrieval → Patch Generation → Reviewer Agent loop across 7 languages via tree-sitter. The core agent architecture is group-authored; the Self-Fix Agent, interactive replay, and UUID-targeted feedback are mine.

Python · LangChain · tree-sitter · Claude 3.5 Sonnet · GPT-4o

zanwenfu/auto-code-rover

jetbrains-ide-plugin

IDE plugin · Kotlin · entirely mine

Brings autonomous code repair into the developer's IDE. A single main orchestrator coordinates six subsystems across conversational UI, IDE events, static analysis, and an AST-level three-way patch merge — so the agent can read the developer's working state, stream reasoning in real time, and land fixes without context-switching out of the editor.

Kotlin · IntelliJ Platform SDK · PSI · GumTree · SonarLint Core 10.3 · OkHttp · JGit

zanwenfu/jetbrains-ide-plugin·DeepWiki

v0 shipped, actively extending · agent infrastructure · open source (MIT)

taste — An Operating System for Agents

An Agent OS kernel: a three-core CPU split (Opus 4.7 planner, Sonnet 4.6 workers, Haiku 4.5 monitor) running on a git memory substrate. v0 is shipped — three demos with committed transcripts, cost telemetry, and self-contained HTML dashboards — and every subsystem is deliberately opt-in.

Three architectural commitments

Three-core CPU separation. Planner / Worker / Monitor run on distinct Claude tiers — the reasoning sandwich. No agent grades its own exam; the Monitor is the only component that can gate a commit.

Git as memory, not sidecar. Branches = execution contexts. Commits = checkpoints. git show = demand paging. reset --hard = rollback. Every kernel artifact is committed — nothing lives in a progress file.

Build to delete. Every subsystem is opt-in, not load-bearing. When next-gen models self-evaluate reliably, disable the Monitor — the kernel's git-based abstractions survive untouched.

Production outcomes

  • Real-Claude run committed with full telemetry (todo_api): $0.0964, 43s, 15/15 tests green, zero rollbacks — 7 LLM calls, 16.5K input / 3.1K output tokens on Sonnet 4.6.
  • Parallel worktree execution shipped (parallel_demo): 3 concurrent workers on `git worktree` branches cut wall-clock from ~32s serial to 21.5s; atomic merge-back only if every worker in the wave passes its Monitor. MergeConflict raised as a typed exception — “merge conflicts as coordination signals” made literal.
  • Hermetic rollback proven without API key (refactor_demo): step-2 regresses → Monitor catches via pytest → kernel runs `git reset --hard` → retry lands clean. Final branch has no trace of the failed attempt. CI asserts on the outcome.
  • Event stream survives rollback — `.git/taste/events.jsonl` lives outside the tracked tree so rollback doesn't erase the audit trail. Self-contained HTML dashboard (`taste dashboard`) renders the timeline, per-step outcomes, and git topology.
  • 40 tests across 5 load-bearing suites, zero cyclic imports by design, pip-installable CLI (`taste run` / `taste log` / `taste dashboard`).

GitHub (opens in new tab)·Design thesis (blog)

Kernel loop and git substrate
taste — Agent OSGit as the memory substrate · three specialized Claude cores · atomic commit-or-rollback per stepCPU — 3 specialized coresreasoning sandwich: xhigh on plan & verify, standard on implementationPlannerClaude Opus 4.7task → DAG of steps + depsplan.json committed to session branchwaves = steps sharing dep-setsWorkerClaude Sonnet 4.6executes one subtask, minimal ctxtools: read / write / shell (CLI-first)runs inside its own worktreeMonitorClaude Haiku 4.5 · pytestgates every commit; no self-evalwrites verdict to monitor/step-NN.jsonopt-in — composable, not load-bearingKernel dispatches each wave → isolated worktreesWave execution — parallel, isolated worktreeseach step gets its own `git worktree` → filesystem-level process isolationworktree · step-01branch: session/step-01Worker (Sonnet 4.6)Monitor gatepass → commitfail → reset --hardworktree · step-02branch: session/step-02Worker (Sonnet 4.6)Monitor gatepass → commitfail → reset --hardworktree · step-03branch: session/step-03Worker (Sonnet 4.6)Monitor gatepass → commitfail → reset --hardatomic merge-back into session branchMemory — git as the substratebranches = execution contexts · commits = checkpoints · `git show` = demand paging · `reset --hard` = rollbacksession branchinitstep-01step-02step-02'step-03HEADrollback (git reset --hard)retry in fresh worktree.git/taste/events.jsonlevent stream stored out-of-tree —survives `git reset --hard`, preserves auditreplayable timeline for the dashboardBuild to deleteevery subsystem is opt-in. When next-gen modelsself-evaluate, turn off Monitor; kernel survives.The stable layer is the git abstractions.v0 demostodo_api: real Claude · $0.096 · 43s · 15/15 testsrefactor: hermetic rollback on step-2 failparallel: 3 worktrees · 21.5s vs ~32s serial

taste-is-all-you-need

Kernel · runtime · Python · Claude Opus 4.7 / Sonnet 4.6 / Haiku 4.5

The full runtime implementing the Agent OS thesis — a kernel orchestration loop, git-based memory substrate, and end-user dashboard that render every decision, checkpoint, and rollback navigable. 7 core modules, no cyclic imports. v0 shipped with three demos. Extensions in progress on long-horizon real-model rollback, autonomous parallelism selection, and LLM-judge monitoring in production.

Python · Git · Worktree · Claude Opus 4.7 · Claude Sonnet 4.6 · Claude Haiku 4.5 · pytest

zanwenfu/taste-is-all-you-need

Researchagents, security, ML systems, fine-tuning, evaluation

Five studies across medical multi-agent systems, security of deployed agents, ML-systems measurement, parameter-efficient fine-tuning, and applied evaluation. Each makes a falsifiable claim against a matched baseline and ships the artifacts to check it.

agentic-reviewers-for-SRMA

Medical NLP · solo first author · 15 SRMAs · ~150K citations

Mean sensitivity 0.982 / FNR 0.018 across 15 published SRMAs (~150K citations); perfect 1.000 sensitivity with 20–40pp specificity improvements over Tran et al. 2024's GPT-3.5 PICOS baseline on 4 held-out benchmark SRMAs (Ann Intern Med). Four small agents — Classifier, PICOS Detailed Screener, Reviewer (LLM-as-a-judge), Improver — cooperate through a bounded review/improve loop, producing a full written audit trail for every inclusion decision. ~150 lines of orchestration plus six prompt files; the design thesis is that small composition is enough when composed carefully. End-to-end cost: ~$0.07 per 10 candidates. Sole first author; code, manuscript, and per-SRMA results tables released under CC BY-NC 4.0.

Python · GPT-4o-mini · GPT-o3-mini

zanwenfu/agentic-reviewers-for-SRMA

architectural-damping

Security research · ρ-metric · ex-ante predictive · 80-case benchmark

A deterministic downstream calculator absorbs 83% of LLM-layer prompt-injection successes (ρ = 1 − ASR_end / ASR_screening = 0.83 on the 12-case held-out pilot; ρ = 1.00 on direct-override attacks) before they reach users — and the exact figure is predictable ex ante from the calculator's source code. Derives a closed-form 7.30pp single-document perturbation budget from the production calculator's source; freezes three-way attackability predictions before running the pilot; 6/6 predictions hold. Identifies attack-surface rotation as a failure mode distinct from Nasr et al.'s ASR recovery — aggregate ASR invariant, attack-family distribution changes. System under study: VYNN AI (my own production deployment, ~500 pilot users; all attacks run against offline replica). 52 tests, frozen manifests with commit pinning, deterministic LLM cache, CI-green on bare clone.

Python · LangGraph · Claude · GPT-4 · MongoDB · pytest

zanwenfu/architectural-damping

speculative-decoding-t4

Systems research · 3× gap decomposed · PyTorch · T4

Sequoia predicts 1.68× speedup on T4; I measured 0.56×. A four-term decomposition reconciles the 3× gap to within 1.1% of measurement noise — the algorithm is sound, but three specific cost-model assumptions break on bandwidth-bound hardware. Attempting the natural fix (cross-iteration KV persistence, a clear A100 win) measurably worsens T4 performance (0.56× → 0.46×) because each cache-extension forward still pays a ~20ms weight-loading floor — the paper's sharpest finding and the fourth hidden assumption. A single controlled probe unifies every finding: per-call cost flat at 20.0 ± 0.2ms across an 8.5× range of cache lengths. PLD is the only family that wins on T4 (1.28–1.39×) because Cr ≈ 0 via CPU n-gram matching is the only structural bypass of the bandwidth floor.

Python · PyTorch 2.1 · Transformers 4.45 · CUDA 12.8 · vLLM · Jupyter

zanwenfu/speculative-decoding-t4

svd-lora

Parameter-efficient fine-tuning · controlled study

~30% of LoRA's parameters, +2.1 F1 over standard LoRA on IMDB — average effective rank collapses from 8 to 2.42 after SVD-guided truncation + brief post-compression fine-tuning, with no accuracy lost on SST-2 and a measurable gain on IMDB. A controlled study of a simple question: after training a LoRA adapter, how much of its rank is actually task-useful? And if you truncate down to that effective rank and keep training, what happens? The compression pass is ~30 lines of code, exact to the Eckart–Young–Mirsky bound.

Python · PyTorch · PEFT · Hugging Face · DistilBERT · SVD

zanwenfu/svd-lora

football-llm

Applied ML evaluation · two-repo study

On the 2022 FIFA World Cup held-out set (n=128), QLoRA-fine-tuned Llama-3.1 8B hits 79.7% O/U 2.5 directional accuracy (84.4% on named-only, Wilson CI [0.736, 0.913]) — and under a coherence-required metric that credits a prediction only when text label, score line, and ground truth all agree, the headline 61.7% score_acc for QLoRA collapses to 42.2%, tying 5-shot ICL. The magnitude/direction decomposition is the contribution: LLM ties feature-matched XGBoost on 1X2 direction but beats it by 19pp pregame / 16pp halftime on O/U 2.5 magnitude — driven by pretrained scoreline priors tabular features can't replicate. Paired McNemar on pregame → halftime+events O/U 2.5: p = 0.006. The broader claim — benchmarks over structured multi-field generative outputs should report coherence-required accuracy as a cheap diagnostic, because parser rescue inflates headline numbers.

Llama 3.1 8B · QLoRA · PyTorch · vLLM · XGBoost · FastAPI · Gradio

zanwenfu/football-llm

Tooling, prototypes, course artifacts, and in-progress work all live at github.com/zanwenfu (opens in new tab) — the curated story is above, the full archive is a click away.