Ito is an execution-driven AI code review tool. It builds and runs a complete copy of the application in an isolated container, automatically navigates the UI via a computer-use agent, executes user flows, detects behavioral regressions, and publishes test results (video replays, screenshots, logs) directly in PRs. No need to write test scripts, get results on your first PR within 60 minutes of connecting to your GitHub repository.

Ito

Ito’s core parameters and statistics

Project	Details
Product Name	Ito
Product Type	AI Code Review and Automated QA Platform
Delivery form	SaaS (GitHub App)
Core Mechanism	Execution-Based Behavioral Regression Testing
Support technology stack	Framework agnostic (React, Vue, Next.js, Rails, Django, etc.)
Test scope	Web application front-end + back-end API
Integration methods	GitHub Checks API (PR level)
Single PR test duration	45 minutes - 2 hours
First output time	Approximately 60 minutes after connecting to the warehouse
Target users	Software development teams, QA teams, open source project maintainers
Category	AI agents (ai-agents)
Support Platform	Web / GitHub
Supported languages	English

Ito's positioning is fundamentally different from traditional "static analysis" code review tools: it does not check code style or potential syntax issues by reading diffs, but actually builds and runs the application, simulates real user operations through AI agents in isolated containers, and verifies from the behavioral level whether each change introduces regression defects. This mechanism determines that it can capture runtime problems that cannot be discovered by static tools - such as UI interaction breaks, API data flow anomalies, permission boundary failures, etc.

Users and market recognition of Ito

Ito is currently in the early commercialization stage, has been adopted by engineering teams of multiple technology companies, and has accumulated verifiable market signals in the following dimensions.

Enterprise Customer Cases: Customers displayed on the official website include Truemed ​​(CTO John Gazzini), Inkeep (Founding Engineer Andrew), CNaught (CTO Dan Kokotov), ​​Temi (Founder Josh Dong), etc. Customer feedback generally focuses on core value points such as "running with zero configuration", "discovering real defects missed by manual review", and "saving 3+ hours of manual verification time every week".

Industry Benchmarking: Ito directly competes with tools such as Cursor Bugbot, CodeRabbit, and Greptile, but the difference is that it does not do static analysis, but execution-level testing. The official claim is that it can "catch 30% more defects than Claude or CodeRabbit." This data is based on its ability to run actual code to find runtime problems, rather than syntax-level scanning.

Community & Open Source Support: Ito offers a free plan for eligible (MIT/Apache licensed) non-commercial open source projects, covering PR-level QA checks on public repositories, which helps build early reputation among the developer community.

Current limitations: As an early product, Ito has not disclosed specific user numbers, financing information or SOC 2 certification completion status (officially said it is "in progress"). The market coverage is mainly dominated by English technical teams, and the Chinese community has not yet seen large-scale promotion.

Ito’s cost advantage: replacing manual verification bottlenecks with automated execution

Ito's pricing system covers three levels: open source projects, start-up teams and large enterprises. Compared with the traditional "hiring QA engineers + maintaining test scripts" model, it has significant cost structure advantages in long-term scale scenarios.

C-side/individual developers: Ito provides free trial for the first 5 PRs (no credit card required), suitable for individual developers or small projects to evaluate tool effects. For eligible open source projects (MIT/Apache license, non-commercial use), Ito offers a complete free plan - including unlimited public repositories, QA testing for every PR, and video and screenshot evidence output. This means that open source maintainers can get regression test coverage at zero cost that would otherwise require full-time QA.

Team/Developer (Pro plan): Pro plan is $40/month/seat, each seat includes 20 code review quotas, and the excess is $3/time. Taking an engineering team of 5 as an example, the monthly base cost is $200, covering approximately 100 PR reviews. Compared with hiring a full-time QA engineer (annual salary in the US market is $120K+, equivalent to about $10K/month), the cost of Ito's Pro plan is only about 2% of the former, and there is no need to bear the risk of recruitment, training and staff turnover.

Enterprise/Private Needs: Customized quote for engineering teams of 25+ including security compliance support, dedicated customer success, custom contract terms, and higher usage caps. The specific price has not been disclosed, please contact the business owner for confirmation.

Comparative Analysis: Cost Structure of Ito vs. Alternatives

Scenarios	Monthly Cost (5 person team reference)	Script Maintenance Cost	Coverage	Scalability
Dedicated QA Engineer (US)	~$10,000	High (requires ongoing maintenance of test suite)	Critical path covered by labor	+$10K/month for each additional person
Playwright / Cypress self-built	Infrastructure ~$50-200	High (UI changes require updating selectors)	Test cases as written	Additional scripts required for each additional coverage
Ito Pro	$200 (5 seats × $40)	Zero (no scripts, adaptive UI changes)	Fully automatic coverage for every PR	Billed by PR times, linear expansion
Ito Open Source Free	$0	Zero	Public Repository PR Level Coverage	Unlimited

Hidden cost considerations: The core hidden benefit of Ito is the elimination of the "test script maintenance tax" - when the traditional E2E testing framework (Playwright/Cypress) frequently changes the UI, selectors become invalid, resulting in large-scale rewriting of scripts. This maintenance cost often accounts for 40%-60% of the total investment in automated QA. Ito's AI agent adapts to UI changes, eliminating the need to maintain test scripts and reducing this cost to zero. The hidden risk lies in vendor lock-in - once Ito is deeply integrated into the CI/CD pipeline, the switching cost will be high; it is recommended to test run in some warehouses to verify compatibility before large-scale adoption of the Pro solution.

Main functions of Ito

Ito provides the following core functions around the closed loop of "PR opening → automated testing → result writeback":

• Targeted Test Plans: Ito reads the diff and description of the PR, combines it with historical feedback, and automatically generates a test plan for this change. Different change types receive different coverage weights - PR acquisition permission boundaries and session exception testing involving authentication logic, PR acquisition pricing rules and state transition testing involving billing calculations. There is no need to manually write test cases, and the plan becomes more accurate as the number of uses increases.

• Containerized Test Execution: Each time a PR is received, Ito builds and runs a complete copy of the application from source in an isolated, disposable container. The AI ​​agent navigates the application like a real user (login, filling out forms, submitting, verifying status), while running real back-end code (business logic, database writing), fully detecting runtime interaction issues between the front-end UI and the back-end API.

• Full evidence chain result output (Evidence-Rich Results): After each PR test is completed, Ito publishes a complete test report in the GitHub PR comment area, including: pass/fail flow summary, failure video playback, responsibility positioning accurate to the line of code, reproduction steps, and severity markers. Developers can complete the review loop directly on the PR page without switching tools. Ito automatically reruns verification after pushing the fix.

• AI Agent's Tool Open List: Ito's AI test agent exposes the following key capabilities in a browser environment:

  • navigate(url): Navigate to the specified page path
  • click(selector/text): click a button, link or interactive element
  • type(input, value): Enter content in the form field
  • submit(): Submit the form
  • extract(selector): Extract text or status information from the page
  • screenshot(): intercept the current page status
  • wait(condition): Wait for specific conditions (element is visible, network request is completed, etc.)
  • assert(condition): Assert that a specific state is true
  • These tools form a closed loop through the LLM → MCP Server → Browser/OS link, model planning steps → perform operations → observe results → adjust the next step until the test goal is completed or a failure condition is triggered.

• Natural language test instruction coverage: The team can set test priority instructions (such as "security priority", "full payment process coverage", "mobile terminal viewport test") at the warehouse, user or organization level through pure English, and Ito will include these instructions into the test plan weight during execution.

• Multi-dimensional test classification: Each PR run covers seven dimensions: Happy-path (core user journey), Edge case (empty state, over-long input, expired session), Adversarial (repeated submission, unauthorized operations), Logic (business rule verification), Accessibility (keyboard navigation, ARIA tags, color contrast), Mobile (responsive layout, touch target), UX (copywriting consistency, layout regression). The actual classification combination performed is dynamically determined by the contents of the diff.

Ito’s model and version evolution

As a SaaS product, Ito's version iterations are driven by continuous updates on the server side, eliminating the need for manual upgrades on the client side. The following is a minimum milestone sequence based on public information:

Early Validation (~Early 2026)

• Version 0.9 (early preview): The core proof-of-concept stage, which implements the basic link from GitHub PR triggering to containerized build and AI agent execution. Trial for a small number of invited users to verify the technical feasibility of "execution-driven review".

Public version (~2026 Q2)

• Version 1.0 (public version): Officially open to the public, covering GitHub App integration, targeted test plan engine, multi-technology stack compatibility (React, Vue, Next.js, Rails, Django, etc.), complete evidence output (video + screenshots + logs). Introducing the Pro/Enterprise/Open Source three-tier pricing system. The first free trial mechanism of 5 PRs is launched simultaneously.

Follow-up roadmap (the official timetable has not been disclosed)

• Native mobile testing: The official FAQ confirms that "Native mobile is on the roadmap" and is expected to be expanded to execution-level testing of iOS/Android applications.
• SOC 2 Compliance Certification: In progress, once completed it will eliminate security compliance concerns for corporate procurement.
• Multiple CI/CD platform integration: Currently centered on GitHub Checks, it may be expanded to GitLab CI, Jenkins, etc. in the future.

Version Constraints: Since Ito is delivered as SaaS, the official does not provide detailed release instructions or download archives of historical versions. The above version nodes are compiled based on public page information, and the exact date is subject to the official release channel.

Ito’s technical advantages

Ito's technical route can be summarized as a three-layer architecture of "LLM planning + computer execution using agents + containerized isolation", which will be dismantled one by one from mechanism to effect below.

Architecture Link (Text Illustration):

GitHub PR trigger
      │
      ▼
┌───────────────────────────────────────────┐
│ Ito control plane │
│ • Read diff + PR description │
│ • Generate targeted test plans │
│ • Allocate disposable execution containers │
└───────────────┬───────────────────────────┘
               │
               ▼
┌───────────────────────────────────────────┐
│ Isolation container (disposable Sandbox) │
│ • Build complete applications from source code │
│ • Start backend service + database │
│ • Initialize test environment credentials │
└───────────────┬───────────────────────────┘
               │
               ▼
┌───────────────────────────────────────────┐
│AI agent layer (LLM + MCP protocol) │
│ │
│ ┌─────────────────────────────────┐ │
│ │ Tool List: │ │
│ │ navigate / click / type / │ │
│ │ submit / extract / screenshot │ │
│ │ wait / assert │ │
│ └───────

───┬───────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────┐ │
│ │ Browser Runtime (Chromium) │ │
│ │ • Realistic rendering engine │ │
│ │ • Desktop viewport (1440×900) │ │
│ │ • Network request interception │ │
│ └──────────┬────────────────────────┘ │
│ │ │
│ ▼ │
│ LLM observation results → Decision next step → Execute action │
└───────────────┬───────────────────────────┘
               │
               ▼
┌───────────────────────────────────────────┐
│ Evidence write-back │
│ • Publish test report in PR comment area │
│ • Video playback + screenshots + logs │
│ • Locating the failed code line + steps to reproduce │
│ • Severity level mark │
└──────────────────────────────────────────┘

Control flow direction: PR trigger → Control plane analysis → Container allocation → AI agent execution → Result writeback Data backflow direction: Browser screenshot/log → AI agent evaluation → Control plane summary → PR comment output

Mechanism → Effect → Applicable scenario causal chain:

1. Execution driver vs. static analysis: Traditional code review tools only read diff and cannot find the problem of "the code looks correct but errors occur during runtime". Ito actually runs the code, so it can catch runtime defects such as UI logic breaks, API response format changes, database write exceptions, etc. Effectiveness: Officially, it captures 30% more bugs than pure static tools. Applicable scenarios: PRs involving multi-service interaction, database status changes, and user permission verification.

2. Computer-Use Agent replaces scripts: Traditional E2E frameworks (Playwright/Cypress) require developers to write and maintain test scripts, and changes in the UI selector will cause widespread script failure. Ito's AI agent understands page semantics through LLM, uses click("Login Button") instead of document.querySelector("#btn-123") to locate elements, and it is still available after UI reconstruction. Effect: Eliminate test script maintenance tax, and test coverage automatically adapts to UI changes. Applicable scenarios: Rapid development teams with frequent UI iterations, small teams that lack full-time QA.

3. Disposable container isolation: The testing of each PR is completed in an independent Sandbox, which is destroyed after construction, with no remaining data. Effect: Eliminate state pollution between tests and ensure the independence and reproducibility of each test. Applicable scenarios: Compliance-sensitive industries with multiple PRs concurrently and requiring strict test isolation.

Guide to engineering pitfalls:

1. Infinite Loop and Token Expansion Control: The AI ​​agent may fall into an infinite loop after repeated attempts in the browser (such as continuous retries after failed login, abnormal page jumps leading to repeated navigation), consuming a large amount of Tokens and testing time. Solution: Ito's built-in max_steps mechanism limits the maximum number of action steps for a single test; it is recommended that the team set a timeout threshold on key PRs and use Ito's repeated action detection (the same operation >3 times to mark an exception) to prevent idling. Officials say that a single PR test is optimized between 45 minutes and 2 hours. If it continues to timeout, you need to check the application building process or test environment configuration.

2. DOM/long-term context overload: The DOM tree of a complex single-page application (SPA) may be extremely large, and the AI ​​agent needs to process a large number of DOM nodes during inference, resulting in the expansion of the context window and a decrease in decision-making speed. Solution: Ito internally implements DOM clipping (retaining only interactive elements in the visible area) and Accessible Tree extraction instead of a complete DOM snapshot. Teams should ensure that key interactive elements of the application have semantic ARIA tags or stable data-testid attributes to improve the agent's element identification efficiency.

3. Security and unauthorized governance: The AI ​​agent may perform irreversible operations (such as deleting data, initiating payments, modifying user permissions) during the testing process, causing damage to data seeds in non-production environments. Solution: Ito uses an isolated test database in the Sandbox container, and all changes are automatically rolled back after the container is destroyed; for high-risk operations such as payment confirmation and data deletion, the model has a built-in confirmation point mechanism - requiring the agent to take a screenshot of the current status and request confirmation before execution. Enterprise users can configure whitelist routing (only test environment URL patterns are allowed) to prevent proxy misoperation from pointing to production endpoints.

How to use Ito

Ito uses GitHub App as the core integration portal, eliminating the need to install local tools or write configuration files. The following is a typical access and usage process.

Quick connection process:

1. Connect to GitHub repository: Visit https://app.ito.ai, log in with a GitHub account, select the repository you want to access, and install the Ito GitHub App. After the warehouse administrator completes the authorization, the access is completed.

2. First time configuration (optional): Set test priority instructions (pure English natural language) in Ito Dashboard, such as "Always test payment flows" and "Skip mobile tests for now". These directives will be factored into the test plan weight of all subsequent PRs. It can be run without configuration, and the framework will automatically generate a test plan based on diff.

3. Submitting PR triggers test: Team members submit PR normally. Ito automatically detects new PRs and posts a summary of the test plan in the PR comment area, then starts execution. Execution status (queued/running/completed) is updated in real time via the GitHub Checks API.

4. View test results: After the test is completed, Ito publishes the full report in the PR comment area. Developers can view pass/fail items, click on video playback, and read failure logs directly on the GitHub page. After repairing, push a new commit and Ito will automatically rerun.

5. Supplementary testing on demand: During or after the test is running, additional tests can be triggered by @Ito in the PR comment area and attached with natural language instructions (such as "Also test the forgot password flow") without modifying the warehouse configuration.

Comparison between entrance and integrated form:

Access method	Applicable scenarios	Prerequisites	Capability description
GitHub App (Web)	All users (standard entrance)	GitHub organization administrator rights	Full functions: PR triggering, testing, result writeback
Ito Dashboard	Configuration management and report viewing	GitHub App installed	Test priority setting, historical report retrieval, team insights
GitHub Checks API	CI/CD pipeline integration	GitHub App installed	Automatically used as a quality gate, you can configure whether to block merge in the warehouse settings

GitHub Installation Reference: Since Ito is a SaaS service, no local configuration files are required. The installation entrance is GitHub Marketplace or App page. For specific steps, please refer to the official documentation.

Ito’s Product Pricing

Ito adopts a tiered pricing model of "free trial + per seat/per usage". The following are the key parameters of each plan.

Plan	Applicable objects	Price	Core quota	Additional instructions
Free trial	All new users	$0	First 5 PRs	No credit card required to evaluate tool performance
Open Source	Qualified Open Source Projects	$0	Unlimited Public Repositories	MIT/Apache Licensed Non-Commercial Projects Only
Pro	Start-up/Small Teams	$40/month/seat	20 reviews/seat, more than $3/time	Includes unlimited read-only users, custom rules, team analytics
Enterprise	Team of more than 25 people	Customized quotation	According to the contract	Including security compliance, dedicated support, customized contract

Key Pricing Details:

• The "20 code reviews" of the Pro plan are billed based on the number of PR executions, regardless of the size of the PR or the length of the test. The excess amount is $3/time, suitable for teams with large fluctuations in PR volume to purchase on demand.
• The unit price of the Enterprise plan is not disclosed, and you need to contact the business to get a quote; it usually includes higher concurrency limit, exclusive SLA, and customized data residency terms.
• Open Source solutions need to apply for review, and the official has not disclosed the specific review standards or processing time. It is recommended to attach proof of the warehouse's license when submitting your application on GitHub.
• All plans have no long-term contract requirements (Pro is monthly subscription, Enterprise annual contract is negotiable). The free trial is automatically embedded with first-time use of the Pro plan, no separate application required.

Application scenarios of Ito

Scenario 1: Engineering team PR-level regression testing access control

• Task Type: The development team needs to confirm within a reasonable time that the changes do not break existing functionality before each PR is merged.
• Actual benefits: Ito automatically completes full-link testing within 45 minutes-2 hours, replacing the manual verification process that originally required 1-2 engineers. Official customer data shows that after adoption, "approximately 30% more features are delivered per sprint" and "production environment return incidents are reduced by approximately 70%." Implementation Tips: It is recommended to pilot it in 1-2 medium-traffic warehouses for 2 weeks, use Ito's test report to compare the team's existing bug tracking system, and quantify the actual capture rate before expanding to the entire team.

Scenario 2: Quality control of community contributions to open source projects

• Task Type: Open source maintainer needs to verify that PRs from unknown contributors are reliable, but lacks dedicated QA resources.
• Actual benefits: Through Ito's Open Source free plan, each community PR automatically gets a complete video + log test report, so maintainers can understand the actual behavioral impact of the change before reviewing the code. This reduces the risk of incorporation of community contributions and reduces the duplication of manual verification efforts by maintainers. Implementation Tips: It is recommended to mark "This repo uses Ito for automated QA on every PR" in the warehouse README to help contributors understand the testing process.

Scenario 3: Quality verification of AI-generated code

• Task Type: After the team generates a large amount of code using AI programming tools (such as Cursor, GitHub Copilot), it needs to quickly verify its runtime correctness.
• Actual benefits: AI-generated code is prone to problems such as "looking reasonable but running errors" - such as calling non-existent API fields, missing error handling branches, and database query logic deviations. Ito verifies the correctness of behavior through actual operation, forming a "generation + verification" closed loop with AI programming tools. Implementation Tips: Ito is particularly sensitive to the PR of AI-generated code, because its diff is usually associated with less context. Ito's "targeted test plan" just makes up for the information gap of "the generator is not present".

Scenario 4: Cross-technology stack migration and refactoring verification

• Task type: When the team performs technology stack migration (such as jQuery → React, REST → GraphQL) or large-scale refactoring, it needs to ensure behavioral consistency between the old and new implementations.
• Actual benefits: The framework-independent nature of Ito enables you to test applications built with different technology stacks, and build new and old versions in containers to compare behaviors. Although the official A/B comparison mode is not explicitly provided, by running Ito on different branches and comparing test reports, the team can obtain evidence of behavioral differences before and after migration. Implementation Tips: During the migration, it is recommended to retain the old version test results in CI as a baseline, and manually compare the new version test results with Ito.

Applicable people for Ito

• Engineering Team Lead/CTO: It is necessary to improve the quality of code integration without increasing the number of QA heads. Ito's Pro/Enterprise plan offers a predictable monthly cost structure suitable for replacing or supplementing existing manual QA processes. Unsuitable scenarios: The team currently does not have a PR process (such as pushing directly to the trunk), or the application is native mobile (in the official roadmap but not yet supported).

• Full stack/front-end engineer: After submitting a PR every day, you need to wait for review, but the reviewer often only reviews the code logic and misses runtime issues. Ito provides a "behavioral test report" before the reviewer intervenes to help engineers self-check before review. Unsuitable scenarios: Engineers need to integrate extremely quickly (Ito test takes 45 minutes to 2 hours), or the project is a pure back-end API without a Web UI (Ito currently mainly covers web applications).

• QA Engineer/Test Leader: Can transform from a "manual regression test executor" to an "AI test strategy designer" to improve coverage by setting test priority instructions and reviewing AI-generated test plans. Unsuitable scenarios: Highly customized test scripts are required (such as complex state machine tests, hard real-time systems). Ito's AI agent is currently more suitable for behavioral verification at the functional and UI levels.

• Open Source Project Maintainer: Use the free Open Source plan to obtain automated QA for community PRs, especially suitable for medium-sized open source projects with insufficient maintainers but active communities. Doesn't fit the boundary: The project uses a non-MIT/Apache license, or the project is a CLI tool/library rather than a web application (Ito requires a runnable application instance).

• Not suitable for crowds and scenes:

  • Native Mobile Development Team: iOS/Android app testing is on the official roadmap but not yet supported.
  • Strict privatization needs in highly compliance industries (finance, healthcare): Ito is delivered in SaaS mode and does not support complete offline deployment; SOC 2 has not yet completed certification, and enterprises with high compliance requirements need to contact the business to confirm the data residency terms.
  • Minimalist Project/Single Page Static Site: A purely static site without back-end logic, Ito's execution-driven testing has limited value, and traditional visual regression tools may be more efficient.
  • Teams that are extremely sensitive to delays: A test cycle of 45 minutes to 2 hours may be too long for hot fix scenarios that require minute-level integration. It is recommended to configure Ito in "non-blocking" mode, that is, the test results are used as a reference but do not prevent integration.

Summary and Outlook

Ito has established a differentiated positioning in the AI ​​code review market with its "execution-driven" approach. Compared with static analysis tools (CodeRabbit, Greptile) and traditional E2E frameworks (Playwright, Cypress), it solves two pain points at the same time: No need to write test scripts (reduce maintenance costs) and Capture runtime defects (increase defect discovery rate). Its technical architecture of "LLM planning + computer usage agent execution + containerized isolation" provides a low access threshold in the SaaS form - you can see the effect within 60 minutes by connecting to the GitHub warehouse, which gives it the potential to spread rapidly among startups and small and medium-sized technical teams.

Current Limitations and Uncertainties:

• The product is still in the early commercialization stage, and SOC 2 certification has not yet been completed, which may pose an obstacle to procurement decisions in compliance-sensitive industries such as finance and medical care.
• A single PR test takes 45 minutes to 2 hours, which may not be agile enough in emergency hot fix scenarios.
• The depth of test coverage is positively related to the LLM capability of the AI ​​agent. When the application interface is extremely complex or involves a large number of non-standard interaction controls, the agent's navigation success rate may decrease.
• The review standards for the "Open Source Free Plan" in pricing have not been made public, and there is uncertainty about whether open source projects can successfully obtain free credits.

Procurement/Adoption Risk Assessment:

• Recommended pilot plan: Select 1-2 non-critical medium-sized warehouses and run on the Pro plan for 2-4 weeks. Focused acceptance: AI agent's success rate in navigating the team's specific technology stack, effective defect detection rate in test reports, and actual changes in PR review cycles.
• Extended Conditions: Defect detection rate during the pilot period ≥15% (increment relative to manual review), each PR test ≤90 minutes (P80), team feedback test report readability is acceptable.
• Terms that enterprises need to verify before purchasing: data storage location and destruction strategy (before SOC 2 is completed), source code protection mechanism in container environment (official statement "does not store code" but requires contract confirmation), test concurrency limit and queuing timeout compensation in SLA.
• Long-term observation points: The release rhythm of native mobile testing, the integration progress of multiple CI/CD platforms (GitLab, Jenkins), and whether the false positive rate of the AI ​​agent continues to decrease with product iteration. These factors will determine whether Ito can evolve from a "PR-level supplementary tool" to a "full-stack quality access control infrastructure."

Related tools: CrewAI, langchain

Version Info

• public version ：The publicly available version supports GitHub PR integration, containerized execution, video playback, and multi-technology stack adaptation. There is no official precise release date yet. （~2026-06）
• early preview ：Early trial run version, core function verification stage, covering basic PR test links. There is no official precise release date yet. （~2026-03）