Looks Good To MeowSecurity live · CLI v2.0.1One 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).
feat: add OAuth login flow
PR #42 into main
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...
critical · auth.ts:42
perf · user.service.ts:88
Minutes
PR opened → review posted
6 + 1 + 1
Specialists · synthesizer · CI security
16
CI/CD security detectors
BYOK
Your OpenAI key, your data
Deep analysis, not shallow linting. Built for teams who want reliable first-pass reviews and CI/CD security they can trust.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Hardcoded API keys, tokens, certs in workflows
pull_request_target + head checkout, shell injection, unpinned actions, write-all perms, self-hosted runners
Privileged flag, USER root final, ADD from URL
Lockfile hash mismatch on dep-only PRs
Unallowlisted outbound calls in CI
When a PR touches CI/CD config, security findings appear in the same review as code-review comments.
Block-action findings post a failed GitHub Check Run. Branch protection respects it — the merge button goes red.
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.
Sign in with GitHub, add your AI provider API key, and connect any repo in two clicks. Webhooks installed automatically.
Push code and open a PR as you normally would. LGTM picks it up instantly via webhook — no config, no CLI.
Security, bugs, performance, readability, best practices, and documentation agents all run simultaneously with full repo context. Then a synthesizer weighs all findings.
A synthesized review is posted as a GitHub comment with inline suggestions. Full report on the LGTM dashboard.
Here's what a finished LGTM review looks like — posted directly on your PR.
PR #42 by @developer into main· reviewed in 2m 14s
6
Findings
2
Critical
14
Files reviewed
5
Inline comments
Security
Bugs
Performance
Readability
Best Practices
Documentation
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
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
Soonclaude-sonnet-4 · claude-opus-4 · claude-haiku-4 — wired, awaiting live verification
Google Gemini
Soongemini-3.1-pro · gemini-3.5-flash · gemini-2.5-pro · gemini-2.5-flash — wired, awaiting live verification
Install the LGTM CLI and get AI-powered reviews on local changes — staged or unstaged — with real-time agent streaming.
$ 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
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
Start free. Upgrade when you need unlimited reviews and auto-review on every PR.
Free
Get started
Pro
For serious devs
or ~399 INR/month
BYOK — Bring Your Own API Keys. You only pay for the AI tokens you use.
Straight answers about how LGTM stores code, handles API keys, blocks bad merges, and what Pro actually unlocks.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
"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.

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.