Elements and Windsurf, now Devin Desktop

Windsurf is now Devin Desktop. Cognition acquired the Windsurf editor in July 2025 and renamed it in June 2026, keeping the same editor, extensions, keybindings and workflows, with the Agent Command Center as its default surface. The agent inside it is Devin Local, which runs on your machine with your files, your tools and your environment: it plans, edits files, runs commands in its own terminal, splits a task across subagents and works in a git worktree so your main workspace stays clean. From the same window you can hand a task to Devin in the cloud and watch every agent, local and cloud, from one place. It is a superb place for a person and their agent to build.

Elements and Devin Desktop make each other better. Devin Local writes the app in the editor, and Elements, the integrated app environment, builds, checks and deploys it, so the app works from the first task and keeps working. Every build error, from type checking to tests, migrations and program analysis, surfaces within milliseconds of a save, and a release goes live only when the build is clean and every test passes (build, deploy).

Elements builds the environment the agent works in; it does not make a model, an editor or a coding agent. Elements works well with agents because it has a manual baked into the binary. Elements is licensed per machine, and nothing the agent does in a project is metered (pricing).

A New Project Is Ready From the First Task

elements create makes a project Devin Local can build in from its first task (start). Every new project comes with an AGENTS.md at its root, and Devin Desktop discovers that file on its own and applies it as always-on rules, so the agent knows what the project already includes before it edits a line. It builds on the bundler, test runner and database that come with Elements instead of adding its own, and it checks its work from the first edit.

One Command Reports Every Mistake

Devin Local checks its work by running a command in its terminal and reading what comes back. On most stacks that is three programs, the type checker, the test runner and the migration tool, with three output formats and the question of whether an error came from this edit or an older one.

In an Elements project the agent runs elements build -json and reads one structured reply listing every build error with its file, line and column, and the command exits 1 when there are errors (build). A failing test is one more entry in that list, and so is a broken migration, since the build that type checks the code also runs the tests and the migrations. The reply always describes the file the agent just saved, never an older build. For test detail, elements test -json returns the tests as a tree, each marked passed, failed or not run (tests).

The Project Server Runs While the Agent Works

Each elements build -json is a question put to a project server that runs while you work and stays up between commands. It holds the build graph and build state in memory, so on every save the build state is updated almost instantly: it redoes only what the change touched and hot reloads the running app (build). The agent gets each answer in microseconds, so it checks after every edit and keeps going.

Your terminal, the agent's terminal and every subagent ask that one server. When Devin Local splits a task across subagents, or runs in several worktrees side by side, each of them reads the same build state, and one agent's edit shows up in the next agent's build (build).

Seeing the App the Agent Builds

A clean build proves the code compiles; it says nothing about how the page looks. The agent has three ways to check the result.

• The running app. elements start serves the app and hot reloads it on every save (start).
• Screenshots. The agent captures any route at desktop or phone width with the Chrome already on your machine, with nothing to install (browser).
• The program log. The running app's output, request-time exceptions included, goes to a log any agent can read (build).

Getting Started

After installing Elements, create a project and open it in Devin Desktop:

Terminal
elements create studio
cd studio

Open the studio folder in Devin Desktop and give Devin Local its first task. It reads the project's AGENTS.md, starts the app, and checks every edit against the project Elements set up.

Questions

Is Windsurf still a thing, and does Elements work with it?

Windsurf is now Devin Desktop, Cognition's editor with the Devin Local agent built in; it is the same editor under a new name. Elements works with it the way it works with any agent: the agent writes the app, and Elements is the environment where it is built, checked and deployed.

How do Elements and Devin Desktop fit together?

Devin Local writes the app in the editor, and Elements is the integrated app environment where it is built, checked and deployed. A new project is ready from the agent's first task, and one command, elements build -json, gives it every build error in one reply, from type checking to tests and migrations.

Is Elements an AI editor or a Devin Desktop alternative?

No. Devin Desktop is where you and the agent write the code. Elements is the environment that code is checked, built and deployed in: a project server that answers the agent's build queries, a test runner, a bundled Postgres database and a deploy command, ready from the first elements create.

How does Devin Local check its work in an Elements project?

It runs elements build -json in its terminal. Because the latest save is already built, the reply arrives in microseconds, giving each error with its file, line and column, and it always reflects the edit the agent just made.