Codeium, known today as Devin Desktop

Codeium, known today as Devin Desktop

If you are looking for Codeium, the product exists under a different name and in a different form. It first became Windsurf, then moved under Cognition, and since 2 June 2026 it is called Devin Desktop. Along the way, what it actually is changed too.

Three names and two changes of character

Codeium started as a free code completion assistant, available as a plugin for dozens of editors. Its main promise was free autocomplete at a time when competitors charged a subscription for it.

The change to Windsurf was more than a rename. The product stopped being a plugin and became a separate editor with an agent that reads files, applies changes across many places, and verifies the result. That was a move toward the model dominating this category today.

July 2025 brought the acquisition by Cognition, the company behind an autonomous software engineering agent. The definitive agreement was signed on 14 July 2025 and the financial terms were never disclosed, so the figures circulating in trade coverage are estimates rather than numbers from the deal. The consequence was another rename in June 2026, this time to Devin Desktop, delivered as an update to existing users that preserved plans, settings, and extensions.

That history matters practically when hunting for material. Guides describe three different products under three names, and some commands and feature names from earlier periods no longer apply. For troubleshooting, search under the current name.

What the change of ownership brought

Three things changed enough to affect the choice of tool.

A dedicated coding model. Cognition shipped a model built for working with code, advertised as markedly faster than general purpose models in this use. In agentic work, where one task means a dozen or more calls, speed translates directly into waiting time.

Codemaps, a feature building a structural picture of a repository rather than relying purely on chunk retrieval. On large projects that is the difference between an agent understanding dependencies between modules and one knowing only the files handed to it.

Price. Billing moved onto Devin rates and now has several tiers rather than one: a free plan with a light quota, Pro at 20 dollars a month, Max at 200 dollars a month, and a team plan at 80 dollars a month plus 40 dollars per developer seat. Pro costs exactly what an individual plan in Cursor costs and twice what Copilot Pro costs, so the old argument about a lower price no longer holds. Once the quota runs out you do not wait for the next month, you buy extra usage charged at API rates.

What happened to the editor plugin

This question comes up most often from people who knew the original product and do not want to change editors.

Codeium's original proposition was that you install a plugin into your environment and get code completion for free. There was no need to abandon habits or a configuration built over years.

The whole category, however, moved toward separate editors, because an agent working across many files needs deeper integration than a plugin interface allows. That is a technical constraint rather than a marketing decision: diff preview, context control, and running commands all require control over the editor.

For somebody attached to their environment that means a choice. You can move to a separate editor and gain the full agent mode, or stay with a plugin in your existing tool and work in completion mode. The second option still makes sense, especially when most of the work is small changes in familiar code.

A third route is a terminal tool running alongside the editor. The agent works on the repository while you keep your environment, since the two need not be the same program. That arrangement is gaining ground precisely among people who do not want to change editors.

Is switching worth it

The answer depends on where you are coming from and what you do.

If you use Cursor and are happy, the price change alone rarely justifies moving. The cost of switching is not the subscription but a week to regain fluency in a new tool, configuration and habits included.

If you work on a large repository and the biggest problem is an agent failing to grasp dependencies, codemaps are worth testing on your own project. That is the only one of the three features solving a problem rather than improving a parameter.

If you want a free code completion tool, the free variant still exists, though it is no longer a rarity in this market, since Cursor and GitHub Copilot both have a free tier as well. Do check the current scope, since with this many ownership changes it is the element most prone to adjustment.

If you work mostly in a terminal, the comparison looks different and it makes more sense to weigh this tool against Claude Code or Aider than against editors.

What working with an agentic editor looks like

The working model differs from classic code completion, and that matters more than the product's name.

You describe a task in natural language, and the agent plans the work, reads the files it needs, applies changes, and shows a diff for approval. It does not suggest the next line, it delivers the whole change.

This model works well on tasks with clear boundaries: adding a form field with validation and a test, moving logic into a separate module, adapting a component to a new API. It works less well on tasks demanding design decisions, since the agent makes them itself and you see the outcome only in the diff.

A practical rule: the more precisely you describe the expected result and the constraints, the fewer correction rounds. A sentence saying what not to touch saves more time than a detailed description of what to do.

Reviewing the output is its own matter. An agent produces syntactically correct, sensible looking code, so reading a diff demands different attention from reviewing human written code. A person leaves traces of hesitation where they were unsure, a model leaves none, and a business logic error looks identical to a correct implementation.

Watch the size of the change too. An agent asked to rebuild a module produces a diff of several hundred lines that nobody reviews properly. Smaller tasks yield changes you can actually check.

What this history teaches about choosing tools

Three names in two years is more than trivia, it is a lesson for picking a tool you use daily.

The category is young and consolidating fast. Companies acquire each other, products change hands, and development priorities move with them. A tool betting today on a generous free tier may, after an acquisition, bet on the enterprise segment instead, and the reverse happens too.

The practical conclusion is not "avoid young tools", since that leaves only the slower options. It is rather: minimise the cost of switching. Keep configuration and project rules in the repository rather than in editor settings. Do not build team processes around a feature specific to one product. Record what actually works somewhere independent of the tool.

The second lesson concerns evaluation. Comparison material in this category goes stale within months, so a review from six months ago describes a different product from the one you install. The only trustworthy comparison is an hour of work on your own repository with each candidate.

The third concerns business risk. If a tool is heading for a whole team, check whether an exit path exists: configuration export, no dependency on a product specific format, the ability to fall back to a plain editor without losing work. With a tool assisting code writing that path usually exists, since the output is code in a repository, but verify it deliberately.

Devin Desktop against the alternatives

Keep in mind that all these tools draw on similar models, so the differences mostly concern the context they can gather and how comfortable the work feels. That explains why comparisons based on generated code quality land close together, while the real difference shows only on a large repository.

The market for model assisted editors shifts faster than most categories, so a two year decision here is an illusion. It makes more sense to pick a tool for a quarter, measure the difference on your own work, and revisit the choice when a reason appears.

Configuration that genuinely improves results

Whichever tool you choose, the biggest difference comes from what it knows about your project. Four elements deliver the most for the least effort.

A project rules file in the repository. Describe the technology stack, naming conventions, how tests run, and what must not change. An agent without that knowledge rediscovers it every time or guesses, and guessing produces code in a style the team does not use.

# Project rules

Stack: Next.js 15, TypeScript in strict mode, Tailwind, Vitest.
Running checks: pnpm verify (lint, tsc --noEmit, tests).

Conventions:
- components in PascalCase under src/components
- API calls only through src/api/client.ts
- tests next to the source file, named *.test.ts

Do not change without asking:
- the database schema in prisma/schema.prisma
- deployment configuration in .github/workflows

A statement of what not to read. Dependency directories, generated code, and test fixtures occupy context and dilute retrieval. Excluding them speeds up work and lowers cost.

node_modules/
.next/
dist/
coverage/
*.generated.ts
fixtures/**/*.json

The name of the file holding that list differs between tools, its content does not, so on switching editors you carry the same set across under a different name.

Tests the agent can run. A tool able to launch the suite itself and read the result fixes its own changes without your involvement. Without that, every iteration means switching to a terminal and pasting an error.

{
  "scripts": {
    "verify": "pnpm lint && tsc --noEmit && vitest run"
  }
}

One command instead of three matters in practice: a rule saying "the task ends when pnpm verify passes" is unambiguous, while a list of three commands usually ends with the first one being run.

Splitting tasks into reviewable sizes. That is a habit rather than a setting, but it affects results more than configuration does. A hundred line change can be checked, a seven hundred line one cannot, and an unreviewed model generated change is debt that returns.

git diff --stat

That single command before accepting a change tells you more than reading half the files. If the agent touched fourteen files for a task described in one sentence, something went wrong, and starting again with a narrower prompt is cheaper than untangling the result.

Spending half a day on this at the first project pays off, because the configuration travels between tools. Rules recorded in the repository work regardless of whether you change editors next month, and in this category that is exactly what is most likely.

Common mistakes

The first is searching for documentation under the old name. Codeium material describes a plugin, Windsurf material the pre acquisition editor, and current documentation sits under the current name.

The second is switching during an urgent project. A week to regain fluency is a real cost invisible in the price list.

The third is accepting large changes without review. An agent produces correct looking code, and a business logic error looks exactly like a correct implementation.

The fourth is relying on one tool with a sensitive repository. Check where the code goes and whether that can be restricted before attaching an agent to a project under a confidentiality agreement.

The fifth is ignoring project configuration. A file with rules and conventions in the repository improves accuracy more than changing tools, and costs half an hour.

FAQ

Does Codeium still exist?

Yes, as Devin Desktop. The product was renamed first to Windsurf and, after Cognition acquired it in July 2025, to Devin Desktop on 2 June 2026. Existing users received an update preserving plans, settings, and extensions.

Is it still free?

A free variant with a light quota was kept, as it was at the competition. The individual Pro plan costs 20 dollars a month, Max costs 200 dollars, and the team plan costs 80 dollars plus 40 dollars per seat. Once the quota runs out you buy extra usage at API rates. Given how many changes there have been, check the current scope before deciding.

How does it differ from Cursor?

Both are editors with an agent, and the differences sit in details rather than in the working model. Devin Desktop has its own coding model and codemaps, and the paid plan costs the same in both tools, 20 dollars a month for the individual tier. Cursor has a more mature ecosystem, a larger community, and a wider model choice.

Is it worth switching from Copilot?

If you work mostly with code completion inside an existing editor, the gain is often small. If you want an agent driving changes across many files, the difference is clear, though GitHub Copilot is developing that mode too, so compare current versions on your own task.

Where does my code go?

Fragments needed to complete a task are sent to the model, so for projects under confidentiality check the privacy settings and the scope of collected data. If code cannot leave the company, consider a tool working with a local model, Continue with a model served by Ollama for instance.

Current documentation and pricing sit on the Cognition site, and the product history is described in coverage of the acquisition.