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 we do not store any code, code snippets, indexes or embedding vectors on Bito’s servers unless you expressly allow it. You decide where you want to store your code, either locally on your machine, in your cloud, or on Bito’s cloud. 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]

AI Architect is a full engineering workflow platform built around a knowledge graph of your codebase, business context, tribal knowledge, docs, tickets, and observability data. It operates across three solution areas — technical design & scoping, grounded coding, and code review — surfacing system-level intelligence at every stage of development.

This page covers the core features that power those workflows.

Knowledge graph

The knowledge graph is the context engine at the core of AI Architect. It ingests your codebase, Git history, issue tracker data (Jira, Linear), documentation (Confluence), observability signals, and Slack conversations into a unified, continuously updated graph.

Rather than treating your codebase as searchable text, the knowledge graph models the relationships between services, APIs, dependencies, past decisions, and recurring incident patterns — capturing how your system actually fits together.

This shared context powers every capability in AI Architect. When an agent runs a feasibility analysis, generates a technical design, or reviews a pull request, it draws from the same knowledge graph — so output is grounded in your real architecture, not generic patterns.

The knowledge graph also enables cross-repo reasoning: it understands blast radius, tracks instability histories, and connects a Jira incident from six months ago to the service a developer is about to change today.

Learn more

Supported integrations

AI Architect connects to the tools your team already uses across planning, coding, review, and communication.

• Jira is the primary surface for technical design and scoping. AI Architect listens for new or updated Epics and Stories, posts implementation plans as ticket comments, and can be triggered on demand via @bito in any comment. Plans include feasibility assessments, story breakdowns, effort estimates, and risk flags — all grounded in your knowledge graph.

• Slack brings AI Architect into team discussions. Mention @Bito in any channel thread and the assistant reads the full conversation context, resolves referenced Jira tickets and Confluence pages, and responds with context-aware answers, task breakdowns, or implementation plans — directly in the thread.

• Coding agents connect to AI Architect via MCP (Model Context Protocol). A one-command installer automatically configures all supported tools detected on your system. Supported agents include Claude Code, Cursor, Windsurf, GitHub Copilot (VS Code), Junie, and JetBrains AI Assistant. Once connected, Agent Skills are available inside each tool, giving developers access to the full knowledge graph while they build.

• Chat agents — including Claude.ai (Web & Desktop) and ChatGPT (Web & Desktop) — can also be connected to AI Architect via MCP for codebase-aware conversational assistance outside of a dedicated coding environment.

• Bito's AI Code Review Agent integrates with AI Architect to bring knowledge graph context into every pull request review across GitHub, GitLab, and Bitbucket. Reviews go beyond the diff — they include cross-repo impact analysis, architectural consistency checks, and blast radius detection, catching issues before they reach production.

Auto triage

When auto-analysis is enabled for Jira, AI Architect evaluates every new or updated Epic and Story before generating an implementation plan. It reads the full ticket — title, description, comments, attachments, and any linked Confluence pages — and assigns a complexity score from 1 to 10. Implementation plans are only generated for tickets that meet or exceed the complexity threshold (default: 7). Tickets below the threshold receive a short note explaining why a plan was skipped, along with a prompt to request one manually if needed.

This keeps your ticket history clean and ensures that AI Architect's output is directed at the work that actually benefits from it — complex, ambiguous, or cross-cutting changes — rather than straightforward tasks that engineers can act on immediately.

Learn more

Flexible trigger

AI Architect can be invoked in two ways: automatically when a ticket is created or updated, or on demand by any team member. On-demand triggering is done by commenting @bito, /bito, or #bito directly on the Jira ticket, or by adding a bito, bito-analyse, or bito-analyze label.

The same comment syntax also works for follow-up requests — you can ask AI Architect to revise its analysis, focus on a specific aspect, or regenerate the plan after requirements change.

This gives teams full control over when AI Architect runs. You can start with on-demand mode to evaluate output quality on specific tickets, then graduate to automatic analysis once you're confident in the results.

Learn more

Iterative refinement

Requirements rarely stay fixed. AI Architect supports iterative refinement by generating new versions of any artifact — technical designs, scope breakdowns, feasibility assessments — as the ticket evolves. As engineers update descriptions, add comments, or link new context, they can re-trigger AI Architect to produce a revised plan that reflects the current state of the work.

This means technical planning stays in sync with changing requirements without manual rework. Each iteration builds on the ticket's full history, so AI Architect understands what has changed and why.

Learn more

Custom templates

By default, AI Architect formats its output using Bito's standard structure. Custom templates let you override that with your team's own format — whether that's a specific TDD layout, an internal RFC structure, or a planning format tied to your sprint process. Output then matches what your engineers expect to see and what your workflow tooling can consume.

Custom templates are configured per workspace. To get started, contact the Bito team at [email protected].

Custom prompts

AI Architect supports free-form prompting directly inside the Jira ticket, coding agents, or Slack. Engineers can mention Bito followed by a question/instruction in natural-language, such as:

In Jira:

• @bito analyze technical feasibility

• @bito focus on database migration risk

• @bito write this as a spike document

• @bito break this into frontend and backend workstreams

In Slack:

• @Bito PROJ-456 is causing errors in production — here are the logs. Identify the root cause?

• @Bito help us break this feature into smaller tasks

• @Bito explain the difference between these two approaches

• @Bito what are the action items from this thread?

• @Bito review the code changes in this thread and suggest improvements

In coding agents:

Open a chat or conversation in your AI tool and try a test query to confirm AI Architect is working:

• "What repositories are available in my organization?"

• "Show me all Python repositories"

• "List the available tools"

• "What are the dependencies of [repo-name]?"

• "Find all microservices using Redis"

• "Show me repository clusters in our organization"

• "Plan a new feature for [component]"

  • (uses bito-feature-plan skill)

• "Write a PRD for [feature]"

  • (uses bito-prd skill)

• "Help me triage this production issue"

  • (uses bito-production-triage skill)

Custom prompts work alongside the knowledge graph context AI Architect already has. You're directing the output, not replacing the grounding.

Web research

AI Architect can pull external technical context alongside your internal knowledge graph when generating plans. When web research is enabled, it incorporates relevant industry patterns, library documentation, and external best practices into its analysis — useful for greenfield work, third-party integrations, or areas where your codebase doesn't yet have established patterns.

Web research is applied selectively. It supplements internal context rather than replacing it, so the output remains grounded in your actual system.

Slack agent

The Bito AI Assistant brings AI Architect directly into Slack. You can ask system-level questions, trigger implementation plans, iterate on technical designs, and triage production issues — all without leaving the channel where the discussion is already happening. Mention @Bito in any thread, and the assistant reads the full conversation context, including any referenced Jira tickets or Confluence pages, before responding.

Common use cases include summarizing long planning threads, generating task breakdowns from a discussion, and pulling context from a specific ticket mid-conversation. The Slack agent is available in both public and private channels and supports file attachments including code files, configs, and logs.

Learn more

Agent skills

Agent Skills are structured instruction files that define how AI Architect approaches specific engineering tasks. Each skill is purpose-built for a different type of work: feasibility analysis, epic planning, spike investigations, production triage, PRD or TRD generation, pre-commit reviews, and more. Skills can be triggered in Jira and Slack by commenting with natural language (@bito is this feasible?, @bito turn this epic into tasks), or invoked directly inside your coding agent via MCP.

Skills have full access to your knowledge graph — codebase, Jira history, Confluence docs, and observability data — so their output is always grounded in how your system actually works, not a generic template. In coding agents, skills are installed automatically and discoverable via / in the chat interface.

Learn more

Detailed agent specs

After a technical plan is approved, AI Architect can transform it into self-contained workstream agent specs — structured documents that give a coding agent everything it needs to implement a single workstream without further clarification. Each spec includes file paths, relevant patterns from your codebase, verification gates, and a dependency contract describing what other workstreams it relies on or produces.

Agent specs are designed to be passed directly into Cursor, Claude Code, Codex, or any MCP-compatible coding agent. They eliminate the back-and-forth between planning and implementation by encoding architectural decisions into the spec itself.

Learn more

Automated implementation

Once a workstream plan is approved, AI Architect can execute it directly. It creates a new branch from your default branch, implements the code changes across the relevant repositories, and follows the patterns and conventions already present in your codebase. Implementation is guided by the agent spec, with verification gates checked at each step.

This capability is available via the bito-agent-spec-executor skill in your connected coding agent. It is designed for well-scoped workstreams with clear acceptance criteria and works best when paired with the detailed agent spec output.

Learn more

Automated pull request creation

After implementation is complete, AI Architect opens a pull request per workstream, linked back to the originating Jira ticket. PRs include a summary of the changes made, the workstream spec they were generated from, and any verification results from the implementation run. This closes the loop between planning and review, giving engineers and reviewers immediate context on what was built and why.

Automated PRs work across GitHub, GitLab, and Bitbucket. They follow your existing branch naming and PR conventions.

Learn more

Single Sign-On (SSO)

SSO integration lets your team authenticate with AI Architect through your organization's existing identity provider instead of managing shared access tokens. When someone joins or leaves, access is granted or revoked through the same system that controls their email, Slack, and other business tools — no separate credential rotation required.

AI Architect's SSO implementation supports a broad range of identity providers including Google Workspace, Okta, Azure Entra ID, Microsoft AD FS, Auth0, Keycloak, and others, as well as any custom SAML 2.0 or OIDC configuration.

For self-hosted deployments, SSO runs entirely on-premises — no authentication traffic leaves your environment except for identity provider federation (if Enterprise IdP is configured) and Bito API calls for SSO configurations.

Session duration, refresh token TTL, and concurrent session limits are all configurable per workspace.

Learn moreSSO for self-hosted deployments

Quick reference for bitoarch CLI commands used to configure and manage Bito's AI Architect.

Lifecycle

Commands used to control the lifecycle of AI Architect.

Examples:

AI Architect management commands

Use these bitoarch commands to manage AI Architect.

Core operations

Examples:

Repository management

Examples:

Service operations

Examples:

Configuration

Config file types:

Examples:

MCP operations

Examples:

SSO authentication

SSO is optional and disabled by default (bearer-token auth). When enabled, bitoarch mcp-info reflects the active auth mode.

Auth modes:

Output options

Add these flags to any command:

Common workflows

Initial setup

Daily operations

Adding new repositories

Credential rotation

Tear-down

Troubleshooting

Getting help

Examples:

Environment

Configuration is loaded from .env-bitoarch file. (path: bitoarch config path env)

Key variables:

Version

Check CLI version:

Bito's AI Architect plugin brings cross-repository intelligence to Claude Code. Search code, explore dependencies, analyze architecture, and discover patterns across all your organization's repositories. Use it to build implementation plans, write requirements documents, diagnose production issues, and understand complex codebases.

It enables users to explore and understand any codebase — from high-level architecture to line-level code traces — calibrated for multiple personas (Developer, EM, PM, VP, CTO).

Key capabilities:

• Deep codebase exploration across multiple repositories

• AI-powered architecture analysis and documentation

• Production incident triage with blast radius mapping

• Feature planning grounded in real system context

Installation

Step 1: Add the marketplace

Run this command in Claude Code:

Step 2: Install the plugin

Step 3: Configure your credentials

Run the interactive setup:

This command guides you through configuring your workspace ID, bearer token, and email.

Alternative: manual configuration

Set these environment variables manually:

After configuration, restart Claude Code and run /mcp to verify the server is connected.

Available commands

Once installed, access these slash commands in Claude Code:

Getting started

Explore a codebase

Use the codebase explorer to understand any repository:

The explorer uses a 4-phase workflow to analyze architecture, dependencies, and code patterns. Choose your persona (Developer, EM, PM, VP, CTO) to get insights calibrated to your role.

Plan a feature

Create an implementation plan with cross-repo context:

The plugin analyzes your codebase to identify affected components, dependencies, and potential conflicts.

Triage production issues

Diagnose incidents across repositories:

Get cross-repo context and blast radius mapping to understand the full impact of production issues.

GitHub repository

• https://github.com/gitbito/claude-plugins

Enhance your code reviews with deeper codebase intelligence by connecting Bito's AI Code Review Agent to AI Architect. This integration enables significantly more accurate and context-aware reviews by leveraging the comprehensive knowledge graph that AI Architect builds from your codebase.

What this integration provides

When AI Code Review Agent accesses AI Architect's knowledge graph, it gains a complete understanding of your codebase architecture — including microservices, modules, APIs, dependencies, and design patterns.

This enhanced context allows the AI Code Review Agent to:

• Provide system-aware code reviews - Understand how changes in one service or module impact other parts of your system

• Catch architectural inconsistencies - Identify when new code doesn't align with your established patterns and conventions

• Detect cross-repository issues - Spot problems that span multiple repositories or services

• Deliver more accurate suggestions - Generate fixes that are grounded in your actual codebase structure and usage patterns

• Reduce false positives - Better understand context to avoid flagging valid code as problematic

Setup instructions

Follow these steps to connect AI Architect with AI Code Review Agent:

1. Log in to Bito Cloud

2. Open the AI Architect Settings dashboard.

3. In the Server URL field, enter your Bito MCP URL

4. In the Auth token field, enter your Bito MCP Access Token

Need help?

Contact our team at [email protected] to request a trial. We'll help you configure the integration and get your team up and running quickly.

AI Architect's MCP server provides a comprehensive suite of tools for exploring, analyzing, and understanding your organization's codebase. These tools enable AI coding assistants to access deep repository intelligence, architectural insights, and code-level information across all your Git repositories.

Below is the complete list of MCP tools provided by AI Architect:

Bito's Knowledge graph is the context engine behind Bito's AI Architect that captures your entire engineering system. It ingests your codebase, business context, and tribal knowledge into a unified graph, giving AI and dev tools a shared understanding of the system.

This always-updated graph powers smarter planning, grounded code generation, and faster problem-solving across a variety of tools, including:

• Issue trackers (Jira, Linear)

• Coding agents (Claude Code, Cursor, etc.)

• Code reviews (GitHub, GitLab, Bitbucket)

• Team communication (Slack)

The knowledge graph is great at answering questions like "What will be affected if we change Service A?" or "Have we seen this issue before?" without manual research.

Table of contents

1. How the knowledge graph is built

2. Capabilities enabled by the knowledge graph

3. How the knowledge graph differs from other AI tools

4. Why the knowledge graph matters

How the knowledge graph is built

The knowledge graph ingests data from multiple sources to form a complete context layer.

The following sources are fed into Bito's indexing pipeline, which scans and parses each type of data to populate the knowledge graph.

• Code and commits history: All source code (microservices, libraries, modules) and Git history (commits, branches). The graph records entities like classes, functions, and API endpoints, and notes code changes (e.g. refactor patterns) from commit metadata.

• Issue trackers: Jira or Linear tickets, epics, and bugs. Each ticket is connected to the code or service it involves, and recurring incident patterns (like frequent hotfixes) become part of the context.

• Documentation: Design documents, architecture decisions, wikis (e.g. Confluence). The graph links these to the relevant code components, capturing business intent and past decisions for reference.

• Observability data: Logs, errors, and performance metrics. For example, if a service has repeated errors or missing logs, the graph notes that instability. This means operational risk indicators (like outage-prone services) are surfaced in the graph.

  • Note: Observability data integration is available as a custom-built solution for your organization. We can integrate with your existing observability platform (such as DataDog, New Relic, or others) to enrich the knowledge graph with operational insights. Contact the Bito team at [email protected] to discuss your observability integration needs.

• Team communication: Slack messages that contain tribal knowledge like incident discussions, architecture debates, undocumented context.

• Custom instructions: Enrich the knowledge graph with additional context that's relevant to your engineering workflow. By providing supplementary documentation, you help AI Architect develop a more complete understanding of your project.

  • Learn more

Capabilities enabled by the knowledge graph

Feasibility analysis

The knowledge graph evaluates proposed changes against your actual system state. It understands service boundaries, existing patterns, historical constraints, and known limitations. This allows it to determine what is realistically buildable, highlight risks early, and surface constraints that may not be obvious from specifications alone.

Impact assessment

Before any change is made, the knowledge graph maps its full system impact. It traces dependencies across services, APIs, and shared components, and combines this with historical usage and change patterns. This ensures that decisions are based on a complete view of downstream effects, not partial assumptions.

Technical design

The knowledge graph grounds design decisions in how your system actually works. It reflects existing architectural patterns, prior design decisions, and service-level responsibilities. This leads to designs that are consistent with your environment and easier to implement, operate, and maintain.

Epic breakdown

The knowledge graph connects high-level work to real system components. It uses past implementation patterns, system dependencies, and team workflows to break down epics into actionable units. This results in tasks that are aligned with how work is actually executed in your organization.

Context for AI coding agents

When generating code, the knowledge graph provides system-specific context such as API contracts, service interactions, error handling patterns, and operational constraints. This ensures that generated code aligns with your architecture and integrates correctly with existing systems.

Code review enhancement

The knowledge graph adds system-wide context to code reviews. It highlights relevant patterns, prior issues, and cross-service implications that may not be visible within a single pull request. This helps reviewers make more informed decisions with less manual investigation.

How the knowledge graph differs from other AI tools

Beyond RAG and vector search

Most AI coding tools use retrieval-augmented generation: embedding code as vectors and retrieving relevant snippets. This treats your codebase as searchable text rather than an interconnected system.

When you ask about authentication, vector search finds files containing "auth" keywords. It doesn't understand that your authentication service depends on specific Redis configuration, that an Architecture Decision Record (ADR) documents why Redis was chosen, or that a recent incident involved rate limiting.

The difference is between finding information and understanding relationships. A vector database can retrieve your authentication service code and a Jira ticket separately, but can't connect that the ticket describes an incident that led to the code change, which implemented a pattern from an ADR, and monitoring shows the pattern's effectiveness.

More context isn't better context

Some tools add more context to prompts — feeding more code and documentation to the AI. But retrieving fifty potentially relevant files when only three matter creates noise, not clarity.

The knowledge graph solves a different problem: identifying which information matters for specific decisions and why it matters.

Understanding system evolution

Traditional AI tools treat codebases as relatively static, re-indexing periodically without modeling change over time. The knowledge graph understands that your current architecture results from decisions made in specific contexts.

When your team has been migrating from monolith to microservices for a year, that's not historical trivia — it's a pattern that should inform how new features are designed.

Operational context

Code analysis tools build dependency graphs and trace function calls, but they don't capture operational reality. Knowing Service A calls Service B is useful. Knowing that Service B has rate limits that caused a production incident eight months ago, that the response involved implementing circuit breakers, and that a shared library now exists for this pattern — that's the context difference between adequate code and production-ready code.

Why the knowledge graph matters

Scaling engineering organizations

The constraint in scaling engineering isn't hiring developers — it's enabling them to make good decisions without complete context. When critical knowledge lives in senior engineers' heads, scaling means either accepting decisions with less context (leading to rework) or creating bottlenecks.

The knowledge graph distributes accumulated knowledge. Mid-level engineers access the same contextual understanding staff engineers bring, not through years of experience but through the graph making that context explicit and queryable.

Technical debt visibility

Technical debt is the gap between how your system is designed and how it needs to work. The graph makes this visible by connecting what was decided (ADRs, design docs), what was built (code), what happened (incidents, monitoring), and what's planned (Jira epics).

This visibility enables informed decisions about what technical debt costs and what remediation provides value.

Compliance and auditability

For organizations with regulatory requirements, the graph provides an auditable record of technical decisions. When you need to demonstrate why architectural choices were made, what alternatives were considered, and how security requirements were addressed, the graph traces these relationships explicitly.

AI for high-level decisions

Most AI tools excel at isolated tasks: writing functions, explaining code, suggesting refactors. The knowledge graph makes AI useful for decisions requiring system-wide understanding: feasibility analysis, architectural design, impact assessment, etc.

These are tasks senior engineers spend most time on, and where AI historically provided least value due to lacking context.

Organizational learning

Every decision captured in the graph becomes training data for better future decisions. Organizations accumulate knowledge over time, but it usually remains implicit until people leave and understanding walks out the door.

The knowledge graph makes accumulation explicit, preserving it in a form that informs decision-making as teams evolve.

The Architect MCP Analytics dashboard in Bito Cloud provides visibility into how Bito's AI Architect is being used across your workspace through the Model Context Protocol (MCP). Use these metrics to track tool usage, monitor engagement, and understand what tasks the AI Architect is being applied to.

All charts update on a rolling basis and are accessible directly from the Bito UI.

Overview

Each time the AI Architect invokes a structured capability — such as code search, file reading, or architecture analysis — it is recorded as a tool call. The analytics page aggregates these tool calls to help you answer questions like:

• How much is the AI Architect being used?

• Who is using it, and how many people are actively engaged?

• Which types of tasks is it being used for most?

• Is usage growing or declining over time?

Available charts

Tool Call Volume — Last 4 Weeks

Displays the total number of MCP tool calls made by all users in the last 4 weeks.

Use this as a high-level indicator of overall AI Architect activity. A rising count suggests growing adoption or deeper integration into developer workflows. A sudden drop may point to access issues, a change in team workflow, or a degraded experience worth investigating.

Active Users — Last 4 Weeks

Shows the number of unique workspace members who triggered at least one MCP tool call within the last 4 weeks.

This metric reflects the breadth of adoption rather than total volume. Compare it alongside tool call volume to understand usage distribution:

• High volume + low active users → a few power users driving most activity

• Growing active users + stable volume → broader but lighter adoption across the team

Tool Call Volume — Last 8 Weeks

Breaks down tool call volume week by week over the last 8 weeks.

The longer time horizon makes it easier to identify growth trajectories, plateau periods, or regressions following a product change or team event. Use this chart to compare performance before and after AI Architect rollouts, onboarding pushes, or feature updates.

Tool Calls by Purpose — Last 4 Weeks

Segments tool calls by their functional category, showing which types of tasks the AI Architect is most frequently being used for. Volume is displayed over time so you can track how the purpose distribution shifts within the 4-week window.

Use this chart to identify which Architect capabilities are most valued by your team and where adoption of specific features may need support or enablement.

Interpreting the data

Glossary

Get a 14-day FREE trial of Bito's AI Code Review Agent.

Features overview

A quick look at powerful features of Bito's AI Code Review Agent—click to jump to details.

1. AI that understands your code

2. One-click setup for GitHub, GitLab, and Bitbucket

3. Automated and manually-triggered AI code reviews

4. Pull request summary

5. Changelist

6. One-click to accept suggestions

7. Chat with AI Code Review Agent

8. Incremental code reviews

9. Code review analytics

10. Custom code review rules and guidelines

11. Multiple specialized engineers for targeted code analysis

12. Integrated feedback from dev tools you use

13. Jira integration

14. Supports all major programming languages

15. Enterprise-grade security

Start free trialGet a demo

AI that understands your code

The AI Code Review Agent understand code changes in pull requests. It analyzes relevant context from your entire repository, resulting in more accurate and helpful code reviews.

To comprehend your code and its dependencies, it uses Symbol Indexing, Abstract Syntax Trees (AST), and Embeddings.

One-click setup for GitHub, GitLab, and Bitbucket

Bito Cloud offers a one-click solution for using the AI Code Review Agent, eliminating the need for any downloads on your machine.

Bito supports integration with the following Git providers:

• GitHub

• GitHub (Self-Managed)

• GitLab

• GitLab (Self-Managed)

• Bitbucket

• Bitbucket (Self-Managed)

Automated and manually-triggered AI code reviews

By default, the AI Code Review Agent automatically reviews all new pull requests and provides detailed feedback.

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

Pull request summary

Get a concise overview of your pull request (PR) directly in the description section, making it easier to understand the code changes at a glance.

Each pull request includes an automatically generated summary that explains the intent and scope of the changes in a clear, easy-to-read format.

The summary highlights the main objective of the update, outlines the most important modifications, and provides a high-level view of their impact on the codebase. This allows reviewers to quickly understand what the pull request is about before diving into the detailed code changes.

Changelist

A tabular view that displays key changes in a pull request, making it easy to spot important updates at a glance without reviewing every detail. Changelist categorizes modifications and highlights impacted files, giving you a quick, comprehensive summary of what has changed.

One-click to accept suggestions

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

You can accept the suggestions with a single click, and the changes will be added as a new commit to the pull request.

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.

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.

Incremental code reviews

AI Code Review Agent automatically reviews only the recent changes each time you push new commits to a pull request. This saves time and reduces costs by avoiding unnecessary re-reviews of all files.

You can enable or disable incremental reviews using the Agent settings.

Code review analytics

Get in-depth insights into your org’s code reviews with user-friendly Code Review Analytics dashboard. Track key metrics such as pull requests reviewed, issues found, lines of code reviewed, and understand individual contributions.

Custom code review rules and guidelines

The AI Code Review Agent offers a flexible solution for teams looking to enforce custom code review rules, standards, and guidelines tailored to their unique development practices. Whether your team follows specific coding conventions or industry best practices, you can customize the Agent to suite your needs.

We support two ways to customize AI Code Review Agent’s suggestions:

1. Provide feedback on Bito-reported issues in pull requests, and the AI Code Review Agent automatically adapts by creating code review rules to prevent similar suggestions in the future.

2. Create custom code review guidelines via the dashboard. Define rules through the Custom Guidelines dashboard in Bito Cloud and apply them to agent instances in your workspace.

Multiple specialized engineers for targeted code analysis

The AI Code Review Agent acts as a team of specialized engineers, each analyzing different aspects of your pull request. You'll get specific advice for improving your code, right down to the exact line in each file.

The areas of analysis include:

• Security

• Performance

• Scalability

• Optimization

• Will this change break anything? Based on the diff can we include anything?

• Code structure and formatting (e.g., tab, spaces)

• Basic coding standards including variable names (e.g., ijk)

This multifaceted analysis results in more detailed and accurate code reviews, saving you time and improving code quality.

Integrated feedback from dev tools you use

Elevate your code reviews by harnessing the power of the development tools you already trust. Bito's AI Code Review Agent seamlessly integrates feedback from essential tools including:

• Static code analysis

• Open source security vulnerabilities check

• Linter integrations

• Secrets scanning (e.g., passwords, API keys, sensitive information)

Static code analysis

Using tools like Facebook’s open-source fbinfer (available out of the box), the Agent dives deep into your code—tailored to each language—and suggests actionable fixes. You can also configure additional tools you use for a more customized analysis experience.

Open source security vulnerabilities check

The AI Code Review Agent checks real-time for the latest high severity security vulnerabilities in your code, using OWASP Dependency-Check (available out of the box). Additional tools such as Snyk, or GitHub Dependabot can also be configured.

Linter integrations

Our integrated linter support reviews your code for consistency and adherence to best practices. By catching common errors early, it ensures your code stays clean, maintainable, and aligned with modern development standards.

Secrets scanning

Safeguard your sensitive data effortlessly. With built-in scanning capabilities, the Agent checks your code for exposed passwords, API keys, and other confidential information—helping to secure your codebase throughout the development lifecycle.

Jira integration

Seamlessly connect Bito with Jira to automatically validate pull request code changes against linked Jira tickets. This ensures your implementations meet specified requirements through real-time, structured validation feedback directly in your pull requests.

Support for Jira Cloud and Jira Data Center setups enables flexible integrations, while multiple ticket-linking methods ensure accurate requirement tracking.

Boost your team's code quality, collaboration, and traceability with automated Jira ticket validation.

Supports all major programming languages

No matter if you're coding in Python, JavaScript, Java, C++, or beyond, our AI Code Review Agent has you covered. It understands the unique syntax and best practices of every popular language, delivering tailored insights that help you write cleaner, more efficient code—every time.

Enterprise-grade security

Bito and third-party LLM providers never store or use your code, prompts, or any other data for model training or any other purpose.

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.

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), GitLab (Self-Managed), and Bitbucket (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.

Speed up code reviews by configuring the AI Code Review Agent with your GitHub 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

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

• Bitbucket (Self-Managed)

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

This will redirect you to GitHub.

Step 4: Install the Bito app for GitHub

To enable pull request reviews, you need to install and authorize the Bito’s AI Code Review Agent app.

On GitHub, select where you want to install the app.

Grant Bito access to your repositories:

• Choose All repositories to enable Bito for every repository in your account.

• Or, select Only select repositories and pick specific repositories using the dropdown menu.

Click Install & Authorize to proceed. Once completed, you will be redirected to Bito.

Step 5: Enable AI Code Review Agent on repositories

After connecting Bito to your GitHub account, you'll see a list of repositories that Bito has access to.

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 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 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 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.

Step 9: Configure Agent settings

Agent settings let you control how reviews are performed, ensuring feedback is tailored to your team’s needs. By adjusting the options, you can:

• Make reviews more focused and actionable.

• Apply your own coding standards.

• Reduce noise by excluding irrelevant files or branches.

• Add extra checks to improve code quality and security.

Learn more

Screenshots

Screenshot # 1

Screenshot # 2

Screenshot # 3

Speed up code reviews by configuring the AI Code Review Agent with your GitLab (Self-Managed) server. In this guide, you'll learn how to set up the Agent to receive automated code reviews that trigger whenever you create a merge 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 the following GitLab documentation:

• SAML SSO for GitLab.com groups

• SAML SSO for GitLab Self-Managed

• 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

• Bitbucket (Self-Managed)

Since we are setting up the Agent for GitLab (Self-Managed) server, select GitLab (Self-Managed) to proceed.

Step 4: Connect Bito to GitLab

To enable merge request reviews, you’ll need to connect your Bito workspace to your GitLab (Self-Managed) server.

You need to enter the details for the below mentioned input fields:

• Hosted GitLab URL: This is the domain portion of the URL where you GitLab Enterprise Server is hosted (e.g., https://yourcompany.gitlab.com). Please check with your GitLab administrator for the correct URL.

• Personal Access Token: Generate a GitLab Personal Access Token with api scope in your GitLab (Self-Managed) account and enter it into the Personal Access Token input field. For guidance, refer to the instructions in the Prerequisites section.

Click Validate to ensure the token is functioning properly.

If the token is successfully validated, you can select your GitLab Group from the dropdown menu.

• Note: You can select multiple groups after the setup is complete.

Click Connect Bito to GitLab to proceed.

Step 5: Enable AI Code Review Agent on repositories

After connecting Bito to your GitLab self-managed server, you'll see a list of repositories that Bito has access to.

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.

Step 9: Configure Agent settings

Agent settings let you control how reviews are performed, ensuring feedback is tailored to your team’s needs. By adjusting the options, you can:

• Make reviews more focused and actionable.

• Apply your own coding standards.

• Reduce noise by excluding irrelevant files or branches.

• Add extra checks to improve code quality and security.

Learn more

Managing multiple GitLab groups in Bito Cloud

Bito Cloud allows you to connect and manage multiple GitLab groups for GitLab (Self-Managed) integrations. Use the instructions below to add or remove GitLab groups for AI code reviews.

How to add multiple GitLab groups?

You can connect more than one GitLab group to Bito for AI code reviews.

Follow these steps to add additional groups:

1. Go to the Repositories page.

1. At the top-center of the page, click the “+” (plus) icon next to the currently selected GitLab group name, then select Add group from the dropdown menu.

1. A popup will appear. Use the dropdown menu to select a GitLab group you want to add.

1. Click the Add group button.

Once added, all repositories from that group will be listed and available for AI code reviews under the default agent.

How to remove a GitLab group?

To disconnect a GitLab group from Bito Cloud:

1. Go to the Repositories page.

1. At the top-center of the page, click the three dots icon next to the currently selected GitLab group name, then select Manage groups from the dropdown menu.

1. A popup will appear showing a list of connected groups. Click the “✕” (cross) icon next to the group you want to remove.

1. Confirm the removal in the prompt.

Once removed, the repositories from that group will no longer appear in Bito or be included in AI code reviews.

How to select one or more GitLab Groups?

When you have multiple GitLab groups connected in Bito Cloud, the group name at the top-center of the Repositories page becomes a dropdown menu.

From this dropdown, you can:

• Select a single group

• Select multiple groups as needed

• Select All groups

The list of repositories displayed below will update automatically based on your selection—showing only the repositories from the selected groups.

Screenshots

Screenshot # 1

Screenshot # 2

Screenshot # 3

Save time and effort by quickly creating a new AI Code Review Agent 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. Log in to Bito Cloud and select a workspace to get started.

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

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 Code Review Agents page.

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.

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 Review Agent offers a flexible solution for teams looking to enforce custom code review rules, standards, and guidelines tailored to their unique development practices. Whether your team follows specific coding conventions or industry best practices, you can customize the Agent to suite your needs.

We support three ways to customize AI Code Review Agent’s suggestions:

1. Provide feedback on Bito-reported issues in pull requests, and the AI Code Review Agent automatically adapts by creating code review rules to prevent similar suggestions in the future.

2. Create custom code review guidelines. Define rules through the Custom Guidelines dashboard in Bito Cloud and apply them to agent instances in your workspace, or add them directly to your repository using a .bito.yaml file.

3. Use project-specific guideline files. Add guideline files (like .cursor/rules/*.mdc, .windsurf/rules/*.md, CLAUDE.md, GEMINI.md, or AGENTS.md) to your repository, and the AI Code Review Agent automatically uses them during pull request reviews to provide feedback aligned with your project's standards.

1- Provide feedback on Bito-reported issues

AI Code Review Agent refines its suggestions based on your feedback. When you provide negative feedback on Bito-reported issues in pull requests, the Agent automatically adapts by creating custom code review rules to prevent similar suggestions in the future.

Depending on your Git platform, you can provide negative feedback in the following ways:

• GitHub: Select the checkbox given in feedback question at the end of each Bito suggestion or leave a negative comment explaining the issue with the suggestion.

• GitLab: React with negative emojis (e.g., thumbs down) or leave a negative comment explaining the issue with the suggestion.

• Bitbucket: Provide manual review feedback by leaving a negative comment explaining the issue with the suggestion.

The custom code review rules are displayed on the Learned Rules dashboard in Bito Cloud.

These rules are applied at the repository level for the specific programming language.

By default, newly generated custom code review rules are disabled. Once negative feedback for a specific rule reaches a threshold of 3, the rule is automatically enabled. You can also manually enable or disable these rules at any time using the toggle button in the Status column.

After you provide negative feedback, Bito generates a new code review rule in your workspace. The next time the AI Code Review Agent reviews your pull requests, it will automatically filter out the unwanted suggestions.

2- Create custom code review guidelines

We understand that different development teams have unique needs. To accommodate these needs, we offer the ability to implement custom code review guidelines in Bito’s AI Code Review Agent.

Once you add guidelines, the agent will follow them when reviewing pull requests.

You can manage guidelines in two ways:

1. Through the Bito Cloud dashboard - Create, apply, and edit guidelines entirely in the web interface

2. Using a .bito.yaml file - Add custom guidelines directly to your repository for version-controlled, repository-specific configuration

By enabling custom code review guidelines, Bito helps your team maintain consistency and improve code quality.

How to add a guideline

Step 1: Open the Custom Guidelines tab

• Sign in to Bito Cloud.

• Click Custom Guidelines in the sidebar.

Step 2: Fill the form

A. Manual setup

1. Click Add guidelines button from the top right.

2. Fill out:

   • Guideline name

   • Language (select a specific programming language or select General if the guideline applies to all languages)

   • Custom Guidelines and Rules (enter your guidelines here)

3. Click Create guideline.

B. Use a Template

1. Click Add guidelines button from the top right.

2. Choose a template from the Use template dropdown menu.

3. Review/edit fields as needed.

4. Click Create guideline.

Step 3: Apply to an Agent

• After creating a guideline, you’ll see an Apply review guideline dropdown.

• Select the Agent instance, then click Manage review guidelines to open its settings.

Step 4: Save configuration

On the Agent settings page, hit Save (top-right) to apply guideline changes.

Managing review guidelines from agent settings

Efficiently control which custom guidelines apply to your AI Code Review Agent through the Agent settings interface.

1. Go to Repositories dashboard from the Bito Cloud sidebar.

2. Click Settings next to the target agent instance.

1. Navigate to the Custom Guidelines section. Here you can either create a new guideline or select from existing guidelines.

1. Create a new guideline

   • If you click Create a new guideline button, you will see the same form as mentioned earlier where you can enter the details to create a review guideline.

1. Or select an existing guideline

   • If you click Select from existing guidelines button, you will get a popup screen from where you can select from a list review guidelines you already created. Use checkboxes to enable or disable each guideline for the selected agent and then click Add selected.

1. Once you’ve applied or adjusted guidelines, click the Save button in the top-right corner to confirm changes.

FAQs

What types of custom code review guidelines can be implemented?

You can implement a wide range of custom code review guidelines, including:

• Style and formatting guidelines

• Security best practices

• Performance optimization checks

• Code complexity and maintainability standards

• etc.

Is "custom code review guidelines" feature available in Team Plan?

No, this feature is available on the Professional Plan. Enabling the "custom code review guidelines" feature also upgrades your workspace to the Professional Plan.

For more details on Professional Plan, visit our Pricing Page.

3- Use project-specific guideline files

The AI Code Review Agent can read guideline files directly from your repository and use them during code reviews. These are the same guideline files that AI coding assistants (like Cursor, Windsurf, and Claude Code) use to help developers write code.

By adding these files to your repository, the agent automatically follows your project's specific coding standards, architecture patterns, and best practices when reviewing pull requests.

Supported guideline files

The AI Code Review Agent currently supports analyzing the following guideline files that are commonly used by different AI coding agents:

CRA currently supports analyzing the following guideline files that are commonly used by different AI coding agents:

How to organize your guideline files

Multiple files in one directory

You can split your guidelines across multiple files:

For Windsurf, use the .md extension:

Module-specific guidelines:

Place guideline files in subdirectories to create rules for specific parts of your codebase:

The agent finds all relevant guideline files based on which files changed in your pull request.

How citations work

Every relevant Bito comment includes a Citations section that links to the specific guideline that triggered the comment. The link takes you directly to the relevant line in your guideline file, making it easy to verify the feedback and understand why it was given.

Example scenario

Let's say you're building an application that integrates multiple LLM providers. Your guideline file specifies:

• All providers must extend the BaseLLMProvider class

• All providers must implement standard methods like generateResponse() and streamResponse()

• New providers must be registered in the config/providers.json file

When someone submits a pull request to add a new provider, the agent can catch issues like:

• The new provider doesn't extend the base class

• Required methods are missing

• The provider wasn't added to the configuration file

Each comment links back to the specific guideline, so the developer knows exactly what needs to be fixed.

Sample guideline file

Here's an example AGENT.md file to help you get started:

The Interaction Diagram is a visual feature in Bito's AI Code Review Agent that automatically generates sequence diagrams to help you quickly understand the impact of code changes in your pull requests.

This diagram visualizes how different components of your code interact with each other, making code reviews faster and more intuitive.

How to enable

1. Navigate to the Code Review > Repositories dashboard.

2. Click the Settings button next to the Agent instance you wish to modify.

3. Under Review tab, enable the Generate interaction diagrams option.

Once enabled, Bito will automatically post interaction diagrams during code reviews.

Understanding sequence diagrams

A sequence diagram is a type of visual diagram that shows how different parts of your system interact with each other over time.

It illustrates the flow of operations by displaying the order in which methods are called and how data flows between different components.

This makes it easy to trace the execution path of your code and understand dependencies between modules.

Diagram components

Boxes

The main components in the diagram are displayed as boxes. The level of detail shown depends on the size of your code changes:

• Small changes: Boxes may represent individual classes or functions with detailed interactions

• Large changes: Boxes may represent higher-level abstractions for better readability

Bito's AI automatically determines the appropriate level of detail based on your pull request.

Labels and indicators

Within boxes, you'll see labels that provide quick insights:

Change type:

Indicates what kind of modification was made to each module in your codebase.

• 🟩 Added - New code introduced to the codebase. These are components, functions, or classes that didn't exist before this pull request.

• 🔄 Updated - Existing code that has been modified. This indicates changes to the logic, behavior, or implementation of existing components.

• Deleted - Code that has been removed from the codebase. These components are no longer present after this pull request is merged.

Impact level:

Shows the scope and significance of changes to help you prioritize your code review efforts.

• Low - Minimal impact (● ○ ○)

  • Changes are localized and unlikely to affect other parts of the system. Safe to review with standard attention.

• Medium - Moderate impact (● ● ○)

  • Changes affect multiple components or have moderate complexity. Requires careful review of interactions and side effects.

• High - Significant impact (● ● ●)

  • Changes are extensive or critical, affecting core functionality or multiple system areas. Demands thorough review and testing.

These visual indicators help you identify critical changes at a glance.

Arrows and flow

Solid arrows (→): Represent forward calls flowing left to right

• Example: If main() calls UserService, a solid arrow points from main() to UserService

Dotted arrows (⇢): Represent return flows going right to left

• Example: When UserService returns data to main(), a dotted arrow points back from UserService to main()

Circular arrows (↻): Indicate internal calls within the same module

• Example: One component of UserService calling another component within UserService

Control flow blocks

Alt block (if-else logic)

• Displayed as a dotted box around multiple lines

• Contains two sections separated by a dotted line representing "if" and "else" branches

• Shows conditional execution paths in your code

Opt block (optional parameters)

• Used for functions with parameter overloading

• Contains a single section for optional execution flow

• Represents code that may or may not execute depending on optional parameters

Code outside these blocks represents the normal execution flow.

Platform-specific behavior

GitHub

• Diagrams are posted in Mermaid format

• Interactive controls available:

  • Pan (move top, bottom, left, right)

  • Expand/collapse

  • Zoom in/out

GitLab

• Diagrams are posted in Mermaid format

• Note: For very large diagrams, GitLab may not render automatically. You'll see a notice box with a "Display" button - click it to manually render the diagram

Bitbucket

• Diagrams are posted as image format

Incremental reviews

When you run incremental reviews (for example, by using the /review command in pull request comments), the existing interaction diagram will be updated rather than creating a new comment with a separate diagram.

Interaction diagram vs impact analysis diagram

Bito can generate two types of diagrams, but only one is displayed at a time:

• Interaction diagram: Generated by the standard Code Review Agent, focusing on code changes in the current pull request

• Impact analysis diagram: Generated using Bito AI Architect with complete cross-repository codebase understanding.

  • Note: This feature is not publicly available yet. Please contact Bito at [email protected] to have it enabled for your account.

Best practices

• Review the diagram before diving into code details to get a high-level understanding

• Use impact indicators to prioritize which changes need closer examination

• Follow the arrow flows to understand the execution path

• Pay special attention to "High" impact modules

Troubleshooting

• Diagram not appearing: Verify that "Generate interaction diagrams" is enabled in Bito Cloud settings

• Rendering issues:

  • In GitLab, you may need to click the Display button to manually render the diagram.

  • Refresh the page - this often resolves transient rendering errors.

• Syntax errors: In some cases, the Mermaid diagram may contain syntax errors that prevent it from rendering. Try updating the pull request so the diagram is regenerated.

Get up and running with Bito in just a few steps! Bito seamlessly integrates with Cursor, providing powerful AI-driven code reviews 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, and more.

Install on Cursor

Installation Steps

Step 1: Open Cursor IDE

Launch Cursor IDE on your computer.

Step 2: Access the extensions marketplace

From the top menu, click View -> Extensions to open the Extensions marketplace.

Step 3: Search for Bito and install the extension

1. In the Extensions search bar at the top, type "Bito"

2. Look for the official Bito extension in the search results. The extension should be published by "Bito".

3. Click the Install button

4. Wait for the installation to complete (this usually takes just a few seconds)

Step 4: Sign in to Bito

Once installed, you'll need to authenticate:

1. Click "Sign up or Sign-in"

2. Bito authentication screen will display.

3. Log in with your Bito account credentials (or create a new account)

Step 5: Verify installation

To confirm Bito is working correctly:

1. You should see the Bito icon in your Cursor IDE sidebar

2. Click on it to open the Bito panel

3. You should now have access to all Bito features

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

The Bito free trial gives you access to premium features for 14 days, allowing you to experience the full capabilities of Bito's AI-powered coding assistant.

You can start your free trial directly from the Bito IDE extension using any of the three methods below.

How to start your free trial

Method 1: Using Bito AI chat

The easiest way to start your trial is through natural interaction:

1. Type a message in the Bito chat box and send it.

2. Look for the popup that appears after sending your message.

3. Click Try for free in the popup notification.

4. Complete signup in the browser window that opens.

5. Select Start Trial to activate your free trial.

Method 2: Click upgrade button

For a direct approach to upgrading:

1. Click the UPGRADE button given at the top of the chat window

2. Complete signup in the browser window that opens.

3. Select Start Trial to activate your free trial.

Method 3: Quick trial activation

The fastest way to start your free trial:

1. Hover over Include my code (located above the Bito chat box).

2. In the popup, select Click for 14 day free trial to immediately activate your trial.

Available features in free trial

During your free trial, you'll have access to all the features of Bito Team Plan as mentioned on our Pricing page. It includes:

• AI Code Reviews in Git

• AI Code Reviews in IDE

• AI Chat

• AI that understands your code

• and more.

Visit our Pricing page

Need Help?

If you encounter any issues while starting your free trial:

• Check your internet connection.

• Ensure your Bito extension is up to date.

• Contact [email protected] if the trial doesn't activate properly.

Next steps

Once your free trial is active, explore all the premium features available to you. Consider upgrading to a paid plan before your trial expires to continue enjoying advanced functionality.

Bito AI chat is the most versatile and flexible way to use AI assistance. You can type any technical question to generate the best possible response. Check out these Use cases and examples to understand all you can do with Bito.

To use AI Chat, type the question in the chat box, and press 'Enter' to send. You can add a new line in the question with 'SHIFT+ ENTER'.

Bito starts streaming answers within a few seconds, depending on the size and complexity of the prompt.

Bito makes it super easy to use the answer generated by AI, and take a number of actions.

Copy Answer

Copy the answer to the clipboard.

Regenerate Answer

AI may not give the best answer on the first attempt every time. You can ask Bito AI to regenerate the answer by clicking "Regenerate" button next to the answer.

Rate Response

Vote response "Up" or "Down". This feedback Bito improve the prompt handling.

Modify Last Prompt

Many of these commands can be executed with keyboard shortcuts documented here: Keyboard shortcuts

Easily share insights from any AI Chat 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 AI Assistance can help with generating new content or help with your existing code.

Click on each use case for an example instruction and response.

• Generate Code

• Command Syntax

• Learn technical concepts

• Generate test cases

• Explain code

• Comment method

• Improve code performance

• Check security

• Find style issues

Generate Code

Instruction

Response

Command Syntax

Instruction

Response

Learn Technical Concepts

Instruction

Response

Test Case

Instruction

Response

Explain this Code

Instruction

Response

Comment Method

Instruction

Response

Improve Performance

Instruction

Response

Instruction

Response

Check for Security

Instruction

Response

Instruction

Response

Find Style Issues

Instruction

Response

Templates help you improve your code quality instantly with AI-powered analysis. Get automated suggestions for performance optimization, security fixes, style improvements, and code cleanup without leaving your editor. Each template provides actionable feedback and ready-to-use code improvements that you can review and apply with a single click.

Available templates

1. Performance Check: Optimize code performance and efficiency

2. Security Check: Identify and fix security vulnerabilities

3. Style Check: Apply coding style and formatting standards

4. Improve Readability: Enhance code clarity and organization

5. Clean Code: Remove debugging and logging statements

How to use templates

Prerequisites

Select the code you want to analyze in your editor before using any template.

Method 1: Click Templates button

1. Select code in your editor

2. Click the Templates button at the bottom of the Bito extension panel

1. Choose the desired template from the dropdown menu

Method 2: Open context menu

1. Select code in your editor

2. Right-click in the editor window

3. Hover over "Bito AI" in the context menu

4. Select the desired template from the submenu

Method 3: Using slash / command in Bito chat box

1. Select code in your editor

2. Type / at the start of the Bito chat box

3. Choose the desired template from the dropdown menu

1. Type some text after the slash / to filter templates by name

Method 4: Command Palette (VS Code)

1. Select code in your editor

2. Go to View → Command Palette (or press Ctrl+Shift+P / Cmd+Shift+P)

3. Type "bito" to see available templates

4. Select the desired template from the list

Applying code suggestions

When templates provide code improvements, you'll see an Apply button above the suggested code snippet.

1. Click the Apply button to open the diff view

1. Review the changes highlighted in the diff:

   • Red lines show code to be removed

   • Green lines show code to be added

2. Choose your action:

   • Accept - Apply the suggested changes to your code

   • Undo - Reject the changes and keep your original code

Tips

• Select meaningful code blocks for better analysis results

• Templates work best with complete functions or logical code segments

• Review suggested changes before applying them to your codebase

• Verify that the changes don't break existing functionality

• Use multiple templates on the same code for comprehensive analysis

• Use the diff view to understand exactly what changes will be made

Here is the list of keywords in different languages to ask questions regarding your entire codebase. Use any of these keywords in your prompts inside Bito chatbox.

English:

• my code

• my repo

• my project

• my workspace

Chinese:

• 我的代码

• 我的仓库

• 我的代码库

• 我的项目

• 我的文件夹

Chinese Traditional:

• 我的程式碼

• 我的倉庫

• 我的項目

• 我的工作區

Spanish:

• Mi código

• Mi repo

• Mi proyecto

• Mi espacio de trabajo

Japanese:

• 私のコード

• 私のリポ

• 私のプロジェクト

• 私のワークスペース

Portuguese:

• Meu código

• Meu repo

• Meu projeto

• Meu espaço de trabalho

Polish

• Mój obszar roboczy

• moje miejsce pracy

• mój obszar roboczy

• moj kod

• mój kod

• moim kodzie

• moje repo

• moje repozytorium

• moim repo

• moj projekt

• mój projekt

• moim projekcie

Bito deploys a Vector Database locally on the user’s machine, bundled as part of the Bito IDE plug-in. This database uses Embeddings (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 Large Language Models (LLMs) 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 AI Stack to simplify coding for everyone. To learn more about this head over to Bito’s AI Stack documentation.

AI Code Reviews in CLI brings fast, intelligent code reviews directly to your terminal, helping you catch issues early — before they reach production.

It analyzes your code changes using AI to provide instant feedback on:

• Security vulnerabilities - Detects issues such as SQL injection, XSS, insecure authentication, and unsafe data handling.

• Potential bugs - Identifies logic errors, edge cases, incorrect assumptions, and runtime-related issues.

• Performance problems - Flags inefficient algorithms, unnecessary computations, memory-intensive patterns, and scalability risks.

• Code quality & best practices - Improves readability, maintainability, and design by suggesting better patterns, structure, and conventions.

Unlike traditional linters or static analyzers, the analysis is context-aware and explains why an issue matters and how to fix it.

By reviewing changes as you work, it helps you improve code consistency and reliability across your projects.

Perfect for Agentic coding workflows

The CLI integrates seamlessly with AI coding agents like Cursor, Claude Code, Windsurf, and others. Simply tell your agent "review my changes" and it automatically runs the review, presents findings, and can even implement fixes for you.

Stay in natural conversation while getting expert code analysis - no manual command typing or context switching required.

Learn more

Supported platforms

Supported Operating Systems

• Windows

• macOS

• Linux

Source Code Management (SCM) compatibility

Works seamlessly across a wide range of version control systems and workflows:

• Git

• Subversion (SVN)

• Mercurial

• Perforce

• Plain files (no SCM required)

This makes it suitable for both modern Git-based projects and legacy or enterprise codebases.

Why use AI Code Reviews in CLI?

Terminal-first by design

Run reviews directly from your terminal — locally, over SSH, or in cloud environments — without pushing code or opening an IDE. This makes it ideal for remote servers, containers, and minimal development setups.

Catch issues earlier (Shift Left)

Review code:

• Before committing

• Before pushing

• Before opening a pull request

• As part of automated CI/CD checks

Earlier feedback means fewer regressions, faster reviews, and lower cost of fixes.

Precise control over what gets reviewed

Review exactly what you want, when you want:

• Uncommitted local changes

• One or more recent commits

• Specific files or directories

• Differences against any branch, tag, or commit

This flexibility makes it easy to integrate into both individual and team workflows.

AI that understands context

Instead of only matching rules, the AI analyzes intent and structure. It can:

• Detect non-obvious bugs

• Explain trade-offs

• Suggest safer or cleaner alternatives

• Adapt feedback based on surrounding code

Fits seamlessly into existing workflows

Use it as:

• A pre-commit quality gate

• A pre-push validation step

• A CI/CD job that fails builds on critical issues

• An interactive review tool during active development

How it fits into the broader Bito ecosystem

AI Code Reviews in CLI complements other review surfaces by covering scenarios where IDEs or Git platforms are not ideal.

Use the CLI when you need:

• Terminal-native workflows

• Automation and scripting

• Reviews in headless or remote environments

• Fast feedback without opening an IDE or browser

• Pre-commit/pre-push validation

Key features

Smart review modes & filtering

Focus on what matters most at each stage of development:

• Essential mode Shows only HIGH-severity issues — ideal for pre-commit or CI gates.

• Comprehensive mode Includes all severity levels for deeper analysis.

• Focus areas Limit reviews to specific concerns such as:

  • Security

  • Performance

  • Bugs

  • Tests

  • Documentation

• Severity filtering Display only high, medium, or low-priority findings as needed.