On this page · 11 sections
- What Cursor shipped on 5 November 2026
- Who can open an app, and who can change it
- The guardrails before anything goes live
- What admins control today
- The gaps a CTO should plan around
- Why this is a shadow IT question as much as a security one
- The 12-point checklist before staff publish
- What the plans and costs look like
- India-specific considerations
- How eCorpIT can help
- References
Summary. On 5 November 2026 Cursor released a feature that lets a cloud agent build a web app, add a Postgres database if one is needed, put the app behind Cursor sign-in, host it at an address the user picks and share it with named people, groups or the whole team. Before anything goes live, four always-on checks block secrets and credential files and leave .env files and source maps out, and an AI security review then reads the app's files. Team admins can see every app and secret, add their own review instructions, approve some blocked publishes and unpublish any app. Apps deploy from Cursor Origin or GitHub repositories, with GitLab promised later, on every paid plan with cloud agents. On Cursor's pricing page today that means Premium at $30 a month (about ₹2,799) and above, plus Teams and Enterprise. The feature has been out for 15 days. Our verdict: the guardrails are real, but every licensed employee is now a potential app publisher. Decide public sharing, secret ownership, review rules, retention and an app register before the first payroll dashboard ships on a Friday afternoon.
About this article. This is for CTOs, CISOs and engineering leads at organisations that already pay for Cursor or are piloting it. We checked every feature, setting and plan detail on 20 November 2026 against Cursor's changelog, its Apps, cloud agent security, network and secrets, audit log, Origin and Security Review documentation, and its pricing page, and set them against OWASP, NIST and UK NCSC guidance. Rupee figures use European Central Bank reference rates for 19 November 2026 (₹93.30 per US dollar, rounded to two decimals). Cursor changes plans and settings often, so re-check before you rely on a detail. This is not legal advice, and no vendor paid for inclusion. Researched with AI assistance and checked against the primary sources listed in the references.
What Cursor shipped on 5 November 2026
Cursor's changelog frames the feature around a familiar problem: agents make code cheap to write, yet most tools people build never leave their own machine. To use it, someone starts a cloud agent and says plainly that they want an app. Cursor scaffolds a web app, adds a Postgres database when needed, sets up sign-in through Cursor single sign-on and provisions hosting. If the app must reach other systems, such as a data warehouse, the agent asks for the secrets it needs. The feature does not run in a local agent.
The documentation fills in the mechanics. Each app runs in a dedicated hosting account that Cursor creates for the team, or for the individual on a personal plan, isolated from every other customer. The agent never sees secret values; in most cases a team admin creates team secrets in the Apps dashboard. At publish, the user picks the address, Cursor runs its checks and, if a check fails, lists what must be fixed. Nothing goes live until the checks pass and the person explicitly publishes.
Cursor says its own staff in sales, operations, legal, finance and engineering use the feature for event registration, desk seating, customer presentations, onboarding material, sales pipeline dashboards and engineering service portals. That list is a fair preview of what will appear in your organisation within weeks: small tools that touch customer, employee and pipeline data.
Who can open an app, and who can change it
Sharing has three levels. An app can be limited to invited people or groups signed in to Cursor, opened to the whole Cursor team, or made public to anyone with the link. Public sharing is off by default on Teams and Enterprise, and an admin can switch it on. Users on individual plans can share publicly without Cursor sign-in, which matters if staff use personal Cursor accounts for work.
Invited people get one of two roles, and API keys add machine access. The table summarises Cursor's Apps documentation.
| Role or key | What it allows | Governance note |
|---|---|---|
| Viewer | Open the app while it is private | Low risk, but still data access |
| Editor | Open the app and republish it from their own agents | Can change code that uses the app's secrets |
| Owner (the creator) | Change the app's settings | Only the owner can do this |
| Personal API key | Opens every app its owner can open | Treat like a user credential |
| Team API key | Opens only team apps it has been granted | Scope per app and rotate |
The Editor role is the one to watch. Cursor warns that editors can change the app's code, including code that uses its secrets and API keys, and publish it to the same address, so only trusted people should hold it. Editors see the app's dashboard page read-only, without its secrets or access settings, but that does not stop them changing what the code does with a warehouse credential an admin approved for another purpose.
API keys let scripts, CI jobs and bots call an app by sending the key in a request header; such requests are marked as automated and name the key, not a person. Admins can allow or block API-key access to apps for the whole team.
The guardrails before anything goes live
Cursor runs two layers of checks on every publish, and the first layer stays on even when the AI review is switched off.
| Check | Type | Can admins remove it? |
|---|---|---|
| Block secrets written in app files | Deterministic, always on | No |
| Block credential files such as private or service-account keys | Deterministic, always on | No |
| Leave .env files out of what ships | Deterministic, always on | No |
| Remove source maps | Deterministic, always on | No |
| AI security review of the app's files | Agentic | Admins can add rules, not remove built-in ones |
Admins can approve a publish the review blocked, except where the block is for malicious code, hardcoded secrets or exposed credentials. That exception is sensible: the most damaging findings cannot be waved through by a busy admin.
These checks are not a full application security review. They look for leaked secrets and serious issues in the files being published. They do not tell you whether the app's access rules are right, whether it shows one sales region's pipeline to another, or whether a form writes personal data to a table nobody will delete. Broken access control and security misconfiguration are first and second in the OWASP Top 10:2025, with injection fifth. An app that passes Cursor's review can still fail on both, because the platform cannot know your data-access policy.
Cursor's separate Security Review product, which reviews pull requests through Automations on Teams and Enterprise plans, is a different tool from the publish-time review in Apps. If you already run it, extend it to the repositories behind apps so their changes get the same scrutiny as the rest of your code.
What admins control today
The Apps dashboard gives team admins a short but useful set of switches, summarised below from Cursor's documentation.
| Setting | Default or scope | Our recommendation |
|---|---|---|
| Apps on or off for the team | Team-wide switch | Off until the policy below is written |
| Public apps | Off on Teams and Enterprise | Keep off; disallowing moves public apps back to team visibility |
| API keys opening apps | Team-wide switch | Off unless a named integration needs it |
| Custom security review instructions | Adds rules to Cursor's built-in checks | Add your data classes and banned patterns |
| Approve blocked publishes | Admin only, with exceptions | Two-person rule in your own process |
| App retention period | Enterprise only, 60 to 365 days of inactivity | 90 days for most internal tools |
| Unpublish any app | Admin only | Use as the kill switch in your incident runbook |
Changes to these settings are recorded in the team's audit log. Audit logs are an Enterprise feature: admins can view and filter them in the dashboard, export to CSV, pull them through the Admin API and stream them to Splunk, Sumo Logic, an HTTPS webhook or an S3 bucket. Secret events record the secret's name and scope, not its value.
Retention needs care. On Enterprise, an app with no activity for the chosen period is unpublished, the owner is emailed 30 days before, and an unpublished app's secrets and database cannot be recovered. If an app holds records you must keep, such as event registrations used for billing, export them on a schedule. Do not treat the app's Postgres database as your system of record.
The gaps a CTO should plan around
Three gaps stood out when we read the documentation on 20 November 2026.
No per-app publish event in the published audit list. The event table covers sign-ins, roles, API keys, settings, cloud agent secrets and Origin events, among others, but we found no event for an individual hosted app being published, republished or unpublished. The Apps page says setting changes are logged; it does not say each publish is. Until Cursor documents one, keep your own register and ask your account team whether app lifecycle events can reach your SIEM.
Origin is still an early beta. An app started from scratch creates a new repository on Cursor Origin; an existing GitHub repository can be deployed instead. Cursor's Origin documentation describes Origin as an early beta. If your policy requires production code to live in GitHub or GitLab with branch protection, tell staff to start from a GitHub repository. Our piece on the governance questions Cursor Origin left open covers this in detail.
Cloud agents reach the internet by default. The agent that builds the app runs in its own virtual machine with internet access on, and Cursor names prompt injection leading to code exfiltration as the resulting risk. Admins can restrict egress to a default set plus an allowlist, or to an allowlist only; locking that setting for the whole team is Enterprise only. Runtime secrets are redacted from transcripts, tool output and commits, but stay visible to anyone using the agent's terminal. If people will build apps against your warehouse, set egress and secret types before they start.
Why this is a shadow IT question as much as a security one
The UK National Cyber Security Centre treats shadow IT as unknown assets used within an organisation, and its guidance is about finding and managing them. Cursor Apps changes the economics of that problem. Before November, an analyst who wanted a pipeline dashboard filed a ticket or ran a script on a laptop. Now they can describe it to an agent and publish a hosted app with a database in an afternoon, inside a tool IT already approved.
That is better than an unapproved SaaS trial, because the app sits behind your Cursor sign-in and your admins can see it. It is worse in one respect: hosted apps with their own databases and credentials can multiply faster than any review board can track. NIST's Secure Software Development Framework expects organisations to prepare security requirements, protect their software, produce it securely and respond to vulnerabilities, whatever tool wrote the code. An agent-built internal app is still software your organisation released.
If you are weighing this against a dedicated internal-tools platform, our comparison of Superblocks on AWS against building internal tools yourself sets out questions that apply here too: where the data lives, who owns the app when its builder leaves, and what happens at renewal.
The 12-point checklist before staff publish
- Decide whether Apps is on. Turn the team switch off until the rest of this list is done; it takes minutes to turn back on.
- Keep public apps off. Leave the default in place on Teams and Enterprise, and ban work use of personal Cursor accounts, where public sharing is allowed.
- Write a one-page app policy. Say which data classes may appear in an app (for example, no salary, health or customer payment data) and who signs off exceptions.
- Put that policy into the review. Add custom instructions to the AI security review naming restricted data classes, internal hostnames that must not be called and patterns to block.
- Own the secrets centrally. Have admins create team secrets in the Apps dashboard, limited to named apps, and check who has permission to create personal secrets.
- Use read-only, narrow credentials. Give each app a service account with read access to the specific schema it needs, never a shared admin credential.
- Restrict agent egress. Set cloud agents to default plus allowlist or allowlist only, lock it on Enterprise, and mark sensitive values as runtime secrets.
- Limit the Editor role. Grant it only to people who could already hold the app's credentials, and review editor lists monthly.
- Decide on API keys. Keep API-key access to apps off unless a named job needs it, and prefer team keys granted to one app over personal keys.
- Set retention and backups. On Enterprise, set an inactivity period (we suggest 90 days) and export any data you must keep before an app can be unpublished.
- Keep an app register. Record owner, purpose, data classes, secrets used, visibility and review date for every published app, and reconcile it monthly against the Apps dashboard.
- Wire up logs and a kill switch. Stream audit logs to your SIEM on Enterprise, and make admin unpublish the first containment step in your incident runbook.
What the plans and costs look like
Cursor's pricing page, checked today, shows cloud agents and automations on Premium ($30 a month), Super ($100), Ultra ($200), Teams (from $30 per user a month) and Enterprise (custom price), but not on Free or the $8 Plus plan. Apps follows cloud agent access. Audit logs and app retention controls need Enterprise.
At the Teams list price, 20 seats cost at least $600 a month (20 x $30), about ₹55,977 at the ECB rate above. Prices exclude tax, and usage beyond each plan's included pool is paid through top-offs. Cursor's Apps documentation does not say how app hosting and databases are billed, so ask before you announce the feature and set spending limits. If you need audit-log streaming for app oversight, budget for an Enterprise conversation rather than Teams.
India-specific considerations
Indian teams should map Apps against the Digital Personal Data Protection Act 2023 before anyone builds a tool that holds employee or customer personal data. An event-registration app or onboarding portal collects names, phone numbers and sometimes identity documents, so it needs a stated purpose, a notice and a deletion plan like any other system. Our DPDP Rules compliance checklist for 13 May 2027 lists the obligations that fall due.
Two practical points follow. First, the Apps documentation does not say where app hosting and databases are located, so ask your account team before you allow personal data in an app. Second, Cursor lists prices in US dollars, so rupee costs move with the exchange rate; at ₹93.30 per dollar, each $30 seat is about ₹2,799 a month before usage and tax.
How eCorpIT can help
eCorpIT is a Gurugram-based technology organisation, founded in 2021, assessed at CMMI Level 5 and MSME certified, with senior-led engineering teams working across AWS, Microsoft and Google platforms. Our application development services team can review agent-built internal apps, set up the admin controls and app register described here, and rebuild any app that outgrows the platform as a supported service. Talk to us at /contact-us/.
Last updated: 20 November 2026.