Changelog

Computer use in TREX

TREX starts the services your change touches and uses computer use to test them end to end. It can use desktop apps, browsers, and terminals like a real user would, at the same time when a flow needs them. It also tests edge cases in parallel.

TREX is generally available

TREX tests your pull requests end to end. It starts your app in a sandbox, clicks through the flows the change affects, and posts what it found with a video of each flow.

• Environments: tell TREX how to build and start each repository with a setup script, build variables, setup instructions, and network access. Test the setup with TREX Simulation.
• Custom flows: write the journeys TREX should test, step by step, in Memory → TREX Flows.
• Recordings: every tested flow links to a captioned video of TREX using your app.

A TREX run costs 3 credits and works with every review tier.

Review Tiers

Choose how much work Greptile puts into each review:

• Base (1 credit): thorough code review with full codebase context.
• Plus (3 credits): a deeper review for PRs that need extra scrutiny.
• Apex (10 credits): our most intensive review for large, complex PRs.
• Auto: Greptile picks a tier for each PR.

Set the tier for the organization in Settings → Code Review → Greptile Review Configuration, per repository or directory in .greptile/config.json, or per PR with @greptileai review this at apex. Tier rules set the tier for PRs that match them, and the CLI takes --plus and --apex.

Redesigned review summaries

We've redesigned review summaries with less clutter and fewer sections to scroll through, so you can get to the fixes faster.

What's new

• Confidence score and a short verdict at the top.
• A Findings list sorted by severity, with links to each comment.
• Unresolved findings stay in the summary across reviews until you resolve their threads.
• A "What we checked" section for reviews with no issues.
• A separate comment for issues outside the changed code.

What we said goodbye to

• The Important Files Changed table, T-Rex Logs section, and review footer.
• The Comments Outside Diff section in the summary.
• Separate fix buttons for each agent. One Fix All button now uses your preferred agent.

Knowledge Base MCP Tools

The Greptile MCP server now has four tools that give your coding agent read access to a repository's knowledge base, the same material Greptile reads while reviewing. Knowledge base synthesis is being rolled out per organization, so ask your Greptile contact if you need it enabled.

Knowledge Base

Greptile now builds a knowledge base for the repositories it reviews: a set of docs that explain how the codebase works. Greptile reads it on every review as additional context, and your team can read and edit it. Each knowledge base includes:

• Index: an architecture overview, a glossary, and a map of where files live.
• Per-area docs: each significant module and end-to-end flow gets a doc covering what it does, how it connects to the rest of the system, its risk areas, and key files.
• Reverts section: past high-signal revert, rollback, and incident PRs from the repository.

No manual setup is required. Greptile builds the knowledge base with an initial scan of the repository, then updates it as the codebase changes. Coding agents like Cursor, Claude Code, VS Code, and Codex can also read it through the Greptile MCP server. Knowledge bases are being rolled out per organization, so ask your Greptile contact if you need it enabled.

Linear Integration

Connect Linear so that Greptile reviews pull requests against related Linear issues. Issue descriptions, comments, and acceptance criteria become review context, so Greptile can point out where a change does not do what the issue asked for. Key details:

• Issue discovery: Greptile reads issue identifiers and links from the PR title, description, and branch name, and can search Linear for related work.
• Cited sources: comments that depend on an issue link to it, and the review summary lists every issue Greptile read.
• Follow-up questions: ask about a Linear issue in a reply to a Greptile comment.
• Read-only access: Greptile never writes to Linear, and you can limit it to specific Linear teams.

An admin can connect Linear in Memory → Integrations in the Greptile dashboard.

Greptile v5

Greptile Agent v5 is now enabled for all users. v5 is faster, catches more bugs, and flags fewer false positives by running a swarm of narrowly scoped agents in parallel. Key changes:

• Narrower agents: each agent explores one hypothesis for a potential bug.
• Faster reviews: median review time went from 5:04 to 2:25 in production A/B tests.
• Better signal: comments addressed by the author increased from 52% to 66%.
• More positive feedback: positive replies increased by 28.6%.

Security Agent

Greptile security review now pairs static scanning with an AI security agent to catch vulnerabilities in every pull request. It combines deterministic rules, dependency checks, and context-aware AI review before code merges. Key changes:

• Opengrep scanning: catches dangerous code constructs with pattern-matching rules.
• SCA: checks dependencies against known vulnerability databases.
• AI exploit detection: catches chained exploits and issues static tools can miss.
• On by default: security review is enabled for all Greptile users.

Model Inversion

Greptile can now detect when a PR was authored by a coding agent and route the review to a different model. If Claude wrote it, GPT reviews it, and if GPT wrote it, Claude reviews it. Key details:

• Detection signals: commit trails, branch prefixes, and PR titles.
• Inverted routing: the reviewer is not the authoring model.
• Experimental: based on Greptile research showing models catch more bugs in code written by another model.

CLI Onboarding

You can now set up Greptile from your terminal with greptile onboard. The command creates your organization, connects GitHub or GitLab, enables repositories, and imports existing AI rules files, the same setup the dashboard does.

npm i -g greptile@latest
cd path/to/your/repo
greptile onboard
greptile review

Key details:

• Agent-ready setup: hand the onboarding doc to Claude Code, Cursor, Codex, or any agent that can read a URL and run shell commands.
• AI rules import: Greptile imports CLAUDE.md, .claude/rules/**/*.md, AGENTS.md, .cursorrules, and .cursor/rules/**/*.mdc as org-wide custom context.
• Requirements: CLI v3.2.0 or newer and Node 22+.

Free Tier for Individual Developers

Greptile now has a free Starter plan for individual developers. Starter includes unlimited repositories and 50 credits per month for a single developer, with no team creation. Key details:

• 1 active developer
• 50 credits per month
• Unlimited repositories

Auto-approve PRs

Auto-approve is now in beta. Greptile can approve low-risk, bug-free PRs after a clean 5/5 review, with risk limits and filters to keep sensitive changes in the normal review path. Key details:

• Clean review required: Greptile only approves PRs with a clean 5/5 review.
• Risk ceiling: choose the highest risk level Greptile is allowed to approve.
• Filters: exclude PRs by labels, branches, files, and authors.
• Recommended use: docs, tests, styling, and small low-risk code changes.
• Critical changes: auth, secrets, billing, database migrations, infra, CI, and public APIs are never auto-approved.

Partner Program

Greptile can now review code with insider context for the third-party APIs your product depends on. When a PR touches a supported partner API, SDK, config, or integration, Greptile reviews the change against partner-maintained docs, implementation rules, and common failure patterns. Key details:

• Partner context: Greptile uses guidance supplied directly by partners.
• Source-attached comments: comments are marked with the partner logo and link back to the relevant docs.
• On by default: the Partner Program is enabled for all users.
• Featured partners: OpenAI, Vercel, Stripe, PostHog, Datadog, WorkOS, Mintlify, and Braintrust.

TREX

TREX is now available in public beta. With TREX enabled, Greptile doesn't just review your PR, it writes and runs targeted tests in a sandbox, resulting in 20% more bugs caught in evals. Key changes:

• Test generation: generates targeted tests for every PR, covering the changes and edge cases humans might miss.
• Sandbox execution: runs tests in an isolated sandbox environment with no setup or workflow changes required.
• Evidence on comments: attaches logs, screenshots, traces, scripts, or videos when something fails.
• Stack-aware runs: runs against the services, dependencies, and framework your repo already uses, not a generic mock environment.

Greptile CLI

You can now run a full Greptile review from your terminal. Install the CLI, check out a branch, and run greptile review to review your current branch against its base branch.

npm i -g greptile
greptile login
greptile review

Key commands:

• greptile review -b main: compare your current branch against a specific base branch.
• greptile review --resume: continue the latest unfinished review.
• greptile review --diff: show findings inline with the relevant code.
• greptile review --json: print machine-readable output.
• greptile review --agent: print plain text for agent workflows or scripts.

Repo Clusters

You can now create Repo Clusters so Greptile can read related repositories as context during reviews. Group tightly coupled repos once, and whenever Greptile reviews a PR in one of them, it automatically reads the others as read-only context. Key details:

• Dashboard equivalent of context.repos: define a group once instead of pointing each repo at the others manually.
• Suggested clusters: Greptile suggests clusters based on shared contributors over the last 90 days.
• Review context: Greptile reads up to 7 related repositories per review across Repo Clusters and explicit context.repos entries.

Directory-Scoped .greptile/ Configuration

The .greptile/ folder is now the recommended way to configure Greptile. Place it at the root or in any directory; settings cascade from root to leaf, so child directories inherit parent config and override what they need.

.greptile/
├── config.json    # Review settings and structured rules
├── rules.md       # Rules written as plain markdown
└── files.json     # Existing files the reviewer should read for context

Key details:

• config.json: review settings, structured rules, severity, and disable-by-ID.
• rules.md: plain-English rules scoped to the directory containing the .greptile/ folder.
• files.json: existing repo files Greptile should read for context, like schemas, API specs, or architecture docs.
• Cascading inheritance: parent and child rules and context are combined, and child settings can override parent settings.

Memory and Learning

Greptile's improved memory system learns from your team's comments, replies, reactions, and commits to deliver increasingly personalized review suggestions. Over time, Greptile adapts to your team's coding style, filters suggestions your team ignores, and focuses on the issues that matter to your team. Greptile learns from:

• Team PR comments: patterns in code review discussions.
• Replies to Greptile: positive, dismissive, and context-setting responses.
• Reactions: thumbs up/down feedback on suggestion quality.
• Commits: whether comments were addressed between the first and last commit.
• Repeated patterns: suggested custom rules inferred from team behavior.

Flex Usage Limits

You can now set a dollar cap for flex review spend. Flex reviews are reviews beyond the 50 included reviews per active developer in a billing period.

When projected flex review spend reaches the cap, Greptile skips new flex reviews until the next billing period or until you raise the limit. Included reviews still run.

Brand Refresh

We refreshed Greptile's brand in-house. The new logo combines a reptile eye, a tile that works alone or in a tessellated pattern, and a "G". The wider system adds a broader color palette, more detailed illustration, and modular geometric forms, and shows bugs as visual distortions rather than insects.

Redesigned Web App

The Greptile dashboard has been rebuilt with a new organization and team hierarchy. Key changes:

• Breadcrumb navigation: switch between organizations and teams from a single dropdown. The sidebar adapts to show organization-level or team-level pages.
• Auto-enable repositories: a toggle in Code Review Settings automatically enables Greptile on new repos as they are created in a GitHub org or GitLab group.
• Inheritance and sync: team-level settings inherit from the organization, and you can sync a team back to org defaults with one click.
• Analytics dashboard: track PRs reviewed, addressed rate, critical bugs caught, merge times, and upvote/downvote ratios. Filter by team, repository, author, and time period, and export the data.
• Redesigned onboarding: new users joining an existing organization get a guided setup in Personal Settings to link a profile, install the bridge app, choose coding agents, and set review preferences.

Multi-Repo Context

You can now give Greptile read-only access to related repositories during reviews. Add a context.repos field to your .greptile/config.json or greptile.json to reference shared libraries, SDKs, or other repos that help Greptile understand your code.

{
  "context": {
    "repos": ["acme/shared-types", "acme/payment-sdk"]
  }
}

Security Review Beta

Greptile now has security-focused reviews in beta for all users. The new reviewer is better at detecting and surfacing potential vulnerabilities, including preventative patterns that are not vulnerabilities yet but could make future vulnerabilities more likely. Key changes:

• Security badges: security comments now show a small security badge.
• Preventative review: Greptile can optionally flag risky patterns before they become exploitable.
• Better detection: in testing on a dataset of insecure PRs, Greptile's ability to flag security issues increased by nearly 3x.

Fix with your Agent

Every Greptile review can send review comments straight to Claude Code, OpenAI Codex, Conductor, Cursor, or Devin with full context: the file, line numbers, the comment, and the suggested fix. Key changes:

• More agents: Claude Code, OpenAI Codex, Conductor, Cursor, and Devin are now supported.
• Fix All: the review summary includes a Fix All button that sends every issue at once.
• Greptile Bridge: a small CLI routes fix requests from GitHub to your local agent.
• Auto-addressed comments: when you push a commit that touches the flagged files, Greptile marks the corresponding comments as addressed.

Severity Badges

Inline review comments now display a severity badge, P0 (critical), P1 (high), or P2 (medium), so you can triage feedback at a glance.

Review Footer Updates

The review summary footer has been updated with new controls:

• Review counter: shows how many times Greptile has reviewed the PR (e.g. "Reviews (2)").
• Longer commit messages: the "Last reviewed commit" link now shows more of the commit message for easier identification.
• Re-trigger button: click "Re-trigger Greptile" in the footer to re-run a review without tagging @greptileai.

Greptile v4

Major upgrade to the review engine. v4 delivers significantly more actionable feedback across the board:

"Addressed" is determined by an LLM-as-judge evaluating whether the author acted on each comment.

Fix in Claude Code, Codex, and Cursor

Every Greptile review comment now includes a Fix in X button. Click it, and the issue gets sent straight to your coding agent (Claude Code, OpenAI Codex, or Cursor) with full context: file paths, line numbers, the review comment, and suggested fixes. Your agent opens, applies the fix, and you review the diff. A Fix All button in the review summary sends every issue at once.

Grepository

Grepository ranks trending repositories from a curated set of open source projects. Repositories are ranked by averaging their 7-day star growth rank (absolute) and percentage growth rank, so a project needs both strong momentum and relative acceleration to reach the top.

Greploop

/greploop is an agent skill that iterates on a pull request until Greptile gives it a 5/5 confidence score with zero unresolved comments. It triggers a Greptile review, fixes the actionable comments, pushes, and repeats, stopping after 5 iterations if the PR is not yet clean. npx skills add greptileai/skills -g installs it along with the other Greptile skills.

Cascading Config Files

greptile.json files can now be placed in subdirectories to override parent-level review configuration. Settings cascade from root to subdirectory, allowing teams to define org-wide defaults while customizing review behavior for specific folders or modules.

Greptile Plugin for Claude Code

Address Greptile review comments, manage custom context, and trigger reviews directly from Claude Code. Available in the official Anthropic plugin marketplace.

Feature Discovery

Code reviews now surface contextual tips highlighting relevant Greptile features based on the content of each review, such as custom rules, greptile.json configuration options, and integration capabilities.

Wildcard Repository Scopes

Apply rules across all repositories in an organization or group using wildcards (e.g. myorg/* or groupa/subgroupb/*). Wildcard options are automatically generated based on your connected repositories.

Rule Optimization

Rules can now be generated and refined using AI directly from the custom context dashboard. Try it in the + Add Context dialog at app.greptile.com/review/custom-context.

greptile.json v3 Support

greptile.json configuration file now supports v3 code review settings, including custom instructions, skip rules, comment types, and review triggers.

GitLab Reverse Proxy Support

Greptile can now connect to self-hosted GitLab instances routed through reverse proxies, supporting environments where GitLab is not directly accessible from the public internet. Configure your reverse proxy URL in your integration settings.

Clarification Questions

Reviews can now append a clarification question to an inline comment when change intent is ambiguous. Follow-up discussion happens in the same thread via implicit thread replies, with no retrigger required.

Thread Replies

Greptile now responds to follow-up comments in review threads. Ask a question, request a revision, or push back on a suggestion and Greptile replies in-thread. A classifier decides whether to respond and skips acknowledgments, approvals, or human-to-human discussion.

Code Review v3

Completely rebuilt review engine around an agentic workflow. Reviews now learn your team's standards from past GitHub and GitLab PR comments, pull context from tools like Jira and Notion, auto-detect project rule files (e.g. CLAUDE.md, .cursor/rules), and include a copy-prompt action on each comment for quick fixes in your editor.

Greptile MCP Server

Greptile is now available as an MCP server, bringing code reviews into your AI-powered development environment. Trigger and re-run reviews, inspect results, manage custom context, and update repository rules without leaving your editor.

Long-Term Memory

Greptile now learns from your team's review comments. If team members keep leaving the same kind of comment, Greptile learns the preference and starts leaving that comment too.

Jira Integration

Connect Jira so Greptile can read the ticket associated with a pull request and check that the PR implements what the ticket specified.

Scoped Rules

Custom rules can now be scoped to specific repositories, directories, or file patterns. For example, a rule like "use prop types for type checking" can apply only to TypeScript files in certain repos.

Per-Developer Pricing

Pricing moved from capped usage-based pricing to a flat $30 per developer per month. Note: This pricing no longer applies. For current plans, see the pricing page.

Redesigned Web App and Website

We redesigned the Greptile web app and website, including better dark mode support.

Ask Greptile Questions

Tag @greptileai in a pull request comment to ask Greptile a question, such as a follow-up on one of its review comments, an explanation of the code, or suggestions for improvements.

PR Summaries

When you open a pull request, Greptile posts a summary of the changes in plain language, written with context from your entire codebase, not just the diff.