Cursor now deploys internal apps (5 Nov 2026): a governance checklist for CTOs

Cursor cloud agents now build, host and share internal apps. Set public sharing, secrets, review rules, retention and an app register first.

Read time
15 min
Word count
2.4K
Sections
11
FAQs
8
Share
Two technology leaders review internal app plans beside the title Cursor Apps Governance, Controls Before You Deploy
On this page · 11 sections
  1. What Cursor shipped on 5 November 2026
  2. Who can open an app, and who can change it
  3. The guardrails before anything goes live
  4. What admins control today
  5. The gaps a CTO should plan around
  6. Why this is a shadow IT question as much as a security one
  7. The 12-point checklist before staff publish
  8. What the plans and costs look like
  9. India-specific considerations
  10. How eCorpIT can help
  11. 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

  1. 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.
  1. 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.
  1. 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.
  1. 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.
  1. 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.
  1. 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.
  1. Restrict agent egress. Set cloud agents to default plus allowlist or allowlist only, lock it on Enterprise, and mark sensitive values as runtime secrets.
  1. Limit the Editor role. Grant it only to people who could already hold the app's credentials, and review editor lists monthly.
  1. 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.
  1. 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.
  1. 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.
  1. 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.

References

  1. Build Live Apps in Cursor, 5 November 2026 — Cursor
  1. Apps (Cloud Agents documentation), checked 20 November 2026 — Cursor
  1. Pricing, checked 20 November 2026 — Cursor
  1. Euro foreign exchange reference rates, 19 November 2026 — European Central Bank
  1. OWASP Top 10:2025 — OWASP Foundation
  1. Security Review — Cursor
  1. Compliance and monitoring: audit logs — Cursor
  1. Origin overview — Cursor
  1. Cloud Agents security — Cursor
  1. Cloud Agents secrets and network — Cursor
  1. Shadow IT guidance — UK National Cyber Security Centre
  1. SP 800-218, Secure Software Development Framework version 1.1 — NIST

Frequently asked

Quick answers.

01 What did Cursor release on 5 November 2026?
Cursor added the ability for a cloud agent to build a web app, create a Postgres database if needed, set up sign-in through Cursor, host the app at a chosen address and share it with people, groups or the whole team. Security checks run before every publish, and nothing goes live until the user explicitly publishes it.
02 Which Cursor plans include Apps?
Cursor says Apps is available on every paid plan with access to cloud agents. On the pricing page checked on 20 November 2026, that covers Premium, Super, Ultra, Teams and Enterprise, but not Free or the $8 Plus plan. Audit logs and the app retention setting are Enterprise features, so oversight options differ by plan.
03 Can employees share a Cursor app publicly?
On Teams and Enterprise plans public sharing is off by default, and only a team admin can turn it on. Turning it off later moves existing public apps back to team visibility. Users on individual plans can share apps publicly, so organisations should stop staff using personal Cursor accounts for work tools that touch company data.
04 What do Cursor's pre-publish security checks catch?
Four always-on checks block secrets written in app files and credential files such as private keys, and leave out environment files and source maps. An AI security review then reads the app's files and blocks serious issues. Admins can add rules but cannot remove the built-in checks, and some blocked findings cannot be overridden.
05 Do the checks replace an application security review?
No. The checks focus on leaked secrets and serious issues in the files being published. They cannot know your data-access rules, so an app can still show the wrong records to the wrong people or keep personal data too long. Treat them as a floor and keep your own review for apps that handle sensitive data.
06 Who should own secrets for Cursor apps?
Cursor documents that in most cases a team admin creates team secrets in the Apps dashboard, and the agent never sees their values. We suggest admins own every secret, limit each to named apps, use read-only service accounts and control who may create personal secrets, because editors can change code that uses those secrets.
07 Are app publishes recorded in Cursor's audit log?
Cursor says changes to Apps settings are recorded in the team audit log, which is an Enterprise feature. When we read the published event list on 20 November 2026, we found no specific event for each app publish or unpublish, so keep your own app register and confirm streaming options with Cursor.
08 What happens to an inactive Cursor app?
On Enterprise plans an admin can set a retention period of 60 to 365 days. An app with no activity for that long is unpublished, and its owner is emailed 30 days beforehand. Once unpublished, the app's secrets and database cannot be recovered, so export any records you must keep well before that point.

About the author

Manu Shukla

Founder & Director

Founder of eCorpIT. Hands-on engineer leading senior-only delivery for AI apps, custom software, and cloud systems for global clients.

Subscribe

One engineering note a week. No fluff, no spam.

Senior-architect playbooks on AI agents, mobile apps, cloud, security, data, and marketing — delivered every Wednesday.

Past the reading

Read enough. Let's build something.

A senior architect responds in 24 working hours with scope, indicative cost, and a timeline. NDA before any technical conversation.

Loading search…

Browse all guides