The user-friendly Code Review Analytics dashboards help you track key metrics such as pull requests reviewed, issues found, lines of code reviewed, and understand individual contributions.

The AI Code Review Agent supports two deployment options:

• Bito Cloud (fully managed)

• Self-hosted service (run on your own infrastructure)

Each option comes with its own set of benefits and considerations.

This guide walks you through both options to help you determine which deployment model best fits your team’s needs.

Bito Cloud

Bito Cloud provides a managed environment for running the AI Code Review Agent, offering a seamless, hassle-free experience. This option is ideal for teams looking for quick deployment and minimal operational overhead.

Pros:

• Simplicity: Enjoy a straightforward setup with a single-click installation process, making it easy to get started without technical hurdles.

• Maintenance-Free: Bito Cloud takes care of all necessary updates and maintenance, ensuring your Agent always operates on the latest software version without any effort on your part.

• Scalability: The platform is designed to easily scale, accommodating project growth effortlessly and ensuring reliable performance under varying loads.

Cons:

• Handling of Pull Request Diffs: For analysis purposes, diffs from pull requests are temporarily stored on our servers.

Install/run using Bito Cloud

Self-hosted service

Self-hosted AI Code Review Agent offers a higher degree of control and customization, suited for organizations with specific requirements or those who prefer to manage their own infrastructure.

Pros:

• Full Control: Self-hosting provides complete control over the deployment environment, allowing for extensive customization and the ability to integrate with existing systems as needed.

• Privacy and Security: Keeping the AI Code Review Agent within your own infrastructure can enhance data security and privacy, as all information remains under your direct control.

Cons:

• Setup Complexity: Establishing a self-hosted environment requires technical know-how and can be more complex than using a managed service, potentially leading to longer setup times.

• Maintenance Responsibility: The responsibility of maintaining and updating the software falls entirely on your team, which includes ensuring the system is scaled appropriately to handle demand.

Install/run as a self-hosted service

On your machine or in a Private Cloud, you can run the AI Code Review Agent via either CLI or webhooks service. This guide will teach you about the key differences between CLI and webhooks service and when to use each mode.

Difference Between CLI and webhooks service

The main difference between CLI and webhooks service lies in their operational approach and purpose. In CLI, the docker container is used for a one-time code review. This mode is ideal for isolated, single-instance analyses where a quick, direct review of the code is needed.

On the other hand, webhooks service is designed for continuous operation. When set in webhooks service mode, the AI Code Review Agent remains online and active at a specified URL. This continuous operation allows it to respond automatically whenever a pull request is opened in a repository. In this scenario, the git provider notifies the server, triggering the AI Code Review Agent to analyze the pull request and post its review as a comment directly on it.

When to Use CLI and When to Use webhooks service

Selecting the appropriate mode for code review with the AI Code Review Agent depends largely on the nature and frequency of your code review needs.

CLI: Ideal for Specific, One-Time Reviews

CLI mode is best suited for scenarios requiring immediate, one-time code reviews. It's particularly effective for:

• Conducting quick assessments of specific pull requests.

• Performing periodic, scheduled code analyses.

• Reviewing code in environments with limited or no continuous integration support.

• Integrating with batch processing scripts for ad-hoc analysis.

• Using in educational settings to demonstrate code review practices.

• Experimenting with different code review configurations.

• Reviewing code on local setups or for personal projects.

• Performing a final check before pushing code to a repository.

CLI mode stands out for its simplicity and is perfect for standalone tasks where a single, direct execution of the code review process is all that's needed.

Webhooks service: For Continuous, Automated Reviews

Webhooks service, on the other hand, is the go-to choice for continuous code review processes. It excels in:

• Continuously monitoring all pull requests in a repository.

• Providing instant feedback in collaborative projects.

• Seamlessly integrating with CI/CD pipelines for automated reviews.

• Performing automated code quality checks in team environments.

• Conducting real-time security scans on new pull requests.

• Ensuring adherence to coding standards in every pull request.

• Streamlining the code review process in large-scale projects.

• Maintaining consistency in code review across multiple projects.

• Enhancing workflows in remote or distributed development teams.

• Offering prompt feedback in agile development settings.

Webhooks service is indispensable in active development environments where consistent monitoring and immediate feedback are critical. It automates the code review process, integrating seamlessly into the workflow and eliminating the need for manual initiation of code reviews.

Bito Cloud offers a single-click solution for using the AI Code Review Agent, eliminating the need for any downloads on your machine. You can create multiple instances of the Agent, allowing each to be used with a different repository on a Git provider such as GitHub, GitLab, or Bitbucket.

We also support GitHub (Self-Managed) and GitLab (Self-Managed).

Connect Bito to your Git provider

Select your Git provider from the options below and follow the step-by-step installation guide to seamlessly set up your AI Code Review Agent.

If you no longer need an AI Code Review Agent instance, you can delete it to keep your workspace organized. Follow the steps below to quickly remove any unused Agents.

1. Log in to Bito Cloud and select a workspace to get started.

2. From the left sidebar, select Code Review Agents.

   If your Bito workspace is connected to your GitHub/GitLab/Bitbucket account, a list of AI Code Review Agent instances configured in your workspace will appear.

1. Before deleting an Agent, ensure that any repositories currently using it are reassigned to another Agent otherwise a warning popup will appear.

1. Locate the Agent you wish to delete and click the Delete button given in front of it.

Save time and effort by quickly creating a new instance using the configuration settings of an existing one. It’s a fast and simple way to set up multiple Agent instances without having to reconfigure each one.

Follow the steps below to get started:

1. and select a workspace to get started.

2. From the left sidebar, select .

1. If your Bito workspace is connected to your GitHub/GitLab/Bitbucket account, a list of AI Code Review Agent instances configured in your workspace will appear. Locate the instance you wish to duplicate and click the Clone button given in front of it.

1. An Agent configuration form will open, pre-populated with the input field values. You can edit these values as needed.

1. Click Select repositories to choose Git repositories for the new Agent.

1. To enable code review for a specific repository, simply select its corresponding checkbox. You can also enable repositories later, after the Agent has been created. Once done, click Save and continue to save the new Agent configuration.

1. When you save the configuration, your new Agent instance will be added and available on the page.

Bito is an AI-powered code review tool that helps you catch bugs, security vulnerabilities, code smells, and other issues in your pull requests. By understanding your entire codebase, Bito provides context-aware, actionable suggestions to improve both code quality and security.

It includes real-time recommendations from dev tools you already use such as static code analysis, open source vulnerability scanners, linters, and secrets scanning tools (e.g., passwords, API keys, sensitive information, etc.).

Bito seamlessly integrates with GitHub, GitLab, and Bitbucket.

Start free trialGetting started guide

Quickstart guide

1. Sign up for Bito Create your account at alpha.bito.ai to get started.

2. Connect your Git provider Select your preferred Git platform and follow the guided setup to install the agent:

   • GitHub

   • GitHub (Self-Managed)

   • GitLab

   • GitLab (Self-Managed)

   • Bitbucket

   Once installed, the agent will be linked to your repositories and ready to assist.

3. Review pull requests The AI agent will automatically review new pull requests and leave inline comments with suggestions. You can also manually trigger a review by commenting /review on any pull request.

   See full list of available commands

4. Chat with the agent You can reply to comments posted by the Bito AI agent in a pull request to ask follow-up questions or request clarification. The agent will respond with context-aware answers to help you understand the feedback better.

   Learn more

5. Configure agent settings

   To customize your agent, go to Repositories and click the Settings button next to the relevant agent. From there, you can choose the review feedback mode, enable or disable automatic reviews, define custom guidelines to align with your team’s standards, and more.

   Learn more

Helpful resources

Feature guides

Video library

Need help?

If you have any questions, feel free to email us at [email protected]

Bito’s is the first agent built with Bito’s AI Agent framework and engine. It is an automated AI assistant (powered by Anthropic’s Claude Sonnet 3.7) that will review your team’s code; it spots bugs, issues, code smells, and security vulnerabilities in Pull/Merge Requests (PR/MR) and provides high-quality suggestions to fix them.

It seamlessly integrates with Git providers such as GitHub, GitLab, and Bitbucket, automatically posting recommendations directly as comments within the corresponding Pull Request. It includes real-time recommendations from Static Code Analysis and OSS vulnerability tools such as fbinfer, Dependency-Check, etc. and can include high severity suggestions from other 3rd party tools you use such as Snyk.

The AI Code Review Agent acts as a set of specialized engineers each analyzing different aspects of your PR. They analyze aspects such as Performance, Code Structure, Security, Optimization, and Scalability. By combining and filtering the results, the Agent can provide you with much more detailed and insightful code reviews, bringing you a better quality code review and helping you save time.

The AI Code Review Agent helps engineering teams merge code faster while also keeping the code clean and up to standard, making sure it runs smoothly and follows best practices.

It ensures a secure and confidential experience without compromising on reliability. Bito neither reads nor stores your code, and none of your code is used for AI model training. Learn more about our .

By accessing Bito's feature, the AI Code Review Agent can analyze relevant context from your entire repository, providing better context-aware analysis and suggestions. This tailored approach ensures a more personalized and contextually relevant code review experience.

To comprehend your code and its dependencies, we use Symbol Indexing, Abstract Syntax Trees (AST), and Embeddings. Each step feeds into the next, starting from locating specific code snippets with Symbol Indexing, getting their structural context with AST parsing, and then leveraging embedding vectors for broader semantic insights. This approach ensures a detailed understanding of the code's functionality and its dependencies. For more information, see

The AI Code Review Agent is built using Bito Dev Agents, an open framework and engine to build custom AI Agents for software developers that understands code, can connect to your organization’s data and tools, and can be discovered and shared via a global registry.

Why use an AI Agent for code review?

In many organizations, senior developers spend approximately half of their time reviewing code changes in PRs to find potential issues. The AI Code Review Agent can help save this valuable time.

AI Code Review Agent speeds up PR merges by 89%, reduces regressions by 34%, and delivers 87% human-grade feedback.

However, it's important to remember that the AI Code Review Agent is designed to assist, not replace, senior software engineers. It takes care of many of the more mundane issues involved in code review, so senior engineers can focus on the business logic and how new development is aligned with your organization’s business goals.

Pricing details

The Free Plan offers AI-generated pull request summaries to provide a quick overview of changes. For advanced features like line-level code suggestions, consider upgrading to the Team Plan. For detailed pricing information, visit our page.

Learn more

The self-hosted AI Code Review Agent offers a more private and customizable option for teams looking to enhance their code review processes within their own infrastructure, while maintaining complete control over their data. This approach is ideal for organizations with specific compliance, security, or customization requirements.

Understanding CLI vs webhooks service

When setting up the AI Code Review Agent, you have the flexibility to choose between two primary modes of operation: CLI and webhooks service.

• CLI allows developers to manually initiate code reviews directly from terminal. This mode is ideal for quick, on-demand code reviews without the need for continuous monitoring or integration.

• Webhooks service transforms the Agent into a persistent service that automatically triggers code reviews based on specific events, such as pull requests or comments on pull requests. This mode is suitable for teams looking to automate their code review processes.

For more details, visit the page.

Deployment Options

Based on your needs and the desired integration level with your development workflow, choose one of the following options to install and run the AI Code Review Agent:

1. : Ideal for developers seeking a simple, interactive way to conduct code reviews from the command line.

2. : Perfect for teams looking to automate code reviews through external events, enhancing their CI/CD workflow.

3. : A great option for GitHub users to seamlessly integrate automated code reviews into their GitHub Actions workflows.

Bito automatically saves the chat session History. The session history is stored locally on your computer. You can return to any chat session and continue the AI conversation from where you left off. Bito will automatically maintain and restore the memory of the loaded chat session.

You can "Delete" any saved chat session or share a permalink to the session with your coworkers.

Here is the video overview of accessing and managing the session history.

Bito deploys a locally on the user’s machine, bundled as part of the Bito IDE plug-in. This database uses (a vector with over 1,000 dimensions) to retrieve text, function names, objects, etc. from the codebase and then transform them into multi-dimensional vector space.

Then when you give it a function name or ask it a question, that query is converted into a vector and is compared to other vectors nearby. This returns the relevant search results. So, it's a way to perform search not on keywords, but on meaning. Vector Databases are able to do this kind of search very quickly.

Bito also uses an Agent Selection Framework that acts like an autonomous entity capable of perceiving its environment, making decisions, and taking actions to achieve certain goals. It figures out if it’s necessary to do an embeddings comparison on your codebase, do we need to perform an action against Jira, or do we do something else.

Finally, Bito utilizes from Open AI, Anthropic, and others that actually provide the answer to the question by leveraging the context provided by the Agent Selection Framework and the embeddings.

This is what makes us stand out from other AI tools like ChatGPT, GitHub Copilot, etc. that do not understand your entire codebase.

We’re making significant innovations in our to simplify coding for everyone. To learn more about this head over to .

This document explains some of Bito's privacy and security practices. Our Trust Center outlines our various accreditations (SOC 2 Type II) and our various security policies. You can read our full Privacy Policy at https://bito.ai/privacy-policy/.

Bito AI

Security is top of mind at Bito, especially when it comes to your code. A fundamental approach we have taken is to allow you to decide where you want to store your code, either locally on your machine, in your cloud, or on Bito’s cloud (coming soon). We do not store any code, code snippets, indexes or embedding vectors on Bito’s servers unless you expressly allow that. Importantly, our AI partners do not store any of this information.

All requests are transmitted over HTTPS and are fully encrypted.

None of your code or AI requests are used for AI model training. None of your code or AI requests are stored by our AI partners. Our AI model partners are OpenAI, Anthropic, and Google. Here are their policies where they state that they do not store or train on data related to API access (we access all AI models via APIs):

1. OpenAI: https://openai.com/enterprise-privacy/

2. Anthropic: https://www.anthropic.com/uk-government-internal-ai-safety-policy-response/data-input-controls-and-audit

3. Google Cloud: https://cloud.google.com/blog/products/ai-machine-learning/google-cloud-unveils-ai-and-ml-privacy-commitment (5th paragraph)

The AI requests including code snippets you send to Bito are sent to Bito servers for processing so that we can respond with an answer.

Interactions with Bito AI are auto-moderated and managed for toxicity and harmful inputs and outputs.

Any response generated by the Bito IDE AI Assistant is stored locally on your machine to show the history in Bito UI. You can clear the history anytime you want from the Bito UI.

SOC 2 Type II Compliance

Bito is SOC 2 Type II compliant. This certification reinforces our commitment to safeguarding user data by adhering to strict security, availability, and confidentiality standards. SOC 2 Type II compliance is an independent, rigorous audit that evaluates how well an organization implements and follows these security practices over time.

Our SOC 2 Type II compliance means:

• Enhanced Data Security: We consistently implement robust controls to protect your data from unauthorized access and ensure it remains secure.

• Operational Excellence: Our processes are designed to maintain high availability and reliability, ensuring uninterrupted service.

• Regular Monitoring and Testing: We conduct continuous monitoring and regular internal reviews to uphold the highest security standards.

This certification is an assurance that Bito operates with a high level of trust and transparency, providing you with a secure environment for your code and data.

For any further questions regarding our SOC 2 Type II compliance or to request a copy of the audit report, please reach out to [email protected]

Code Flow through Bito’s System

AI Code Review Agent

When you use the self-hosted/docker version that you have setup in your VPC, in the docker image Bito checks out the diff and clones the repo for static analysis and also to determine relevant code context for code review. This context and the diff is passed to Bito's system. The request is then sent to a third-party LLM (e.g., OpenAI, Google Cloud, etc.). The LLM processes the prompt and return the response to Bito. No code is retained by the LLM. Bito then receives the response, processes it (such as formatting), and returns it to your self-hosted docker instance. This then posts it to your Git provider. However, the original query is not retained, nor are the results. After each code review is completed, the diff and the checked out repo are deleted.

If you use the Bito cloud to run the AI Code Review Agent, it runs similarly to the self-hosted version. Bito ephemerally checks out the diff and clones the repo for static analysis and to determine the relevant code context for code review. This context and the diff is passed to Bito's system. The request is then sent by Bito to a third-party LLM (e.g., OpenAI, Google Cloud, etc.). The LLM processes the prompt and return the response to Bito. No code is retained by the LLM. Bito then receives the response, processes it (such as formatting), and posts it to your Git provider. However, the original query is not retained, nor are the results. After each code review is completed, the diff and the checked out repo are deleted.

AI Chat and Code Completions

When we receive an AI request from a user, it is processed by Bito's system (such as adding relevant context and determining the Large Language Model (LLM) to use). However, the original query is not retained. The request is then sent to a third-party LLM (e.g., OpenAI, Google Cloud, etc.). The LLM processes the prompt and return the response to Bito. Bito then receives the response, processes it (such as formatting), and returns it to the user’s machine.

For enterprises, we have the ability to connect to your own private LLM accounts, including but not limited to OpenAI, Google Cloud, Anthropic, or third-party services such as AWS Bedrock, Azure OpenAI. This way all data goes through your own accounts or Virtual Private Cloud (VPC), ensuring enhanced control and security.

Data and Business Privacy Policy

In line with Bito's commitment to transparency and adherence to data privacy standards, our comprehensive data and business privacy policy is integrated into our practices. Our complete Terms of Use, including the Privacy Policy, are available at https://bito.ai/terms-of-use/, with our principal licensing information detailed at https://bito.ai/terms-of-service/.

Data Retention Policy

Our data retention policy is carefully designed to comply with legal standards and to respect our customers' privacy concerns. The policy is categorized into four levels of data:

1. Relationship and Usage Meta Data: This includes all data related to the customer's interaction with Bito, such as address, billing amounts, user account data (name and email), and usage metrics (number of queries made, time of day, length of query, etc.). This category of data is retained indefinitely for ongoing service improvement and customer support.

2. Bito Business Data: Includes customer-created templates and settings. This data is terminated 90 days after the end of the business relationship with Bito.

3. Confidential Customer Business Data: This includes code, code artifacts, and other organization-owned data such as Jira, Confluence, etc. This data is either stored on-prem/locally on the customer’s machines, or, if in the cloud, is terminated at the end of the business relationship with Bito.

4. AI Requests: Data in an AI request to Bito’s AI system. AI requests are neither retained nor viewed by Bito. We ensure the confidentiality of your AI queries; Bito and our LLM partners do not store your code, and none of your data is used for model training. All requests are transmitted via HTTPS and are fully encrypted.

Sub-processor

Bito uses the following third-party services: Amazon AWS, Anthropic, Clearbit, Github, Google Analytics, Google Cloud, HelpScout, Hubspot, Microsoft Azure, Mixpanel, OpenAI, SendGrid, SiteGround, and Slack for infrastructure, support, and functional capabilities.

Personal Data

Bito follows industry standard practices for protecting your e-mail and other personal details. Our password-less login process - which requires one-time passcode sent to your e-mail for every login - ensures the complete security of your account.

If you have any questions about our security and privacy, please email [email protected]

Bito can suggest code for these programming languages:

• C

• C++

• C#

• CSS

• Clojure

• Dart

• Elixir

• Erlang

• Fortran

• Go

• GoogleSQL

• Groovy

• Haskell

• HTML

• Java

• JavaScript

• JavaServer Pages

• Kotlin

• Lean (proof assistant)

• Lua

• Objective-C

• OCaml

• Perl

• PHP

• Python

• R

• Ruby

• Rust

• Scala

• Shell script

• Solidity

• SQL

• Swift

• TypeScript

• XML

• Verilog

• YAML

The AI Code Review Agent offers a suite of commands tailored to developers' needs. You can manually trigger a code review by entering any of these commands in the comment box below a pull/merge request on GitHub, GitLab, or Bitbucket and submitting the comment. Alternatively, if you are using the self-hosted version, you can configure these commands in the bito-cra.properties file for automated code reviews.

/review

This command provides a broad overview of your code changes, offering suggestions for improvement across various aspects but without diving deep for secure coding or performance optimizations or scalability improvements etc. This makes it ideal for catching general code quality issues that might not necessarily be critical blockers but can enhance readability, maintainability, and overall code health.

Think of it as a first-pass review to identify potential areas for improvement before delving into more specialized analyses.

Review Scope

Five specialized commands are available to perform detailed analyses on specific aspects of your code. Details for each command are given below.

1. /review security

2. /review performance

3. /review scalability

4. /review codeorg

5. /review codeoptimize

Combining general feedback with specialized review scopes

If you'd like to receive general code quality feedback alongside specialized analyses, include the general keyword in your review command.

For example, to receive feedback on general code quality, performance, and security, use:

• Example: /review general,performance,security

This ensures a holistic review encompassing both general code quality and specific areas of concern.

/review security

This command performs an in-depth analysis of your code to identify vulnerabilities that could allow attackers to steal data, gain unauthorized access, or disrupt your application. This includes checking for weaknesses in input validation, output encoding, authentication, authorization, and session management. It also looks for proper encryption of sensitive data, secure coding practices, and potential misconfigurations that could expose your system.

/review performance

This command evaluates the current performance of the code by pinpointing slow or resource-intensive areas and identifying potential bottlenecks. It helps developers understand where the code may be underperforming against expected benchmarks or standards. It is particularly useful for identifying slow processes that could benefit from further investigation and refinement.

This includes checking how well your code accesses data and manages tasks like database interactions and memory usage.

/review scalability

This command analyzes your code to identify potential roadblocks to handling increased usage or data. It checks how well the codebase supports horizontal scaling and whether it is compatible with load balancing strategies. It also ensures the code can handle concurrent requests efficiently and avoids bottlenecks from single points of failure. The command further examines error handling and retry mechanisms to promote system resilience under pressure.

/review codeorg

This command scans your code for readability, maintainability, and overall clarity. This includes checking for consistent formatting, clear comments, well-defined functions, and efficient use of data structures. It also looks for opportunities to reduce code duplication, improve error handling, and ensure the code is written for future growth and maintainability.

/review codeoptimize

This command helps identify specific parts of the code that can be made more efficient through optimization techniques. It suggests refactoring opportunities, algorithmic improvements, and areas where resource usage can be minimized. This command is essential for enhancing the overall efficiency of the code, making it faster and less resource-heavy.

Control code review workflow

These commands allow you to manage the AI Code Review Agent's behavior directly within your pull requests across GitHub, GitLab, and Bitbucket.

/pause

Pauses automatic AI reviews on the current pull request.

Use case: Useful when significant changes are underway, and you want to prevent the AI from reviewing incomplete code.

Example: Add a comment with /pause to the pull request.

/resume

Resumes the automatic AI reviews that were previously paused on the pull request.

Use case: Once your code changes are ready for review, use this command to re-enable the AI's automatic analysis.

Example: Add a comment with /resume to the pull request.

/resolve

Marks all Bito-posted review comments as resolved.

Use case: After addressing the issues highlighted by the AI, use this command to clean up the comment threads.

Example: Add a comment with /resolve to the pull request.

/abort

Cancels all in-progress AI code reviews on the current pull request.

Use case: If an AI review is no longer needed or was initiated by mistake, this command stops the process.

Example: Add a comment with /abort to the pull request.

Display Code Review in a Single Post

By default, the /review command generates inline comments, placing code suggestions directly beneath the corresponding lines in each file for clearer guidance on improvements. If you prefer a single consolidated code review instead of separate inline comments, use the #inline_comment parameter and set its value to False.

Example: /review #inline_comment=False

Example: /review scalability #inline_comment=False

Get up and running with Bito in just a few steps! Bito seamlessly integrates with popular JetBrains IDEs such as IntelliJ IDEA, PyCharm, and WebStorm, providing powerful AI-driven coding assistance directly within your editor. Click the button below to quickly install the Bito extension and start optimizing your development workflow with context-aware AI Chat, AI Code Completions, and more.

Video guide

Watch the video below to learn how to download the Bito extension on JetBrains IDEs.

Step-by-step instructions

1. In JetBrains IDEs such as IntelliJ, go to File -> Settings to open the Settings dialog, and click Plugins -> Marketplace tab in the settings dialog. Search for Bito.

2. Click "Install" to install the Bito extension. We recommend you restart the IDE after the installation is complete.

3. Bito panel will appear on the right-hand sidebar. Click it to complete the setup process. You will either need to create a new workspace if you are the first in your company to install Bito or join an existing workspace created by a co-worker. See Managing workspace members

The IDE customization settings are accessible through the new toolbar dropdown menu titled "Extension Settings".

Light and Dark Themes

In Visual Studio Code and JetBrains IDEs, you can choose between a light or dark theme for the Bito panel to match your coding environment preference. For VS Code users, Bito also offers an adaptive theme mode in which the Bito panel and font colors automatically adjust based on your selected VS Code theme, creating a seamless visual experience.

You can set the desired theme through the Theme dropdown.

Theme Screenshots

“Always Light” Theme

“Always Dark” Theme

“Light” or “Dark” Theme - Matching IDE

“Adaptive” Theme

Theme adapted from “Noctis Lux”:

Theme adapted from “Solarized Light”:

Theme adapted from “Tomorrow Night Blue”:

Theme adapted from “barn-cat”:

Font Size Control

Take control of your code readability! Within the Bito extension settings, you can now adjust the font size for a comfortable viewing experience.

You can set the desired font size through the Font Size text field. However, if you check the Font Size (Match with IDE Font) checkbox, it will override the set font size with the Editor font size.

Bito’s "AI Code Completions" capabilities offer real-time, personalized code suggestions as you type. Powered by the latest best-in-class Large Language Models (such as GPT-4o mini and Google PaLM 2 – 540B parameters compare to Copilot’s 12B parameter model), Bito understands your codebase and provides contextually accurate code suggestions right from within your IDE. Bito’s model is also trained on data until 2 months back, many other models are trained on 12-18 months old data.

Speed up your development workflow with AI-assisted code completion. Watch as lines of code, full functions, or even entire code blocks are generated for you on the fly.

Supporting a wide range of over 35 programming languages—from Python to SQL, from C++ to Go and JavaScript—this feature is designed to make coding faster, easier, and more efficient for developers like you.

Let's dive in to see how it works.

Minimum System Requirements

A machine with the following minimum specifications is recommended for Docker image deployment and for obtaining optimal performance of the AI Code Review Agent.

Supported Operating Systems

• Windows

• Linux

• macOS

OS Prerequisites

Required Access Tokens

• Bito Access Key: Obtain your Bito Access Key.

• GitHub Personal Access Token (Classic): For GitHub PR code reviews, ensure you have a CLASSIC personal access token with repo access. We do not support fine-grained tokens currently.

• GitLab Personal Access Token: For GitLab PR code reviews, a token with API access is required.

• Snyk API Token (Auth Token): For Snyk vulnerability reports, obtain a Snyk API Token.

1. Prerequisites: Before proceeding, ensure you've completed all necessary AI Code Review Agent.

2. Start Docker: Ensure Docker is running on your machine.

3. Repository Download: GitHub repository to your machine.

4. Extract and Navigate:

• Extract the downloaded .zip file to a preferred location.

• Navigate to the extracted folder and then to the “cra-scripts” subfolder.

• Note the full path to the “cra-scripts” folder for later use.

1. Open Command Line:

   • Use Bash for Linux and macOS.

   • Use PowerShell for Windows.

2. Set Directory:

   • Change the current directory in Bash/PowerShell to the “cra-scripts” folder.

   • Example command: cd [Path to cra-scripts folder]

   • Adjust the path based on your extraction location.

1. Configure Properties:

   • Open the bito-cra.properties file in a text editor from the “cra-scripts” folder. Detailed information for each property is provided on page.

   • Set mandatory properties:

     • mode = cli

     • pr_url

     • bito_cli.bito.access_key

     • git.provider

     • git.access_token

• Optional properties (can be skipped or set as needed):

  • git.domain

  • code_feedback

  • static_analysis

  • dependency_check

  • dependency_check.snyk_auth_token

  • review_scope

  • exclude_branches

  • exclude_files

  • exclude_draft_pr

1. Run the Agent:

   • On Linux/macOS in Bash: Run ./bito-cra.sh bito-cra.properties

   • On Windows in PowerShell: Run ./bito-cra.ps1 bito-cra.properties

1. Final Steps:

   • The script may prompt values of mandatory/optional properties if they are not preconfigured.

   • Upon completion, a code review comment is automatically posted on the Pull Request specified in the pr_url property.

Screenshots

Screenshot # 1

Screenshot # 2

Screenshot # 3

Easily share insights from any session by creating a unique shareable link directly from the Bito extension in VS Code or JetBrains IDEs.

Whether you need to share AI-generated code suggestions, explanations, or any other chat insights, this feature allows you to create a public link that others can access. The link will remain active for 15 days and can be viewed by anyone with access to the URL, making collaboration and knowledge sharing seamless.

Additionally, you can quickly share your AI Chat session through a pre-written Tweet or an Email.

Let's see how it is done:

1. Open Bito in Visual Studio Code or any JetBrains IDE.

2. Start a conversation in Bito’s AI Chat user interface.

3. Locate the share button on the top right of the Bito extension side-panel.

4. Click the share button to open a menu with options, including X (Twitter), Email, and Link.

5. Share on X (Twitter):

   1. Click on X (Twitter) from the menu, and a dialogue window will appear, asking whether you want to open the external site.

   2. Simply click "Open" to proceed.

   3. You will be redirected to the X (Twitter) website, with a pre-written tweet containing a link to your Chat Session ready to be published.

   4. Click the "Post" button to send the tweet.

6. Share Through Email:

   1. Click on Email from the menu, and you will be redirected to your email application.

   2. Select your email account if needed.

   3. The email will be pre-filled with all the necessary information, including the link to your Chat Session.

   4. Add the receiver(s) of this email using the "To" input field.

   5. Click the "Send" button to send the email.

7. Share the Link:

   1. Click on Link from the menu.

   2. A confirmation popup will appear. Click Share session to generate a unique URL for your chat session, which will automatically be copied to your clipboard for easy sharing.

   3. Feel free to share this link with anyone you'd like to.

Bito's AI helps developers dramatically accelerate their impact. It's a Swiss Army knife of capabilities that can 10x your developer productivity and save you an hour a day, using the same models as ChatGPT!

Bito AI makes it easy to write code, understand syntax, write test cases, explain code, comment on code, check security, and even explain high-level concepts. Trained on billions of lines of code and millions of documents, it's pretty incredible what we can help you do without having to search the web or waste time on tedious stuff.

What can you do with Bito?

Bito AI is a general-purpose AI assistance in that developers can ask any technical question, generate code from the natural language prompts, and get feedback on the existing code. Here are some things you can do with Bito AI Knowledge Assistance.

1. Generate Code: Ask Bito to generate code in any language with the natural language prompt. (e.g., write a Java function to convert a number from one base to another)

2. Command Syntax: Ask for the syntax of any technical command. (e.g., How to set a global variable for git?")

3. Test Cases: Generate test cases for the code.

4. Explain Code: Explain the selected code. Ask how this code works or what it does.

5. Comment Method: Generate a comment for the function or method to add to your code.

6. Improve Performance: Ask how you can improve the performance of a given code.

7. Check Security: Ask if the selected code has any known security issues.

8. Learn Technical Concepts: Ask a question about any technical concept (e.g., Explains B+ trees, explain Banker's algorithm)

Through extensions, Bito meets you where you work, your IDEs, like Visual Studio Code or JetBrains family of IDE.

Next, learn how to install Bito extensions.

Bito analyzes the file you are currently editing and your codebase to understand the context. It offers two types of AI Code Completions:

1- Autocompletions (complete the line as you type)

In this method, as you are writing a line of code, Bito will automatically predict what you will write next and generate relevant suggestions based on your codebase.

2- Comment to code

In this method, you can write any kind of requirements you have in natural language comments, and Bito will suggest the best code tailored to your codebase to fulfill those requirements – often writing the entire function.

How Good are AI Code Completions?

Since Bito is familiar with your entire codebase, it can provide more accurate code suggestions than other AI Coding Assistants available today.

For example:

1. Bito can see your imports and predict what task you are trying to complete.

2. Bito can read the function you're inside and predict what you'll do next.

3. Bito can spot the APIs you've integrated and suggest possible endpoints to call.

After gathering the context, Bito uses different to come up with some options that you will most likely want to write next. So, if one solution doesn’t work, there are more you can try.

Bito provides high-quality code completions that align with the code you are working on. However, if the suggested completions are not as accurate in your specific case, you can write additional code or provide explicit instructions in comments to help Bito better understand the context and generate more precise solutions.

Enabling unicode For Windows 10 and below

Unicode characters (using other languages) might not be readily supported on command prompt if you are on Windows 10 or below. You can run command chcp 936 in cmd prior to using bito to support unicode characters in Windows 10 or below (To undo the settings done here you can follow ).

Using Homebrew for Bito CLI

1. Before using homebrew, please make sure that you uninstall any previously installed versions of Bito CLI using the .

2. Once above is done then you can use following commands to install Bito CLI using homebrew:

   1. First tap the CLI repo using brew tap gitbito/bitocli command, this should be a one time action and not required every time.

   2. Now you can install Bito CLI using following command:

      • brew install bito-cli - this should install Bito CLI based upon your machine architecture.

   3. To update Bito CLI to the latest version, use following commands:

      1. Please make sure you always do brew update before upgrading to avoid any errors.

      2. brew update - this will update all the required packages before upgrading.

      3. brew upgrade bito-cli - once above is done, this will update Bito CLI to the latest version.

   4. To uninstall Bito CLI you can either use the or use following commands:

      • brew uninstall bito-cli - this should uninstall Bito CLI completely from your system.

Advanced AI planning and reasoning capabilities

Wingman excels at understanding high-level instructions and breaking them into actionable steps. Unlike traditional assistants, it plans and executes tasks, making it an invaluable partner for complex projects.

The more detailed and specific your instructions, the better the results Wingman can deliver. You can also iterate with Wingman as the project evolves, refining its output step by step to meet your exact requirements.

Example use case: Provide a detailed prompt like:

Create an API for user authentication and integrate it into my backend. Please review my code thoroughly to suggest the key interfaces that should be created. Besides normal user registration and authentication, also include token management capabilities and risk-based scoring mechanisms to help alert us if a user might be trying to breach the system.

Contextual/focused research capabilities

When tasked with challenges requiring additional information, Wingman conducts targeted research to gather relevant details and context for your project.

Example use case: If you're building a feature but need to confirm industry-standard practices, Wingman will gather up-to-date information and incorporate it into the solution.

Seamless web browsing and information gathering

Wingman can browse the web autonomously to find and retrieve useful data. This feature ensures that your projects benefit from the latest tools, libraries, or guidelines available.

Example use case: If you ask Wingman to implement a feature using a cutting-edge library, it will search for the library, understand its documentation, and integrate it into your code.

Code writing in multiple programming languages

Wingman can generate high-quality code across a variety of programming languages. It understands your project’s requirements and provides context-aware solutions tailored to your tech stack.

Example use case: Ask Wingman to write a function in Python, JavaScript, or another language—it will deliver optimized and functional code.

Integration with popular tools

Wingman integrates seamlessly with tools you already use, including:

• Version control: Support for Git operations like git push, git commit, and git clone for GitHub and GitLab workflows.

• Project management: Jira, Linear

• Documentation: Confluence

• File operations: Manage and update files directly.

This integration ensures that Wingman fits naturally into your existing workflow.

Example use case: Assign a Jira ticket to Wingman, and it will complete the associated coding task, update the ticket, and link it to the appropriate pull request.

Extensible architecture

Wingman is designed with flexibility in mind, allowing you to easily integrate it with tools that fit your workflow. Its adaptable architecture ensures it evolves with your development needs.

Example use case: If your team starts using a new project management tool, Wingman’s flexibility lets you integrate it into your process effortlessly.

Have a specific tool in mind? Drop us a note at [email protected] to request adding support for it.

Task completion made easy

Wingman is designed to assist you in completing tasks efficiently, working alongside you and checking in as needed. Once provided with clear instructions, it handles everything from planning to execution while keeping you in the loop.

Example use case: Wingman can help implement a feature, document it in Confluence, and create a pull request—keeping you informed every step of the way.

Natural language interaction

Communicate with Wingman in any language through a chat interface. Describe what you need, and Wingman will take care of the rest. Additionally, you can set your preferred AI output language on the Advanced settings page. For example, if you set Spanish as your preferred language, Wingman will respond to you in Spanish.

Example use case: Type "Generate a REST API for user management and write tests for it" in the chat, and Wingman will handle the implementation and testing.

Get up and running with Bito in just a few steps! Bito seamlessly integrates with Visual Studio Code, providing powerful AI-driven coding assistance directly within your editor. Click the button below to quickly install the Bito extension and start optimizing your development workflow with context-aware AI Chat, AI Code Completions, and more.

Video guide

Watch the video below to learn how to download the Bito extension on VS Code.

Step-by-step instructions

1. In Visual Studio Code, go to the extension tab and search for Bito.

1. Install the extension. We recommend you restart the IDE after the installation is complete.

1. After a successful install, the Bito logo appears in the Visual Studio Code pane.

1. Click the Bito logo to launch the extension and complete the setup process. You will either need to create a new workspace if you are the first in your company to install Bito or join an existing workspace created by a co-worker. See Managing workspace members

Setup Bito extension in VS Code running through SSH

SSH (Secure Shell) is a network protocol that securely enables remote access, system management, and file transfer between computers over unsecured networks.

Visual Studio Code IDE allows developers to access and collaborate on projects from any connected machine remotely. The corresponding extension [Remote -SSH] must be installed on the host machine's Visual Studio Code IDE to utilize this feature.

The Bito VS Code extension seamlessly integrates with Remote development via SSH, allowing developers to utilize Bito features and capabilities on their remote machines.

Remote SSH connection and setup

Please follow the instructions given in the links below:

• https://code.visualstudio.com/docs/remote/ssh

• https://learn.microsoft.com/en-us/windows-server/administration/openssh/openssh_install_firstuse

Video Guide:

Setup Bito extension in VS Code running through WSL

Running VS Code on WSL allows developers to work in a Linux-like environment directly from Windows. This kind of setup is to take advantage of development experience on both operating systems.

WSL provides access to Linux command-line tools, utilities, and applications, to enhance productivity and streamline the development process.

This setup ensures a consistent development environment across different systems, making it easier to develop, test, and deploy applications that will run on Linux servers.

WSL connection and setup

Please follow the instructions given in the links below:

• https://code.visualstudio.com/docs/remote/wsl-tutorial

• https://learn.microsoft.com/en-us/windows/wsl/install

Video Guide:

Bito’s Request changes comments feature helps enforce code quality by blocking merges until all AI-generated review comments are resolved—fully supported in GitHub, GitLab, and Bitbucket.

When enabled, Bito identifies actionable issues in pull requests and posts them as formal “Request changes” review comments. If your repository uses branch protection rules that require all review conversations to be resolved before merging, Bito’s flagged comments will automatically block the pull request until addressed.

This ensures developers don’t accidentally merge incomplete or unreviewed code.

How it works

1. Enable comment resolution rules in your Git provider

GitHub:

• Go to your repository → Settings → Branches

• Create or edit a branch protection rule (e.g., for main)

• Enable:

  • ✅ Require a pull request before merging

  • ✅ Require conversation resolution before merging

GitLab:

• Go to your project → Settings → Merge requests

• Under Merge checks, enable:

  • ✅ All threads must be resolved before merging

Bitbucket:

• Go to your repository → Repository settings → Pull requests

• Under Merge checks, enable:

  • ✅ All pull request tasks must be resolved before merging

2. Turn on “Request changes comments” in Bito

• Go to Repositories in the Bito dashboard.

• Click on Settings for your desired AI Code Review Agent instance.

• Enable the toggle: “Request changes comments”

• Save changes

When this is on, Bito will flag actionable AI feedback as formal review comments requiring resolution. Informational or minor suggestions will remain as regular comments.

3. What happens in a pull request

• Bito runs an AI code review on your pull request or merge request.

• Actionable issues are posted as change requests.

• Your Git provider treats these comments according to your configured merge rules.

• If comment resolution is required, the merge is blocked until the flagged issues are resolved.

Example workflow

1. Developer opens a pull request or merge request.

2. Bito reviews the code and posts a “request change” comment on a problematic line.

3. The Git provider blocks the merge due to unresolved comments or threads.

4. Developer fixes the issue and marks the thread as resolved.

5. Merge becomes possible once all conditions are met.

Why use this feature?

• Enforces follow-up on critical AI-detected issues.

• Works natively with GitHub, GitLab, and Bitbucket workflows.

• Ensures only reviewed and clean code gets merged.

• Helps maintain consistent code quality at scale.

Bito's Team Plan users can either start a conversation with Basic AI Models (e.g. GPT-4o mini, Claude Haiku, Nova Lite 1.0, and similar models) or more Advanced AI Models (e.g. o3-mini, DeepSeek-V3 (served from the US and Europe), GPT-4o, Claude Sonnet 3.5, and best in class AI models). In contrast, the Free Plan users are limited to using only Basic AI Models.

This guide will help you understand when to use Basic and when to use Advanced AI models. You will also learn how to select and chat with these models in the Bito chatbox.

When to use Basic vs Advanced AI Models?

Basic AI Models

These models are designed to provide essential AI capabilities for most everyday coding tasks. They offer a solid starting point for generating boilerplate code, writing documentation, explaining code snippets, and solving simple coding problems.

While using Basic AI models, your prompts and the memory of the chat are limited to 40,000 characters (about 18 single-spaced pages).

They are also less expensive in terms of API costs. So, if you are frequently asking less-important questions in the Bito chatbox, then these Basic AI models will definitely help you save costs.

Advanced AI Models

These models are more suitable for high-complexity tasks that require long/complex prompts and advanced reasoning.

They provide more accurate and relevant code snippets, comments, or solutions to complex coding problems.

Additionally, when using Advanced AI models, your prompts and the chat memory can extend up to 240,000 characters (about 110 single-spaced pages). This means that these models can process your entire code files, leading to more accurate answers.

So, if you are looking for the best results for complex tasks, then go with Advanced AI models.

How to Chat with Basic/Advanced AI Models?

When you open the Bito plugin in VS Code or JetBrains IDEs, the "AI Chat" tab is displayed by default. This tab includes a drop-down menu at the bottom-right corner that allows you to select the AI model you want to chat with.

The available AI models are categorized under two sections "BASIC" and "ADVANCED". You can either let Bito auto-select an AI model or manually pick one that best suits your needs.

Once you select an AI model and start a chat with it, the drop-down menu will disappear, and your chosen model will handle the entire chat session.

If you want to change the AI model, click the New Chat icon located in the bottom-left corner of the Bito plugin pane. In the new chat session, select a different model from the drop-down menu.

Ask questions directly to the AI Code Review Agent regarding its code review feedback. You can inquire about highlighted issues, request alternative solutions, or seek clarifications on suggested fixes.

Real-time collaboration with the AI Code Review Agent accelerates your development cycle. By delivering immediate, actionable insights, it eliminates the delays typically experienced with human reviews. Developers can engage directly with the Agent to clarify recommendations on the spot, ensuring that any issues are addressed swiftly and accurately.

Bito supports over 20 languages—including English, Hindi, Chinese, and Spanish—so you can interact with the AI in the language you’re most comfortable with.

How to chat?

To start a conversation, type your question directly as a reply to the Agent’s code review comment.

The AI Code Review Agent will analyze your comment and determine if it’s a valid and relevant question.

• If the agent decides it’s a valid question, it will respond with helpful insights.

• If the agent determines it’s unclear, off-topic, or not related to its feedback, it will not respond.

To help the agent recognize your question faster, you can also tag your comment with @bitoagent or @askbito. Tagging informs the Agent that your message is intended as a question. However, tagging does not guarantee a reply. The agent will still analyze your comment and decide whether it is a valid question worth responding to.

Bito usually responds within about 10 seconds.

• On GitHub and Bitbucket, you may need to manually refresh the page to see the response.

• On GitLab, updates happen automatically.

What you can ask about

When chatting with the AI Code Review Agent, you can ask questions to better understand or improve the code feedback it provided. Here are examples of what you can ask:

• Clarifications about a highlighted issue Ask the AI to explain why it flagged a certain line of code or why something might cause a problem.

• Request for alternative solutions Request different ways to fix or improve the code beyond what was originally suggested.

• Deeper explanations If you want to understand the technical reasoning behind a suggestion (e.g., security concerns, performance impacts, best practices), you can ask for more detailed explanations.

• Request for examples Ask the AI to provide an example snippet showing the corrected or improved code.

• Trade-off discussions Ask the AI about pros and cons of different approaches it may have suggested (e.g., performance vs. readability).

• Best practices guidance Request advice on best practices related to the specific code snippet — such as naming conventions, error handling, optimization tips, or design patterns.

• Language-specific advice If you’re working in a particular language (e.g., JavaScript, Python, Java), you can ask for language-specific guidance related to the comment.

• Request for more context If the suggestion feels too "short" or "surface level," you can ask the AI to explain more about the broader coding or architectural concept behind its feedback.

• Security and safety questions If a suggestion touches on security (like input validation, authentication, or encryption), you can ask for further security-related advice.

• Testing and validation Ask the AI if it recommends writing any tests based on its code suggestions and what those tests might look like.

What you cannot ask about

The AI can only answer questions related to its own code review comments.

• You cannot ask general questions about the repository or unrelated topics.

• You cannot start a new thread independently — your question must be a reply to a comment made by Bito’s AI Code Review Agent.

If your comment is not linked to a Bito review comment, the AI will not respond.

Bito's AI Code Completions doesn't interfere with your coding process. It offers code suggestions only after you have paused typing for 250 milliseconds (you can adjust this in settings), or if you explicitly ask for AI Code Completions by typing Alt + Shift + K on Windows or Option + Shift + K on macOS, and the suggested code is merely displayed as a placeholder.

To accept the entire code suggestion, simply press the "Tab" key on your keyboard. Alternatively, you can accept the code completion incrementally, word by word, by pressing "" (coming soon...). To accept one line at a time, click the three dots button in the code completion UI toolbar and then select "Accept Line" (coming soon...).

If you don’t like the suggestion, Bito does not force you to use it. You can simply dismiss it by pressing the “Esc” key on your keyboard or continue typing as normal.

Bito also provides alternative suggestions, which you can navigate using the arrow keys in the code completion UI toolbar or by using the shortcut keys mentioned below.

In Bito, team members collaborate by joining a workspace. In most cases, every organization would create one Workspace. Anyone can sign up on Bito, create a workspace for their team, and invite their coworkers to join the Workspace.

Inviting coworkers to the Workspace

You can use Bito in a single-player mode for all the use cases. However, it works best when your coworkers join the Workspace to collaborate with Bito. There are three ways you can invite your coworkers.

Option 1 - Allow your work e-mail domain for the Workspace. This setting is turned on by default, and all users with the same e-mail domain as yours will automatically see the Workspace under "Pending Invitations" when signing up in Bito. You can manage this setting after you create the Workspace through the "Settings" page in your Bito account.

Option 2 - Invite your coworkers via e-mail when you create your Workspace or later from your workspace setting.

Option 3- Share a web link specific to your Workspace via the channel of your choice: e-mail, Slack, or Teams. The link is automatically created and shown when creating a workspace or on the workspace settings page.

Managing coworkers in Workspace

If you are the Owner or Admin of the Workspace, you can take the following actions:-

Deactivate User

Deactivate any user to remove them from the given Workspace. Once the user is deactivated, they can't access the workspace. They can request to join the Workspace, which requires approval from the admin or owner.

A deactivated user can be activated again by the admin/owner.

Activate User

Activate the user who was previously deactivated.

Force Reauthentication

A Bito user can check "Remember Me" to auto log-in. Admin/Owner can force the user to re-authenticate if needed for security.

Change Access Level

Bito has primarily three user types - Owner, Admin, and User as defined in the following page:Managing user access levels. Admins/Owners can change the user's access level.

The following Loom demonstrates managing the workspace and its members.

We are excited to announce that one of our users has developed a dedicated Vim and Neovim plugin for Bito, integrating it seamlessly with your favorite code editor. This plugin enhances your coding experience by leveraging the power of Bito's AI capabilities directly within Vim and Neovim.

Installation

To get started with "vim-bitoai," follow these steps:

Step 1: Install Bito CLI

Make sure you have Bito CLI installed on your system. If you haven't installed it, you can find detailed instructions in the Bito CLI repository at.

Step 2: Install the Plugin

Open your terminal and navigate to your Vim or Neovim plugin directory. Then, clone the "vim-bitoai" repository using the following command:

Step 3: Configure the Plugin

Open your Vim or Neovim configuration file and add the following lines:

Save the configuration file and restart your editor or run :source ~/.vimrc (for Vim) or :source ~/.config/nvim/init.vim (for Neovim) to load the changes.

Step 4: Verify the Installation

Open Vim or Neovim, and you should now have the "vim-bitoai" plugin installed and ready to use.

Usage

You can use its powerful features once you have installed the "vim-bitoai" plugin. Here are some of the available commands:

• BitoAiGenerate: Generates code based on a given prompt.

• BitoAiGenerateUnit: Generates unit test code for the selected code block.

• BitoAiGenerateComment: Generates comments for methods, explaining parameters and output.

• BitoAiCheck: Performs a check for potential issues in the code and suggests improvements.

• BitoAiCheckSecurity: Checks the code for security issues and provides recommendations.

• BitoAiCheckStyle: Checks the code for style issues and suggests style improvements.

• BitoAiCheckPerformance: Analyzes the code for performance issues and suggests optimizations.

• BitoAiReadable: Organizes the code to enhance readability and maintainability.

• BitoAiExplain: Generates an explanation for the selected code.

To execute a command, follow these steps:

1. Open a file in Vim or Neovim that you want to work on.

2. Select the code block you want to act on. You can use visual mode or manually specify the range using line numbers.

3. Execute the desired command by running the corresponding command in command mode. For example, to generate code based on a prompt, use the : BitoAiGenerate command. Note: Some commands may prompt you for additional information or options.

4. The plugin will communicate with the Bito CLI and execute the command, providing the output directly within your editor.

By leveraging the "vim-bitoai" plugin, you can directly harness the power of Bito's AI capabilities within your favorite Vim or Neovim editor. This integration lets you streamline your software development process, saving time and effort in repetitive tasks and promoting efficient coding practices.

Customization

The "vim-bitoai" plugin also offers customization options tailored to your specific needs. Here are a few variables you can configure in your Vim or Neovim configuration file:

• g:bito_buffer_name_prefix: Sets the prefix for the buffer name in the Bito history. By default, it is set to 'bito_history_'.

• g:vim_bito_path: Specifies the path to the Bito CLI executable. If the Bito CLI is not in your system's command path, you can provide the full path to the executable.

• g:vim_bito_prompt_{command}: Allows you to customize the prompt for a specific command. Replace {command} with the desired command.

To define a custom prompt, add the following line to your Vim or Neovim configuration file and replace your prompt with the desired prompt text:

Remember to restart your editor or run the appropriate command to load the changes.

We encourage you to explore the "vim-bitoai" plugin and experience the benefits of seamless integration between Bito and your Vim or Neovim editor. Feel free to contribute to the repository or provide feedback to help us further improve this plugin and enhance your coding experience.

Bito's supports different configuration methods depending on the deployment environment:

1. Bito-hosted – The agent runs on Bito's infrastructure and is configured through the .

2. Self-hosted – The agent runs on user-managed infrastructure and is configured by editing the .

The sections below provide configuration guidance for each setup.

Bito-hosted agent configuration

In Bito-hosted AI Code Review Agent, you can configure the agent through the .

To customize an existing agent, open the page and click the Settings button next to the Agent instance to be modified.

The agent settings page allows configuration of options such as:

• Agent name – Define a unique name for easy identification.

• Review options – Choose the review mode (Essential or Comprehensive), set feedback language, and enable features like auto-review, incremental review, summaries, and change walkthroughs.

• Custom guidelines – Create and apply custom code review rules tailored to your team’s standards directly from the dashboard.

• Filters – Exclude specific files, folders, or branches from review to focus on relevant code.

• Tools – Enable additional checks, such as secret scanning and static analysis.

• Chat – Configure how the agent responds to follow-up questions in pull request comments and manage automatic replies.

These settings tailor the agent’s behavior to match team workflows and project needs. For detailed guidance, see .

Self-hosted agent configuration

In self-hosted deployments, configuration is managed by editing the . This file defines how the agent operates and connects to required services.

Key configuration options include:

• Mode

  • mode = cli: Processes a single pull request using a manual URL input.

  • mode = server: Runs as a webhook service and listens for incoming events from Git platforms.

• Authentication

  • bito_cli.bito.access_key: Required for authenticating the agent with the Bito platform.

  • git.provider, git.access_token, etc.: Required for connecting to the appropriate Git provider (e.g., GitHub, GitLab, Bitbucket).

• General feedback settings

  • code_feedback: Enables or disables general feedback comments in reviews.

• Analysis tools

  • static_analysis: Enables static code analysis.

  • dependency_check: Enables open-source dependency scanning.

  • dependency_check.snyk_auth_token: Required when using Snyk for vulnerability detection.

• Review format and scope

  • review_comments: Defines output style (e.g., single post or inline comments).

  • review_scope: Limits the review focus to specific concerns such as security, performance, or style.

• Filters

  • include_source_branches and include_target_branches: Restrict reviews to pull requests that match specified source and target branch patterns.

  • exclude_files: Skips selected files based on glob patterns.

  • exclude_draft_pr: Skips draft pull requests when enabled (default: True).

Each property is documented in detail on the page.

Step-by-Step Instructions

1. to open the Bito Chrome Extension page.

2. Now click on the “Add to Chrome” button.
3. A popup will appear. Click on “Add extension” to install Bito in Google Chrome. The installation process will only take a few seconds.
4. Once Bito is installed, a new popup will appear, informing you that the Bito extension has been added to Chrome. Simply close this popup.
5. Now click on the “Extensions icon” given on the top-right side of your browser window. A popup box will appear. Here you will see something like “Bito” in the list. Select the small pin icon in front of it to always show the “Bito icon” in the browser ribbon.

   For example:
6. Now, click the “Bito icon” from the browser ribbon. You will be asked to create a new Bito account or sign in to your existing account. You can also try Bito as a Guest user. But you will be limited to only asking 10 questions as a Guest. So, it is better to sign up to get unlimited access for free.
7. Type your email address and click on “Continue”. A six-digit confirmation code will be sent to your email.
8. Enter the confirmation code in the given input field and click on “Submit”.
9. If the confirmation code you entered is correct, you will be logged in to Bito Chrome Extension. Here is how the user interface (UI) will look like.
10. You can try the prompts already given in the UI by simply clicking on them. Additionally, you can type your own technical questions in the given input box and click on the “Send” button.
11. Bito will quickly start writing the answer. Once the answer is generated, you can select the “Copy Answer” button to copy it to your clipboard and paste it wherever you want to.

How do I whitelist Bito's gateway IP address for my on-premise Git platform?

To ensure the operates smoothly with your GitHub (Self-Managed) or GitLab (Self-Managed), please whitelist all of Bito's gateway IP addresses in your firewall to allow incoming traffic from Bito. This will enable Bito to access your self-hosted repository.

List of IP addresses to whitelist:

• 18.188.201.104

• 3.23.173.30

• 18.216.64.170

The agent response can come from any of these IPs.

How can I prevent the AI Code Review Agent from stopping due to token expiry?

You should set a longer expiration period for your GitHub Personal Access Token (Classic) or GitLab Personal Access Token. We recommend setting the expiration to at least one year. This prevents the token from expiring early and avoids disruptions in the AI Code Review Agent's functionality.

Additionally, we highly recommend updating the token before expiry to maintain seamless integration and code review processes.

For more details on how to create tokens, follow these guides:

• GitHub Personal Access Token (Classic):

• GitLab Personal Access Token:

What is "Estimated effort to review" in code review output?

This is an estimate, on a scale of 1-5 (inclusive), of the time and effort required to review this Pull Request (PR) by an experienced and knowledgeable developer. A score of 1 means a short and easy review, while a score of 5 means a long and hard review. It takes into account the size, complexity, quality, and the needed changes of the PR code diff. The score is produced by AI.

Why does Bito need access to my Git account?

Bito requires certain permissions to analyze pull requests and provide AI-powered code reviews. It never stores your code and only accesses the necessary data to deliver review insights.

What permissions does Bito need?

Bito requires:

1. Read access to code and metadata: To analyze PRs and suggest improvements

2. Read and write access to issues and pull requests: To post AI-generated review comments

3. Read access to organization members: To provide better review context

I don’t have admin permissions. Can I still use Bito?

If you don’t have admin access, you’ll need your administrator to install Bito on your organization’s Git account. Once installed, you can use it for PR reviews on allowed repositories. GitHub also sends a notification to the organization owner to request the organization owner to install the app.

Does Bito store my code?

No, Bito does not store or train models on your code. It only analyzes pull request data in real-time and provides suggestions directly within the PR.

Can I choose which repositories Bito has access to?

Yes, after installation, you can select specific repositories instead of granting access to all. You can also manage repository access later through our web dashboard.

What happens after I install the Bito App?

Once installed, you’ll be redirected to Bito, where you can:

1. Select repositories for AI-powered reviews

2. Customize review settings to fit your workflow

3. Open a pull request to start receiving AI-driven suggestions

Where can I get help if I have issues installing Bito?

Contact for any assistance.

lets you integrate the into your CI/CD pipeline for automated code reviews. This document provides a step-by-step guide to help you configure and run the script successfully.

Installation and Configuration Steps

1. based on your Git provider, and follow the step-by-step instructions to install the AI Code Review Agent using Bito Cloud. Be sure to review the prerequisites and the installation/configuration steps provided in the documentation.

2. , which includes a shell script (bito-actions.sh) and a configuration file (bito_action.properties).

3. You can integrate the AI Code Review Agent into your CI/CD pipeline in two ways, depending on your preference:

• Option 1: Using the bito_action.properties File

  • Configure the following properties in the bito_action.properties file located in the downloaded bito-action-script folder.

• Run the following command:

  • ./bito_actions.sh bito_action.properties

  • Note: When using the properties file, make sure to provide all the three parameters in .properties file

• Option 2: Using Runtime Values

  • Provide all necessary values directly on the command line:

    • ./bito_actions.sh agent_instance_url=<agent_instance_url> agent_instance_secret=<secret> pr_url=<pr_url>

    • Replace <agent_instance_url>, <secret>, and <pr_url> with your specific values.

  • Note: You can also override the values given in the .properties file or provide values that are not included in the file. For example, you can configure agent_instance_url and agent_instance_secret in the bito_action.properties file, and only pass pr_url on the command line during runtime.

    • ./bito_actions.sh bito_action.properties pr_url=<pr_url>

    • Replace <pr_url> with your specific values.

1. Incorporate the AI Code Review Agent into your CI/CD pipeline by adding the appropriate commands to your build or deployment scripts. This integration will automatically trigger code reviews as part of the pipeline, enhancing your development workflow by enforcing code quality checks with every change.

seamlessly integrates with various tools such as Jira, Linear, Confluence, and more.

Below is a list of developer tools available to Wingman. Each tool comes with unique parameters and capabilities, and Wingman is ready to assist you in configuring and using them effectively.

Keeping your Bito plugin up to date ensures you have access to the latest features and improvements. In this article, we will guide you through the steps to update the Bito plugin on both VS Code and JetBrains IDEs. Let's dive in!

Updating Bito Plugin on VS Code

1. Open your VS Code IDE

2. Navigate to the Extensions view by clicking on the square icon in the left sidebar

3. In the search bar, type "Bito" to locate the Bito plugin

4. Once you locate the Bito plugin, click on the update button to initiate the update

Pro Tip 💡: Enable Auto-update for Bito Plugin on VS Code (as shown in the video)

Updating Bito Plugin on JetBrains IDEs

1. Open your JetBrains IDE (e.g., IntelliJ IDEA, PyCharm, etc.)

2. Go to Settings by clicking on "File" in the menu bar (Windows/Linux) or by clicking on "IntelliJ IDEA" in the menu bar (macOS).

3. In the Settings window, navigate to the "Plugins" section

4. Switch to the "Installed" tab to view the list of installed plugins

5. Locate the Bito plugin in the list and click on the update button to initiate the update

Any Shortcut such as "Performance Check" or "Improve Readability" that proposes changes to your existing code automatically opens a "Diff View" between the proposed and actual code. This allows you to review the changes before accepting them into your code. The diff view opens automatically when Bito AI returns the proposed changes. You can also view the diff at any point through the "Diff" action.

Video showing side-by-side diff view

You would need to create an account with your email to use Bito. You can sign up for Bito directly from the IDE extension or the Bito web interface at .

1. After you install the Bito extension, click the "Sign up or Sign-in" button on the Bito sign-up flow screen.

1. In the next screen, enter your work email address, and verify through a six-digit code sent to your email address.

1. Once your email is verified, you will get an option to create your profile. Enter your full name and set the language for the AI setup. Bito uses this setting to generate the output regardless of prompt language.

Now, let's learn to start using Bito.

Prerequisites

To get started with Bito Wingman, ensure the following requirements are met:

1. Bito Team Plan:

   • Subscribe to the Bito Team Plan to unlock Bito Wingman along with all other premium features. For detailed pricing information, visit our Pricing page.

2. Install or update the VS Code extension:

   • Ensure you have Bito v1.4.7 or later installed in your VS Code editor.

   • The Bito Wingman will download automatically after you install or update the Bito IDE extension.

   • Once the download is complete, Wingman will prepare itself, and you'll be ready to use it.

How to use Bito Wingman?

Bito Wingman can be used in the following ways:

• Using Bito Wingman via IDE

• Using Bito Wingman via CLI

Using Bito Wingman via IDE

1. Open Bito Wingman:

   • Open Bito in your IDE and click on "Launch Bito Wingman" button from the Bito panel.

2. Start a session:

   • In the Wingman window, type your instructions in the chatbox and submit them.

3. Set or change the working directory:

   • Default Behavior:

     • If no project is open in the IDE, Wingman defaults to your home directory.

   • Set working directory:

     • Click "Select specific directory" to choose a working directory for a new session.

   • Change working directory:

     • For existing sessions, click the edit icon next to the folder path at the top of the Wingman screen.

     • Enter the complete path to your desired directory.

1. Manage sessions:

   • All active Wingman sessions are listed in the left sidebar.

   • You can run multiple sessions simultaneously, and Wingman will manage them in the background.

Using Bito Wingman via CLI

This section explains how to run Bito Wingman from the command line. The prerequisites are the same as above, and the CLI binary is installed automatically with the Bito IDE extension.

1. Locating the executable:

   • After installation, the Bito Wingman binary is located at:

     • <User home directory>/.bitowingman/bin

   • The executable file is named with the version number and target platform. For example:

     • macOS: bitowingman-1.0.9-darwin-arm64

     • Windows: bitowingman-1.0.9-win32-x64.exe

1. CLI usage modes:

   Bito Wingman supports two modes for interacting via the CLI:

   • Interactive mode (recommended): Interactive mode provides a chat-like interface for real-time command execution.

     • On macOS: ~/.bitowingman/bin/bitowingman-1.0.9-darwin-arm64 -i

     • On Windows (PowerShell): & "$env:USERPROFILE\.bitowingman\bin\bitowingman-1.0.9-win32-x64.exe" -i

     Note: After launching interactive mode, type help and press Enter to view the list of supported commands.

   • Non-interactive mode: Non-interactive mode allows you to execute a command directly and receive the results without entering a full session.

     • On macOS: ~/.bitowingman/bin/bitowingman-1.0.9-darwin-arm64 "run git diff and summarize the changes"

     • On Windows (PowerShell): & "$env:USERPROFILE\.bitowingman\bin\bitowingman-1.0.9-win32-x64.exe" "run git diff and summarize the changes"

Configuring tools in Wingman

Bito Wingman seamlessly integrates with various tools such as Jira, Linear, Confluence, and more. Click the "Tools" button in the top-right corner of the Wingman screen to view all supported tools.

1. To configure a tool, simply ask Wingman, "How do I configure [Tool Name]?"

2. Wingman will provide detailed step-by-step instructions. Follow the instructions to complete the configuration process.

3. If a tool requires an API token, Wingman will guide you through the process of obtaining it. Once you provide the token, Wingman will handle the configuration automatically.

bito config [flags]

• run bito config -l or bito config --list to list all config variables and values.

• run bito config -e or bito config --edit to open the config file in default editor.

Sample Configuration

bito:
 access_key: ""
 email: [email protected]
 
 preferred_ai_model: ADVANCED
settings:
 auto_update: true
 max_context_entries: 20

What is an Access Key and How to Get it?

Access Key is an alternate authentication mechanism to Email & OTP based authentication. You can use an Access Key in Bito CLI to access various functionalities such as Bito AI Chat. Here’s a guide on how to create an Access Key. Basically, after creating the Access Key, you have to use it in the config file mentioned above. For example, access_key: “YOUR_ACCESS_KEY_HERE”

Access Key can be persisted in Bito CLI by adding it in the config file using bito config -e. Such persisted Access Key can be over-ridden by running bito -k <access-key> or bito --key <access-key> for the transient session (sessions that last only for a short time).

Preferred AI Model Type

By default AI Model Type is set to ADVANCED and it can be overridden by running bito -m <BASIC/ADVANCED>. Model type is used for AI query in the current session. Model type can be set to BASIC or ADVANCED, which is case insensitive.

"ADVANCED" refers to AI models like GPT-4o, Claude Sonnet 3.5, and best in class AI models, while "BASIC" refers to AI models like GPT-4o mini and similar models.

When using Basic AI models, your prompts and the chat's memory are limited to 40,000 characters (about 18 single-spaced pages). However, with Advanced AI models, your prompts and the chat memory can go up to 240,000 characters (about 110 single-spaced pages). This means that Advanced models can process your entire code files, leading to more accurate answers.

If you are seeking the best results for complex tasks, then choose Advanced AI models.

To see how many Advanced AI requests you have left, please visit the Requests Usage page. On this page, you can also set hard and soft limits to control usage of Advanced AI model requests for your workspace and avoid unexpected expenses.

Also note that even if you have set preferred_ai_model: ADVANCED in Bito CLI config but your Advanced AI model requests quota is finished (or your self-imposed hard limit is reached) then Bito CLI will start using Basic AI models instead of Advanced AI models.

Parameters are the individual elements of a Large Language Model that are learned from the training data. Think of them as the synapses in a human brain—tiny connections that store learned information.

How Parameters Work in LLMs

Each parameter in an LLM holds a tiny piece of information about the language patterns the model has seen during training. They are the fundamental elements that determine the behavior of the model when it generates text.

For example, imagine teaching a child what a cat is by showing them pictures of different cats. Each picture tweaks the child's understanding and definition of a cat. In LLMs, each training example tweaks the parameters to better understand and generate language.

The Role of Parameters in Understanding and Generating Language

Parameters are crucial because they allow the model to perform tasks such as translation, write articles, and even generate source code. When you ask an AI a question, the parameters work together to sift through the learned patterns and generate a response that makes sense based on the training it received.

For instance, if you ask an AI to write a poem, the parameters will determine how to structure the poem, what words to use, and how to create rhyme or rhythm, all based on the data it was trained on.

The Scale of LLM Parameters: Just How Large Are We Talking?

When we say "Large" in LLM, we're not kidding. The size of a language model is directly related to the number of parameters it has.

Take GPT-4, for example, with its 1.76 trillion parameters. That's like 1.76 trillion different dials the model can tweak to get language just right. Each parameter holds a piece of information that can contribute to understanding a sentence's structure, the meaning of a word, or even the tone of a text.

Earlier models had significantly fewer parameters. GPT-1, for instance, had only 117 million parameters. With each new generation, the number of parameters has grown exponentially, leading to more sophisticated and nuanced language generation.

Training LLMs: How Parameters Learn

Training an LLM involves a process called "backpropagation" where the model makes predictions, checks how far off it is, and adjusts the parameters accordingly.

Let's say we're training an LLM to recognize the sentiment of a sentence. We show it the sentence "I love sunny days!" tagged as positive sentiment. The LLM predicts positive but isn't very confident. During backpropagation, it adjusts the parameters to increase the confidence for future similar sentences.

This process is repeated millions of times with millions of examples, gradually fine-tuning the parameters so that the model's predictions become more accurate over time.

Parameter’s Impact on AI Performance and Limitations

The number of parameters is one of the key factors influencing an AI model's performance. However, more parameters can mean a model requires more computational power and data to train effectively, which can lead to increased costs and longer training times.

With great power comes great responsibility—and greater chances of making mistakes. More parameters can sometimes mean that the model starts seeing patterns where there aren't any, a phenomenon known as "overfitting" where the model performs well on training data but poorly on new, unseen data.

The Future of Parameters in LLMs

The future of LLMs might not just be about adding more parameters, but also about making better use of them. Innovations in how parameters are structured and how they learn are ongoing.

AI researchers are exploring ways to make LLMs more parameter-efficient, meaning they can achieve the same or better performance with fewer parameters. Techniques like "parameter sharing" and "sparse activation" are part of this cutting-edge research.

Conclusion

Parameters in LLMs are the core elements that allow these models to understand and generate human-like text. While the sheer number of parameters can be overwhelming, it's their intricate training and fine-tuning that empower AI to interact with us in increasingly complex ways.

As AI continues to evolve, the focus is shifting from simply ramping up parameters to refining how they're used, ensuring that the future of AI is not just smarter but also more efficient and accessible.

Speed up code reviews by configuring the AI Code Review Agent with your GitLab repositories. In this guide, you'll learn how to set up the Agent to receive automated code reviews that trigger whenever you create a pull request, as well as how to manually initiate reviews using available commands.

Video tutorial

Coming soon...

Prerequisites

Before proceeding, ensure you've completed all necessary prerequisites.

1. Create a GitLab Personal Access Token:

For GitLab merge request code reviews, a token with api scope is required. Make sure that the token is created by a GitLab user who has the Maintainer access role.

View Guide

2. Authorizing a GitLab Personal Access Token for use with SAML single sign-on:

If your GitLab organization enforces SAML Single Sign-On (SSO), you must authorize your Personal Access Token through your Identity Provider (IdP); otherwise, Bito's AI Code Review Agent won't function properly.

For more information, please refer to these GitLab documentation:

• https://docs.gitlab.com/ee/user/group/saml_sso/

• https://docs.gitlab.com/ee/integration/saml.html

• https://docs.gitlab.com/ee/integration/saml.html#password-generation-for-users-created-through-saml

Installation and configuration steps

Follow the step-by-step instructions below to install the AI Code Review Agent using Bito Cloud:

Step 1: Log in to Bito

Log in to Bito Cloud and select a workspace to get started.

Step 2: Open the Code Review Agents setup

Click Repositories under the CODE REVIEW section in the sidebar.

Step 3: Select your Git provider

Bito supports integration with the following Git providers:

• GitHub

• GitHub (Self-Managed)

• GitLab

• GitLab (Self-Managed)

• Bitbucket

Since we are setting up the Agent for GitLab, select GitLab to proceed.

Step 4: Connect Bito to GitLab

To enable merge request reviews, you’ll need to connect your Bito workspace to your GitLab account.

You can either connect using OAuth (recommended) for a seamless, one-click setup or manually enter your Personal Access Token.

To connect via OAuth, simply click the Connect with OAuth (Recommended) button. This will redirect you to the GitLab website, where you'll need to log in. Once authenticated, you'll be redirected back to Bito, confirming a successful connection.

If you prefer not to use OAuth, you can connect manually using a Personal Access Token.

Start by generating a Personal Access Token with api scope in your GitLab account. For guidance, refer to the instructions in the Prerequisites section.

Once generated, click the Alternatively, use Personal or Group Access Token button.

Now, enter the token into the Personal Access Token input field in Bito.

Click Validate to ensure the token is functioning properly.

If you've successfully connected via OAuth or manually validated your token, you can select your GitLab Group from the dropdown menu.

Click Connect Bito to GitLab to proceed.

Step 5: Enable AI Code Review Agent on repositories

After connecting Bito to your GitLab account, you need to enable the AI Code Review Agent for your repositories.

Click the Go to repository list button to view all repositories Bito can access in your GitLab account.

Use the toggles in the Code Review Status column to enable or disable the Agent for each repository.

Step 6: Automated and manual merge request reviews

Once a repository is enabled, you can invoke the AI Code Review Agent in the following ways:

1. Automated code review: By default, the Agent automatically reviews all new merge requests and provides detailed feedback.

2. Manually trigger code review: To initiate a manual review, simply type /review in the comment box on the merge request and submit it. This action will start the code review process.

The AI-generated code review feedback will be posted as comments directly within your merge request, making it seamless to view and address suggestions right where they matter most.

Step 7: Specialized commands for code reviews

Bito also offers specialized commands that are designed to provide detailed insights into specific areas of your source code, including security, performance, scalability, code structure, and optimization.

• /review security: Analyzes code to identify security vulnerabilities and ensure secure coding practices.

• /review performance: Evaluates code for performance issues, identifying slow or resource-heavy areas.

• /review scalability: Assesses the code's ability to handle increased usage and scale effectively.

• /review codeorg: Scans for readability and maintainability, promoting clear and efficient code organization.

• /review codeoptimize: Identifies optimization opportunities to enhance code efficiency and reduce resource usage.

By default, the /review command generates inline comments, meaning that code suggestions are inserted directly beneath the code diffs in each file. This approach provides a clearer view of the exact lines requiring improvement. However, if you prefer a code review in a single post rather than separate inline comments under the diffs, you can include the optional parameter: /review #inline_comment=False

For more details, refer to Available Commands.

Step 8: Chat with AI Code Review Agent

Ask questions directly to the AI Code Review Agent regarding its code review feedback. You can inquire about highlighted issues, request alternative solutions, or seek clarifications on suggested fixes.

To start the conversation, type your question in the comment box within the inline suggestions on your merge request, and then submit it. Typically, Bito AI responses are delivered in about 10 seconds. On GitHub and Bitbucket, you need to manually refresh the page to see the responses, while GitLab updates automatically.

Bito supports over 20 languages—including English, Hindi, Chinese, and Spanish—so you can interact with the AI in the language you’re most comfortable with.

Screenshots

Screenshot # 1

Screenshot # 2

Screenshot # 3

Bito Wingman is an AI coding agent designed to revolutionize the way you build software. Unlike traditional code assistants or autocomplete tools, Wingman acts as a virtual developer on your team capable of handling complex coding tasks from start to finish, with direction from you. Much of Bito Wingman was built by Bito Wingman.

Wingman understands high-level instructions, breaks them into actionable steps, researches relevant information, and executes tasks autonomously.

Wingman can handle everything from code generation to managing Jira tickets and updating files. It deeply understands your code, excels at reasoning and planning to handle complex tasks, and has access to apps such as file operations, Jira, Linear, Confluence, GitHub, GitLab, and many more.

AI in its purest form frees us up to work much more iteratively and on many things at one time. But you need tools that work that way too. Wingman is designed to be nimble to meet your work habits, from the browser to your local IDE. Run as many tasks as you have browser tabs open. Work in your IDE too. Switch back and forth. It’s all possible with your Wingman.

Example instructions for Wingman

Here are some real-world examples of tasks you can ask Wingman to handle, from coding and documentation to building and testing.

• “Review jira ticket AI-5623, write the code, update the necessary files, and commit it. Mark the ticket as in testing”

• “Document my repo and upload it to confluence. Please be sure to highlight the major modules and the key dependencies. Diagram out the system architecture in mermaid.”

• “Update my build script, then build and run my code”

What can Wingman do?

• Write code: Generate high-quality, context-aware code to implement features, fix bugs, or even start entire projects from scratch.

• Plan and execute: Understand your objectives, break them into smaller steps, and manage execution intelligently.

• Research on demand: Use web browsing capabilities to gather information, research APIs, or solve challenges in real time.

• Automate repetitive tasks: Handle the grunt work, from generating boilerplate code to managing Jira tickets and updating files.

• Integrate seamlessly: Work across popular tools like Jira, Linear, Confluence, and more to fit right into your workflow.

• Collaborate intelligently: Act as an AI pair programmer, offering proactive suggestions, reasoning about solutions, and scaling alongside your team’s needs.

How does Wingman work?

Wingman uses a combination of large language models, planning algorithms, and integrations with your favorite tools to deliver results. When you give Wingman an instruction, it:

• Understands: Processes the intent behind your high-level request.

• Plans: Breaks down the task into actionable steps with a clear roadmap.

• Researches: Fetches relevant information if needed, such as documentation or examples.

• Executes: Writes, tests, and manages code or other assets to complete the task end-to-end.

Why use Bito Wingman?

• Save time: Offload tedious and repetitive tasks, freeing you to focus on creative and strategic aspects of development.

• Increase productivity: Tackle more in less time with an AI developer that handles projects autonomously. Many developers on our own team report being 50% to 300% more productive.

• Boost quality: Generate clean, functional code with minimal errors thanks to Wingman’s intelligent reasoning.

• Seamless collaboration: Work smarter with an AI assistant that integrates with your workflow and scales with your team.

Pricing details

Bito Wingman is available to use as part of our Team Plan. For detailed pricing information, visit our Pricing page.

Learn more

• Getting started

• Supported tools

How many repositories can Bito index?

Bito can index unlimited repositories for workspaces that have subscribed to our Team Plan. This feature is also coming soon for our Free Plan. But it will be limited to 10MB maximum indexable size of repository.

Why is the index creation taking a long time?

Bito takes time to thoroughly read your entire repository and understand it. This is completely normal. If your repository is a bit large, then it can take several hours to get indexed.

Bito usually takes around 12 minutes per each 10MB of code to understand your repo.

Why is the answer not complete?

There is a limit on the amount of memory/context that can be used at a time to answer the question, so the answers sometimes may not cover all the code. To solve for this, restrict the questions by providing additional criteria like:

• In my code explain message_tokens in ai/request.js

Where can I see the status of my Index?

Open your project in VS Code or JetBrains IDEs. From the Bito plugin pane, click the laptop icon located in the top-right corner.

On this tab, you will see the status of your current project as well as the status of any other project that you indexed previously.

What happens if my IDE got closed while indexing is in progress?

In case you close the Visual Studio Code or JetBrains IDE (e.g., PyCharm) while the indexing is in progress then don’t worry. The indexing will be paused and will automatically continue from where it left off when you reopen the IDE. Currently, the indexing will resume 5-10 minutes after reopening the IDE.

How to delete project index from IDE?

1. To delete an index, navigate to the "Manage repos" tab.
2. Next, click on the three dots button located in front of your project’s name, and then select the "Delete" option.
3. A warning popup box will appear at the bottom of Bito's plugin pane. You can choose to click the "Delete" button to remove the project's index from your system, or click the "Cancel" button to go back.

How to fix indexing issues in Visual Studio Code and JetBrains IDEs (e.g., IntelliJ IDEA, PyCharm, etc.)?

If for some reason you are struggling to index your project’s folder while using Visual Studio Code or JetBrains IDEs, then follow the below steps to delete the folder that contains all the indexes and try to re-index your project.

1. Close all JetBrains IDEs and VS Code instances where Bito is installed.

2. Go to your users directory. For example, on Windows it will be something like C:\Users\<your username>

3. Now, find .bito folder and delete it. (Note: All configuration settings and project indexes created by Bito will be deleted. You will also be logged out from Bito IDE plugin)

1. Once you have deleted the .bito folder, open your project in the IDE again.

2. After restarting the IDE, you will need to enter your email ID and a 6-digit code to log in. Once you're logged in, select the workspace that has an active paid subscription.

3. After that, when Bito asks if you wish to index the folder, you can select "Maybe later".

4. Then, navigate to the "Manage repos" tab in the Bito plugin pane, where you should see the folder name listed under the "Current project" along with its size, indicating that it is not indexed. Since you have deleted the .bito folder, the "Other projects" section will no longer display any entries.

5. Finally, click on "Start Indexing" and it should begin indexing the folder.

🤯 Sick of typing out long prompts every time? 😩 Bito's got your back! Now, create custom prompt templates for all your frequently used prompts and save yourself some stress.

With "Create Prompt Template," you can create and save custom prompt templates for use in your IDE. By defining a custom template with a template name and prompt, Bito can execute the prompt as is on the selected code. With this feature, you can save time and streamline your workflow by quickly executing frequently used prompts without inputting them manually each time.

The custom prompt templates feature and standard prompt templates are located below the chatbox.

Here is a quick overview of the Custom Prompt Templates in Bito

Creating a Custom Prompt Template

1. Open Bito Plugin in your IDE

2. Below the chatbox, click on "New Template".

1. Enter the "Template Name" and "Prompt" for your custom template. You can use {{%code%}} as a macro to insert the selected code in your prompt. If this macro is not used, Bito will insert the selected code at the end of your prompt. Next, select the "Output Format". You currently have two options:

   1. Display in Bito panel (Default)

   2. Output in diff view

1. Click on "Create Template" to save your new custom template. All custom templates will appear below the chatbox alongside standard templates. You can create up to four custom templates.

Editing or Deleting a Custom Template

You can edit or remove the templates anytime by clicking on the three dots over the template that you want to edit or remove. Note that you can edit or remove the standard templates provided by Bito.

Using a Custom Template

1. Select any code that you want to execute the prompt.

2. Run the Custom Template by clicking it in the Bito Templates panel or from the IDE context menu.

3. Bito starts generating output

Here’s an example of how to execute prompts using your custom templates.

Let’s say you want to create a custom template to add a comment describing the logic behind the code. Here's how you can do it:

1. Below the chatbox, click on "New template".

2. Enter a name for your custom template, e.g. "Add Comment"

3. In the "Prompt" field, enter the following: "Please add a comment describing the logic behind the code. " and then click on "Create Template" to save your new custom template

1. Now, select the code to which you want to comment and click on the "Add Comment" template.

1. Bito adds the selected code at the end of the prompt and executes it via Bito AI.

Generating the best possible response is as much science as art. The Bito AI models are built on the same technology as ChatGPT handles the science part. Crafting a good prompt is the art part. The Templates in Bito takes the burden off your shoulder in being crafty. You can select a piece of code and use one of the eight prompts, whether you want to check the code for performance or add error handling. Behind-the-scene actor "Bito Prompt Manager" crafts a well-versed prompt that squeezes the best response out of the machine. You can also save your favorite prompts for quick access anytime. Check out Custom Prompt Templates.

Templates are accessible:

1- In the Bito panel

Click on the Templates button to expand or collapse Templates menu.

2- Using Slash / Command in Bito Chat Box

Type a forward slash / right at the start in the Bito chat box. Once you do, the template menu will open from where you can quickly select and use the template you want.

Want to narrow down your choices? Simply start typing after the / slash, and it'll only show you templates that match your words. And hey, you can also use the arrow keys, or Tab and Shift + Tab, to navigate the templates menu.

3- From the Code Editor's Context Menu

Select code, right click, and click Bito AI to access shortcuts

4- Through the Command Palette in Visual Studio Code

Go to View -> Command Palette -> Type "Bito" to access the templates

The following Loom demonstrates Standard Templates in Bito:

Bito includes the following standard templates out of the box.

AI Code Completions are disabled by default. To enable them follow the steps below.

VS Code

1. Click the gear icon at the bottom left of the VS Code window. Then select “Settings” to open the main settings page.

1. From the settings sidebar, click on "Text Editor" and then select "Suggestions". Now, on the right-side, tick the checkbox given in front of "Inline Suggest: Enabled" option. Please note that if this option is disabled then Bito's AI Code Completions functionality will not work.

1. In the search bar, type "bito" and then from the sidebar click on "Bito" under "Extensions" to access the Bito extension settings.

1. Here you will see three options that can be configured. These are:

   1. Enable Auto Completion: Tick this checkbox to enable inline code suggestion in the editor. Uncheck it to disable this feature.

   2. Enable Comment to Code: Tick this checkbox to enable generating code from comment in the editor. Uncheck it to disable this feature.

   3. Set Auto Completion Trigger Logic: Decide how fast Bito makes suggestions by setting your preferred pause time. This input field allows you to set the pause time in milliseconds. Lower values make suggestions more often. Minimum and default value is 250 milliseconds.

JetBrains IDEs (e.g. IntelliJ IDEA, WebStorm, PyCharm, etc.)

1. Click the gear icon at the top right of the JetBrains IDE window, then select "Settings" to open the main settings window.
2. Now, in the sidebar click on "Tools" and then click "Bito" to access the Bito extension settings.
3. Here you will see three options that can be configured. These are:

   1. Enable Auto Completion: Tick this checkbox to enable inline code suggestion in the editor. Uncheck it to disable this feature.

   2. Enable Comment to Code: Tick this checkbox to enable generating code from comment in the editor. Uncheck it to disable this feature.

   3. Set Auto Completion Trigger Logic: Decide how fast Bito makes suggestions by setting your preferred pause time. This input field allows you to set the pause time in milliseconds. Lower values make suggestions more often. Minimum and default value is 250 milliseconds.

1. After doing all of the above steps, you must click on "Apply" and then "OK" button to save your changes. Otherwise, your modifications will be lost.

Speed up code reviews by configuring the with your Bitbucket repositories. In this guide, you'll learn how to set up the Agent to receive automated code reviews that trigger whenever you create a pull request, as well as how to manually initiate reviews using .

Video tutorial

Coming soon...

Prerequisites

Before proceeding, ensure you've completed all necessary prerequisites.

1. Create a Bitbucket App Password:

For Bitbucket pull request code reviews, you’ll need to connect your Bito workspace to your Bitbucket account.

Start by . App Passwords allow apps like Bito to access your Bitbucket account. Make sure that the App Password is created by a Bitbucket user who has the Admin access role to the repositories.

Ensure the required permissions are checked:

• Under Account, select Read.

• Under Pull requests, select Write.

• Under Webhooks, select Read and write.

Installation and configuration steps

Follow the step-by-step instructions below to install the AI Code Review Agent using Bito Cloud:

Step 1: Log in to Bito

and select a workspace to get started.

Step 2: Open the Code Review Agents setup

Click under the CODE REVIEW section in the sidebar.

Step 3: Select your Git provider

Bito supports integration with the following Git providers:

• GitHub

• GitHub (Self-Managed)

• GitLab

• GitLab (Self-Managed)

• Bitbucket

Since we are setting up the Agent for Bitbucket, select Bitbucket to proceed.

Step 4: Connect Bito to Bitbucket

To enable pull request reviews, you’ll need to connect your Bito workspace to your Bitbucket account.

Start by . App Passwords allow apps like Bito to access your Bitbucket account. Make sure that the App Password is created by a Bitbucket user who has the Admin access role to the repositories.

Ensure the required permissions are checked:

• Under Account, select Read.

• Under Pull requests, select Write.

• Under Webhooks, select Read and write.

For guidance, refer to the instructions in the section.

Once generated, enter your Bitbucket username and App password into the input fields in Bito.

Click Authorize to ensure the login credentials are working correctly.

If the credentials are successfully authorized, you can select your Bitbucket workspace from the dropdown menu.

Click Connect Bito to Bitbucket to proceed.

Step 5: Enable AI Code Review Agent on repositories

After connecting Bito to your Bitbucket account, you need to enable the AI Code Review Agent for your repositories.

Click the Go to repository list button to view all repositories Bito can access in your Bitbucket account.

Use the toggles in the Code Review Status column to enable or disable the Agent for each repository.

Step 6: Automated and manual pull request reviews

Once a repository is enabled, you can invoke the AI Code Review Agent in the following ways:

1. Automated code review: By default, the Agent automatically reviews all new pull requests and provides detailed feedback.

2. Manually trigger code review: To initiate a manual review, simply type /review in the comment box on the pull request and click Add comment now to submit it. This action will start the code review process.

The AI-generated code review feedback will be posted as comments directly within your pull request, making it seamless to view and address suggestions right where they matter most.

Step 7: Specialized commands for code reviews

Bito also offers specialized commands that are designed to provide detailed insights into specific areas of your source code, including security, performance, scalability, code structure, and optimization.

• /review security: Analyzes code to identify security vulnerabilities and ensure secure coding practices.

• /review performance: Evaluates code for performance issues, identifying slow or resource-heavy areas.

• /review scalability: Assesses the code's ability to handle increased usage and scale effectively.

• /review codeorg: Scans for readability and maintainability, promoting clear and efficient code organization.

• /review codeoptimize: Identifies optimization opportunities to enhance code efficiency and reduce resource usage.

By default, the /review command generates inline comments, meaning that code suggestions are inserted directly beneath the code diffs in each file. This approach provides a clearer view of the exact lines requiring improvement. However, if you prefer a code review in a single post rather than separate inline comments under the diffs, you can include the optional parameter: /review #inline_comment=False

For more details, refer to .

Step 8: Chat with AI Code Review Agent

Ask questions directly to the AI Code Review Agent regarding its code review feedback. You can inquire about highlighted issues, request alternative solutions, or seek clarifications on suggested fixes.

To start the conversation, type your question in the comment box within the inline suggestions on your pull request, and then submit it. Typically, Bito AI responses are delivered in about 10 seconds. On GitHub and Bitbucket, you need to manually refresh the page to see the responses, while GitLab updates automatically.

Bito supports over 20 languages—including English, Hindi, Chinese, and Spanish—so you can interact with the AI in the language you’re most comfortable with.

Screenshots

Screenshot # 1

Screenshot # 2

Screenshot # 3

Prerequisites

• Bito Access Key: Obtain your Bito Access Key.

• GitHub Personal Access Token (Classic): For GitHub PR code reviews, ensure you have a CLASSIC personal access token with repo access. We do not support fine-grained tokens currently.

Installation and Configuration Steps:

1. Enable GitHub Actions:

   • Login to your account.

   • Open your repository and click on the "Settings" tab.

   • Select "Actions" from the left sidebar, then click on "General".

   • Under "Actions permissions", choose "Allow all actions and reusable workflows" and click "Save".

2. Set Up Environment Variables:

   • Still in the "Settings" tab, navigate to "Secrets and variables" > "Actions" from the left sidebar.

   • Configure the following under the "Secrets" tab:

     For each secret, click the New repository secret button, then enter the exact name and value of the secret in the form. Finally, click Add secret to save it.

     • Name: BITO_ACCESS_KEY

       • Secret: Enter your Bito Access Key here. Refer to the .

     • Name: GIT_ACCESS_TOKEN

       • Secret: Enter your GitHub Personal Access Token (Classic) with repo access. We do not support fine-grained tokens currently. For more information, see the section.

• Configure the following under the "Variables" tab:

  For each variable, click the New repository variable button, then enter the exact name and value of the variable in the form. Finally, click Add variable to save it.

  • Name: STATIC_ANALYSIS_TOOL

    • Value: Enter the following text string as value: fb_infer,astral_ruff,mypy

  • Name: GIT_DOMAIN

    • Value: Enter the domain name of your Enterprise or self-hosted GitHub deployment or skip this if you are not using Enterprise or self-hosted GitHub deployment.

    • Example of domain name: https://your.company.git.com

  • Name: EXCLUDE_BRANCHES

    • Value: Specify branches to exclude from the review by name or valid glob/regex patterns. The agent will skip the pull request review if the source or target branch matches the exclusion list.

    • Note: For more information, see .

  • Name: EXCLUDE_FILES

    • Value: Specify files/folders to exclude from the review by name or glob/regex pattern. The agent will skip files/folders that match the exclusion list.

    • Note: For more information, see .

  • Name: EXCLUDE_DRAFT_PR

    • Value: Enter True to disable automated review for draft pull requests, or False to enable it.

    • Note: For more information, see .

1. Create the Workflow Directory:

   • In your repository, create a new directory path: .github/workflows.

2. Add the Workflow File:

   • from AI Code Review Agent's GitHub repo.

   • In your repository, upload this test_cra.yml file inside the .github/workflows directory either in your source branch of each PR or in a branch (e.g. main) from which all the source branches for PRs will be created.

   • Commit your changes.