🚀 Ship Code 10x Faster with these Open-source AI Tools 🛠️

I typically juggle multiple projects at once, which can become overwhelming to manage. As a result, I've been experiencing burnout more quickly.

So, I sought tools that would enable me to ship codes more efficiently and accomplish tasks more quickly.

I was looking for a solution that offered the following features:

• 
  Open-source: Provides transparency and the ability to modify as needed.


• 
  LLM agnostic: Supports the use of any LLM, whether open-source or proprietary.


• 
  Code sandboxing: It lets me select various code execution environments, such as a Host machine, Docker, or Cloud hosting services.


• 
  Extensible: Supports adding custom integrations, like Notion and Slack, to maximize efficiency.

Of course, the first thing that struck me was Devin. However, Devin is neither open-source nor publicly available (yet).

So, I dug further and found out these open-source alternatives. I have tried them all, and here is my experience working with them.

Feel free to star the repository and contribute to the ones you like better.

Composio 👑 - Build and Customize Agents 10x Faster

I have been using and contributing for a while now, and it is the most straightforward platform for building customizable AI agents. It ticked all the criteria I was looking for.

Composio has a template framework called SweKit. It lets you build AI agents perfectly tailored to your choice.

Here are the Pros and Cons of Composio SweKit

Pros

• 
  LLM agnostic: You can use it with any LLM you choose, such as OpenAI, Anthropic, or Llama 3.1 via Groq...


• 
  Framework Agnostic: Use any AI framework you choose, such as LangChain, LlamaIndex, and more.


• 
  Customizable: You can add any tool or application you choose, such as Tavily, GitHub, Discord, Calendar, and more.


• 
  Multiple-Language Support: Use Python or Javascript/Typescript at your convenience.


• 
  Flexible Code Sandboxing: Sandbox code using Docker or cloud hosting services like E2B and FlyIo.

Cons

• 
  No Frontend: It does not have a dedicated frontend. You have to manage it from the terminal.


• 
  DIY: You have to tailor agents on your own to get the best of it.

If you are looking for a quick solution, they have a GitHub SWE agent that can automate resolving GitHub issues. I have been using it heavily for the last few days.

Get Started with the SweKit GitHub Agent by installing the following libraries.

pnpm install -g composio-core

Connect GitHub account.

export GITHUB_ACCESS_TOKEN=<github_access_token>

Clone the template from GitHub.

git clone https://github.com/ComposioHQ/swe-js-template.git swe-js

Install rest of the dependencies.

cd swe-js && pnpm i

Run the SWE agent.

pnpm start

Provide the required information and let the agent do its job.

For complete code, check the repository. Also, check out the Python example.

Star the Composio repository ⭐

OpenDevin - Opensource Devin

The first open-source alternative to achieve simillar performance metrics to that of Devin. It is a platform for autonomous software engineers powered by AI and LLMs.

OpenDevin agents work alongside human developers to write code, fix bugs, and deploy features.

Here are the Pros and Cons of OpenDevin

Pros

• 
  Mature: It has been around for a while, so its code base and community are somewhat mature.


• 
  Frontend: It has a dedicated frontend. It is convenient to interact with agents.


• 
  Performant: It has performed on par with Devin on the SWE Benchmark.

Cons

• 
  Not Customizable: Cannot add tools and applications to extend the usability of agents.


• 
  Non-Composable: You cannot build agents tailored for your specific use cases.

To use OpenDevin, install Docker and execute the following command.

WORKSPACE_BASE=$(pwd)/workspace

docker run -it \

    --pull=always \

    -e SANDBOX_USER_ID=$(id -u) \

    -e WORKSPACE_MOUNT_PATH=$WORKSPACE_BASE \

    -v $WORKSPACE_BASE:/opt/workspace_base \

    -v /var/run/docker.sock:/var/run/docker.sock \

    -p 3000:3000 \

    --add-host host.docker.internal:host-gateway \

    --name opendevin-app-$(date +%Y%m%d%H%M%S) \

    ghcr.io/opendevin/opendevin:0.8

This will pull the OpenDevin Image from the Docker registry and run the application on localhost:3000.

For more, check out their official repository.

Star the OpenDevin repository ⭐

3. Aider - The AI Pair-programmer

This is the perfect choice if you're looking for a pair programmer to help you ship code faster.

Aider lets you pair programs with LLMs to edit code in your local GitHub repository. You can start a new project or work with an existing GitHub repo.

Here are the Pros and Cons of Aider.

Pros

• 
  LLM agnostic: You can use any LLM you choose, including OpenAI, Claude, and Llama.


• 
  Code efficiency: It can work efficiently with GitHub repositories, adding features, fixing bugs, writing tests, etc.

Cons

• 
  Non-customizable: You cannot customize the Agent for any specific use cases.


• No Frontend: It has no dedicated front end, so you must manage it from the terminal.

You can get started quickly like this:

pip install aider-chat



# Change directory into a git repo

cd /to/your/git/repo



# Work with Claude 3.5 Sonnet on your repo

export ANTHROPIC_API_KEY=your-key-goes-here

aider



# Work with GPT-4o on your repo

export OPENAI_API_KEY=your-key-goes-here

aider

For more details, see the installation instructions and other documentation.

Star the Aider repository ⭐

4. Devon - Open-source Devin Alternative

Yet another open-source replica of Devin. Devon can explore codebases, write features, fix bugs and write tests.

Here are Devon's pros and cons.

Pros

• 
  LLM agnostic: It can work with the GPT and Claude models and Groq and Ollama.


• 
  Code efficiency: It can explore repositories, add features, fix bugs, write tests, and config files, etc.

Cons

• Limited functionalities for non-pythonic languages.


• It may not be ideal for hard-core use cases.


• It lacks customization to extend the agent’s abilities.

To get started with Devon, execute the following commands.

# Step 1: Ensure the directory where pipx stores apps are in your PATH environment variable

pipx ensurepath



# Step 2: For the backend

pipx install devon_agent



# Step 3: For the main UI (install and run)

npx devon-ui

Run the main UI.

npx devon-ui

And you are done.

For more information, check out their repository.

Star the Devon repository ⭐

5. Mentat

Mentat is an AI tool designed to assist you with any coding task directly from your command line.

Unlike Copilot, Mentat coordinates edits across multiple locations and files. And unlike ChatGPT, Mentat already has the context of your project—no copy and pasting required!

Pros

• 
  Efficiency: It is efficient at understanding codebases and editing to add features, tests, etc. It uses GIT for branching and version control.


• 
  LLM agnostic: It can use multiple LLMs, including local models via Ollama.

Cons

• 
  No frontend: It works from the terminal. So, no dedicated front end.


• 
  Non-customizable: Cannot customize agents as needed.

To get started, create a virtual environment

# Python 3.10 or higher is required

python3 -m venv .venv

source .venv/bin/activate

There are then 3 install methods. The first two will just let you run it:

• PyPI: python -m pip install mentat
  


• Github: python -m pip install git+https://github.com/AbanteAI/mentat.git
  

The third option is useful if you'd also like to modify Mentat's code as well as run it:

git clone https://github.com/AbanteAI/mentat.git

cd mentat



# install with pip in editable mode:

pip install -e .

Set OPENAI_API_KEY.

export OPENAI_API_KEY=<your key here>

Run the Mentat agent.

mentat <paths to files or directories>

For more information, refer to the official repository.

Star the Mentat repository ⭐

6. Auto Code Rover

AutoCodeRover offers a fully automated solution for resolving GitHub issues, including bug fixes and feature additions.

By combining LLMs with advanced analysis and debugging capabilities, AutoCodeRover prioritizes patch locations to create and implement patches efficiently.

Here are the pros and cons of Auto Code Rover.

Pros

• 
  Highly Efficient: AutoCodeRover now resolves 30.67% of issues (pass@1) in SWE-bench lite.


• 
  LLM Agnostic: It can work with multiple LLM providers like OpenAI, Anthropic, Groq, etc.

Cons

• 
  Non-Customizable: You cannot customize the agent to extend its abilities.


• 
  It's a bit complicated: It runs in a Docker container, and setting it up is a bit more complicated than others.

To get started, set the OPENAI_API_KEY or any other for that matter,

export OPENAI_KEY=sk-YOUR-OPENAI-API-KEY-HERE

Build and start the docker image:

docker build -f Dockerfile -t acr .

docker run -it -e OPENAI_KEY="${OPENAI_KEY:-OPENAI_API_KEY}" -p 3000:3000 -p 5000:5000 acr

For more information, check out their official repository.

Star the Auto Code Rover repository ⭐

7. Devika

Another open-source Devin replica. It can take complex problem statements and break them down to solve it step by step.

Here are the pros and cons of Auto Code Rover.

Pros

• 
  Has Frontend: Devika has a dedicated frontend that runs agents interactively.


• 
  Extensible: It has an extensible architecture for adding new features and integrations.

Cons

• The project seems to be abandoned.

To install Devika, follow these steps:

1. 
   

   Clone the Devika repository:
   
   

   
   

   git clone https://github.com/stitionai/devika.git
   
   

   
   
   


2. 
   

   Navigate to the project directory:
   
   

   
   

   cd devika
   
   

   
   
   


3. 
   

   Create a virtual environment and install the required dependencies (you can use any virtual environment manager):
   
   

   
   

   uv venv
   
   
   
   # On macOS and Linux.
   
   source .venv/bin/activate
   
   
   
   # On Windows.
   
   .venv\Scripts\activate
   
   
   
   uv pip install -r requirements.txt
   
   

   
   
   


4. 
   

   Install the playwright for browsing capabilities:
   
   

   
   

   playwright install --with-deps # installs browsers in playwright (and their deps) if required
   
   

   
   
   


5. 
   

   Start the Devika server:
   
   

   
   

   python devika.py
   
   

   
   
   


6. 
   

   if everything is working fine, you will see the following output:
   
   

   
   

   root: INFO   : Devika is up and running!
   
   

   
   
   


7. 
   

   Now, for frontend, open a new terminal and navigate to the UI directory:
   
   

   
   

   cd ui/
   
   bun install
   
   bun run start
   
   

   
   
   



8. Access the Devika web interface by opening a browser and navigating to http://127.0.0.1:3001

For more information, visit the official repository.

Star the Devika repository ⭐

8. Amazon Q Developer

Although this is not open-source, it definitely deserves a place here. This is the coding agent from Amazon.

This is arguably the most capable SWE agent you can use right now.

Amazon Q generates code, performs testing and debugs, and possesses multistep planning and reasoning capabilities, allowing it to transform and implement new code based on developer requests.

Pros

• 
  Performant: The Q Developer is highly performant; it has scored highest on the SWE bench, with 19.75% of issues solved.


• 
  From Amazon: It’s from Amazon, so you get the goodwill of Amazon.

Cons

• 
  Closed: It’s not open-source.


• Non-Customizable: You cannot add other integrations.


• 
  Vendor Lock-In: You have to rely on Amazon, which can only be accessed on AWS, and you have to use authorized LLMs via AWS services.

For more information, check the official page.

If you are using or know any other tool that has made you more productive.

Let me know in the comments.