Study kernels, scheduling, service orchestration, and agent behavior as one continuous system rather than isolated layers.
Large Model Research
From training systems to inference engines to production-grade agent runtimes
This site focuses on the part of large model research that most often breaks between theory and deployment: training throughput, memory layout, inference paths, tool execution, long-context behavior, exposure boundaries, and safety operations. The standard here is simple: can a technical path survive on real machines, under real load, with real failure modes?
Performance matters, but stability and interpretability decide whether a system remains usable after the benchmark ends.
Run small, reproducible experiments before making architectural claims. Abstraction should follow evidence, not replace it.
The real subject is the full path from GPU kernels and distributed execution to serving gateways and agent toolchains.
Explore Our Work
Dive deeper into our research areas and access detailed resources
Research Projects
Detailed case studies and implementations of our training systems, inference engines, and agent runtime architectures.
Browse Projects →Technical Documentation
Comprehensive guides, API references, and implementation notes for researchers and engineers.
View Docs →Research Blog
Insights, findings, and technical discussions from our ongoing work in large model systems.
Read Articles →Tools & Libraries
Open-source tools, benchmarks, and utilities developed during our research projects.
Explore Tools →Research Agenda
Four long-running tracks for turning large model research into engineering questions that can be tested, measured, and maintained.
Training systems and resource orchestration
Study the real coupling between data loading, activation checkpointing, pipeline parallelism, tensor parallelism, and network topology instead of treating the cluster as a black box.
- Balance between throughput and operational stability
- Long-run recovery and checkpoint consistency
- Interaction between mixed precision and communication cost
Inference engines and serving paths
From single-card kernels to multi-tenant request scheduling, analyze how inference systems trade off latency, throughput, and memory pressure.
- Prefill/decode split scheduling
- KV cache reuse and fragmentation control
- Batching policy and tail-latency management
Agent execution and tool reliability
Track what happens after model output meets a real system: tool-call formatting, permissions, recovery, state compression, and multi-turn consistency.
- Robustness of tool-call protocols
- Long-session compaction and instruction drift
- Auditability of automated workflows
Safety governance and infrastructure exposure
Do not outsource security to an edge layer. Study risk as a property of gateways, model routing, panels, logs, and execution policy together.
- Minimal exposure surface by default
- Device pairing and origin validation
- Layered authentication for external access
Featured Projects
Active research projects and implementations
Observation Rhythm
Break research progress into stages that make engineering decisions easier to track.
Phase 1
First, prove a path can close the loop
Environment, build, debugging, verification, and observability come first.
Phase 2
Then ask whether performance really improved
Compare against baseline, measure variance, and reject optimizations that only look good once.
Phase 3
Finally, turn the method into reusable infrastructure
Capture scripts, templates, gateway policy, and operating practice so the result can survive beyond a one-off experiment.
Reading Entry Points
Not a paper dump. A pragmatic map for deciding where an engineer should start reading or experimenting.
If you care about training
Start with data paths, gradient synchronization, checkpoint recovery, and communication topology before chasing stories about ever larger clusters.
Training Docs →If you care about inference
Clarify latency targets, memory budget, and request distribution before deciding whether quantization, batching, or routing complexity is justified.
Inference Docs →If you care about agents
Secure tool boundaries, permission models, output cleanup, and state consistency before you get distracted by claims about autonomous planning.
Agent Docs →