For a lot of people, AI assisted programming still means finishing the line you were typing. That is useful, and it is also the smallest possible version of the idea. The moment the task becomes a bug spread across three files, a project with no tests, or a module that needs reorganising, completion has nothing to offer. It will not break the work into steps, it will not open the files, it will not run the tests and read the failure, and it certainly will not gather its own changes into a commit for you to review.

OpenHands is aimed at that second kind of task. It is an open platform for software engineering agents, published under a permissive licence by a team that has been working on this problem for years; its earlier name was OpenDevin. You describe what you want, and the agent plans, writes code, runs commands, reads the errors, and tries again until the task settles. It does not type for you. It closes the loop.

Why the sandbox is the whole difference

Nobody sensible lets a language model run arbitrary commands on their own machine. So every session here executes inside its own container. Code and files come in and out through mounted volumes, the container is discarded when the session ends, and the host stays untouched. That is what makes the useful behaviour possible: the agent can install dependencies, run a test suite, or attempt something risky, and if it makes a mess the mess is inside a box that is about to be thrown away.

For an individual this buys peace of mind. For an organisation it is the price of admission. In sectors where data sovereignty is scrutinised, such as finance and public administration, the fact that source code does not leave the perimeter and that every action can be audited afterwards counts for more than a few points of model capability.

The model is your decision

The architecture is model independent, with a routing layer underneath that speaks to most providers. Commercial models can be attached, and so can open models running on your own hardware. The practical arrangement most teams settle on is a split: routine tasks go to a local model because it costs nothing per call, and a difficult multi-file refactor is switched to a stronger remote model for the hour it is needed. Cost and quality become dials rather than a subscription decision someone else made for you.

Four ways in

There is a command line interface for people who already live in a terminal and want the agent to feel like the tools around it. There is a local graphical interface, opened in a browser, where the agent's reasoning and each action can be watched as they happen, which is how most people build trust in it. There is a software development kit for teams that want the capability inside their own product. And there is a hosted service for those who would rather not run the containers themselves.

The project has gathered a large following on its repository page, more than eighty thousand watchers, and its community activity is among the highest for open projects of this kind. That matters for a tool of this shape: the value is not only in the agent but in the collection of habits, configurations and fixes that a community accumulates around it.

Where it works, and where it does not

Reports from users and the project's own examples share a pattern: the tasks that go well have a clear goal and an objective way to check it. Working through a queue of issue reports, upgrading the dependencies of an old project and applying the security patches that follow, raising test coverage, reorganising a set of files according to a written convention. In each case the question of whether it worked has a mechanical answer, so the agent can converge without needing taste.

The reverse is equally true. Vague requirements that need product judgement send it off course exactly as they would any autonomous agent, and the sensible response is to stay close and confirm at the important junctions rather than to hope. Treat it as a colleague who can do a day of physical work unsupervised, not as a product manager who knows what the customer wants.

What it costs

The software itself is open source and free. The only continuing cost is what you spend calling models, and that is a dial you control: a quiet week of small tasks costs little, and an intense week of hard refactors costs more, visibly and predictably. Compared with a per-seat subscription, the difference is that the bill tracks the work rather than the headcount.

The honest summary is that this is the most defensible shape the idea has taken so far: an agent that finishes development tasks end to end, inside a boundary you can audit, with a model you chose. It is not magic, and it is not a replacement for judgement. It is what happens when the boring half of engineering is handed to something that never gets bored.