AI Platform Developer @ IBM Research · ML Systems × Compilers · AI Inference Optimization

$ ssh gsmoon97@portfolio-os
Welcome to PORTFOLIO_OS (GNU/Linux 6.1.0 aarch64)

 [ OK ]  Mounted /dev/brain
 [ OK ]  Started service: AI Platform Developer @ IBM Research
 [ OK ]  Loaded backend: torch-spyre  (target: Spyre AIU accelerator)
 [ OK ]  Reached target: AI Inference Optimization
 [WARN]  impostor_syndrome.service masked — will not start
 System ready. 1 recruiter session waiting on /dev/hire ...

$ whoami
> "Geonsik" / "Gun-Shik" / "/kʌn.ɕik/" — call me "GS" 🙋🏻‍♂️

I'm an AI Platform Developer building the systems layer that makes large models run fast on real hardware. My work sits where ML compilers, model serving, and inference optimization meet: I extend PyTorch's torch.compile stack, trace performance down to individual kernels, and turn that visibility into speed.

Right now I'm at IBM Research on torch-spyre — IBM's PyTorch backend for the Spyre AI inference accelerator — building compiler-level provenance so kernel hotspots can be attributed back to the exact source line that produced them.

That systems focus is grounded in a research background: 5 peer-reviewed papers (ICLR / ACL / AACL / EACL) and hands-on LLM training, evaluation, and NLP at ByteDance, Apple, and NUS. I like problems where a paper-grade idea has to survive contact with a production pipeline.

• PyTorch compilation stack — torch.compile internals: TorchDynamo, AOTAutograd, and Inductor lowering to custom hardware backends
• Kernel-level performance — source-to-kernel provenance, profiling, hotspot attribution, quantization, FlashAttention
• Hardware backends — lowering ATen ops → optimized kernels for the Spyre AIU inference accelerator

• Serving & runtimes — vLLM, llama.cpp, Ollama; backend integration for accelerated inference
• Efficient adaptation — LoRA / QLoRA / PEFT, 4-bit quantization for parameter-efficient fine-tuning
• RAG & orchestration — LangChain / LangGraph pipelines, vector search over Chroma / Pinecone

• Training-data & RL pipelines — end-to-end data ops for code-generation and agentic RL benchmarks
• Agent evaluation — failure-mode analysis and eval feedback loops for SWE agents; LM Eval Harness, W&B
• NLP research — timeline summarization, lexical semantics, grammatical error correction (ACL / EACL / AACL)

• Contributing to IBM's open-source ML compiler stack that lowers torch.compile graphs to optimized kernels for the Spyre AIU inference accelerator.
• Built source-to-kernel provenance: a Phase-1 audit (PR #2720, merged) that pinpointed where source attribution was dropped in the Inductor → OpSpec → SuperDSC path, then a debug_handle schema (PR #2945, in review) threading each kernel back to its PyTorch source line + ATen op — the foundation for source-level inference-perf tuning.
• Tech Stack: PyTorch torch.compile Inductor AOTAutograd ATen Spyre AIU

• Integrated the Granite Speech 3.3 model into IBM's Foundation Model Stack — Conformer encoder, Q-Former projector, LoRA-adapted decoder — with torch.compile optimization. Opened a PR to the upstream repo.
• Tech Stack: PyTorch FMS Granite-Speech-3.3 LoRA torch.compile

• Co-authored an open-source competitive-programming benchmark (released on Hugging Face) evaluating whether frontier LLMs can win IOI/ICPC-tier contests. Orchestrated data pipelines across 17K+ samples and 70+ annotators.
• Tech Stack: LLM Evaluation RL Benchmarks Hugging Face Multi-Agent Codegen

• LLM-driven incremental event clustering and timeline construction from text streams; outperformed SOTA on 4 TLS benchmarks.
• Tech Stack: PyTorch vLLM Llama-2-13B LangChain ChromaDB

• Framework showing encoder-only models outperform decoder-only LLMs on lexical semantic tasks (WSD, WiC).
• Tech Stack: PyTorch Transformers LoRA PEFT W&B

• End-to-end Gmail pipeline: topic classification via AWS Bedrock LLMs, RAG-enriched semantic search, and AI-generated thread summaries, with a Streamlit UI and structured outputs (instructor + Pydantic).
• Tech Stack: AWS Bedrock Streamlit instructor Pydantic Gmail API FAISS Titan Embeddings LangChain

• Research toolkit for analyzing LLM-agent trajectories on software-engineering tasks — surfacing failure modes across thousands of runs.
• Tech Stack: Python Jupyter Agent Frameworks

Programming Languages

ML Frameworks

ML Systems & Performance

LLM Training & Evaluation

LLM Infrastructure

Systems & DevOps

1. AetherCode: Evaluating LLMs' Ability to Win in Premier Programming Competitions
   ICLR 2026 · [Dataset | Paper]

2. From Moments to Milestones: Incremental Timeline Summarization Leveraging Large Language Models
   ACL 2024 (Main Conference) · [Code | Paper]

3. Are Decoder-Only Language Models Better than Encoder-Only Language Models in Understanding Word Meaning?
   ACL 2024 (Findings) · [Code | Paper]

4. WAMP: Writing, Annotation, and Marking Platform
   IJCNLP-AACL 2023 (System Demonstrations) · [Code | Paper]

5. ALLECS: A Lightweight Language Error Correction System
   EACL 2023 (System Demonstrations) · [Code | Paper]

$ cat /etc/gsmoon97/contact.conf
  location   = New York, NY
  website    = https://gsmoon97.github.io
  linkedin   = https://linkedin.com/in/gsmoon97
  scholar    = https://scholar.google.com/citations?user=si3AXV8AAAAJ
  orcid      = https://orcid.org/0009-0001-5646-466X
  status     = open to full-time roles (starting Jan 2027)

$ echo "Ping me before my RAM gets overwritten."