CHAPTERS
- 0:12 – 0:42
Why the bottleneck shifted from model IQ to tooling, context, and objectives
Alexi frames the core problem: models are strong enough that human effort—providing tools, context, and ambitious goals—has become the limiting factor. Cursor’s mission is to remove that bottleneck by making agents more autonomous, safely.
- •Model capability is no longer the main constraint for many tasks
- •Humans bottleneck progress by feeding context/tools and defining objectives
- •Cursor focuses on “setting agents free” while maintaining safety
- •Talk will share practical methods used at Cursor
- 0:42 – 1:44
Three-stage evolution: autonomy → leverage stronger models → self-improving systems
Cursor’s approach progresses through three stages: enabling autonomy with tools/context, adapting workflows to exploit better models, and finally building systems that improve themselves. The end goal is shifting from hand-holding tasks to engineering a scalable agentic pipeline.
- •Stage 1: give agents tools + context for autonomy
- •Stage 2: update patterns/behaviors to exploit more capable models
- •Stage 3: build “the system that builds the system”
- •Move from guiding A→D to enabling A→Z automation
- 1:44 – 2:45
Onboarding analogy: agents need what new hires need (including a computer)
Alexi compares agent enablement to onboarding a new developer at Cursor. Humans get a machine, a working dev environment, and documentation—while agents were previously thrown into a codebase without the ability to run or test, creating friction and poor outcomes.
- •Human onboarding includes a computer, environment setup, and documentation
- •Agents often “sight-read” code without executing the app
- •Lack of testing/interaction leads to frustrating human-agent loops
- •Observation: it’s surprising it works as well as it does
- 2:45 – 3:45
Cloud onboarding agent: exploring repos to learn how to run them
Cursor built a cloud onboarding agent (cursor.com/onboard) that explores a repository to figure out how to run it rather than immediately changing code. It iteratively works with the developer to handle env vars, permissions, and service setup, and can return a demo.
- •Cloud agent’s first job is operational: get the repo running
- •Exploration includes services, commands, env vars, and permissions
- •Interactive back-and-forth with developers to validate setup
- •Returns a runnable demo once it successfully boots the system
- 3:45 – 4:16
Scaling cloud agents exposed DevEx friction: cold starts and waiting
With many developers running many cloud agents daily, small inefficiencies compound. Unlike local dev, cloud environments restart from scratch; agents waste time sleeping while services start and lacked robust “wait/check” mechanisms.
- •Cloud runs multiply problems across the team
- •Every run recreates the dev environment from scratch
- •Agents spend time waiting on slow startups
- •Need better primitives for waiting, readiness, and status checks
- 4:16 – 4:46
Anydev CLI and agent-ready documentation to accelerate cloud workflows
Cursor built an “Anydev” CLI as a Swiss Army knife for common environment operations (start services, wait, status, test accounts, third-party sign-in). They also produced simplified documentation so agents can resolve edge cases with less human help, creating a positive feedback loop of adoption.
- •Anydev CLI: start services, wait for readiness, check statuses
- •Utilities for test accounts and third-party service sign-ins
- •Simplified docs tailored for agent consumption
- •Better DevEx drives more agent usage, reinforcing investment
- 4:46 – 5:47
Principles of autonomy: give agents eyes, tools, and high-quality inputs
Alexi lays out foundational autonomy principles. Agents need visibility into what humans can see (apps, state changes, even other agent chats), plus tools with sensible security constraints; and because agents are autoregressive, code quality and instructions strongly shape outputs.
- •“Give agents eyes”: shared visibility into apps, state, and chats
- •Give tools to do what humans do, under security constraints
- •Agents must run apps/services to be truly effective
- •High-quality code and instructions improve downstream agent output
- 5:47 – 6:47
Computer use as the next primitive: raw pixels in, mouse/keyboard out
Cursor sees “computer use” as a core primitive for autonomy beyond coding. The challenge isn’t clicking accurately, but navigating partial observability and irreversible UI states—more like a video game than chess—requiring metacognition, backtracking, and robust reasoning.
- •Computer use: pixels input, mouse/keyboard actions output
- •Hard part is planning under partial visibility and one-way doors
- •GUI navigation has failure states and requires backtracking
- •Claude-family models are positioned as strong at this kind of reasoning
- 6:47 – 7:18
Demo-first verification: agents return interactive evidence before code review
A computer-use example shows an agent implementing a “private marketplace” feature and recording a demo. This serves both as end-to-end testing and as a high-bandwidth artifact for humans to review functionality before diving into code—especially valuable when many agents run in parallel.
- •Agent builds feature and records a demo of behavior
- •Demo doubles as end-to-end validation
- •Humans can review outcomes before reviewing diffs
- •Critical for managing multiple concurrent cloud agents
- 7:18 – 8:18
Two ways developers scale work: prompt away small issues, delegate big projects
With autonomy in place, teams learn to hand agents more work. One pattern is converting bug/issue backlogs directly into prompts; the other is delegating larger, longer-running projects to cloud agents—supported by demos to reduce review burden.
- •Pattern 1: turn small tasks/bugs directly into prompts
- •Pattern 2: give agents larger, longer projects to execute
- •Demos reduce the need to read lots of code for every task
- •More capable agents change what developers attempt
- 8:18 – 8:48
Security-through-freedom: cloud isolation increases ambition and enjoyment
Alexi explains how cloud-based agent execution can increase developer confidence and reduce context-switching and resource management. Isolation also reduces risk around secrets/environment variables, and the team found it surprisingly improved the enjoyment of programming.
- •Cloud execution improves safety and reduces local risk
- •Less resource management and context switching for developers
- •Reduced concern about agents mishandling env vars/secrets
- •In practice, it made programming feel more enjoyable
- 8:48 – 10:19
Compounding reliability: invest in debugging failures because effects multiply
When agents fail repeatedly, distrust compounds across the organization and usage drops. Conversely, taking time to diagnose and fix failure modes improves reliability at scale, builds trust, and enables bigger “one-shot” tasks—shifting effort toward improving the system itself.
- •Persistent failure modes compound negatively across the company
- •Debugging and fixing issues pays off multiplicatively
- •Reliability increases trust and usage
- •Developers shift toward “programming the system”
- 10:19 – 11:50
Agent Experience (AX): a workflow where agents report issues and improve tooling
Cursor formalizes “agent experience” alongside developer experience. Agents are instructed to report annoyances/confusion into a system of record; humans then triage into technical issues, permission gaps, or knowledge gaps, and both humans and agents implement fixes to reduce human involvement over time.
- •AX matters as much as (or more than) DevEx at scale
- •Agents file reports when workflows are broken/confusing
- •Managers triage: technical fixes vs permissions vs ignorance
- •Goal: reduce required human intervention while increasing trust
- 11:50 – 13:21
WCF (“Work On the Factory”): agents as continuous improvement mechanisms
Every cloud agent is equipped with the WCF skill: pause to report what’s broken rather than grinding through. Cursor also improved how fixes are validated—agents test changes across many runs (an eval set) to combat flakiness, raising confidence in PRs returned to humans.
- •WCF prompt: report annoyances to improve tools/workflows
- •Modern models can recognize confusion and reliably report issues
- •Fix validation: spawn many cloud runs to ensure robustness
- •Higher trust in PRs when solutions are broadly validated
- 13:21 – 14:35
Generalizing beyond coding and closing remarks
Alexi argues these self-improving, cloud-agent patterns will extend beyond coding, noting that cloud DevEx issues are often non-coding and highly variable. He closes with an invitation to connect and points viewers to Cursor’s onboarding agent.
- •Patterns from coding likely generalize to other domains
- •Cloud workflow problems often involve non-code variables
- •These skills act like background “cleanup” processes
- •Call to action: try cursor.com/onboard; contact info provided
