PhD @MIT_CSAIL, previously @IBMResearch, @haverfordedu .
Cambridge, Massachusetts
Joined March 2015
- Tweets239
- Following493
- Followers577
- Likes428
Pinned Tweet
Introducing Learned Asynchronous Decoding w/ friends from MIT/Google! LLM responses often have chunks of tokens that are semantically independent. We train LLMs to identify and decode them in parallel, speeding up inference by 1.46x geomean (AlpacaEval) w/ only 1.3% quality loss.
Tian Jin retweeted
Do you love training LLMs? 👇
At [un] @unconvAI we're not only rethinking computers, but also how intelligence emerges from the physical world. We're working at the frontier and our computing primitives are physics.
If you're interested in the intersection of nonlinear dynamics and language and reasoning, apply here:
unconv.ai/careers/?gh_jid=42…
Tian Jin retweeted
Mercury 2 is now live! 🚀
The fastest reasoning LLM built for production speed.
~1000 tokens/sec vs <200 tokens/sec for comparable models.
What this enables:
🤖 Fast agents: fast iteration loops, no compounding delays
🎙️ Voice and Search AI: tight turn-taking, natural conversations under strict latency budgets
💻 Interactive code completions, editing, and design workflows
Tian Jin retweeted
We introduce a new approach for fast and high-quality context compaction in latent space.
Attention Matching (AM) achieves 50× compaction in seconds with little performance loss, substantially outperforming summarization and other baselines.
Tian Jin retweeted
Nice! A generated compiler.
But there is a little subtlety:
“The fix was to use GCC as an online known-good compiler oracle to compare against. I wrote a new test harness that randomly compiled most of the kernel using GCC, and only the remaining files with Claude's C Compiler. If it broke, then it could further refine by re-compiling some of these files with GCC. This let each agent work in parallel, fixing different bugs in different files, until Claude's compiler could eventually compile all files.”
Sure will be possible to overcome eventually
New Engineering blog: We tasked Opus 4.6 using agent teams to build a C compiler. Then we (mostly) walked away. Two weeks later, it worked on the Linux kernel.
Here's what it taught us about the future of autonomous software development.
Read more: anthropic.com/engineering/bu…
Tian Jin retweeted
Most CS work on prosocial recommender systems is happening in HCI, b/c in ML, recommender systems are basically boring, legacy systems
But LLMs / agentic capabilities could be utilized to really improve how we interact with information and communicate with others (e.g. see one proposal by @sethlazar et al arxiv.org/abs/2410.12123)
For students interested in societal impacts of ML, IMO there is a lot of creative methodological work to be done in this intersection...
</day 1 experimenting with posting random thoughts on X>
Tian Jin retweeted
📢Feb 2 (Mon): Planned Diffusion
🙅Diffusion language models are capable of parallelizing text generation but can struggle with coherence in low time-step regimes.
💡Planned Diffusion unlocks a new axis of parallelism: Token-level parallelism ➡️ semantic parallelism
✍️Planned diffusion first generates a structured plan, then diffuses semantically independent spans of text in parallel according to the plan.
This Monday, Daniel Israel (UCLA) (@danielmisrael) and Tian Jin (MIT) (@jintian) will discuss their exciting Planned Diffusion paper as joint first authors.
Collaborators: Ellie Cheng (elliecheng.com/), Guy Van den Broeck (@guyvdb), Aditya Grover (@adityagrover_), Suvinay Subramanian (@suvinay), Michael Carbin (@mcarbin)
Paper link: arxiv.org/abs/2510.18087
Tian Jin retweeted
1/ We found that deep sequence models memorize atomic facts "geometrically" -- not as an associative lookup table as often imagined.
This opens up practical questions on reasoning/memory/discovery, and also poses a theoretical "memorization puzzle."
Tian Jin retweeted
Let's do a simple upgrade for GRPO.
GRPO=normalize(sum(reward_i))
GDPO=sum(normalize(reward_i))
it makes difference when i>=2
RLVR is powerful — but how do you train with multiple rewards effectively? 🤔
🎯GDPO (not GRPO) is coming.
We introduce Group reward-Decoupled Normalization Policy Optimization (GDPO), a new multi-reward RL algorithm that consistently improves per-reward convergence over GRPO across a wide range of tasks. (1/n)
Tian Jin retweeted
This tracks. More velocity but more tech debt. Lines of code has always been a bad measure of output, but even more now when getting executable code is now free.
Going to be interesting shift where value is software specification and design instead of implementation.
A Carnegie Mellon study found Cursor can boost output fast, about 3x to 4x more lines of code added in the 1st month after adoption.
Researchers identify 807 repos via committed Cursor config files like .cursorrules, match 1,380 controls, and run difference-in-differences (DiD) that compares each repo before vs after adoption against controls in the same months.
Code Velocity is commits and lines added, and quality is SonarQube static analysis warnings, which are automated checks for reliability, maintainability, and security, plus duplicate line density and cognitive complexity.
It found a sharp velocity spike, roughly 3-5x more lines added in month 1 and an average 1.84x increase post-adoption.
It also measured trade-offs, static-analysis warnings up ~30% and code complexity up ~41%, which later drags velocity. This shows real, measurable impact, and it shows why you pair agents with tests, code review, and quality gates.
----
Paper Link – arxiv. org/abs/2511.04427v2
"Does AI-Assisted Coding Deliver? A Difference-in-Differences Study of Cursor's Impact on Software Projects"
Tian Jin retweeted
New MIT paper lets a LLM share live Python state, meaning current data and where code is running.
In benchmarks, NIGHTJAR cut code by 39.6% on average, without losing accuracy.
A LLM mostly works by reading text and predicting text, so it normally cannot see real program memory.
Most prompt and Python setups keep the model separate, so developers turn objects into text, send it, then parse the reply and patch the program by hand.
Shared program state flips that, natural language blocks can read or write variables, named boxes holding values, mutate Python objects in memory, and stop or skip loops.
It works by having the model emit small requests like read a variable, write a value, update an object, or exit a loop, and a Python handler performs them, a contract the paper calls a natural function interface.
On SPSBench with 25 programs, correctness stayed comparable or better than manual glue code, but runtime sometimes rose up to 4.3x because each request can mean another model call.
----
Paper Link – arxiv. org/abs/2512.14805
Paper Title: "Sharing State Between Prompts and Programs"
Tian Jin retweeted
We let the genie out! In this new paper we argue for LLM to have direct access to your python variables, heap and control flow state and unlocked new patterns for programming with LLMs.
We let the genie out! In this new paper we argue for LLM to have direct access to your python variables, heap and control flow state and unlocked new patterns for programming with LLMs.
Tian Jin retweeted
🦜✨Nightjar ✨makes your prompts first-class code in your Python programs: Your prompts read and write program variables, compute with program objects, and implement program control flow. 🧵(1/n)
Tian Jin retweeted
I'm in the bay area for the next few days and would like to meet folks at the intersection of AI/robotics. DMs open
Tian Jin retweeted
Modern computation interfaces with a physical world that is continuous...noisy...analog.
My group and community's research over the last 15 years or so has shown that peeling back the digital abstraction and embracing computation's analog nature leads to robust, efficient systems.
At @unconvAI , we're bringing new levels of energy efficiency by mapping AI to its physical analog.
Come join us! unconv.ai/careers
AI scaling will be energy-limited at the global level in the next 3-4 years. Conventional computing is reaching its limits.
It’s time to stop simulating neural networks on digital logic and start building hardware that actually behaves like them.
We are Unconventional AI. Learn more about our mission: unconv.ai/introducing-unconv…
Tian Jin retweeted
presenting proofoptimizer at ai for math workshop tomorrow!
Tian Jin retweeted
📢 Happening Today at NeurIPS 2025!
🚀Come check out our spotlight paper, Multiverse. We propose a native generative modeling framework that delivers adaptive and lossless parallel generation, , powered by data, algorithm, and system co-design.
📍 San Diego Convention Center, Exhibit Hall C/D/E
🖼️ Poster: #3704
⏰ Time: 11:00am – 2:00pm (PST)
Really appreciate a parallel-reasoning paper that reports both speedup and parallelism.
Speedup = seq / par latency.
Parallelism ≈ (latency if you generate the parallel content sequentially) / par latency.
They differ because the sequential baseline and the parallel model often produce *different* content. You can game speedups by training for conciseness; you can game parallelism by training for (parallel) verbosity, but it's been hard so far to game both.
