Why look for open source alternatives to Manus and Devin?
Manus and Devin are impressive demos, and both are closed products: you send your code and prompts to someone else's servers, you pay per seat or per task, and you cannot inspect what the agent actually does between the ticket landing and the pull request appearing. For a weekend project that is fine. For a codebase you are paid to protect, it starts to matter. The open source alternatives to Manus and Devin give you the same broad idea, an agent that reads a repo, plans, edits files, runs commands, and iterates, but with the source in front of you and the freedom to run it on hardware you control.
A few reasons developers make the switch:
Data control. Your source never leaves infrastructure you own. That is often the difference between a security review passing and stalling.
Model choice. Most of these projects let you point at GPT-4o, Claude, a local model through Ollama, or whatever you have an API key for. You are not locked to one vendor.
Cost predictability. You pay for tokens and compute, not a per-agent subscription that scales with headcount.
Auditability. You can read the prompt templates, the tool definitions, and the loop that decides what to run next.
One thing these projects share is architecture. They are all built around the same loop that Manus and Devin popularized: the agent gets a goal, forms a plan, picks a tool (edit a file, run a test, search the web), observes the result, and repeats until the task is done or it gives up. Understanding that loop is more portable than mastering any single tool, because it is what lets you swap one project for another when your needs shift.
The tradeoff is real and worth saying up front: you become the operator. Nobody else keeps the thing patched, fed with credentials, and online. More on that below.
The self-hostable projects worth knowing
Every project here is open source, actively used, and something you can clone and run today. For each one: what it is, who it is for, its license, and a link to the repo.
OpenHands (formerly OpenDevin)
OpenHands is the most direct answer to "I want a Devin I can run myself." It started life as OpenDevin and is now the busiest project in this space, with a full agent that writes code, runs it in a sandboxed runtime, browses the web, and fixes its own errors. Who it is for: teams that want a general software-engineering agent with a real UI and an active community behind it. License: MIT. Repo: All-Hands-AI/OpenHands.
SWE-agent
Built at Princeton, SWE-agent is the research-grade engine behind a lot of the SWE-bench numbers you have seen quoted. It is narrower than OpenHands on purpose: hand it a GitHub issue and a repo, and it produces a patch. Who it is for: people who care about benchmark-style bug fixing and want a clean, hackable agent-computer interface to build on. License: MIT. Repo: SWE-agent/SWE-agent.
Aider
Aider is the pragmatist's pick. It is a terminal tool that pairs with you on an existing git repo, committing as it goes so every change is reviewable and reversible. It is not trying to be autonomous; it is trying to be the best AI pair programmer at your keyboard. Getting started is genuinely two commands:
# Aider: from zero to pairing in two commands
python -m pip install aider-chat
aider --model gpt-4o# Aider: from zero to pairing in two commands
python -m pip install aider-chat
aider --model gpt-4oWho it is for: developers who want speed and control in the terminal, not a dashboard. License: Apache 2.0. Repo: Aider-AI/aider.
Devika
Devika was one of the first community "Devin clones" and remains a readable, approachable codebase for understanding how these agents plan and execute. Development has been less constant than the others here, so treat it as a strong learning project more than a production bet. Who it is for: people who want to read and modify a full agent end to end. License: MIT. Repo: stitionai/devika.
GPT-Engineer
GPT-Engineer takes a spec in plain English and scaffolds a whole project from scratch. It shines at greenfield generation rather than surgical edits inside a large existing codebase. Who it is for: prototyping and bootstrapping new projects fast, then handing the result to a human to refine. License: MIT. Repo: gpt-engineer-org/gpt-engineer.
Cline
Cline (formerly Claude Dev) runs as a VS Code extension, so the agent lives inside the editor you already use. It creates and edits files, runs terminal commands with your approval, and can drive a browser. Who it is for: developers who want agentic help without leaving VS Code, and who like an approve-each-step workflow rather than a fully autonomous loop. License: Apache 2.0. Repo: cline/cline.
Goose (Block)
Goose is Block's open agent. It is less a single coding bot and more a local, extensible agent that connects to tools through the Model Context Protocol and automates real developer tasks on your machine. Who it is for: teams that want an extensible on-machine agent backed by a company that runs it internally at scale. License: Apache 2.0. Repo: block/goose.
Comparison table: focus, self-host difficulty, license
| Project | Focus | Self-host difficulty | License |
|---|---|---|---|
| OpenHands | General SWE agent with UI and sandbox | Medium (Docker runtime) | MIT |
| SWE-agent | Issue to patch, benchmark-grade | Medium (Python and container) | MIT |
| Aider | Terminal pair programmer | Low (pip install) | Apache 2.0 |
| Devika | Readable full-agent reference | Medium (services and models) | MIT |
| GPT-Engineer | Greenfield project generation | Low (pip install) | MIT |
| Cline | In-editor VS Code agent | Low (extension and API key) | Apache 2.0 |
| Goose | Extensible on-machine agent | Low to medium (CLI or desktop) | Apache 2.0 |
"Self-host difficulty" here means the effort to get it running on your own box, not the effort to keep it running around the clock. Those are different problems, and the second one is easy to underestimate.
How do you choose between these open source alternatives to Manus and Devin?
Match the tool to the job rather than the hype:
You want the closest thing to Devin, with a UI. Start with OpenHands. It has the momentum, the sandboxed runtime, and the broadest capability set.
You want to fix issues in an existing repo, benchmark-style. SWE-agent is purpose-built for that loop.
You want fast, reviewable pairing in the terminal. Aider, every time. The per-commit workflow keeps you in control.
You live in VS Code. Cline puts the agent where you already work and asks before it acts.
You are scaffolding something new from a description. GPT-Engineer.
You want an extensible local agent for general automation. Goose.
You want to learn how these agents are wired. Read Devika's source top to bottom.
Do not over-optimize the first choice. All of these read a repo, edit files, and run commands, so a project you outgrow is straightforward to leave. Pick the one that matches how you already work, run it on a real task for a day, and change your mind later if it stops fitting.
If your real question is not "which agent" but "which framework do I build my own agent on," that is a different fork in the road. Our LangChain vs CrewAI comparison covers the two most common starting points for rolling your own from scratch.
Self-hosting means you own the infrastructure
Here is the honest part. Every project above solves the agent-brain problem. None of them solves the keep-it-alive problem for you. Once you go past a laptop experiment, you inherit a list of chores:
A long-running process that does not die when you close your terminal.
Secrets management for the API keys and repo credentials the agent needs.
A persistent workspace so the agent's files survive a restart.
Resource limits so a runaway loop does not burn your token budget or peg a CPU core for an hour.
Observability, so when the agent does something strange at 3 a.m. you can see why.
Isolation, because an agent that can run shell commands is an agent that can run the wrong shell command.
Self-hosting means all of that is yours. That is the point, and also the cost. A container on your laptop is fine for testing. It is not where you want a coding agent running against production credentials for weeks at a time.
Once you have picked one, you still have to run it 24/7 somewhere
Choosing an open source agent is step one. Step two is giving it a home that stays online. You can wire up your own Kubernetes, systemd units, secret store, and dashboards, or you can hand the operational layer to something built for exactly that. Sokko runs long-lived agents on secure, always-on infrastructure we manage for you, so the process, secrets, resource limits, and a persistent workspace are taken care of without you ever running a server. If you have landed on OpenHands or Aider and now need it running around the clock, the walkthrough in run any AI agent 24/7 on Sokko is the natural next read.
Whichever one you pick from these open source alternatives to Manus and Devin, the win is the same: an agent whose code you can read, whose model you can choose, and whose infrastructure answers to you.