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:
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.
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.
| Kind | What it holds | How it is cited |
|---|---|---|
| Log lines | Entries from Google Cloud Logging (named log sources), files and Windows Event Logs read through the optional agent, and log files attached to the incident | Cited by byte offset or record ID, with the exact excerpt and a hash of what was collected |
| Baselines | The same step's logs from successful runs, up to 30 days back | Cited the same way, and shown beside the finding as what normal looks like |
| Code | Files, commits and pull requests from the GitHub repositories you selected | Cited by file and line range from a snapshot frozen at a commit |
| Ticket snapshot | A linked Jira issue: description, comments and attachments | Copied once when linked; later edits to the ticket do not change it |
| Attachments | Files you add to the incident, up to 500 MB each: log exports, data extracts, screenshots | Cited by file and line range, with the file's SHA-256 |
| Check results | Output your team submits for a check Decim proposed: a query result, a fetched file, notes | Tied to the check and to the revision it triggered |
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:
{
"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:
{
"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"
} | Field | What it is | Why it matters |
|---|---|---|
location.taskId | The collection task that read the data | Ties the citation to one specific read, not to a source in general |
offset, length | Byte range of the excerpt | In a file, the position in the file; in a record, the position in its message |
recordIndex, recordId | Which log entry, for record-based sources | Cloud Logging and Event Log entries are cited as records, not as byte positions in a file |
excerpt | The exact cited text | Checked against the collected bytes before the finding is saved |
source, channel, relativePath | Where it came from | The named log source or agent, the log or channel, the file path |
timestampUtc | When the entry was written, where the source records it | Lets you line the citation up against the run and the release |
sha256 | Hash of the collected payload | Shows which exact read the excerpt came from |
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 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.
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.
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.
| Section | What it shows |
|---|---|
| Root cause analysis | Each 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 |
| Evidence | Each 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 checks | Each check with what it tests, the query or steps, when it supports, refutes or is inconclusive, and the result submitted |
| Remediation | The proposed fix, the diagnosis it rests on, and any inputs still required |
| Appendix | The original report, the source ticket snapshot, and the detail behind locating the pipeline |
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.
| What | How long |
|---|---|
| Raw payloads collected through the agent | Purged 3 days after the incident closes |
| Files attached to the incident | Purged 7 days after the incident closes |
| Cited excerpts, with their location and hash | Kept with the incident record |
Common questions
Can I verify a cited log line myself?
Does Decim read our database?
Is our data redacted before it is processed?
How long do you keep our data?
What if the repository changed after the investigation?
How is this different from attaching logs to a ticket?
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.