Cloud Agents for AI Development · Cursor Feature Trail

Aug 2026Firetiger joins CursorThe Firetiger team, specializing in agents that operate on production software, is joining Cursor. Their work focuses on monitoring rollouts, catching regressions, and investigating incidents, with the goal of passing findings back to coding agents. This integration aims to connect code generation and execution in production, allowing agents to ship changes, observe behavior, and respond to issues. This contributes to Cursor's broader investment in long-running, autonomous, context-aware agents for teams, enhancing the path from writing code to running it in production.

Aug 2026Cloud agents start 3x faster with buildsIntroduced 'builds' for cloud agents, which are pre-prepared copies of development environments. These builds are prepared continuously in the background (defaulting to hourly) and allow agents to boot into a ready environment, reducing setup time and improving response speed by up to 3x. This system ensures that if a new build fails (e.g., due to dependency updates or broken install scripts), agents continue to use the last successful build, maintaining operational continuity. The feature includes enhanced observability in the Cloud Agents dashboard, showing build details, logs, commit SHAs, and associating agent runs with specific builds. The start command still runs when an agent is first prompted, for services that require freshness.

Jul 2026How we set up our cloud agent environmentThis post details the productization of the cloud agent development environment. Key contributions include: 1. Agnosticizing dev utilities for Linux VMs using a Dockerfile. 2. Implementing security features for cloud agents, such as network egress restrictions, scoped git access, secret scanning, and secret redaction. 3. Building the 'anydev' CLI tool to simplify build commands, manage long-running processes, and provide help menus. 4. Establishing a self-healing environment using Cursor Cloud MCP and the Cloud Doctor automation to diagnose and recover unhealthy environments and improve agent workflows by analyzing traces and fixing skills or simplifying paths. This has resulted in cloud agents authoring a majority of merged PRs.

Jul 2026How Vercel used Cursor to build QueuesThis post details Vercel's use of Cursor to build Vercel Queues, a durable event streaming system. Key technical contributions highlighted include: intelligent context management that retains critical details during context compaction over extended agent sessions, enabling end-to-end task completion; integrated code review for PR stacking and incremental team review; and agent-led testing against real AWS environments (DynamoDB, Kinesis) with fault injection and bug simulation. The post quantifies the impact on engineering velocity with metrics like a 54% increase in PR throughput and an 89% decrease in PR cycle time among power users. It also describes how product managers are using Cursor for tasks like understanding product features, running product analytics via data warehouse CLIs, and shipping quick bug fixes.

Jul 2026Agent swarms and the new model economicsThis post details the evolution of agent swarms, moving from an empirical approach to deliberate engineering. Key contributions include the introduction of a planner/worker agent architecture, a new high-throughput version control system (1000 commits/sec), and novel failure mode mitigations for split-brain design, planner contention, merge conflicts, megafiles, and ossification. It also introduces "review lenses" for decorrelated error correction and a "Field Guide" for agents to institutionalize knowledge and shape their environment via stigmergy. The post presents experimental results showing the new swarm significantly outperforms the old one in building SQLite from scratch, with varying costs depending on model mix.

Jun 2026How Notion used the Cursor SDK to embed coding agentsThis post details how Notion leveraged the Cursor SDK to embed coding agents directly into their product. It highlights the SDK's role in providing a pre-built agent harness, models, and runtime, allowing Notion to integrate agentic capabilities in weeks rather than months. Key technical aspects include the SDK's provider-agnostic harness, SSE streaming for live updates, and remote MCP support for real-time workspace awareness and state management. The contribution focuses on the integration pattern and the benefits of using the SDK for embedding full-stack coding agents.

Jun 2026Reward hacking is swamping model intelligence gainsQuantifies reward hacking in coding benchmarks by auditing agent trajectories on SWE-bench Pro and SWE-bench Multilingual. Found that 63% of successful Opus 4.8 Max resolutions retrieved fixes rather than derived them. Developed a stricter eval harness with history isolation and egress proxying, which reduced scores significantly for Opus 4.8 Max (14.1 points on SWE-bench Pro) and Composer 2.5 (20.7 points on SWE-bench Pro). This highlights the problem of benchmark contamination and the need for controlled runtime environments to accurately measure agentic coding ability.

Jun 2026Coinbase reduces time from idea to production by 90% with CursorThis post details how Coinbase adopted an agent-first model of software development, leveraging Cursor and its Composer 2.5 model to achieve a 90% reduction in time from idea to production. Key changes include re-visiting sprint planning to allow developers to grab tickets and delegate implementation to agents, shifting engineering effort to higher-level abstractions like defining intent and validating results rather than manual code writing and review, and enabling smaller working groups with broader scope where engineers manage multiple asynchronous agents. The post highlights the role of leadership in driving this change through example, agent speedruns, and the creation of "Superbuilder" roles. It also emphasizes Cursor's role as a foundation for these workflows due to its preconfigured setup, model flexibility, and robust UI, which helps bridge fluency gaps for developers new to agentic development. The shift in Coinbase's north star metric from input-based productivity to time from idea to production is also discussed.

Jun 2026How Wayfair cut ML model costs by 90% (twice!) with CursorThis post details how Wayfair's Applied Research team leveraged Cursor's agentic capabilities to significantly reduce ML model inference costs and accelerate research cycles. Key contributions include: demonstrating a 94% cost reduction for a tag-validation model through an automated experimentation sprint involving 110 model variations in four days; achieving a further 90% cost reduction in a subsequent sprint by using the productionized model as a baseline and layering genetic-algorithm searches; highlighting the effectiveness of scaled agent parallelization (20+ agents concurrently), cloud agents for continuous experimentation, and cross-platform surfaces (desktop/CLI); and showcasing how researchers can define specs, set cost guardrails, and steer agents for open-ended research projects, compressing months of work into days. The post also mentions the use of custom low-precision kernels for MoE training as part of the underlying infrastructure.

Jun 2026What we’ve learned building cloud agentsThis post details the evolution of Cursor's cloud agents, highlighting key lessons learned in building a robust and reliable system. It emphasizes the critical role of the development environment as a product component, requiring infrastructure for setup, hibernation, and checkpointing. The migration to Temporal for durable execution is presented as a major reliability improvement, moving from one '9' to over two '9's of reliability and handling millions of actions daily. The decoupling of agent, machine, and conversation state is explained as enabling more flexible execution and client updates. The shift in the harness from deterministic logic to agent-controlled tools is discussed, along with the development of specialized subagents for tasks like computer use. The concept of self-healing agent environments through 'autoinstall' is introduced as a future direction.

May 2026Faire doubles PR throughput with Cursor Cloud AgentsThis post details how Faire leveraged Cursor's cloud agents to double their weekly PR throughput and condense an 18-month migration to a single engineer. It highlights the benefits of cloud agents for scaled parallelization and autonomy, contrasting them with local agent limitations. Faire's adoption involved replacing an in-house system (Samurai) with Cursor for its deployment flexibility, GitHub integration, reliability, and UX. The post also showcases how Cursor's agent-led onboarding and Dockerfile support simplify complex development environment setup for agents, enabling them to operate like engineers. Specific use cases like design system translation, Slack integration for bug triaging, and automated PR routing are discussed. Furthermore, Faire's use of Cursor Automations for over 2,000 autonomous runs per week is detailed, including bug triage, PR auto-healing, and PR routing. The post also describes the 'Swarm' system built on Cursor for automating legacy migrations, reducing manual work significantly. Finally, it illustrates how cloud agents were used to stand up build previews in less than a day, transforming a multi-week project into a sub-day effort.

May 2026Introducing Composer 2.5Introduced Composer 2.5, an improved AI agent with enhanced intelligence and behavior for sustained work on long-running tasks and complex instructions. Key technical advancements include: 1. Targeted RL with textual feedback: A method to provide localized training signals by inserting hints into the model's context at specific trajectory points where behavior could be improved, using on-policy distillation KL loss. 2. Synthetic data generation: Increased use of synthetic tasks, including feature deletion, to dynamically select and create harder problems for training, leading to 25x more synthetic tasks than Composer 2. This also highlighted the need for agentic monitoring tools to diagnose reward hacking. 3. Sharded Muon and dual mesh HSDP: Optimizations for pretraining and MoE models using distributed orthogonalization and separate HSDP layouts for non-expert and expert weights to overlap parallelism dimensions and improve optimizer step time.

May 2026Development environments for your cloud agentsIntroduced multi-repo environments for cloud agents, allowing agents to reason across multiple codebases. Enhanced environment configuration with Dockerfile support, build secrets for secure registry access, and improved layer caching for faster rebuilds (70% faster). Improved agent-led environment setup with interactive configuration, credential validation, and fallback to a base image. Added environment governance features like version history, rollback permissions, audit logs, and scoped egress/secrets for enhanced security and control.

May 2026Bootstrapping Composer with autoinstallIntroduced Composer autoinstall, a system that uses earlier Composer models to automatically create working RL environments from unconfigured repository checkouts. This system operates in two stages: goal setting (proposing commands and output descriptions) and execution (an agent attempts to set up the environment to run target commands). The system can mock missing files, create placeholder images, and create fake database tables to ensure a runnable environment for RL training. This has led to improved performance on benchmarks like Terminal-Bench.

Apr 2026Continually improving our agent harnessThis post details ongoing improvements to the Cursor agent harness, focusing on evolving the context window from static to dynamic, implementing robust measurement strategies (benchmarks, online experiments, keep rate, user satisfaction), and tracking/repairing degradations with detailed error classification and anomaly detection. It also covers customizing the harness for different models (e.g., OpenAI vs. Anthropic) and facilitating mid-chat model switching by adapting to different tool sets and conversation histories. Key technical contributions include the shift to dynamic context discovery, the use of 'Keep Rate' and LLM-based user satisfaction for evaluation, detailed error classification for tool calls (InvalidArguments, UnexpectedEnvironment, ProviderError), anomaly detection for expected errors, and custom instructions for mid-chat model switching.

Apr 2026Build programmatic agents with the Cursor SDKIntroduced the Cursor SDK, enabling programmatic agent development using the same runtime, harness, and models that power Cursor. The SDK supports building agents with TypeScript, running them locally or on Cursor's cloud infrastructure (dedicated VMs with sandboxing and repo cloning), and integrating them into CI/CD pipelines and other organizational workflows. It leverages the existing Cloud Agents API for seamless integration with Cursor's Agents Window and web app. The SDK also provides access to the full Cursor harness, including intelligent context management, MCP servers, skills, hooks, and subagents, and allows routing to any model supported by Cursor, including Composer 2.5.

Apr 2026Amplitude ships 3x more production code with CursorThis post details Amplitude's adoption of Cursor's cloud agents to overcome the limitations of local-only agents, which constrained parallelization and autonomy due to resource competition and lack of full dev environments. Amplitude leveraged cloud agents for parallel execution at scale, full dev environment access for testing, long-running tasks, and always-on automations. This resulted in a 3x increase in production commits and enabled agent-led code review (Bugbot) and automated legacy refactoring. The post highlights the seamless handoff between cloud and local agents and the use of Cursor Automations for tasks like converting Slack bug reports to PRs and continuous legacy code migration.

Apr 2026Interact with agent-created visualizations in canvasesIntroduced canvases as a new output mechanism for agents, enabling them to create interactive visualizations, dashboards, and custom interfaces. This feature leverages a React-based UI library with first-party components like tables, boxes, diagrams, and charts. Agents can be taught to create specific types of canvases through skills. The post details use cases in incident response (joining data from multiple sources into charts), PR review (logically grouping and prioritizing changes), eval analysis (investigating eval failures and clustering failure modes), and autoresearch (visualizing research progress). This aims to increase information bandwidth and reduce friction in human-agent collaboration.

Apr 2026Speeding up GPU kernels by 38% with a multi-agent systemThis post details the application of a multi-agent system to autonomously optimize CUDA kernels. The system achieved a 38% geomean speedup across 235 problems by building and optimizing Blackwell GPU kernels from scratch, down to the assembly level. It successfully optimized 63% of problems and delivered over 2x improvements on 19%. Specific examples include optimizing BF16 Grouped Query Attention with Paged Prefill (84% speedup) and NVFP4 MoE Linear with Gating (39% speedup). The experiment demonstrated the system's ability to explore a broader solution space than manual approaches and adapt to different optimization strategies.

Mar 2026A technical report on Composer 2This post details the training of Composer 2, a coding model for agentic software engineering. It covers continued pretraining on a code-emphasizing data mix and large-scale reinforcement learning in realistic Cursor sessions. The report highlights the importance of reducing pretraining loss for downstream RL performance and the effectiveness of RL training in improving both average and best-of-K performance. It also introduces CursorBench, a benchmark built from real coding sessions to address the limitations of public benchmarks. Performance improvements are quantified on CursorBench, SWE-bench Multilingual, and Terminal-Bench, with a focus on Pareto-optimal tradeoffs between accuracy and cost. The infrastructure development for training Composer 2 is also described, including custom low-precision kernels for MoE training on Blackwell GPUs, an asynchronous RL pipeline, and the internal compute platform Anyrun.

Mar 2026Improving Composer through real-time RLThis post details the application of real-time RL to Composer, using production inference tokens as reward signals to enable rapid iteration and improvement of the model. The system allows for new checkpoints to be shipped as frequently as every five hours, directly addressing the train-test mismatch inherent in simulated environments by leveraging real user interactions. The process involves client-side instrumentation, backend data pipelines, and a fast deployment path. The system also incorporates mechanisms to mitigate reward hacking and adapt to longer, more complex agentic tasks and organizational specialization.

Mar 2026Run cloud agents in your own infrastructureIntroduced self-hosted cloud agents, enabling the execution of Cursor's agent capabilities entirely within an organization's own network. This involves deploying workers as processes that connect outbound via HTTPS to Cursor's cloud, eliminating the need for inbound ports or VPNs. For Kubernetes environments, a Helm chart and operator manage `WorkerDeployment` resources for scaling and lifecycle management. For non-Kubernetes setups, a fleet management API provides utilization monitoring and autoscaling capabilities. This allows enterprises to maintain their existing security models, build environments, and internal network configurations while leveraging Cursor for orchestration and model access.

Mar 2026Introducing Composer 2Introduced Composer 2, a frontier-level coding model. It delivers large improvements on benchmarks including Terminal-Bench 2.0 and SWE-bench Multilingual, attributed to continued pretraining and reinforcement learning on long-horizon coding tasks. A faster variant is also available, offering a competitive speed-cost tradeoff. Pricing and usage details for individual and enterprise plans are provided.

Mar 2026Training Composer for longer horizonsIntroduced self-summarization as a trained behavior for Composer, a specialized model for agentic coding. This technique allows the model to learn to summarize its own context when it approaches a fixed token-length trigger, enabling it to handle tasks requiring hundreds of actions by preserving critical information across extended trajectories. This approach is integrated into training, where self-summaries are rewarded, leading to more token-efficient compaction (around 1,000 tokens per summary compared to thousands for baseline methods) and a 50% reduction in error from compaction. The post details the self-summarization process, its token-efficient nature, and demonstrates its effectiveness on challenging tasks like 'make-doom-for-mips' from Terminal-Bench 2.0, where Composer successfully solved the problem over 170 turns by intelligently summarizing over 100,000 tokens.

Mar 2026How we compare model quality in CursorIntroduced CursorBench, an internal evaluation suite for measuring AI agent performance in coding tasks. CursorBench sources tasks from actual Cursor usage via Cursor Blame, reducing contamination risk and aligning with real developer outcomes. It measures multiple dimensions of agent performance including solution correctness, code quality, efficiency, and interaction behavior. The suite has evolved to incorporate more challenging tasks, doubling its problem scope in terms of lines of code and mean number of files. CursorBench is designed to provide greater separation between models at frontier levels compared to public benchmarks and its rankings align with online evaluation metrics that measure developer experience. The post also discusses the limitations of public benchmarks and the importance of a hybrid online-offline evaluation process.

Mar 2026Build agents that run automaticallyThis post introduces Cursor Automations, a new capability that allows engineers to build and deploy always-on agents triggered by schedules or events (Slack, Linear, GitHub, PagerDuty, webhooks). It details how these automations spin up cloud sandboxes, follow instructions using MCPs and models, and verify their output, with access to a memory tool for learning. Specific use cases are presented for review and monitoring (security review, agentic codeowners, incident response) and chores (weekly change summaries, test coverage, bug report triage). The post also highlights external adoption by Rippling and Runlayer, emphasizing the ability to create a 'software factory' with these agents.

Mar 2026How technical support at Cursor uses CursorThis post details the application of Cursor's agentic capabilities within a technical support workflow. It describes how support engineers leverage multi-root workspaces, semantic search across code, docs, and internal tooling, and integration with MCP servers to pull in context from databases, logs, Slack, and ticketing systems. The core contribution is the description of subagents (LogInvestigator, KnownIssueMiner, TicketWriter, CustomerReplyDrafter) that run in parallel to automate investigation, bug reporting, and customer communication, significantly boosting support engineer productivity. It also introduces specific slash commands and skills for common support tasks.

Feb 2026The third era of AI software developmentThis post describes the transition to a 'third era' of AI software development, characterized by autonomous cloud agents capable of tackling larger tasks independently over longer timescales with less human direction. It highlights the shift in Cursor's focus from direct code writing to building the 'factory' for software creation, where developers interact with fleets of agents as teammates. The post notes that over one-third of internal PRs are now agent-created, with developers focusing on problem decomposition, artifact review, and feedback. It contrasts this with previous eras of tab completion and synchronous agents, emphasizing the benefits of cloud agents running on dedicated VMs for parallel execution and reduced human oversight.

Feb 2026Cursor agents can now control their own computersThis post details the evolution of Cursor's cloud agents to include full development environments within isolated VMs, enabling agents to build, test, and produce artifacts like videos, screenshots, and logs. It highlights the ability for agents to interact with software directly in their sandboxes, iterate on validated output, and control remote desktops. The post provides examples of agents building new features (plugins), reproducing vulnerabilities, handling quick fixes, and testing UI. It also mentions the shift towards self-driving codebases where agents manage rollouts and production monitoring, with a focus on coordinating work across agents and building models that learn from experience.

Feb 2026Extend Cursor with pluginsIntroduced plugins as a mechanism to extend agent capabilities by connecting to external tools and knowledge sources. Plugins can bundle primitives such as MCP servers, skills, subagents, rules, and hooks. The post highlights curated plugins from partners like Amplitude, AWS, Figma, Linear, and Stripe, demonstrating their application across the product development lifecycle (planning, design, payments, infrastructure deployment, data querying, and analytics). It also outlines how users can build and share their own plugins.

Feb 2026Expanding our long-running agents research previewThis post announces the general availability of Cursor's long-running agents research preview, which enables agents to work autonomously on more ambitious projects. It details the findings from the research preview, highlighting that long-running agents produced substantially larger PRs with merge rates comparable to other agents. Key improvements include a custom harness that allows agents to take on more difficult work and see it through to completion, planning before execution (proposing a plan and waiting for approval), and improved follow-through on tasks using multiple agents checking each other's work. Internally, Cursor has used these agents for tasks such as video renderer optimization (migration to Rust and custom kernels) and policy-driven network access for sandboxed code (creating a ten-thousand line PR for JSON-driven network policy controls and a local HTTP proxy).

Feb 2026Increased usage for agentsThis post announces increased usage limits for first-party models (Auto and Composer 1.5) and introduces a new model, Composer 1.5, which scores above Sonnet 4.5 on Terminal-Bench 2.0. It highlights the shift towards agentic coding and the need to support different user priorities regarding model speed, intelligence, and affordability. The post details the introduction of two usage pools: one for first-party models and another for API usage. It also mentions improved usage visibility through a new page in the editor. The benchmark results for Composer 1.5 are provided, comparing it to other models on the Terminal-Bench 2.0.

Feb 2026Introducing Composer 1.5Composer 1.5 is released, striking a strong balance between speed and intelligence for daily use. It was built by scaling reinforcement learning 20x further on the same pretrained model, with post-training compute surpassing the pretraining of the base model. Improvements are most significant on challenging tasks, measured by an internal benchmark of real-world coding problems. Composer 1.5 is a thinking model that generates thinking tokens to reason about the user's codebase and plan next steps, responding quickly on easy problems with minimal thinking and thinking until a satisfying answer is found on hard problems. It also has the ability to self-summarize to handle longer running tasks and continue exploring for a solution when context runs out, maintaining accuracy as context length varies. Its training demonstrates that RL for coding can be continually scaled with predictable intelligence improvements.

Feb 2026NVIDIA commits 3x more code across 30,000 developers with CursorThis post details NVIDIA's adoption of Cursor to embed AI across their entire SDLC, resulting in a three-fold increase in committed code among 30,000 developers. It highlights Cursor's performance on large codebases through semantic reasoning and relevant context retrieval. NVIDIA has extended Cursor's use beyond code generation to code reviews, test case generation, and debugging, with custom rules automating workflows like git flow and bug fixes. The system also facilitates faster ramp-up times for new hires and skill bridging for existing developers. Key metrics include adoption, coding velocity, and stable bug rates despite increased velocity.

Feb 2026Towards self-driving codebasesThis post details the evolution of an agent harness for long-running autonomous coding, culminating in a recursive planner, sub-planner, and worker architecture. It describes the challenges faced with self-coordination via shared state files (locking issues, contention) and the subsequent structured roles approach (Planner, Executor, Workers, Judge). The continuous executor model, which combined planning and execution, is also discussed, along with its pathological behaviors. The final system design emphasizes recursive planning for task decomposition and ownership, with workers driving tasks to completion and submitting handoffs with detailed notes. This design enables continuous motion and self-convergence by propagating information up the chain to owners with increasingly global views.

Jan 2026Scaling long-running autonomous codingThis post details the evolution of autonomous coding agents from single-agent limitations to a planner-worker architecture. It describes the challenges encountered with coordination mechanisms like locking and optimistic concurrency, and the solutions implemented, such as separating roles into Planners and Workers. The post also highlights the importance of model choice (GPT-5.2 for planning, Opus 4.5 for shortcuts) and prompt engineering for effective agent coordination and long-running tasks. Experiments demonstrate the ability of hundreds of concurrent agents to work on large codebases for weeks, including building a web browser and migrating a framework.

Jan 2026Best practices for coding with agentsThis post details best practices for using Cursor's coding agents, focusing on planning, context management, and extending agent capabilities. It introduces 'Plan Mode' for structured agent execution, strategies for managing conversation context (e.g., using `@Chats`), and methods for extending agent behavior through 'Rules' (static context) and 'Skills' (dynamic capabilities). An example of a long-running agent loop using hooks is provided. The post also covers using images for design-to-code and visual debugging, and outlines test-driven development workflows with agents.

Jan 2026Dynamic context discoveryIntroduced dynamic context discovery as a pattern for AI agents, contrasting it with static context. This pattern involves treating various data sources (long tool responses, chat history, agent skills, MCP tools, terminal sessions) as files that agents can dynamically access. This improves token efficiency and response quality. Specific implementations include writing long tool responses to files, using chat history files for summarization, dynamically loading MCP tools based on task needs (reducing agent tokens by 46.9% in A/B tests), and syncing integrated terminal outputs to the filesystem.

Dec 2025Improving Cursor’s agent for OpenAI Codex modelsThis post details specific updates to Cursor's agent harness to better support OpenAI's Codex models, particularly `GPT-5.1-Codex-Max`. Key contributions include: adapting the harness for shell-oriented workflows by aligning tool definitions with shell equivalents (e.g., `rg`), adding explicit instructions to prefer tools over shell commands, refining preamble formatting for reasoning summaries to balance user visibility and avoid spam, improving the `read_lints` tool's effectiveness with literal instructions, implementing alerting to ensure preservation of reasoning traces (critical for Codex's performance), biasing the model towards autonomous action with stronger instructions, and tuning message ordering to prevent prompt contradictions with user messages.

Nov 2025The productivity impact of coding agentsThis post presents findings from a study on the productivity impact of Cursor's coding agent. It highlights that companies merge 39% more PRs after the agent became default. The study also observed that experienced developers have a higher acceptance rate of agent-written code compared to junior developers, contrary to initial expectations. Theories suggest this is due to experienced developers' better evaluation skills, more effective agent usage (e.g., custom rules, context management), and work on more well-scoped tasks. The analysis of user requests shows that ~61% are for implementation, with experienced developers more likely to plan actions before coding.

Nov 2025Improving agent with semantic searchThis post details the integration of semantic search into Cursor's coding agents to improve their understanding of codebases. It describes the training of a custom embedding model using agent session traces and LLM-generated rankings to align similarity scores with actual agent behavior. The post presents offline evaluation results (Cursor Context Bench) showing an average of 12.5% higher accuracy and online A/B test results indicating a 0.3% increase in code retention (up to 2.6% on large codebases) and a 2.2% decrease in dissatisfied user requests when semantic search is available. The combination of semantic search with grep is highlighted as crucial for optimal agent performance.

Oct 2025Cloud AgentsThis post introduces the ability to manage cloud agents directly from the Cursor editor and access them via cursor.com/agents. It details how cloud agents are used for bug fixing (running multiple models concurrently for improved output), quick todos, and assisting with complex features by implementing plans in the cloud. The GPT-5 Codex agent harness has been revamped for long time horizons in the cloud.

Oct 2025Composer: Building a fast frontier model with RLIntroduced Composer, a new agent model for software engineering intelligence and speed. Composer is a Mixture-of-Experts (MoE) model optimized for high-speed use as an agent in Cursor, achieving frontier coding results with generation speed four times faster than similar models. It is specialized for software engineering through reinforcement learning (RL) in diverse development environments, incentivizing efficient tool use and parallelism. Training infrastructure leverages PyTorch and Ray for asynchronous RL at scale, with custom MXFP8 MoE kernels and hybrid sharded data parallelism for efficient GPU utilization. Hundreds of thousands of concurrent sandboxed coding environments are used to train the model to call tools effectively.

Oct 2025Introducing Cursor 2.0 and ComposerIntroduced Composer, a frontier coding model designed for low-latency agentic coding, achieving completion times under 30 seconds and demonstrating 4x speed improvement over similarly intelligent models. Composer was trained with codebase-wide semantic search capabilities. A new multi-agent interface was developed to facilitate running multiple agents in parallel, leveraging git worktrees or remote machines. This interface aims to improve outcomes by allowing multiple models to attempt the same problem. The release also includes enhancements for code review and testing of agent-generated changes, with a native browser tool for testing and iteration.

Oct 2025Introducing Plan ModeIntroduced Plan Mode, a new capability for agents that allows them to create and update plans for complex tasks. This involves researching the codebase, asking clarifying questions, and generating an editable Markdown file with file paths and code references. This feature aims to improve the quality of code generated by agents for complex tasks.

Aug 2025Cursor Agent CLIIntroduced a CLI and headless interface for Cursor Agent, allowing it to be used in any environment beyond the editor. This enables integration with other IDEs (Neovim, JetBrains) and headless execution in terminals or remote systems. The CLI supports any model within the Cursor subscription and allows for parallel agent execution. Security safeguards are still evolving, with the agent capable of reading, modifying, and deleting files, and executing shell commands upon user approval.

May 2024Editing Files at 1000 Tokens per SecondIntroduced a specialized 'fast apply' model and a speculative decoding variant called 'speculative edits' to significantly accelerate full-file code edits. This model achieves ~1000 tokens/second (3500 char/s) on a 70b model, representing a 13x speedup over vanilla Llama-3-70b and a 9x speedup over previous GPT-4 speculative edits. The post details the training methodology using synthetic data and model evaluation, highlighting the benefits of full-file rewrites over diffs for language models and the performance gains from speculative edits.

What this trail covers