How Sigilix works, answered.

Both — it just stops short of committing for you. Every finding ships a ready-to-apply suggested fix plus a one-click "Prompt to Fix with AI" you can hand straight to your coding agent. You never get a bare "this is wrong" — you get the change to make and the context to make it. Sigilix reviews and proposes; you (or your agent) apply and merge.

It meets your team where work already happens — GitHub, Linear, Slack, and the CLI. Sigilix's models are grounded in your codebase and your team's memory, so wherever they show up — reviewing a change, turning a red build into a root-cause comment, or answering in your terminal — they carry the same context. Everything lands in the rails you already use, not a separate dashboard to babysit.

No. Sigilix is a hosted GitHub App: install it, grant repo access, and reviews fire automatically on every pull request. There is nothing to add to your repo — no .github/workflows YAML, no self-hosted runner, no Docker image — and all review compute runs on Sigilix infrastructure, so your build times are untouched. You can also trigger it on demand with /sigilix review or @sigilix in any PR thread.

Same surface, different scope. CodeRabbit is a mature PR reviewer with real depth — multiple models, parallel agents, sandboxed analysis, and its own memory. Our difference isn't that we have specialists and they don't. It's that Sigilix isn't review-only: review is one surface of an org-aware platform that also runs CI triage, a CLI, Slack, and chat, and every surface reads and writes one persistent memory index scoped both to your org and to each developer. A review comment knows the issue that motivated it; a CLI repair knows the failing check; a Slack answer knows the review that found the risk. On the review itself, a finding can't post unless it earns it: every claim is checked against your code, has to cite specific evidence, survives a self-refutation pass, and — where it's checkable — is backed by live execution that produces a tamper-evident receipt (the VERIFIED / GROUNDED / MODEL pill), with a recall-safety floor that forbids any suppression path from dropping a real P0/P1. That's how Sigilix works: memory that spans the whole workflow, and findings you can act on without re-verifying.

Greptile is a strong whole-repo reviewer — it leads with codebase-aware context, and our retrieval is the same class (vector + AST + dependency graph + symbol-aware expansion). So context isn't the moat; we concede that. Two things set Sigilix apart. First, Sigilix isn't review-only: the same memory index — scoped to your org and to each developer — carries context across review, CI triage, the CLI, Slack, and chat, so a review isn't a standalone pass but part of a chain connected to the issue that motivated it and the repairs that follow. A review-only tool, however sophisticated, doesn't carry memory across triage, CLI, and Slack. Second, on the review itself, evidence is assembled before any model speaks, the specialists must cite that evidence, and three gates — provenance, self-refutation, and live execution — run before a finding is allowed to post, each survivor carrying a proof tier you can verify rather than just trust and anchored to the exact line, with a per-repo trust ledger that learns what your team confirmed versus dismissed and a provable floor that no suppression path can drop a P0/P1. The numbers are in the review accuracy case study.

Today Sigilix runs as a hosted GitHub App on your pull requests — that's the surface. We're exploring editor integrations, but nothing is committed and there's no timeline yet. In the meantime, every finding ships a one-click prompt you can hand straight to your coding agent.

Every finding has to earn its place. Evidence is assembled before any model speaks, each specialist must cite the specific code it's flagging, and three gates — provenance, a self-refutation pass, and live execution where the claim is checkable — run before a finding is allowed to post. Anything it can't substantiate is demoted, not shown. On top of that, a per-repo trust ledger learns what your team confirms versus dismisses, so the review gets quieter and sharper the longer it runs on your codebase.

Each surviving finding carries a proof tier so you know how much to trust it at a glance. MODEL is a specialist's judgment grounded in your code. GROUNDED is backed by retrieved evidence with provenance. VERIFIED is confirmed by live execution that produces a tamper-evident receipt you can check. It's proof attached to the claim, not an assertion you have to re-verify yourself.

No. A recall-safety floor forbids any suppression path from dropping a real P0 or P1 just to reduce noise. Demotion only ever applies to findings that can't be substantiated — never to a verified high-severity issue. Tidiness never comes at the cost of a bug you needed to see.

No — reviews are incremental. Each new push is reviewed against what actually changed, so you don't re-read the same comments, and existing findings re-anchor to the moved lines instead of going stale on the diff.

Yes. Retrieval pulls whole-repo context — vector search, AST, the dependency graph, and symbol-aware expansion — and review runs in batches so a big diff is covered without truncating. Every finding is anchored inline to the exact line it concerns.

The per-repo trust ledger records it, so the same pattern isn't re-flagged the way it was. The review adapts to the calls your team has already made instead of repeating them.

Install the Sigilix GitHub App, grant repo access, and reviews fire automatically on every pull request. There's nothing to add to your repo — no workflow YAML, no Docker, no self-hosted runner — and you can trigger a review on demand any time with /sigilix review or @sigilix in a PR thread.

Yes — every paid tier includes unlimited repositories under one workspace, so you install once and cover the whole org.

When a build goes red, Sigilix turns the failure into a grounded, inline root-cause comment on the pull request instead of a raw log dump — the likely cause and where to look, right where you're already working.

Sigilix triages issues directly in Linear — the rail your team already uses — so triage lands where the work happens rather than in a separate dashboard you'd have to check.

Yes. A Slack-native assistant is included on paid tiers, so you can ask Sigilix about your code and reviews without leaving Slack.

Yes — the sigilix CLI runs reviews from your terminal. It defaults to the Sigilix model line, and paid tiers can opt into BYOK to route the CLI agent through your own provider key.

On Sigilix infrastructure. Because there's nothing to add to your repo and no runner to host, your CI and build times are untouched. Teams that need it can opt into a self-hosted runner on Ultra.

Sigilix reads the code it needs to review your pull requests and nothing more. For the authoritative, always-current specifics on data handling, processing, and retention, see the Trust Center — that's the source of truth for security questions.

Yes, on Ultra: SSO, audit logs, and the self-hosted runner option, for teams with stricter access and compliance controls.

CLI BYOK is opt-in on paid tiers, and your provider key is used only to route your own CLI agent's calls to the provider you chose. Hosted PR review and Deep-Research Chat always run on the governed Sigilix model line, so your key never leaves the surface you set it on.

Learnings are per-repo and reflect your team's own confirm-and-dismiss decisions rather than anything cross-customer. Org-level data and learning controls live in the Trust Center and your organization settings.

Each tier is a per-seat monthly base with included usage, but usage is tracked in two independent pools: CLI agent work and chat are per-seat; PR reviews, Linear triage, and Slack are organization usage. Free has a low cap window; paid plans have resettable usage windows. When included usage is spent, the capped pool pauses until reset — there are no automatic overages. Teams and Enterprise can opt into extra billed usage by agreement.

Because our cost base is different. Sigilix routes PR-review work across the Sigilix model line based on task difficulty — Boreas for fast everyday coding, Pyroeis for balanced work, and Astraeus for deeper reasoning — so routine review doesn't burn the same budget as the hardest changes. Higher-reasoning review calls simply spend more of your usage window. You get more headroom for the same money, and your usage window resets every 5 days.

Yes, but only for the sigilix CLI. CLI BYOK is optional on every paid tier (Pro, Max, Ultra), and the CLI defaults to Sigilix models unless you opt in with your own provider key. Deep-Research Chat runs on Sigilix models only, so chat answers stay on the same governed Sigilix model line.

Pro is where the paid workflow starts: CI and issue triage, Slack assistant, optional CLI BYOK, unlimited repositories, and standard resettable usage windows. Max has the same product surface with higher usage limits — deeper reasoning runs simply spend more of your usage window, so Max gives you more headroom for those calls. Ultra is Max with the largest usage windows plus org controls (SSO, audit logs, self-hosted runner).

Yes — each developer on the workspace is a seat, and each tier includes a per-seat allowance for CLI agent work and chat. Organization work such as PR reviews, Linear triage, and Slack is metered once for the workspace. When a pool is spent, work in that pool pauses until reset. Teams and Enterprise can choose extra billed usage, but it is opt-in.

Yes. Teams don't work in one mode, so you assign each member the tier that fits them — not everyone needs Max or Ultra — and allocate usage per seat from one workspace. A reviewer-heavy dev can sit on Ultra while the rest of the team is on Pro, all under a single bill.

Yes — switch the toggle to Annually and every paid tier drops 10%: Pro becomes $27, Max $54, and Ultra $90 per seat / mo, billed once a year. Monthly plans bill via the payment method on file; annual plans bill the seat base up front.