Latest / AI Builds It: Easy Coding Tools / Devin vs OpenHands: What Does an ‘Autonomous Coding Agent’ Actually Do?

Transcript

Devin vs OpenHands: What Does an ‘Autonomous Coding Agent’ Actually Do? · AI Builds It: Easy Coding Tools

• 0:00
  SPEAKER_00: Devon vs.
• 0:01
  SPEAKER_00: Open Hands.
• 0:01
  SPEAKER_00: What does an autonomous coding agent actually do?
• 0:04
  SPEAKER_00: By Chloe Dubois, AI Micro SaaS innovator.
• 0:08
  SPEAKER_00: Product and pricing details checked, October 26, 2026.
• 0:13
  SPEAKER_00: Autonomous coding agent.
• 0:15
  SPEAKER_00: Sounds like a robot developer you can hire and forget.
• 0:18
  SPEAKER_00: That is not quite what it means.
• 0:20
  SPEAKER_00: You give an agent a goal, such as fix the broken mobile menu.
• 0:25
  SPEAKER_00: It can inspect a code project, change files, run commands and tests, then try again if something fails.
• 0:32
  SPEAKER_00: Some agents can also open a pull request for a person to review.
• 0:37
  SPEAKER_00: Autonomous describes how the agent works through steps.
• 0:41
  SPEAKER_00: It does not mean the agent is always right or that you should let it ship important changes without review.
• 0:47
  SPEAKER_00: Devon's Getting Started Guide and Open Hands's guide to coding agents describe this task to code workflow.
• 0:54
  SPEAKER_00: Devon and OpenHands can both help with coding tasks, but they are different kinds of products.
• 1:00
  SPEAKER_00: Devon is Cognition's commercial agent and developer tool suite.
• 1:04
  SPEAKER_00: OpenHands is an open source project and workspace that can run its own agent or connect to other coding agents.
• 1:11
  SPEAKER_00: Here's what that difference means in practice.
• 1:14
  SPEAKER_00: Ah, one is an autonomous coding agent.
• 1:17
  SPEAKER_00: A basic code helper may suggest a line of code while you type.
• 1:20
  SPEAKER_00: A coding agent can work on a larger task.
• 1:23
  SPEAKER_00: It may read files, edit several parts of a project, run the project's tests, look at the result, and make another attempt.
• 1:31
  SPEAKER_00: A simple version of the loop looks like this.
• 1:34
  SPEAKER_00: You describe the goal.
• 1:35
  SPEAKER_00: The agent explores the project.
• 1:38
  SPEAKER_00: It makes a change and checks its work.
• 1:40
  SPEAKER_00: It shows you the result, often as a file change or pull request.
• 1:45
  SPEAKER_00: The key difference is that the agent can act inside a project, but it still needs a clear request, access to the right files and tools, and a person to judge whether the result is good.
• 1:56
  SPEAKER_00: Devon, a managed agent with tools around it.
• 2:00
  SPEAKER_00: Devon is made by Cognition.
• 2:02
  SPEAKER_00: You can give it a task through Devon's web app, supported Team Tools, or its command line tool.
• 2:07
  SPEAKER_00: Devon Cloud can work on an assigned task in a remote environment.
• 2:11
  SPEAKER_00: Devon's tools also include an editor, terminal, and browser for checking what it is doing.
• 2:17
  SPEAKER_00: Devon has grown beyond a single web-based agent.
• 2:20
  SPEAKER_00: Devon Desktop is the new name for Windsurf's desktop editor.
• 2:24
  SPEAKER_00: It puts local and cloud agents, pull requests, and project context in one workspace.
• 2:31
  SPEAKER_00: Devon also offers a CLI for working from a computer's terminal.
• 2:36
  SPEAKER_00: For a first task, you can start in ask mode to explore the code and plan.
• 2:41
  SPEAKER_00: Then you can switch to agent mode to let Devin make changes.
• 2:45
  SPEAKER_00: While it works, you can watch progress and inspect its commands and edits.
• 2:50
  SPEAKER_00: If it gets stuck, you can stop the session and take over its editor or terminal.
• 2:55
  SPEAKER_00: That is real control, but it does not guarantee a correct fix.
• 3:00
  SPEAKER_00: Devon's own guidance recommends clear instructions and work that is easy to check.
• 3:05
  SPEAKER_00: Open Hands, an open platform, not just one agent.
• 3:09
  SPEAKER_00: Open Hands began as an open source coding agent project.
• 3:13
  SPEAKER_00: Its current workspace, Agent Canvas, can run the Open Hands agent or connect to other agents that support the agent client protocol, including Claud Code, Codex, and Gemini CLI.
• 3:25
  SPEAKER_00: That makes Open Hands less like one fixed agent and more like a place to manage agents.
• 3:32
  SPEAKER_00: You choose where the work runs, on your computer, a remote machine you manage, or Open Hands Cloud.
• 3:38
  SPEAKER_00: Agent Canvas can show multiple agents, and its current product page describes running them in separate Git work trees, separate copies of a project, so their changes do not all land in the same working folder.
• 3:51
  SPEAKER_00: Okay, this freedom has a trade-off.
• 3:54
  SPEAKER_00: Open hands gives you more choice over the agent, model, and place where work runs.
• 4:00
  SPEAKER_00: You may also have to set up and manage more of those pieces yourself.
• 4:04
  SPEAKER_00: And because agents can read files and run commands, where they run and what they can access matters.
• 4:11
  SPEAKER_00: Open Hands Setup Guide warns users to think carefully about that access.
• 4:17
  SPEAKER_00: Devon versus Open Hands at a glance.
• 4:20
  SPEAKER_00: For the full table, please open this article on Easycoding.tools.
• 4:25
  SPEAKER_00: These are product and workflow differences, not a scorecard for which agent writes better code.
• 4:31
  SPEAKER_00: Devon's documentation describes real-time monitoring and takeover.
• 4:35
  SPEAKER_00: Open Hands current pages describe its agent choices, backends, and review workspace.
• 4:41
  SPEAKER_00: A small website bug, step by step.
• 4:44
  SPEAKER_00: Imagine a website's navigation bar breaks on a phone.
• 4:48
  SPEAKER_00: The menu button covers part of the sign up button.
• 4:51
  SPEAKER_00: The fix should apply only to small screens, and desktop should stay the same.
• 4:56
  SPEAKER_00: A useful task might say, on a 390 pixel wide screen, the menu button overlaps the sign-up button.
• 5:03
  SPEAKER_00: Fix the mobile layout only.
• 5:06
  SPEAKER_00: Keep the desktop layout unchanged.
• 5:08
  SPEAKER_00: Add or update a test for the mobile layout, run the relevant checks, and show me the changes before anything is merged.
• 5:15
  SPEAKER_00: With Devon, you can select the project and ask it to fix the bug.
• 5:19
  SPEAKER_00: It can inspect the files, change the layout, run commands, and use a browser or desktop environment to check the page.
• 5:27
  SPEAKER_00: You can watch its progress, correct it if it misunderstood the request, and review its changes or pull request.
• 5:34
  SPEAKER_00: Devon's documentation says you can stop the session and use its editor and terminal directly.
• 5:40
  SPEAKER_00: With Open Hands, you first choose where the agent will work and which agent or model to use.
• 5:46
  SPEAKER_00: Then you give it the same request in Agent Canvas.
• 5:49
  SPEAKER_00: Depending on your setup, the work could happen on your computer, on a VM you manage, or in Open Hands Cloud.
• 5:56
  SPEAKER_00: You can follow the run and inspect its files and changes.
• 6:00
  SPEAKER_00: Either agent might make a good change.
• 6:03
  SPEAKER_00: Either might also adjust the wrong CSS rule, miss a mobile screen size, or write a test that does not catch the overlap.
• 6:11
  SPEAKER_00: A passing test is useful evidence.
• 6:14
  SPEAKER_00: It is not proof that the page behaves exactly as you wanted.
• 6:18
  SPEAKER_00: My practical advice: ask for a narrow change, name the screen size, and review the page and the change before merging.
• 6:27
  SPEAKER_00: Access pricing and the real cost of self-hosting Devon.
• 6:32
  SPEAKER_00: As of October 26, 2026, Devon's public pricing page lists a free plan, Pro at$20 per month, and Max at$200 per month.
• 6:44
  SPEAKER_00: It lists a Team's plan at$80 per month plus$40 per month for each full developer seat.
• 6:51
  SPEAKER_00: Enterprise pricing is custom.
• 6:53
  SPEAKER_00: Paid plans include usage allowances.
• 6:56
  SPEAKER_00: Extra use can be purchased at API pricing, and the cost depends on the model and task.
• 7:02
  SPEAKER_00: Devon's pricing page also lists Devon Cloud as part of Pro and Higher Plans.
• 7:08
  SPEAKER_00: The main service is a managed product, not an open source package you simply install on your own server.
• 7:14
  SPEAKER_00: Enterprise customers can ask about dedicated deployment options, but the public page does not give a self-hosting price.
• 7:22
  SPEAKER_00: Open Hands.
• 7:23
  SPEAKER_00: Open Hands local open source software is listed as free.
• 7:27
  SPEAKER_00: Open Hands Cloud also has a free individual plan, but its pricing page lists a limit of 10 conversations per day.
• 7:35
  SPEAKER_00: You can bring your own model key or use Open Hands model provider on a pay as you go, at cost basis.
• 7:42
  SPEAKER_00: Enterprise pricing is custom.
• 7:44
  SPEAKER_00: Free software does not mean every setup costs nothing.
• 7:48
  SPEAKER_00: A local setup may still use a paid model API or a model subscription.
• 7:53
  SPEAKER_00: If you run agents on a VM, you pay for that machine and its upkeep.
• 7:59
  SPEAKER_00: Self-hosting saves you from paying for a managed workspace, not from paying for compute, model use, or your own setup time.
• 8:07
  SPEAKER_00: Open hands docs describe local, VM, and cloud backends, while its setup guide explains the security work needed for a public-facing server.
• 8:17
  SPEAKER_00: Notable summer 2026 developments, Devon, from Agent to Command Center.
• 8:23
  SPEAKER_00: On June 2nd, 2026, Cognition announced Devon Desktop as the next generation of Windsurf.
• 8:30
  SPEAKER_00: The idea was to make the editor a place to manage local and cloud agents, related work, and pull requests.
• 8:38
  SPEAKER_00: The announcement also described support for other agents that use the agent client protocol.
• 8:43
  SPEAKER_00: On June 29th, Cognition announced Devon Fusion, a system that pairs a stronger lead agent with a lower cost sidekick.
• 8:52
  SPEAKER_00: Cognition said Fusion kept frontier-level performance at up to 60% lower cost in its tests.
• 8:59
  SPEAKER_00: That is a company-reported benchmark claim, not a promise that every user's task will cost 60% less.
• 9:06
  SPEAKER_00: On July 8th, Cognition released SWE 1.7, its own coding model.
• 9:13
  SPEAKER_00: Cognition published results across its Frontier Code benchmark and other coding tests.
• 9:18
  SPEAKER_00: Those results help show what the company's model did on those tests.
• 9:22
  SPEAKER_00: They do not tell you how reliably Devon will fix every bug in your own project.
• 9:28
  SPEAKER_00: Open Hands, a workspace for many agents.
• 9:32
  SPEAKER_00: In June 2026, Open Hands introduced Agent Canvas as a self-hostable workspace for coding agents and automations.
• 9:40
  SPEAKER_00: A few days later, it announced support for the agent client protocol so users could run compatible agents through the workspace rather than choosing Open Hands.
• 9:51
  SPEAKER_00: Agent Alone.
• 9:52
  SPEAKER_00: In August, Open Hands highlighted improvements to agent activity, usage and cost visibility, automation setup, and reviewing the work agents produced.
• 10:03
  SPEAKER_00: It also reported that its desktop app was still in early preview.
• 10:07
  SPEAKER_00: These are product changes, not evidence that an agent will get every task right.
• 10:13
  SPEAKER_00: What has been shown, and what is still a claim.
• 10:16
  SPEAKER_00: It helps to split the product has this feature from the agent will reliably solve my task.
• 10:22
  SPEAKER_00: A feature can be demonstrated in software and described in documentation.
• 10:27
  SPEAKER_00: Devon's editor can be taken over, Devin's tools can interact with the desktop.
• 10:36
  SPEAKER_00: Those are concrete product features.
• 10:39
  SPEAKER_00: They do not prove that every task will work on the first try.
• 10:43
  SPEAKER_00: Performance claims need more care.
• 10:45
  SPEAKER_00: For example, Cognition says Devon can likely handle work that a person could do in three hours.
• 10:52
  SPEAKER_00: That is useful guidance from the maker, not a guarantee.
• 10:55
  SPEAKER_00: Cognition's Frontier Code benchmark is designed to test code quality and whether a change seems mergeable, but it is Cognition's benchmark and evaluation setup.
• 11:06
  SPEAKER_00: Its results should be read as evidence about those tests, not as an independent promise about your project.
• 11:12
  SPEAKER_00: Independent research also warns against treating benchmark scores as a simple measure of everyday reliability.
• 11:19
  SPEAKER_00: Metter's research measures task success at different levels of human task difficulty and notes limits on how well results generalize beyond its test set.
• 11:30
  SPEAKER_00: It does not directly compare Devon with open hands.
• 11:33
  SPEAKER_00: It does support a more careful question than is this agent autonomous?
• 11:37
  SPEAKER_00: Ask instead, how often does it finish this kind of task with this setup and how easy is it for me to check?
• 11:45
  SPEAKER_00: Which one should you choose?
• 11:46
  SPEAKER_00: Choose Devon if you want a managed service and a clear path from task assignment to a reviewable result.
• 11:53
  SPEAKER_00: It may suit a person or team that wants to hand off well-scoped work without managing the agent's server.
• 12:00
  SPEAKER_00: Check the usage allowance and extra use costs before relying on it for a steady stream of tasks.
• 12:07
  SPEAKER_00: Choose open hands if you value open source software, want to control where agents run, or want to bring agents and model subscriptions you already use into one workspace.
• 12:21
  SPEAKER_00: It can be a strong fit if you are comfortable handling model access, and for a server setup.
• 12:28
  SPEAKER_00: Basic hosting and security.
• 12:31
  SPEAKER_00: For a beginner fixing a small website bug, start with the easiest setup you can trust, not the one with the longest feature list.
• 12:40
  SPEAKER_00: Give the agent a narrow job, tell it how you will judge success, and keep the final review in human hands.
• 12:47
  SPEAKER_00: Conclusion An autonomous coding agent can do more than suggest code.
• 12:52
  SPEAKER_00: It can work through a task, inspect, edit, run checks, and return changes for review.
• 12:58
  SPEAKER_00: That makes it a useful helper.
• 13:01
  SPEAKER_00: Not a replacement for clear goals or a final human decision.
• 13:06
  SPEAKER_00: Devon focuses on a managed product and its surrounding tools.
• 13:10
  SPEAKER_00: Open Hands focuses on an open workspace where you can choose the agent and where it runs.
• 13:18
  SPEAKER_00: The right choice depends less on the word autonomous and more on how much setup, control, and cost you want to take on.
• 13:27
  SPEAKER_00: All links to sources are available in the text version of this article.
• 13:32
  SPEAKER_00: You can find the full article at easycoding.tools slash blog.
• 13:38
  SPEAKER_00: Thanks for listening.
• 13:39
  SPEAKER_00: For more practical AI coding guides, tool comparisons, and resources for builders, visit easycoding.tools.
• 13:47
  SPEAKER_00: And if it's easier to remember, just go to aibuilds.it.
• 13:52
  SPEAKER_00: It redirects to Easy Coding Tools.