Evidence

Every finding, one click from its proof

Decim records exactly what each conclusion rests on: the log lines it cited, with their position and a hash; the successful runs it compared against; the code at a specific commit; the ticket as it was; and the check results your team submitted.

A claim without a citation is a guess

The principle everything else follows from: every conclusion must be traceable to a specific piece of evidence.

Academic work carries citations; incident reports usually do not. In a paper, an uncited claim is a defect anyone can point at. In an incident report, "we think the currency filter changed" sits comfortably next to "the currency filter changed", and a reader six weeks later cannot tell which was established and which was inferred at two in the morning.

That ambiguity costs twice. During the incident, a plausible claim gets acted on before anyone checks it. Afterwards, the report becomes the record of what happened, and nobody can work out which parts were solid.

So a Decim finding is not written first and supported later. Each observation is saved with the evidence it cites, each hypothesis lists the evidence for and against it by reference, and the diagnosis rests on those. Here is how an observation from the worked investigation renders, using sample data from the demo workspace:

An observation and its proof — demo workspace text
Observation  stg_transactions — found something                       88% confidence
             EUR rows stop arriving in staging on Tuesday

  Ledger load jobs  ·  ledger-nightly  ·  step 3            2026-10-13 02:14:09 UTC  record 48213
  │ 2026-10-13 02:14:09 usp_load_transactions Loaded 57911 rows for USD

  Ledger load jobs  ·  ledger-nightly  ·  step 3            2026-10-13 02:14:09 UTC  record 48214
  │ 2026-10-13 02:14:09 usp_load_transactions Loaded 12206 rows for GBP

  Ledger load jobs  ·  ledger-nightly  ·  step 3            2026-10-13 02:14:10 UTC  record 48215
  │ 2026-10-13 02:14:10 usp_load_transactions Step completed successfully (0 errors)

  Baseline: what normal looks like
  │ 2026-10-12 02:13:52 usp_load_transactions Loaded 40903 rows for EUR

Every line under the observation is a citation, not a quotation someone typed. The claim ("EUR rows stop arriving in staging") is above; the evidence is below; and the baseline from the night before shows what the step normally logs. The finding is the difference between the two.

Kinds

What counts as evidence today

Six kinds, each cited in a way that fits what it is.

Different questions need different evidence, and each kind is cited in the way that makes it checkable. A log entry is identified by where it sits in what was collected. Code is identified by a file, a line range and a commit. An attachment is identified by its content hash. A check result is identified by the check that asked for it.

Evidence kinds and how each is cited
Kind What it holds How it is cited
Log linesEntries from Google Cloud Logging (named log sources), files and Windows Event Logs read through the optional agent, and log files attached to the incidentCited by byte offset or record ID, with the exact excerpt and a hash of what was collected
BaselinesThe same step's logs from successful runs, up to 30 days backCited the same way, and shown beside the finding as what normal looks like
CodeFiles, commits and pull requests from the GitHub repositories you selectedCited by file and line range from a snapshot frozen at a commit
Ticket snapshotA linked Jira issue: description, comments and attachmentsCopied once when linked; later edits to the ticket do not change it
AttachmentsFiles you add to the incident, up to 500 MB each: log exports, data extracts, screenshotsCited by file and line range, with the file's SHA-256
Check resultsOutput your team submits for a check Decim proposed: a query result, a fetched file, notesTied to the check and to the revision it triggered
Logs

Cited log lines, to the byte

A citation records where the line is, what it says, and which read it came from.

During an investigation Decim reads logs step by step: from Google Cloud Logging through the named log sources you defined, through the optional Windows agent for files and Windows Event Logs, and from log files attached to the incident. Each read is a collection task, and its result is stored with a SHA-256 hash.

When an observation cites a line, it records the task, the position of the excerpt, the excerpt itself, and the hash. For record-based sources — Cloud Logging entries, Event Log records — the position is the record, plus a byte range within its message. For files, it is a byte offset and length in the file. The simplified record below is the first cited line in the example above:

Log citation — Cloud Logging entry (simplified) json
{
  "location": {
    "taskId": "5b0e2c4a-…",
    "recordIndex": 214,
    "offset": 0,
    "length": 67,
    "excerpt": "2026-10-13 02:14:09 usp_load_transactions Loaded 57911 rows for USD"
  },
  "source": "Ledger load jobs",
  "channel": "ledger-nightly",
  "relativePath": null,
  "timestampUtc": "2026-10-13T02:14:09Z",
  "recordId": 48213,
  "sha256": "c41f…9e07"
}

The same line read from a log file through the agent is cited by byte offset instead:

Log citation — file read through the agent (simplified) json
{
  "location": {
    "taskId": "a91d77f3-…",
    "recordIndex": null,
    "offset": 1048217,
    "length": 67,
    "excerpt": "2026-10-13 02:14:09 usp_load_transactions Loaded 57911 rows for USD"
  },
  "source": "etl-host-02",
  "relativePath": "logs\\ledger\\ledger-nightly-20261013.log",
  "timestampUtc": null,
  "recordId": null,
  "sha256": "7be2…41ac"
}
The fields that make a log line into evidence
Field What it is Why it matters
location.taskIdThe collection task that read the dataTies the citation to one specific read, not to a source in general
offset, lengthByte range of the excerptIn a file, the position in the file; in a record, the position in its message
recordIndex, recordIdWhich log entry, for record-based sourcesCloud Logging and Event Log entries are cited as records, not as byte positions in a file
excerptThe exact cited textChecked against the collected bytes before the finding is saved
source, channel, relativePathWhere it came fromThe named log source or agent, the log or channel, the file path
timestampUtcWhen the entry was written, where the source records itLets you line the citation up against the run and the release
sha256Hash of the collected payloadShows which exact read the excerpt came from
Baselines

Baselines from successful runs

Most log lines look the same on good nights and bad ones. The evidence is in the difference.

A failing run read on its own invites over-interpretation. A warning that appears every night, a slow step that is always slow, a retry that always succeeds: each looks suspicious in isolation and means nothing. So for each step Decim also reads successful runs, up to 30 days back, and cites them as a baseline next to the finding.

In the example, the baseline is one line from the previous night: Loaded 40903 rows for EUR. It turns "the log has USD and GBP lines" — which is unremarkable — into "the log has USD and GBP lines and is missing the EUR line it has had on every previous run", which is the finding. Baseline citations carry the same location, excerpt and hash as any other citation, and the PDF report prints them under the heading "what normal looks like".

Absence, and honest gaps

The decisive evidence is often a line that is not there. That is only meaningful if the search could have found it.

"There was no EUR line on Tuesday" is a finding, and it is the finding the example turns on. But a negative is weaker than a positive: it depends on having read the right source over the right window. A missing line in a log that was only partly read means nothing.

So Decim records what it could not read as explicitly as what it found. A step whose source returned nothing ends as "no logs"; a step with too little to judge ends as "not enough logs"; a source that could not be reached ends as "collection unavailable". When a Cloud Logging read hits its entry or size limit, the gap says so and asks for a narrower window or filter. When a large file is sampled rather than read in full, a citation that falls between the samples is refused. That is why the example's absence carries weight: the run was read continuously, and the baseline shows the EUR line on the night before.

Code

Code citations from a frozen snapshot

A file, a line range, and the commit it was read at.

Decim reads code, commits and pull requests from the GitHub repositories you selected. When a hypothesis or a pipeline match cites code, it cites a file and a line range from a snapshot of the repository frozen at a specific commit, together with the excerpt. Later commits do not move the citation: sql/stg/usp_load_transactions.sql, lines 4–9, means those lines at that commit, not whatever is there today.

Commits are evidence in their own right. In the example, the diff of 9f3c2e1 is what shows the hard-coded ('USD','GBP','EUR') list becoming a parameter @Currencies with a default of 'USD,GBP'. The hypothesis cites the changed lines, and the report labels the excerpt with the commit it was read at.

If a hypothesis was formed against a different revision of the code from the one the pipeline was matched on — the repository moved during the investigation, say — the hypothesis carries a visible note saying so, so you know the two pieces of reasoning looked at different code.

Inputs

Ticket snapshots and attachments

What you bring to the incident becomes evidence too, and it is pinned the moment it arrives.

Jira ticket snapshot

When you link a Jira Cloud issue to an incident, Decim imports its description, comments and attachments once, as an immutable snapshot, over a read-only connection. The investigation reads that snapshot. If someone edits the ticket, adds a comment or deletes an attachment afterwards, the evidence the investigation used is unchanged, and the snapshot is reproduced in the report's appendix as the source ticket. In the example, FIN-2291 ("EUR totals missing from the daily finance dashboard since Tuesday") is what pointed Locate at the finance dashboard and, through it, at fact_transactions.

Attachments

You can attach files to an incident at any time, up to 500 MB each: log exports from systems Decim cannot reach, data extracts, configuration files, screenshots. Text files are cited the way code is, by file name and line range with the excerpt, plus the file's SHA-256 and the version of the upload, so a citation always points at the exact file content that was read. A log export attached to the incident can serve as a baseline as well as a finding.

Check results your team brings back

When the deciding evidence is somewhere Decim cannot read, the answer from your team is evidence with its own record.

Some questions can only be answered where Decim has no access, most often a database. For those, Decim writes a check: a read-only SQL query validated against a read-only allowlist, a file to fetch, or guided steps. Each check states which hypotheses it tests and, before anyone runs it, what result would support them, refute them, or leave the question open. Decim never runs the query; your team does, with their own access.

The submitted result — pasted output, an uploaded file, an explanation — is stored against the check with the time it was submitted, the submission appears in the workspace audit log, and it starts a new revision of the hypotheses. In the example, the team's result showed EUR row counts in staging falling to zero on 13 October while USD and GBP held steady. That result, the cited log lines and the commit diff are the three independent pieces of evidence the diagnosis rests on. Because the check wrote down its criteria in advance, you can see that the result was read against a standard set before it came in, not one chosen after.

Linking

From a finding to its proof

In the incident view and in the PDF report, every claim points down to what it rests on.

In the incident view, each observation from the log sweep expands to its cited lines and its baseline. Each hypothesis lists the evidence that supports it and the evidence that contradicts it, by reference, along with the code it cites and the tests that would settle it. A diagnosis points at the hypothesis it confirms, and that hypothesis points at its evidence. You can walk from the headline down to a single log line without leaving the incident.

The one-click PDF report keeps the same links on paper, so someone who never opens Decim can still check the reasoning. An incident that is still in progress exports as a clearly marked interim report, and the same record is available as JSON.

Where evidence appears in the PDF report
Section What it shows
Root cause analysisEach hypothesis with its confidence, the rationale for it, evidence that supports and contradicts it by reference, code excerpts labelled with the commit, and a chart of confidence across revisions
EvidenceEach observation with its cited log lines (source, path or channel, timestamp, record ID), attachment excerpts with their SHA-256, and the baseline beside it
Verification checksEach check with what it tests, the query or steps, when it supports, refutes or is inconclusive, and the result submitted
RemediationThe proposed fix, the diagnosis it rests on, and any inputs still required
AppendixThe original report, the source ticket snapshot, and the detail behind locating the pipeline
Retention

Retention and processing

Raw material is short-lived. The cited excerpts that make a conclusion checkable stay with the record.

Evidence is gathered for one incident, around one pipeline and one time window. There is no continuous log collection from your systems; Decim reads what the investigation needs, within the request, byte and model-call limits each investigation has.

Once an incident closes, the raw material is purged on a short schedule. What remains is the record: the excerpts that were cited, with their location and hash, alongside the reasoning built on them. That is enough to show what the conclusion rests on without keeping whole log files indefinitely.

Retention after an incident closes
What How long
Raw payloads collected through the agentPurged 3 days after the incident closes
Files attached to the incidentPurged 7 days after the incident closes
Cited excerpts, with their location and hashKept with the incident record

Common questions

Can I verify a cited log line myself?
Yes. A citation records the source, the log or file path, the byte offset or record ID, the timestamp and the exact excerpt. Open the same entry in Cloud Logging, or the same file at the same offset, and you should find the same text. Decim also checks every excerpt against the bytes it collected before saving a finding, so a citation cannot point at a line that was never read.
Does Decim read our database?
No. Decim does not connect to databases today. When the deciding evidence is in a database, it writes a check: a read-only SQL query, validated against a read-only allowlist, that your team runs with their own access. The result you submit becomes evidence. Database connectors are planned.
Is our data redacted before it is processed?
Not today. Evidence — code, logs, ticket content, attachments — is processed by a third-party language-model provider without redaction. Redaction is planned. Scope your log sources and attachments with that in mind, and see the security page for the full picture.
How long do you keep our data?
Raw payloads collected through the agent are purged 3 days after an incident closes, and attached files 7 days after. The cited excerpts, with their location and hash, are kept with the incident record so the conclusion stays checkable.
What if the repository changed after the investigation?
Code citations point at a snapshot frozen at a specific commit, so later commits do not move them. If a hypothesis was formed against a different revision from the one the pipeline was matched on, the hypothesis says so.
How is this different from attaching logs to a ticket?
Addressability. A log excerpt pasted into a ticket has no identity: nothing can reference it, nobody knows where in the file it came from, and nobody can tell whether it was the whole story or the part that supported the argument. A citation has a location, a hash, a baseline beside it, and a reverse link to every finding that rests on it.

Related: investigations for how evidence settles hypotheses; the agent for how files and Windows Event Logs are collected on your own servers; security for retention, access and processing.

Get started

Bring us a pipeline that broke last week

The fastest way to evaluate this is a real incident you already know the answer to. If Decim gets it wrong, that is a far more useful demo than one where it doesn't.