The file format for a Cursor rule; set always_apply to false and scope it so the rule only fires on the files that need it instead of burning context every request.
A prompt invocation that runs your built app in a browser pane inside Cursor; the agent can then take control of it to click, scroll and test the UI itself.
An open standard that lets any IDE host any coding agent; Cursor uses it to run inside JetBrains/IntelliJ and Android Studio via the Cursor CLI bridge.
Cursor's agent-first window: the agent chat sits center, history on the left and the codebase on the right, with a toggle back to the classic editor. Often called the Agents window.
Cursor's full-capability mode: the AI can read the codebase, write and edit files, move them and run terminal commands. Contrast with Ask mode, which is read-only.
A product spec kept as a file in the repo — covering the PR breakdown, stages and architecture — so the agent can treat it as a source of truth and you can run code review on the spec itself.
The US revenue-recognition standard; cited as the canonical judgment-heavy accounting work to keep human-led rather than hand to an agent, because facts and circumstances vary deal to deal.
A step where a prior Cursor model sets up each training repo's environment, proposing install commands and writing tests until the build verifiably works.
The Cursor Settings > Agents setting that decides which commands the agent runs automatically and which wait for your approval, via allow and block lists.
Agents that run in a Cursor-managed virtual machine, check out the repo, do the work and open a pull request, then shut down, with no load on your laptop.
Cursor's in-house agentic coding model: frontier-level coding quality at high speed and low cost, built as a software-engineering specialist rather than a general-purpose model.
The quality drop that happens when one chat accumulates unrelated tasks or tangents, burying the signal the model needs in a haystack of stale context.
An extra large-scale training stage that raises a model's code-domain knowledge: short-context pre-training, then long-context extension, then fine-tuning on agent-like data.
The security principle, missing in today's LLMs, that a system should distinguish trusted instructions from untrusted input; its absence is why prompt injection works.
A Cursor analytics view that passively categorises what agents are doing (new features, bug fixes, refactors) so leaders can see where engineering time goes.
The longest end-to-end chain of dependent work in a plan; it sets the realistic timeline no matter how parallel everything else looks. A slip on the critical path moves the date; a slip on a task with slack does not.
Cursor's hosted layer around each model (context selection, caching, retries) that makes the same model run better and cheaper than calling it directly.
Small scripts Cursor runs at fixed points in an agent's lifecycle (such as before a prompt or before a file write) to enforce policy deterministically.
Probing a running application for vulnerabilities from the outside, the way an attacker would. Complements SAST, which reads the code instead of poking the app.
The shift from writing a text spec to building a live, clickable prototype to convey product intent; what gets cheap to make moves the leverage to vision and taste.
The contract spelling out exactly how a vendor may process your data: purposes, subprocessors, retention and breach duties. The document privacy reviews actually read.
Network policy for where agents may send traffic: an allowlist that auto-runs, a denylist that's always blocked and default-deny for everything else, plus DNS filtering and an HTTP proxy.
An engineer who embeds inside a customer's own engineering org to scope ambiguous problems and ship production-grade Cursor workflows a senior engineer keeps using after they leave.
Cursor as a model-neutral test bed: frontier labs send their newest models to Cursor pre-release to tune them inside the same agent harness every model shares.
Card-processing pricing that passes the underlying network and issuing-bank cost through to you with a fixed markup on top, giving full visibility into cost — unlike a blended sticker rate.
Cursor's built-in browser, driven by Playwright under the hood, so the agent can navigate, click, screenshot and capture each action's metadata while you watch.
The open base model Cursor continued-trained into Composer 2 (1T parameters, 32B active, 256K context), chosen mainly for how well it fit Cursor's serving infrastructure.
Extra Level 2 / Level 3 transaction metadata that can qualify certain US card transactions for cheaper interchange or scheme fees; supplying it correctly is a real cost-optimization lever.
Training a coding agent by running many rollouts on real problems and reinforcing the ones that succeed; a single rollout can reach 200K tokens and hundreds of tool calls.
The overarching contract between customer and vendor that everything else (order forms, DPAs, SLAs) hangs off. Negotiated once so each later purchase doesn't restart legal review.
The modern single sign-on standard, built as an identity layer on top of OAuth 2.0. Where SAML is XML and enterprise-legacy, OIDC is JSON and what newer tools implement first.
A Cursor marketplace package that bundles MCP servers and skills (sometimes sub-agents and hooks); one click installs all of it into your Cursor instance.
The spec describing what to build, for whom and why, before implementation starts. Increasingly the artifact you hand an AI agent as the source of truth for a feature.
Cursor's setting that guarantees code data is not used for training by Cursor or its model providers, and that an admin can enforce org-wide; data-retention terms are a separate, contractual layer.
How skills load: the agent boots knowing only each skill's name and description, then pulls a skill's full instructions into context only at the moment it decides to use it.
A living program-tracking log: Risks (might go wrong), Assumptions (treated as true but unverified), Issues (a risk that already materialized), Dependencies (work blocked on someone else) — each with a single named owner.
The XML-era enterprise standard that powers single sign-on: your identity provider vouches for you to each app. Older than OIDC but still what many enterprise tools speak.
An isolated agent execution mode that contains the blast radius: file access scoped to the workspace, network off by default and git restricted to read-only, enforceable org-wide.
Scanning source code for vulnerabilities without running it. In AI-heavy workflows it is the automated gate that reads every generated diff before a human does.
Short for separation of duties: the rule that authoring, approving and deploying a change never sit with one person. Auditors use the acronym; the control is the same.
A reasoning model (shown with a brain icon in Cursor's picker) that spends extra compute before answering; reach for it on complex, nuanced work and a standard model for fast, simple tasks.
An MCP server Apple maintains inside Xcode that exposes the simulator, build logs and debugging to Cursor, so the agent can run and iterate on iOS apps it writes.