built as a graph

Tangyi (Jerry) Qian

I build intelligent solutions on two pillars:
base models × agent scaffolding.

A weak base model means no foundation; a weak agent layer means a foundation with nothing built on it. So my work lives on both pillars — models: post-training/RFT, model editing, inference & serving — and agents: harness engineering, evaluation, multi-agent supervision.

[Berkeley, CA][Founding AI Engineer @ PiPlan.ai][LLM model-editing research — preprint under review]
Explore PiPlan ↗See my work ↓

nodes/ — things I've built

FOUNDERSHIPPEDFULL-STACK

PiPlan.ai

An agentic planning system — goals become typed graphs, an agent harness governs every change, and the plan re-plans itself as reality drifts.

AgentsInference & ServingML PlatformFull-stack
Details

Problem

Every planner dies the moment reality diverges from the plan. Static to-do lists can't answer the only question that matters: "X just slipped — what should I do now?"

What I built

Built the entire system solo. Full-stack core: Python · FastAPI · SQLAlchemy · NetworkX backend (100+ REST endpoints over a 39-table versioned schema) with a React 18 · TypeScript · React Flow workspace. Agent harness: proposal-first review (draft → diff → human commit), a simulation sandbox for candidate plans, and a full event log doubling as training-data trajectories. Serving: a self-hosted multi-GPU vLLM node with a dynamic routing layer — routine agent steps run locally, complex planning escalates to frontier APIs. Adaptive re-planning re-derives the critical path as reality changes; the conversational planner–executor agent is in progress on top of the same guardrails.

piplan.ai ↗
OpenAI Build WeekFULL-STACKRL

VerifierForge

RFT-in-a-box: point it at your LLM traffic, it finds the expensive task clusters, trains a small model against your own verifier, and proves the gain before routing to it.

Post-training / RLInference & ServingLLM Systems
VerifierForge proof view showing held-out pass@1 rising from 58.3% to 78.3% and pass@8 to 90%.

A 60-row held-out evaluation: independent pass@1 climbs from 58.3% to 78.3% (+20pp), pass@8 to 90.0%.

Details

Problem

Teams burn frontier-model budget on high-frequency, narrow tasks — the exact tasks a small fine-tuned model handles fine. Almost nobody does it, because the RL expertise, the GPU orchestration, and the proof that it actually worked are three separate hard problems.

What I built

A closed loop, built solo in one week: a proxy ingests real traffic and discovers task clusters and their cost; an agent with a fixed action space and custom analysis tools writes the training config; the system auto-provisions a GPU pod, trains with GRPO against a user-supplied programmatic verifier, then proves the result — held-out pass@1 went 0.583 to 0.783 and pass@8 0.767 to 0.900, while a spurious-reward control stayed flat, so the gain isn't placebo. Shipping is a routing toggle with a canary and a drift guardian. Serving scales to zero: a request wakes a GPU pod in about four minutes and reclaims it after thirty idle minutes.

Live app ↗GitHub ↗
OPEN SOURCEAGENT SKILLHARNESS

SafeRoutes

A route-planning agent skill that enforces its own invariants — the agent physically cannot leave the state inconsistent, even when it claims it did the work.

AgentsHarness EngineeringReliability
Route map spanning Chicago to Pittsburgh with waypoints marked along one continuous path.

A generated roadbook: the full planned route with its ordered waypoints, rendered end to end.

Details

Problem

Tool and skill definitions are expose-and-pray: they describe what an agent CAN call, and impose nothing on what it actually does. In practice the failure isn't a crash — the model narrates the step ('removed that waypoint') and never calls the tool. On a general agent harness you don't own, you can't patch the runtime to fix this.

What I built

Enforcement pushed down into the skill itself, so it works on an unmodified host. Every state write is gated by an invariant check — waypoint self-consistency, path continuity, range windows — and a failed check rolls the state back and returns an error written as an instruction, not a complaint, so the model's next turn is corrective rather than apologetic. Waypoint mutation is a first-class operation instead of an emergent side effect of free-form edits. The model's diligence is removed from the critical path: correctness becomes a property of the data plane, not of the prompt.

GitHub ↗
HACKATHON BUILDOPEN SOURCE

Loop Supervision for Multi-Agent Research

A supervisor that watches a multi-agent run as a task graph and tells you WHICH agent is stuck — and why — instead of just timing out.

AgentsHarness EngineeringObservability
Loop supervisor task-graph dashboard with nodes color-coded by state and a live incident stream.

The supervisor watches a run as a live task graph; each node's state updates as the experiment progresses.

Details

Problem

Multi-agent systems don't fail loudly. An agent quietly re-runs the same step, works on a sibling's task, or builds on a result that was invalidated upstream. A timeout tells you something is wrong; it doesn't tell you what.

What I built

A dependency-aware supervisor over an async task graph — no global fork-join barriers, so a three-hour experiment node never blocks a ten-minute one. It detects distinct incident classes rather than generic stalls: scope violations, stale cascades built on invalidated results, taint propagation, and blocked comparisons. Each incident produces a blame trace and a revert. Built for an auto-research workload, with a live dashboard that replays a run step by step. In a live test it caught a real one: a worker silently dropped samples mid-experiment, the data hash diverged, and the comparison was blocked before it produced a bogus number.

GitHub ↗
HACKATHON BUILDOPEN SOURCE

GraphJudge

A graph-grounded factuality judge for LLM output — the verdict is made by Neo4j graph topology, not by another LLM.

AgentsVerificationKnowledge Graphs
Details

Problem

Everyone judges LLMs with LLMs — but an LLM checker hallucinates its own verdicts, and when retrieval comes back empty it falls back to its parametric prior and guesses. A fluent fabrication that only cites itself looks plausible in text; nothing in the prose gives it away.

What I built

A judge that runs downstream of generation: paste generated text, it extracts atomic claims, anchors them to a trusted Neo4j reference graph, and returns a per-claim verdict — SUPPORTED, CONTRADICTED, or UNGROUNDED — each carrying a graph path as evidence. The verdict is made by the graph, not by a model: functional-relation contradictions are deterministic Cypher checks, and GDS component analysis exposes fabricated clusters as components with zero trusted anchors — absence becomes a first-class signal instead of a null. The LLM only parses prose into claims; it never decides truth. Built for HackwithBay 3.0 as a credit-gated web app that renders each result as an inspectable fact constellation. On a 63-claim benchmark against an LLM judge, both detected every planted-false claim, but GraphJudge's exact 3-way labeling scored 100% vs 98.4% — deterministically, with auditable evidence paths.

Live demo ↗GitHub ↗
OPEN SOURCEHACKATHON BUILD

Engram

A continual-learning personal agent that writes your beliefs into model weights.

Model EditingAgentsContinual Learning
Engram title card: continuous-learning memory for LLMs, beliefs in weights, facts in RAG.

Engram's cover: continuous-learning memory for an LLM — beliefs internalized into weights, facts kept in RAG.

Details

Problem

RAG remembers facts, but it can't change what a model believes. Preferences and beliefs shouldn't live in a vector store bolted onto the side of a frozen model.

What I built

An agent with a fact-vs-belief router: facts go to retrieval, beliefs get written directly into the model's weights via model editing. Includes an attribution demo — the agent recalls injected beliefs with RAG fully disabled, proving the knowledge lives in the weights.

GitHub ↗
REPRODUCE → VERIFY → BENCHMARK

Paper Reproductions

I re-implement papers end-to-end and benchmark them against reported numbers.

PyTorchBenchmarking
Details

What I built

DCN-V2 (Google, WWW '21) — implemented and benchmarked on Criteo. ESMM (Alibaba, SIGIR '18) — reproduced the entire-space multi-task framework. ColBERT (Stanford, SIGIR '20) — implemented the MaxSim operator in PyTorch. GRACE (NeurIPS '23) — reproduced its discrete key-value adaptor approach to lifelong model editing on large language models (LLMs). GRPO (DeepSeek, 2024) — implemented the group-relative policy-optimization RL algorithm from DeepSeekMath; it drives VerifierForge's training loop. One-Shot RLVR (NeurIPS '25) — reproduced RL from verifiable rewards with a single training example. In progress: model-architecture and inference-acceleration papers.

GitHub ↗
OPEN SOURCE

ClawConclave

A multi-agent OpenClaw system — LLM agents with distinct roles coordinating in shared channels.

Multi-agentLLM Systems
GitHub ↗

research/ — what I'm working on

Preprint — under review

One Edit, Many Queries: Self-Generated Query Distributions for Unstructured Model Editing

Tangyi Qian and co-authors — first author

LLM Model EditingContinual Learning

Model editing installs a new fact directly into a large language model's (LLM) weights, but the edit has to survive being asked about differently — paraphrases, sub-questions, a hundred edits later. Prior work treats this mostly as a routing problem: does a rephrased query reach the right stored edit? We find routing is only half of it. Even with perfect retrieval, a value trained on one phrasing often fails to produce the stored passage under another. Our method has a frozen model generate its own questions from the edit, then uses them both to build the retrieval key and to train the per-edit adaptor — no benchmark paraphrases or sub-questions are ever used during editing.

On a held-out pool, paraphrase and sub-question ROUGE-L improve by 0.208 and 0.176 over a matched control, with no measured change in MMLU.

path/ — the trajectory so far

Apr 2026 — Present

PiPlan.ai · Founding AI Engineer

Building an agentic planning system end-to-end as the sole engineer — product, agent harness, inference stack, and data platform.

Read details

Architected and shipped the full-stack core (Python · FastAPI · SQLAlchemy 2.0 · NetworkX; React 18 · TypeScript · React Flow — 100+ REST endpoints over a 39-table versioned schema) modeling goals as typed directed multigraphs with live completion-state tracking and versioned snapshots.

Built the agent harness governing all mutations: a proposal-first review protocol (draft → diff preview → human commit/reject), a simulation sandbox for candidate plans, and a full event log capturing every action for auditability and downstream training data.

Built adaptive re-planning services that re-derive the critical path as reality changes (constraint-solver scheduling with Monte-Carlo feasibility checks); now building the conversational planner–executor agent: multi-step tool-call loops over CLI-wrapped system capabilities, bounded retries, and human-in-the-loop batch review.

Deployed a self-hosted 6-GPU inference node (vLLM serving GLM / MiniMax-class open models) for latency-critical agent steps: tuned tensor-parallel vs multi-replica layout and continuous batching, and exploited prefix caching over shared system-prompt and graph-state context across multi-turn sessions.

Built a dynamic model-routing layer trading off latency, cost, and capacity: routine agent steps (tool-argument formatting, summarization) run on the local node, complex planning steps escalate to frontier APIs, with load-aware spillover and per-step cost telemetry.

Engineered stateful agent-session serving: async long-running loops with streaming (WebSocket/SSE), checkpointed and resumable runs, idempotent tool mutations, per-user concurrency caps, and per-step tracing (model, tokens, latency) for production debuggability.

Migrated the platform to multi-tenant Postgres (39-table schema + full versioning system) with per-tenant isolation, graph-hydration caching keyed on (user, graph-version), and monthly event-log archival designed around training-data extraction.

Moved solver workloads off the request path onto a job queue with per-tenant quotas and incremental local-repair scheduling, keeping API latency flat under concurrent re-planning load.

Built the training-data flywheel: trajectory and preference records (proposal → accept / reject → actual outcome) extracted from the event log into parquet datasets, powering evaluation suites and a bandit layer for per-user proposal-style personalization.

AgentsInference & ServingML Platform

Feb 2026 — Jun 2026

GoldenMeadow Investments LLC · Software Developer Intern

Built an automated investment-research agent pipeline that turns raw filings and market data into analyst-ready research briefs for the firm's internal workflow.

Read details

Architected the end-to-end auto-research pipeline: ingestion and parsing of earnings releases, SEC filings, and market news (10K+ document corpus) into structured signals (guidance changes, event tags, sentiment deltas), with a gradient-boosted relevance scorer gating what enters the research queue.

Built the research agent core: given a ticker or event, the agent plans an evidence-gathering workflow (filing sections, price/volume context, peer comparisons, news timeline) compiled into a parallel tool-call DAG (LLMCompiler-style), producing citation-grounded research briefs.

Built a FrugalGPT / RouteLLM-style cascade router — a lightweight classifier over document type, relevance score, and small-model confidence routes routine coverage to a compact model and escalates only complex filings (M&A, restatements, non-standard disclosures) to a frontier model.

AgentsLLM SystemsFinance

Sep — Dec 2025

CMU Heinz XR Lab · Machine Learning Engineer (Capstone)

LLM + knowledge-graph recommendation engine for VR coursework, serving 200+ students. Dual-stage matching over a 4,700-node curriculum KG; implicit-feedback loop lifted offline Recall@5 by 30% (NDCG@10 0.82).

LLM SystemsKnowledge GraphsRetrieval

May 2025 — Feb 2026

XY Investments · AI Implementation Engineer

Three subsystems of an LLM research platform: hybrid retrieval (BGE + BM25 + RRF, Recall@10 62% → 85%); an embedding + LLM intent router for a multi-agent platform (routing accuracy 34% → 91%); multimodal PDF extraction at 95%+ accuracy.

AgentsRAGLLM Systems

Jun — Jul 2024

Century Frontier Asset Management · Quant ML Intern

Pairwise ranking (RankNet-style) for high-frequency cross-sectional selection; VAE over tick-level order-book data for denoised dense features.

MLRanking

Jul — Aug 2023

Global AI · Data Engineering & ML Intern

Heterogeneous-information-network embeddings over a Wikidata-derived company graph; meta-path constrained random walks; query-expansion layer for search Recall@10.

Graph LearningSearch

logs/ — build notes, no thought leadership

full matrix → /logs

state/ — who I am

I'm Jerry — an AI engineer in Berkeley, CA. I like owning the whole stack: data pipelines, training loops, solvers, agents, and the product around them.

In April 2026 I founded PiPlan.ai to build a planner that behaves like an engineer: model the goal as a graph, optimize the schedule, and re-plan automatically when reality drifts. Building a company end-to-end confirmed what I enjoy most — deep technical work close to the model and the system.

Before that: Carnegie Mellon (M.S., Dec 2025), Emory (B.S. Quantitative Sciences), and ML work across retrieval, ranking, and graph learning.

Education

2024 — 2025Carnegie Mellon University · M.S. Information Systems Management

2021 — 2024Emory University · B.S. Quantitative Sciences: Informatics

Stack

Agents & LLM planner–executor runtimes · tool use · model editing · RAG & hybrid retrieval · vLLM

ML PyTorch · GNNs (PyG) · ranking · imitation learning · bandits

Systems FastAPI · SQLAlchemy/Postgres · Redis · Docker/K8s · OR-Tools

Frontend React 18 · TypeScript · React Flow

GitHub: github.com/xesws · LinkedIn: linkedin.com/in/tangyi-qian-jerry · Email: jq@piplan.ai