Cursor

Build from anywhere by launching always-on cloud agents. Or remotely control agents running on your computer from the app. Learn more: cursor.com/blog/ios-mobile-app

Linus Lee, Engineer at Thrive Capital, on notational intelligence: how the ways we write ideas down shape our thinking, and how deep learning might invent entirely new notations. 00:00 Notational intelligence 01:27 What makes good notation 02:28 Abstraction 03:18 Suggestiveness and natural transformations 05:28 Graphical notation 06:27 The coordinate plane and the arrow 08:14 Programming languages as notation 09:28 Inventing new notation with deep learning 11:13 Building the toy model 13:42 The handout and training results 15:03 Invariants that make symbols meaningful 15:56 Our world vs. an alien world of ideas 16:30 Models as a simulator for anything

Alane Suhr, Assistant Professor at UC Berkeley, on agency in language: the kinds of meaning we make with words, what a language model actually is, and why we, not the concept of AI, hold the agency. 00:00 Agency in language 06:31 The reference of AI today 06:57 What a large language model is 09:10 Instruction tuning and RLHF 10:20 The connotation of AI 13:13 We have agency, not the concept

Ben Geist, Research Engineer at Ramp, on intelligence efficiency: why paying more for tokens yields diminishing returns, and how better context, not just more compute, makes models more efficient. 00:00 Intelligence efficiency 01:00 Smarter models aren't more efficiently smart 02:04 Token spend data from Ramp 03:01 Entropy reduction machines 03:45 Two views of entropy 05:01 Context, not just work 06:09 Three examples in latent space 06:39 Multi-agent systems with shared context 08:56 In-context learning and sparse attention

Mudith Jayasekara, Charlie O'Neill, and Harry Partridge of Baseten's research team on the memory problem for long-horizon agents: compressing the KV cache to get near-lossless retrieval of relevant context at inference time. 00:00 The memory problem 03:15 Selection vs. synthesis 04:22 Amortization and sparse autoencoders 05:38 Compressing the KV cache 08:39 Iterative compaction 10:41 A compacted cache is an MLP

Paul Ford, Co-founder of Aboard, on what technologists can learn from how magazines actually work, and why culture is a distributed, lossy prediction model rather than its output. 00:00 Explaining culture to technology 00:58 How a magazine actually works 03:09 Rhetoric greater than facts 04:03 What culture is 05:27 A model of consciousness 06:15 Culture as an operating system 07:17 The tech industry and risk

Claire Vo, founder of ChatPRD, on what product management becomes when code is abundant but the market is not. 0:00 - Anybody can build anything 1:38 - Inventing ways to not build 7:13 - The constraint has shifted 9:42 - The age of abundance 11:51 - What product should be now 13:03 - Build something people want 15:41 - Manifesting novel ideas 17:50 - Bringing people along 20:17 - Is PM dead? 24:42 - Find the money, build companies

Shopify 工程主管法尔汉·萨瓦尔谈当AI编写大部分代码时工程师的职责转变 0:00 - 你现在的工作是什么？ 0:55 - 软件开发生命周期如何演变 3:13 - 学习是副产品 4:33 - 瓶颈永远在移动 7:58 - 托比的备忘录 11:17 - 招聘1000名实习生 12:48 - 半人马时代的终结 19:39 - 原型不等于生产 20:46 - Shopify如何运用AI 25:22 - 什么改变了，什么没变

Sam Lambert, CEO of PlanetScale, on how infrastructure must change for agents, with a live demo of agents optimizing and sharding a real database. 0:00 - Infrastructure for agents 1:18 - A talk run by agents 3:10 - Agents optimize the database 6:00 - Branching, deploys, and safety 8:36 - Catching and undoing a bad change 11:23 - Why sharding is hard 14:02 - Refactoring for sharding 19:28 - Built for humans first 21:34 - A safe loop for agents 24:56 - Infrastructure, not just smarter models

Ryo Lu on how AI changes the way we build and what it must not erase. 0:00 - Building ryOS 1:21 - What should exist? 2:11 - The loop AI changes 4:17 - The black box risk 6:43 - Output vs. material 8:31 - The Glass interface 11:14 - Prototyping Glass with Cursor 14:03 - When software felt alive 17:36 - Where craft moves 20:25 - A more human future

At this opening keynote of Cursor's inaugural Compile conference, co-founder and CEO Michael Truell traces Cursor's path to today. Michael, Kevin Niparko, and Tomas Reimers then announce Cursor Mobile, the Origin Git platform, and updates on a new model trained from scratch. 0:00 - How Cursor started 4:11 - Becoming agent-first 5:10 - 95% of usage is now agents 7:47 - Giving agents their own computer 8:05 - Cursor as a platform 9:55 - Building our own models 13:18 - Updates to cloud agents 18:02 - Cursor Mobile 19:35 - Origin, an agent-native Git platform 23:06 - A new model trained from scratch

Cursor's Sam Whitmore sits down with Baseten's Charlie O'Neill and Harry Partridge to discuss where working with agents goes next: running them by the hundred, getting them to message and review each other, and building systems instead of just managing parallel tasks.

New data from https://cursor.com/insights.

In this workshop, Sasha Rush walks through how Cursor's research team builds Composer 2 - from base model choice to long-horizon reinforcement learning. Key topics covered: Base model selection: Composer 2 starts from Kimi K2.5 (1T params, 32B active, 256K context). The choice came down to both infrastructure fit and initial benchmark scores. Continued pre-training: A coding-focused pre-training stage builds domain knowledge. More tokens here translate into measurably higher rewards after the RL stage. Long-horizon RL with auto-install: Composer 1.5 bootstraps each training environment by exploring the repo, generating install commands, and writing verification tests before RL begins. Reward shaping and self-summarization: A nonlinear length penalty balances speed and depth, while self-summarization lets the model continue past its context limit and still share one final reward across the rollout. Cursor Bench: An internal eval of short, ambiguous prompts and large multi-file diffs from real engineer queries. It separates strong from weaker models much more cleanly than SWE-bench. ----------------------- Helpful resources: Models: https://cursor.com/docs/models Cursor docs: https://cursor.com/docs ----------------------- This is a recording from our live session on May 14, 2026. For more events like this, check out upcoming workshops at https://cursor.com/workshops

Sualeh Asif (Co-Founder of Cursor) sits down with Simon Eskildsen (CEO of turbopuffer) to discuss scaling Shopify through flash sales, why a new database company emerges every 15 years, and what makes a P99 engineer. 0:00 - Scaling Shopify through flash sales and outages 7:11 - How the Shopify infrastructure team evolved 8:13 - How top infrastructure teams collaborated in the 2010s 10:35 - Engineering principles from Logrus and on-call 17:38 - The story behind Simon’s famous-ish blog, Napkin Math 23:05 - Why new database companies keep winning 32:21 - How Simon became a fan of databases 35:45 - AI coding, and where agents still fail 38:44 - What it would take for turbopuffer to become Google-scale 42:10 - Hiring P99 engineers in the AI era 48:45 - What's next for databases

Jordan Topoleski (COO, Cursor) moderates a panel with engineering leaders from Intuit (Chris Kasten), DoorDash (Ryan Sokol), and Atlassian (Taroon Mandhana) on adopting AI coding tools at scale. They cover what's actually changed in their development workflows, how they measure productivity gains, and what advice they'd give other engineering leaders making this transition. 0:00 - How AI coding took hold at Intuit, DoorDash, and Atlassian 3:41 - What's changed most across the SDLC 6:18 - Re-platforming three companies with AI at DoorDash 7:47 - The bell curve is inverting as AI eats the middle of the SDLC 8:14 - Atlassian's engineers spend 15% of time coding and 85% on everything else 11:17 - Measuring the actual impact of AI coding tools 13:42 - Small pods delivering nine-month roadmaps in a month at DoorDash 15:15 - Intuit's alpha teams and the proof-to-release package loop 17:17 - One piece of advice for engineering leaders adopting AI

Jonas Nelle (Engineering Lead, Cursor) demos two new capabilities that remove human bottlenecks between building and shipping: agents that test their own code and produce video proof, and a cloud agent tha babysits your PR to merge. 0:00 - Replacing human bottlenecks with intentional checkpoints 0:51 - Agents that write code, test it, and produce video proof 1:48 - Reviewing a feature by watching the agent's demo video 2:02 - Taking direct control of the agent's cloud environment 3:12 - The new Cursor 3 agents-first view 3:53 - From PR created to merge-ready without human busywork 5:04 - Building your own agent systems with Cursor's primitives

Tido Carriero (VP of Engineering, Cursor) shares how the team is building agent systems across the entire SDLC—from bug triage bots to security reviewers to growth experiment pipelines—and what it takes to break past the 40% productivity plateau. 0:00 - Most companies plateau at 40% more productive with AI coding assistants 2:39 - The broader SDLC is the real bottleneck, not just writing code 3:03 - Figuring out which steps still need humans 5:12 - The threshold problem and removing the rest of the bottlenecks 5:34 - Turning intelligence into software with polished agent artifacts 6:53 - Building agent teams outside the core build phase 7:20 - The PM agent and EM agent that started from a Slack channel 10:48 - The architecture of a fully autonomous bug triage system 12:59 - A security bot that has fixed over two hundred vulnerabilities 14:22 - Agentic risk detection that lets low-risk PRs skip human review 15:52 - Four agents that transformed growth experimentation throughput 18:53 - Organizational shifts for the agent era

Michael Truell (Co-Founder and CEO, Cursor) walks through the evolution of software engineering, from writing every line by hand to managing teams of autonomous agents, and shares data on how fast the shift is happening. 0:00 - The Star Wars premiere and its place in technology history 1:34 - The tedium of building software in formal programming languages 2:58 - Why software complexity is hidden and what that costs 4:22 - The explosion of agent requests vs. tab accepts in 2025 4:57 - 30% of Cursor's PRs are fully agent-developed end-to-end 5:29 - Enterprise code went from 15% to 75% AI-generated in a year 5:53 - Engineers are becoming agent managers 7:36 - Working with dozens of parallel agent colleagues 8:01 - Agents building a browser in a week with no humans in the loop

PayPal could deliver 40% more capabilities in 2026. High-adoption teams are now deploying daily and completed a 3,000-app Java upgrade 6x faster Learn more: https://cursor.com/blog/paypal

We’re introducing Cursor 3. It is simpler, more powerful, and built for a world where all code is written by agents, while keeping the depth of a development environment. Learn more here: cursor.com/blog/cursor-3

We're introducing Cursor Automations for building always-on agents. These agents run on schedules or are triggered by events like a sent Slack message, a newly created Linear issue, a merged GitHub PR, or a PagerDuty incident. You can learn more here: https://www.cursor.com/blog/automations

Micromanagement isn't the future of software engineering. cursor.com/onboard

Cursor can now onboard to your codebase, run in cloud sandboxes, and send you video demos of their work (rather than just diffs). https://cursor.com/onboard

Agents in Cursor can use the software they build and send you videos of their work. Try it at https://cursor.com/onboard. Read our announcement: https://cursor.com/blog/agent-computer-use.

Over 85% of developers at Box now use Cursor daily, driving a 30-50% increase in roadmap throughput and 80-90% reduction in effort for codebase migrations. Learn more here: https://cursor.com/blog/box

Dropbox accepts more than 1 million lines of agent generated code with Cursor every month, improving PR velocity and cycle time. Read more here: https://cursor.com/blog/dropbox

Over 90% of developers at Salesforce now use Cursor, driving double-digit improvements in cycle time, PR velocity, and code quality. Learn more here: https://cursor.com/blog/salesforce

A conversation with John Schulman on the first year LLMs could have been useful, building research teams, and where RL goes from here. 00:00 - Speedrunning ChatGPT 09:22 - Archetypes of research managers 11:56 - Was OpenAI inspired by Bell Labs? 16:54 - The absence of value functions 18:23 - Continual learning 21:09 - Brittle generalization 24:05 - Co-training generators and verifiers, GANs 27:06 - John’s personal use of AI for research 28:54 - Day in the life 33:01 - Slowdowns in consequential ML ideas 36:21 - "Peer review" within the labs 39:19 - Distribution shift in researchers 43:33 - Future of RL 45:33 - Will the labs coordinate if the world needs them to? 44:46 - Forecasting ills in AGI and engineering 47:53 - Thinking Machines

You can now design directly in your codebase. Select elements, modify them visually, and Cursor writes the code. cursor.com/blog/browser-visual-editor