Deep-Research Chat

Deep-Research Chat is plain-language Q&A over your repository and everything Sigilix has already learned about it. Ask why a finding fired, what a change is likely to affect, or how a subsystem fits together — and get answers anchored in the index, the code graph, and past reviews and their receipts, rather than a confident guess from whatever happened to fit in a context window.

The distinction is the substrate. A generic code chatbot reads what fits in its window. Deep-Research Chat reads from the earned-context layer — the same verified understanding of your repo that powers hosted reviews. The chat loop is not the product; the verified context your model fetches is.

Deep-Research Chat is included with your plan — sign up free or start a 14-day Pro trial to use it. Questions? Contact support@sigilix.ai.

Opening the chat

The chat lives in the CLI. Run sigilix with no arguments to open the interactive UI in your repo, or sigilix run "…" for a one-shot question:

sigilix                                        # interactive
sigilix run "what calls money.fromCents?"      # one-shot

See CLI Command Reference for flags, and Sigilix CLI for install and sign-in.

What you can ask

Deep-Research Chat is built for the questions that need grounding, not generation — the ones where a wrong answer is worse than no answer.

Why did this finding fire?

Retrieve a past finding, the specialist that raised it (logic, security, performance, or tests), the code it cited, and its proof-tier receipt — and ask the chat to explain the reasoning behind it.

What does this change affect?

Walk the code graph from the lines you touched to their callers, dependents, and the symbols downstream — so blast-radius answers reason about the real edges, not a guess.

How does this subsystem fit together?

Ask for an architectural read of a module or flow, answered from the index and code graph rather than a partial file dump.

What has Sigilix learned here?

Retrieve taught rules and past dismissals for an area of the repo — what the system already knows about how your team wants this code reviewed.

How grounding works

Every answer is built from retrieved, verified context — not from the model’s parametric memory of your codebase, which it does not have.

Retrieve from earned context

The chat resolves your question against the earned-context layer: the index for relevant files and symbols, the code graph for callers and dependencies, the trust ledger and review memory for past findings, receipts, and taught rules.

Anchor to real artifacts

Retrieved facts come with provenance — the file and lines a symbol lives at, the PR a finding was raised on, the proof tier a receipt carries. The chat reasons over these anchors rather than improvising.

Answer from evidence

The model composes an answer grounded in what it retrieved, citing the code and history it drew on — so you can follow the answer back to its source.

Stay honest about gaps

When the earned-context layer does not contain what a question needs, that is a grounded “I don’t have evidence for that” rather than a fabricated answer. Believability is the same value as on a PR: the chat would rather be silent than wrong.

Retrieving findings and their receipts

The chat can pull up a past finding and the proof-tier receipt it carried when it posted — the same trust ledger that backs the pills on a PR. This is what lets you interrogate the review history, not just the code:

VERIFIED

The finding was corroborated by a signed receipt from your own CI. The strongest tier.

REPRODUCED

The finding was demonstrated by execution — Sigilix’s sealed sandbox re-ran the cited code and reproduced the behavior.

GROUNDED

The finding was anchored to cited code and concrete evidence in the diff or surrounding context.

MODEL

The finding rested on model judgment — surfaced, but flagged as the lowest-evidence tier.

Ask the chat “why did the Security specialist flag the session compare on PR #214, and what tier was it?” and it can retrieve that finding, its cited code, and its receipt — and explain it — instead of re-deriving an opinion from scratch.

A grounded exchange

$ sigilix
 
sigilix › why did the order-total finding fire on the refunds PR?
 
  Retrieving from earned context…
    ↳ finding f-3391 · Logic · GROUNDED · PR #198
    ↳ cited: src/billing/refund.ts L54–61
    ↳ code graph: refund.ts → ledger.applyDelta → money.fromCents
 
  The Logic specialist raised it because `refund.ts` computed the credit in floating-
  point dollars and passed it to `applyDelta`, which the ledger expects
  in integer cents (see money.fromCents). The finding cited L54–61 and
  was GROUNDED — anchored to that conversion, not inferred. A taught
  rule on this repo ("we use integer cents") reinforced it.

Illustrative transcript. The shape is real — retrieval with provenance, a specialist and proof tier on the finding it recalls, and an answer that points back at cited code and history.

Grounded vs. generic chat

It reads the whole repo, not a window

Because answers are built from the index and code graph, the chat reasons about callers, dependencies, and symbols across the entire repository — the same context-before-judgment that powers reviews. It is not limited to the files you paste in.

It remembers what reviews found

Past findings, their cited code, their proof-tier receipts, and the rules you’ve taught are all retrievable. The chat can tell you not just what the code does, but what Sigilix has already concluded about it — and why.

It declines rather than guesses

A generic chatbot will always produce an answer. Deep-Research Chat is held to the same believability bar as a review: when the evidence isn’t there, it says so instead of confabulating.

It uses the model you bring

On paid tiers, the chat can run on your own model-provider key — Anthropic (Claude), OpenAI (GPT), or another provider you use — instead of Sigilix’s hosted models. Whatever model answers is still handed Sigilix’s verified context. See Bring Your Own Key — including the grounding trade-off, since a bring-your-own model may not honor injected context as fully as a hosted one.