Cognition's Devin Apps Turns a Single Prompt Into a Hosted Private Tool
Cognition launches Devin Apps, letting Devin build, host, and update private web tools directly on its own cloud VM with pay-per-use billing.
- Cognition launched Devin Apps, private web applications hosted on Devin's cloud VM with stable URLs.
- Users describe a tool in natural language, Devin builds and deploys it, team members open it via link.
- Powered by hypervisor-level memory snapshots so VMs sleep when idle and wake on traffic.
- Billing is pay-per-awake-second; failed deploys auto-rollback to previous version.
- Access controls scope apps to individuals, organization, or enterprise, with admin-pinned apps.
- Designed for internal tools, dashboards, and staging environments, not high-traffic production workloads.
Cognition has launched Devin Apps, a feature that converts a plain-language request into a private web application with a stable URL. The app runs on Devin’s cloud computer, giving it access to the repositories, Model Context Protocol integrations, and credentials already available in the coding session. Publishing includes hosting and access control, removing the need to configure a separate deployment platform.
One prompt, one private URL
Creating an app starts from the Apps tab in Devin’s sidebar and follows a short workflow:
- Describe the tool or select a template, such as a metrics dashboard, project status page, or review queue.
- Click Build with Devin.
- Answer any clarifying questions and review the first published version.
Devin can also publish an app from an existing coding session. When a session already contains a working browser preview, the developer can promote that preview directly to a hosted application.
Access controls travel with the app
Each published app keeps the same URL across updates. Every viewer must sign in to Devin, and the publisher can grant access to named people, an organization, or an enterprise. Apps cannot be exposed as public websites, which limits their use for customer-facing pages and unauthenticated demos.
The Devin sign-in gate controls who can load the application. Its generated code still determines what viewers can read or change in connected systems. Because the runtime may inherit repository and service credentials, teams should apply least-privilege permissions, review write operations, and add application-level authorization where users need different capabilities.
Updates keep the same address
Updating an app requires opening Edit in session, describing the change, and publishing another version. Devin records each release under Deployments while preserving the application’s URL.
If a new release fails to start, the previous version continues serving traffic. That fallback covers startup failures. Database migrations, destructive API calls, and other state changes still require their own recovery plan.
Snapshots trade idle cost for wake-up time
Memory snapshots allow an app’s virtual machine to hibernate while idle and resume when someone opens its URL. The first request after hibernation can take several seconds, and usage is billed according to how long the machine remains awake.
At the hypervisor layer, a snapshot can preserve the virtual machine’s memory, process tree, and filesystem state. Devin can therefore stop compute without discarding the running environment, then restore the server near the point where it paused. The same mechanism supports long-running coding sessions and hosted applications.
Because the resumed machine retains its development environment, an app can run frameworks such as Flask or Next.js, listen on an HTTP port, and continue using local files and processes. This architecture reduces idle consumption while introducing predictable cold starts.
Useful targets and practical limits
Cognition presents Devin Apps as a home for lightweight internal software, dashboards, and shared previews:
| Use case | Typical implementation | Key consideration |
|---|---|---|
| Internal workflows | Admin panels, request forms, approval queues, and spreadsheet replacements | Review inherited credentials and write permissions |
| Dashboards | Metrics, support queues, infrastructure costs, and sales data | Account for refresh schedules and data-source limits |
| Preview environments | Frontend, backend, database, and worker processes on one machine | Expect cold starts after idle periods |
| Devin-powered tools | Applications that call the Devin API | Track API permissions, usage, and failure handling |
Cognition says it uses the feature for an internal billing dashboard that aggregates spending across infrastructure providers. Devin updates the application as the company’s infrastructure changes.
One machine sets the ceiling
Each app runs on a single Devin machine, which sets a practical limit on traffic and resilience. The service offers no horizontal scaling or multi-region failover, and hibernation adds latency to the first request after an idle period. High-concurrency services and applications with strict availability targets need infrastructure designed for those requirements.
Local SQLite or Postgres databases share the application machine’s lifecycle and failure domain. Teams storing durable or sensitive records should verify backup, restoration, and retention behavior or connect the app to a managed external database.
Awake-time billing aligns with tools that receive intermittent traffic. Continuous requests keep the machine active and increase usage, so teams should estimate costs using their expected traffic and current Devin plan rates.
Deep integration with Devin also creates platform dependence. Applications may rely on Devin’s authentication, runtime, snapshot system, and connected credentials. Keeping source code and configuration in a repository provides a clearer migration path when a tool outgrows the single-machine model.
The deployment handoff shrinks
Cognition previously introduced Devin Outposts, which lets organizations run Devin sessions on their own infrastructure. Apps extends the product’s scope from generating code to hosting and operating the resulting software inside Devin’s environment.
For teams already using Devin, the feature removes several routine handoffs: provisioning a host, configuring a deployment, adding a sign-in gate, and publishing a stable link. A developer can request a tool, review the generated application, and share it without moving the project to another service.
Devin Apps fits internal software with modest traffic, trusted users, and close ties to existing repositories or integrations. Its stable URLs, version history, and idle hibernation make small tools easier to operate, while the single-machine runtime, private-only access, and inherited credentials define the boundaries developers need to plan around.
Comments
