Yufei Wang

Work Experience

Software Engineer · Causal Dynamics Lab

Seattle, WA  |  Feb 2025 – Present

I build LLM agent systems end to end: memory and retrieval services for enterprise data, autonomous agents that diagnose production incidents, and the harnesses, evaluation pipelines and infrastructure that make them reliable. The three projects below are the main things I have worked on.

Enterprise Agent Memory, Retrieval & Agent Harness

Mar 2026 – Present

Built a scalable memory service that turns massive, heterogeneous enterprise histories (chats, documents, email, meetings, app events) into a searchable memory store, and answers questions with cited evidence through agentic retrieval. The system reached #1 on the EnterpriseRAG-Bench leaderboard.

  • Built a concurrent LLM-based memory extraction pipeline supporting a 512k-document corpus, generating dual-resolution memories with embeddings, cue anchors and entity facets stored in PostgreSQL/pgvector; achieved 3x higher throughput through buffered bulk writes, embedding pre-warm and deferred deletes.
  • Implemented an offline memory lifecycle with union-find clustering, cross-batch reconciliation, temporal fact supersession and access-decay scoring; optimized similarity computation with blocked incremental scans, reducing memory usage by 82% (60 GB → 11 GB) and the merge-matrix footprint by 99% (25 GB → 256 MB), while improving retrieval accuracy from 67% to 70% and cutting median latency by 19%.
  • Integrated LLM-generated predictive cues and a hybrid cognitive retriever, improving LoCoMo-Plus accuracy from 46% to 73% and session recall from 30% to 99%.
  • Rearchitected a policy-driven retriever into a plan-based, multi-channel pipeline with LLM query planning, HyDE, hybrid BM25/dense/cue retrieval fused via RRF, and parallel sharded LLM reranking to mitigate position bias; improved LoCoMo accuracy from 83.8% to 93.3% and EnterpriseRAG-Bench from 70.1% to 83.2%.
  • Replaced in-memory BM25 with a disk-based Tantivy search engine featuring crash-safe synchronization, leader election and incremental indexing; reduced index storage by 98% (79 GB → 1.5 GB) and accelerated index builds by 2.7x (4,146 s → 1,557 s).
  • Built a tool-use retrieval agent with candidate adjudication, verification and per-document enrichment, improving EnterpriseRAG-Bench from 83.2% to 90.91% and BEAM-10M accuracy from 55% to 71%.
  • Built an evaluation stack with four configurable quality–latency tiers, multi-provider LLM routing via LiteLLM, and token/cost tracking using Python and FastAPI.
  • Developed an asynchronous Python/FastAPI and PydanticAI agent harness for an Electron desktop app, integrating MCP tools, dynamic skills, human-in-the-loop approvals and real-time streaming for auditable agent workflows.
  • Developed "My Day", integrating Gmail, Slack, Google Workspace, Jira and Calendar for LLM-based task triage and reply drafting; built an ontology-driven knowledge system with typed relationships, temporal reconciliation and incremental updates for personalized agent context.

Technologies: Python, FastAPI, PydanticAI, LLM agents, RAG, PostgreSQL/pgvector, Tantivy, LiteLLM, MCP, Electron.

Illustration of chats, documents, email, meetings and app events flowing into a memory store that answers questions with cited evidence

AI-Powered Root Cause Analysis (RCA) Agent

Apr 2025 – Mar 2026

Developed an autonomous AI agent that diagnoses production incidents by correlating logs, Kubernetes/cloud configurations, metrics and deployment history across distributed systems.

  • Designed and implemented a multi-stage RCA agent (Python, OpenAI function calling, ReAct) that normalizes alerts, compresses raw logs into error templates via two-stage grouping (deterministic exact-match + LLM semantic consolidation), launches three parallel investigations from the top-3 candidate errors and ranks the results; iterative tool use spans Kubernetes config/secrets, GCP resource metadata, deployment history and metrics. Raised the mean evaluation score from 56% to 91% on 13 synthetic incident scenarios.
  • Architected an event-driven incident pipeline (Go, Python, RabbitMQ, PostgreSQL, Docker) that ingests PagerDuty v3 webhooks with HMAC signature verification, applies rule-based filtering (service allow-list, time window, urgency), links incidents to workloads and dispatches investigations to a Python RCA worker; hardened it with manual acks, bounded retries with dead-letter handling, context-aware RabbitMQ reconnection, graceful shutdown, thread-pool execution that keeps the asyncio event loop and heartbeats unblocked, and recovery of pending investigations across restarts.
  • Built a provider-pluggable log retrieval and dependency layer: an Elasticsearch/OpenSearch connector with multi-host failover, exponential backoff honoring Retry-After and configurable timeouts; LLM-driven log-schema discovery (iterative sampling with a diversity score) that identifies level/error/message fields per workload; severity-aware filtering built from index mappings (keyword vs. text) and an error taxonomy; and structured extraction and classification of cloud dependencies (databases, queues, SaaS APIs) from Kubernetes env vars, ConfigMaps, Secrets and volume mounts.
  • Developed a runbook (SOP) execution framework on Semantic Kernel, OpenAI and Pydantic that parses Markdown runbooks into validated atomic plans with dependencies and conditional branches and executes them either as structured plans (LLM parameter preparation, SK-evaluated conditions) or through an autonomous function-calling agent that treats the runbook as guidance; integrated LLM-generated Kubernetes diagnostics (heap/thread dumps) and a threshold-free time-series anomaly detector (Z-score against weekday-aware 1d/7d/14d baselines, STL decomposition) that seeds every investigation with breach windows.
  • Extended the agent with a drop-in skills architecture (SKILL.md playbooks discovered at runtime and executed through a shell tool), contributing skills for Kubernetes dependency/multi-workload investigation, workload configuration extraction, Prometheus/PromQL diagnostics, cloud dependency classification, alert validation (raised scores from 0.3 to 0.95 on service-port misconfiguration cases) and auto-generated repository knowledge bases from OpenDeepWiki documentation; raised the mean score on 32 test scenarios from 0.34 to 0.9.
  • Built an automated evaluation pipeline on Microsoft AIOpsLab, GKE, Chaos Mesh and OpenTelemetry that deploys microservice benchmarks (SocialNetwork, HotelReservation, AstronomyShop), injects faults, generates load, collects telemetry, runs the agent and scores it with an LLM judge against ground truth; maintained a 45-scenario catalog including 13 self-authored cloud-database, credential, third-party-API and network failure cases, and fixed fault-injection reliability (Chaos Mesh authorization webhook, stale-PV simulation, stale-result reuse).

Technologies: Python, Go, OpenAI, Azure OpenAI, Semantic Kernel, ReAct, asyncio, Pydantic, RabbitMQ, PostgreSQL, Elasticsearch/OpenSearch, Kubernetes, GKE, Prometheus, OpenTelemetry, Chaos Mesh, AIOpsLab, Docker, PagerDuty.

Long-exposure photo of a cyclist moving quickly through city lights

AI Security Assistants & Cloud Infrastructure Intelligence

Feb 2025 – Sep 2025

Developed cloud infrastructure AI assistants powered by digital-twin knowledge graphs to support security analysis, compliance verification and infrastructure impact simulation.

  • Developed multi-turn AI assistants using Go, OpenAI, WebSocket, FalkorDB and Milvus, implementing persistent conversation memory, context-window management, streaming responses and graph-grounded retrieval for cloud infrastructure analysis.
  • Built a Text-to-Cypher retrieval pipeline combining LLM-generated graph queries, vector-based query caching, schema-aware prompting and read-only query validation to enable targeted infrastructure knowledge retrieval.
  • Implemented a compliance policy management system using Go and PostgreSQL, supporting custom policies, configurable severity levels, and PCI DSS, NIST 800-53 and SOC 2 mappings to dynamically guide LLM-based Terraform impact analysis.
  • Developed an automated LLM evaluation platform using Python, RAGAS, Arize Phoenix and FastAPI, implementing semantic similarity and hallucination detection; integrated scheduled regression evaluations into GitHub Actions CI/CD workflows to monitor agent quality across releases.

Technologies: Go, Python, OpenAI, FalkorDB, Cypher, Milvus, PostgreSQL, FastAPI, RAGAS, Arize Phoenix, Terraform, Docker, GitHub Actions.

Illustration of a cloud infrastructure knowledge graph with compliance frameworks

Software Engineer Internship at Feel

Earlier experience

Feel is a new type of social media application geared towards supporting its users’ emotional wellbeing. On Feel, users can log and track their emotions to keep a pulse on how they are feeling. I involed in the chatbot development where users can talk with for additional support. Specifically, the chatbot can act as an empathetic listening ear, ask meaningful questions, recommend resources, comfort users, etc.

I firstly started by designing rigid conditions to decide wether the bot would act as a friend or a therapist using intent analysis and sentiment analysis powered by LangChain. Then I optimzed the by function calling chatbot using tools parameter to specify additional tools or features that should be enabled or utilized during the completion (or response generation) process.

The bot can also memorize what users said a long time ago, by vectorizing the conversations and storing in the PGVector concurrently while the bot is answering the user's questions.

Suggested by my manager, I further optimized the bot using Semantic Kernel developed by Microsoft, which involved developments of plugins to lead to more efficient and responsive applications.

I also created a Python script to evaluate the chatbot's performance on the test set using the BLEU metric and GPT-4o scoring to for better hyperparameter fine-tuning and prompt engineering.

Open-source Software Development

Fine-tuned LLaMa using Multi_lora on a code dataset, and added update parameters to base model during inference time.

Published the fine-tuned model to Huggingface. Model card

Test and optimized hyperparameters for MixLoRA (Mix-of-Experts) on the classification task. Repository

AI-driven recommendation assistant

The internship focused on developing a recommendation assistant for agents of Ping’an of China, one of the largest insurance companies in China, utilizing the open-source Large Language Model, ChatGLM. The recommendation process involved a four-step reasoning procedure designed to ensure a personalized and effective user experience. Additionally, the system can also provide recommendation rationales, helping users comprehend the reasons behind the recommendations it offered. For instance,

If a user requested recommendations for medical insurance for a 61-year-old individual, the system would respond as follows: (1/4) Recognizing the need for products recommendation and I am proceeding to offer suggestions. (2/4) Identifying various product options, such as "Hospital Insurance" and "Worry-Free Medical Care."." (3/4) Based on your description, "Worry-Free Medical Care" is more suitable for you. (4/4) Here are the reasons: The insurance age for this insurance is 18-65 years old, and the coverage covers 120 diseases, etc..

My responsibilities included data preprocessing, where I analyzed and cleaned the raw JSON data, and extracted keywords related to product characteristics using an IDF file. Due to lack of user queries for testing, I collaborated with the product manager team to build 10 test set consisting of 10 queries across 3 real-word scenarios: elderly individuals, frequent business travelers, and children. Furthermore, we opted to evaluate the model using two key metrics: "Helpfulness" to ensure that the model provides useful information, and "Honestness" to guarantee that the model refrains from fabricating information or misleading users.

I also engaged in prompt engineering by experimenting with different prompts, such as defined roles (e.g., assuming you are an excellent and professional account manager), specified scenes (e.g., explaining recommended products to users), word limits (e.g., 200 words), delimiters, incorporating non-linguistic context (e.g., marked with colons), and style induction(e.g., introduce friendly).

Using proper prompts, the system can achieve a 10/10 score in terms of Honestness.

Noteworthy Projects

E-commerce product flash sale system based on Golang

  • The characteristics of the flash sale system is that a lot of people would flocked in trying to place an order at the same time. So the system must have high concurrency to handle large traffic and also data consistency is really important.
  • The basic architecture is that when uservisit the page and send requests to web server, and the server would query data from the database. After getting the data, the web server would render the page to user, which involves product, user and order management. However, there are several problems with this architecture:
  • 1. Web server would need to handle lots of request and guarantee secure access, which would put a lot of stress to the web server. 2. Querying the database for every user request results in low performance. 3. Simply interacting between server and database during high traffic may not ensure accurate inventory management, potentially leading to overselling products beyond available quantities.
  • Thus I optimized the system's concurrency using several techniques: Deployed the front-end page using AWS CloudFront for CDN optimization.
  • Designed a distributed authentication module to filter traffic effectively using AES-encrypted cookies. I also implemented a consistent hashing algorithm to store user last login times, controlling access rates.
  • Utilized RabbitMQ to manage database access flow and process messages asynchronously.
  • Created a module that achieved over 15k QPS on a single machine deployed on AWS EC2.
  • Utilizing these techniques, the system can operate concurrently and handle high loads effectively
  • Online Dating Web Application

  • I developed an online dating website where you are free to make friends and share posts. You can visit it here, but note that I will charge for every messages you sent. It's hard to find real love afterall:)
  • I created features for sending smile, friends requests and messaging using Node.js, Bootstrap and MongoDB. And I used Stripe Checkout handling messages charges.
  • I also implemented post sharing with commenting and thumbs-up functionality, storing images in AWS S3 using AJAX.
  • When a new user is registered, an automatic welcome messages will be sent using socket and message notifications will be created at the header of the website using jQuery.
  • YouTube Clone

  • Built a website for users to view videos and upload videos when authenticated with scalability.
  • Created a video processing service to transcode videos using Express, TypeScipt and FFmpeg. Stored videos in Google Cloud Storage and associated metadata in Cloud Firestore. Used Cloud Pub/Sub for message communization.
  • Built the web client with React and Next.js; Showed videos by retrieving URLs from buckets, leveraging Firebase Functions.
  • Deployed services in a containerized environment with Docker and GCP Cloud Run.
  • HDFS Emulation

  • Emulating the Hadoop Distributed File System (HDFS) by self-designing its main tasks. The frontend page was implemented via Vue.js and the backend server was built using python and Flask.
  • Firebase was used for the database to store NameNode and DataNodes. Like HDFS, the NameNode has two main sections, iNodeSection to store inumber of each file and dirSection to explore directory structure.
  • The system can also accept shell commands from the terminal the sockets were used for communication.
  • Click Through Rate Prediction

  • Advertising analysis of predicting whether a mobile ad will be clicked using Wide&Deep model and its variations Deep&Cross model and DeepFM model.
  • The project was built using python and PyTorch and Spark SQL for big data OLAP.
  • Movie Recommendation Engine Development

  • Movie Recommendation System based on the matrix factorization method to recommend top k movies to a user by analyzing his/her reviewing history. Additionally, the system can discover similar movies within the dataset using by utilizing the movie factor matrix and computing Euclidean and cosine distance of the movie factors.
  • The project was implemented by Spark ALS and Spark SQL
  • LA Crime Analysis

  • Spatial and time analysis of crimes for a 10-year dataset of reported crimes from LA government based on OLAP and model building.
  • The project was implemented by Spark SQL, Spark Dataframe and Spark ML.
  • Stock Price Prediction

  • Stock price prediction based on LSTM model.
  • Other Projects

    Skills

    I have been actively engaged in programming since 2018, consistently immersing myself in the realm of technology.

    Below are some of the tools and analytical skills with which I am proficient.

    Programming language

    Golang, C++, Java, C

    Python, SQL

    HTML/CSS, Javascript, TypeScipt

    Front-end / Back-end

    React, Redux, Vue, Next.js

    Node.js, Express, Flask

    FastAPI, Spring

    Socket, Websocket

    Development tools

    Git, Linux

    AWS, GCP

    Docker, Kubernetes

    Big Data Analysis & Management

    Spark (Spark SQL, Spark ML, Spark Dataframe, RDD)

    Hadoop

    PyTroch, Tensorflow

    MySQL, PostgreSQL

    MongoDB, Firebase, Amazon DynamoDB, HBase

    Deep Learning

    Convolutional Neural Networks (CNN)

    Recurrent Neural Networks (RNN)

    Long Short Term Memory (LSTM)

    Transformer

    Transfer Learning

    Large Language Models(LLMs)

    Embeddings

    Word2Vec

    Milvus

    FAISS

    Fast Map

    Data Visulization

    Tableau

    Python (Seaborn, Matplotlib, etc.)

    Excel

    Supervised Learning

    Linear Regreesion

    Logistic Regreesion

    K-Nearest Neighbors (KNN)

    Linear Discriminant Analysis

    Support Vector Machines (SVM)

    Random Forest

    XGBoost, LightGLM

    Unsupervised Learning

    Principal Component Analysis (PCA)

    K Means

    Gaussian Mixture Models (GMM)

    Optimization Techniques

    Local Search

    Dynamic Programming

    Constraint Satisfaction Problems (CSPs)

    Heuristic Seach

    Job Scheduling Problem

    Graph and Netwrok

    Bayesian Networks (BNs)

    Hidden Markov Models (HMMs)

    Complex Network

    Gephi

    Recommendation System

    Collaborative Filtering

    Matrix Factorization

    Feature Interaction (FM, FFM, PNN)

    GBDT + LR

    Wide & Deep, Deep & Cross

    AutoRec, Nerual CF, Deep Crossing

    DeepFM, NFM, AFM, FNN

    DIN, DIEN

    xDeepFM

    Get in touch

    My inbox is always open. Whether you have a question or just want to say hello, feel free to mail me!

    Mail Me