LGTMLooks Good To MeowSecurity live · CLI v2.0.1

AI code review+ CI/CD security, before bad code merges.

One platform, three pillars: PR review (6 specialist AI agents), code context (tree-sitter graph across 12 languages), and CI/CD security (16 detectors, merge-block Check Runs, runtime pipeline halt).

app.looksgoodtomeow.in/review/pr-42

feat: add OAuth login flow

PR #42 into main

Changes
Agent Pipeline
6/8 complete

Context Indexer

Indexed 847 files via tree-sitter

Security

2 critical findings

Bugs

1 logic error found

Performance

1 N+1 query detected

Readability

1 suggestion

Best Practices

All good

Documentation

Analyzing...

Synthesizer

Waiting for agents...

Inline Comments

critical · auth.ts:42

perf · user.service.ts:88

Review progress57%

Minutes

PR opened → review posted

6 + 1 + 1

Specialists · synthesizer · CI security

16

CI/CD security detectors

BYOK

Your OpenAI key, your data

Features

Review, context,
and security

Deep analysis, not shallow linting. Built for teams who want reliable first-pass reviews and CI/CD security they can trust.

Seven-agent review pipeline

Six LLM specialists — security, bugs, performance, readability, best practices, documentation — each with its own system prompt and finding schema. A seventh agent (ci-security) runs deterministically without an LLM on every PR that touches GitHub Actions, Dockerfiles, or lockfiles. A synthesizer weighs all outputs and posts one verdict: approve, request changes, or comment.

Layer 1

Context

Layer 2

6 Specialists

Layer 3

Synthesizer

Full-repo context, not just the diff

We index your codebase with tree-sitter across 12 languages (TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C, C++, C#, Ruby, PHP), build a dependency graph, and rank files with PageRank personalized to your changed files. Each review sees the related files the diff actually depends on — catches API misuse and broken assumptions that diff-only reviewers miss.

LGTM Security — pipeline-layer scanning

Most AppSec scans source code. LGTM Security scans your pipeline: 16 deterministic detectors for hardcoded secrets, pull_request_target supply-chain RCE, unpinned GitHub Actions, privileged containers, shell-injection in workflows, lockfile drift, and unallowlisted outbound network. Three enforcement gates: inline PR review, merge-block Check Run, and a runtime GitHub Action that halts the pipeline before checkout.

Reviews in minutes, not days

Six LLM agents run concurrently with 150ms stagger to respect provider rate limits. Findings stream live to the dashboard via Socket.IO so you watch agents complete in real-time. A small PR typically returns a verdict in 1-3 minutes; a 5000-file backfill finishes in 5-30 minutes (one-time). Compare to async human review measured in days.

Bring Your Own OpenAI Key

Configure your own OpenAI API key once. Pick your default model from gpt-5.4, gpt-5.4-pro, gpt-5.4-mini, gpt-5.4-nano, gpt-5.3-codex, gpt-5.2, or gpt-4.1-mini. Override the model per-repo for cost vs. capability tuning. We validate the key against the LLM before saving, never proxy your tokens, and never bill you for inference. Anthropic and Google Gemini are wired structurally; live verification coming soon.

GitHub-native, branch-protection compatible

Reviews post as a single PR review with verdict (APPROVE / REQUEST_CHANGES / COMMENT) and up to 25 inline comments anchored to changed lines. LGTM Security findings post as a separate "LGTM Security" Check Run with conclusion=failure on blocking findings — set this Check as required in branch protection and bad config can't merge.

Real-time progress + actionable alerts

Each agent's status — queued, running, completed, failed — streams to the dashboard via Socket.IO with a Redis adapter for cross-instance fan-out. In-app notifications + email alerts on completed reviews, AI-approved PRs, blocking security findings, and subscription state changes. Every failure path surfaces with a friendly message; nothing fails silently.

lgtm CLI — review locally before pushing

Install once: npm i -g @tarin/lgtm-cli. Review staged or unstaged diffs against your default branch with `lgtm review --staged`. Same agents, same context, SSE-streamed agent progress in your terminal. Includes `lgtm security` for scanning + audit, `lgtm config` for BYOK, `lgtm doctor` for diagnostics, and `lgtm completion` for bash/zsh/fish.

Architecture

6 specialists. 1 synthesizer.
One senior-level review.

Each agent is a specialist. They run in parallel, then a synthesizer weighs all findings and posts the final verdict — like a senior engineer would.

Layer 1
Runs on push to main

Context Indexer

Parses your repo with tree-sitter across 12 languages, builds a dependency graph with PageRank, extracts coding conventions, and summarizes recent PR history. Runs on every push to your default branch.

Layer 2
6 specialists in parallel on every PR

Security

SQL injection, hardcoded secrets (regex pre-scan + LLM), XSS, SSRF, IDOR, insecure deserialization, path traversal, weak crypto, missing auth checks. Findings emit critical / high / medium / low severities with a fix suggestion.

Bugs

Null & undefined reference errors, off-by-one, race conditions, unhandled promise rejections, type coercion bugs, missing error handling, edge cases the diff forgot, and gaps in test coverage on the modified surface area.

Performance

N+1 queries, O(n²) loops, missing pagination, React unnecessary re-renders, blocking I/O on the request path, memory leaks, inefficient regex, missing DB indexes for new query patterns, and unjustified bundle growth.

Readability

Complex functions, poor names, dead code, deep nesting (3+ levels), magic numbers and strings, code duplication, unclear control flow, and missing type annotations where they'd help future readers.

Best Practices

Missing try/catch on async work, swallowed errors, input validation gaps, framework anti-patterns (React, Express, FastAPI, etc.), missing logging on error paths, ad-hoc config that should be env-driven, API design slips, and convention drift vs. the rest of your codebase.

Documentation

New public functions without JSDoc / docstrings, undocumented API endpoints, outdated README references, complex logic with no inline explanation, and missing type docs on exported surfaces.

Layer 3
Synthesizer after all specialists complete

Synthesizer

Consumes all 6 reports + repo context. Weighs findings, resolves conflicts, generates a changelog entry, and posts the final verdict with inline comments on your PR.Approve, request changes, or comment.

LGTM Security

CI/CD security,
caught at every gate.

Most AppSec tools scan source code. We scan the layer most teams forget: the workflows, Dockerfiles, and pipeline configs that ship your code to production. 16 deterministic detectors, no LLM required.

16 detectors
Pure functions, deterministic, zero LLM cost

Secrets

× 1

Hardcoded API keys, tokens, certs in workflows

Workflow YAML

× 10

pull_request_target + head checkout, shell injection, unpinned actions, write-all perms, self-hosted runners

Dockerfile

× 3

Privileged flag, USER root final, ADD from URL

Dependencies

× 1

Lockfile hash mismatch on dep-only PRs

Network

× 1

Unallowlisted outbound calls in CI

3 enforcement gates
We stop the bad pipeline, not just report it
01

Inline PR review

When a PR touches CI/CD config, security findings appear in the same review as code-review comments.

02

Merge-block Check Run

Block-action findings post a failed GitHub Check Run. Branch protection respects it — the merge button goes red.

03

Runtime pipeline halt

Our published GitHub Action runs first in every job. On block findings it exits non-zero before checkout, before tests, before deploys.

Every finding goes into an immutable audit log

Schema-level write-once. Per-rule false-positive rates surface in the policy editor. Per-repo allowlists for trusted action sources and internal mirrors.

How it works

From PR to review
in 4 steps

01

Connect your repo

Sign in with GitHub, add your AI provider API key, and connect any repo in two clicks. Webhooks installed automatically.

02

Open a pull request

Push code and open a PR as you normally would. LGTM picks it up instantly via webhook — no config, no CLI.

03

Agents analyze in parallel

Security, bugs, performance, readability, best practices, and documentation agents all run simultaneously with full repo context. Then a synthesizer weighs all findings.

04

Get your review

A synthesized review is posted as a GitHub comment with inline suggestions. Full report on the LGTM dashboard.

Review Complete

Here's what a finished LGTM review looks like — posted directly on your PR.

github.com/acme/api/pull/42

feat: add OAuth login flow with JWT refresh

PR #42 by @developer into main· reviewed in 2m 14s

Request Changes
91% confidence
6 agents + synthesizer done

6

Findings

2

Critical

14

Files reviewed

5

Inline comments

Security

2 findings

Bugs

1 finding

Performance

1 finding

Readability

1 finding

Best Practices

1 finding

Documentation

0 findings
Final Verdict — Synthesizer

2 critical security issues must be fixed before merge. The login endpoint atsrc/routes/auth.ts:42accepts unsanitized input vulnerable to injection. Token refresh logic has no test coverage for edge cases. One N+1 query in the user service needs batching. Documentation is up to date. Changelog has been auto-drafted.

5 inline comments posted on GitHub

auth.ts:42
auth.ts:67
user.service.ts:88
auth.test.ts:1
auth.controller.ts:23

Bring your own API key. Pick your model. Override per-repo for cost vs. capability tuning.

OpenAI

gpt-5.4 · gpt-5.4-pro · gpt-5.4-mini · gpt-5.4-nano · gpt-5.3-codex · gpt-5.2 · gpt-4.1-mini

Anthropic Claude

Soon

claude-sonnet-4 · claude-opus-4 · claude-haiku-4 — wired, awaiting live verification

Google Gemini

Soon

gemini-3.1-pro · gemini-3.5-flash · gemini-2.5-pro · gemini-2.5-flash — wired, awaiting live verification

CLI

Review before you push.
From your terminal.

Install the LGTM CLI and get AI-powered reviews on local changes — staged or unstaged — with real-time agent streaming.

~/projects/my-api

$ npm install -g @tarin/lgtm-cli

$ lgtm login

✓ Logged in as @developer

$ lgtm review --staged

Reviewing staged changes in acme/api...

Agents running:

Security 2 issues (3.2s)

Bugs 0 issues (2.8s)

Performance 1 issue (3.5s)

Readability 0 issues (2.1s)

Best Practices 1 issue (2.9s)

Synthesizer done (4.1s)

──────────────────────────────

Verdict: REQUEST CHANGES

Confidence: 87%

──────────────────────────────

Issues: 2 critical 1 medium

@tarin/lgtm-cli

Available on npm

$npm install -g @tarin/lgtm-cli

Real-time streaming

Watch agents work live in your terminal

Secure auth

GitHub OAuth with auto-refreshing tokens

Local diff review

Review uncommitted or staged changes

PR review

Trigger reviews for open PRs by number

Pricing

Simple, transparent
pricing

Start free. Upgrade when you need unlimited reviews and auto-review on every PR.

Free

Get started

₹0/month
20 PR reviews / month (counter rolls over)
All 6 specialist review agents
Tree-sitter context across 12 languages
LGTM Security — read-only access
Full CLI + Dashboard
BYOK — your own OpenAI key
POPULAR

Pro

For serious devs

₹399/month

or ~399 INR/month

Unlimited PR reviews
Auto-review on every PR
Full LGTM Security — enroll, scan, policy, runtime watchdog
All 16 CI/CD security detectors
All 6 specialist review agents
BYOK + per-repo model overrides
Full CLI + Dashboard
Priority email support

BYOK — Bring Your Own API Keys. You only pay for the AI tokens you use.

FAQ

Questions
developers ask first.

Straight answers about how LGTM stores code, handles API keys, blocks bad merges, and what Pro actually unlocks.

Do you store our source code?

No. Code is read on-demand via the GitHub API when a PR opens or a push lands on the default branch. We index symbol tables, definitions, and a file-level dependency graph in MongoDB to power PageRank-ranked context — that's structural metadata, not source. File contents are loaded into agent prompts at review time and not persisted after the review completes. Your source never leaves GitHub except as the slice of context an LLM call needs.

Bring Your Own Key — do you ever see our OpenAI tokens?

Your API key is encrypted at rest in MongoDB with a key only the LGTM server holds. At review time the server uses the key to call OpenAI on your behalf, then drops the in-memory reference. We do not proxy your inference through our infrastructure, we don't see your token billed against our account, and we don't subsidize your usage. You pay OpenAI directly for tokens; you pay LGTM ₹399/mo for the platform.

Anthropic Claude and Google Gemini — when are they live?

Both providers are wired into the AI service layer (SDK upgrades done, JSON-mode mapping done, system-instruction shape corrected) but they haven't been live-tested against the full 6-agent + synthesizer pipeline with real workloads. We're not going to ship them under "production" until they pass end-to-end verification on your dollar. Until then they show as Coming Soon in Settings.

How fast is a review actually?

It depends on diff size and how many files the agents need to pull in for context. A typical PR with ~10 changed files completes in 1-3 minutes wall-clock: six LLM specialists run concurrently with 150ms stagger, then a synthesizer pass. The deterministic ci-security agent only runs if you touched workflow YAML / Dockerfiles / lockfiles and adds milliseconds, not minutes. Cold indexing on a 5000-file backfill takes 5-30 minutes once, then incremental indexing on push completes in seconds.

What languages do you support for code context?

Tree-sitter parsing covers TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, C, C++, C#, Ruby, and PHP. That gets you symbol-level indexing and the PageRank graph. The LLM specialists can read and reason about code in any language; you just lose the smarter context bundling outside the tree-sitter list. Most reviews of unindexed languages still surface real findings — they just see less of the surrounding codebase.

Does LGTM Security actually block bad code from merging?

Three gates. Gate 1: inline PR review surfaces the finding on the offending line as a critical comment. Gate 2: a Check Run named "LGTM Security" posts with conclusion=failure on any rule whose configured action is block — if you add this check to your branch protection "required" list, the merge button is disabled until resolved. Gate 3: the LGTM Security Watchdog GitHub Action (lgtm-action) runs as the first step of your CI job, polls our pipeline-decision API, and exits non-zero before checkout, before tests, before deploys. Bad config can't reach production.

Which 16 detectors does LGTM Security run?

Secrets: hardcoded API keys, GitHub PATs, AWS access keys, private keys, JWTs. Workflow YAML: unpinned actions/checkout, unpinned third-party actions, permissions write-all, missing job permissions, untrusted-input shell injection, pull_request_target with head checkout, self-hosted runner on public repo, privileged container, external reusable workflow, weak workflow_dispatch triggers. Dockerfile: --privileged flag in RUN, USER root in final stage, ADD from HTTP URL. Dependencies: lockfile-only edits without a manifest change. Network: unallowlisted curl/wget in CI shell blocks (escalates if piped to bash). Each rule has a default action (block / warn) you can override per-repo.

Can I disable individual security rules?

Yes. Each detector ships with a default action — block, warn, or off — and you can override it per-repo in the policy editor or via CLI: lgtm security policy set <rule-id> <block|warn|off>. You can also maintain allowlists for trusted action sources (e.g. actions/*, your-org/*), permitted outbound domains, and approved self-hosted runner labels. The policy is versioned so audits show exactly what was active at the time of any finding.

Does the CLI need internet / can I review air-gapped?

The CLI talks to the LGTM API at api.looksgoodtomeow.in for review orchestration, BYOK validation, and context fetching. It can't run fully air-gapped today — agents run on the LGTM server, not your laptop. If you need on-prem or self-hosted, get in touch; it's something we'd consider for serious teams.

Is LGTM India-compliant for data protection?

We're a single founder operating from India. Source code is read via GitHub API and not persisted as source. User account data is minimal (GitHub username, email from the GitHub /user endpoint, encrypted BYOK keys). We're working through the DPDP Act 2023 obligations — formal data fiduciary disclosures, retention policies, grievance officer details — and will publish a compliant Privacy Policy on docs.looksgoodtomeow.in before any India-specific enterprise launch.

Pricing in INR — what does Pro actually unlock?

Free is ₹0/month with a hard cap of 20 reviews per calendar month (resets on the 1st), full access to all 6 specialist agents, all 16 security detectors, the CLI, and the dashboard. Pro is ₹399/month and removes the cap (unlimited reviews) and turns on auto-review — every PR opened on a connected repo gets reviewed automatically, no manual click. Payments go through Dodo Payments; cancel anytime, no contracts.

Why "LGTM"? Why a cat?

"LGTM" — Looks Good To Me — is what reviewers type when they're done. We made it Looks Good To Meow because (a) it's memorable, (b) the brand permits being friendly about a dry topic, and (c) every senior engineer secretly wishes their reviews were one-line approvals. The tool exists so yours can be.

LGTM

Stop waiting days
for code reviews

Connect your first repo in under a minute. Your next PR gets a full AI-powered review automatically.

Your API keys stay with you. Code is read via GitHub API and never stored.