The Cost of a Correct Triage
Raw logs get AI triage wrong every time - zero correct verdicts across nine test runs, because the model can't tell malicious from benign without enrichment context. OCSF-normalized data fixes that: enrich once at ingest instead of per query, and you get correct triage at $0.48 per alert - 23% cheaper than raw logs, with the accuracy raw logs can't reach at any price.

The Cost of a Correct Triage
We ran Claude Opus 4.8 through the triage of one security alert, three ways - as raw vendor logs, as OCSF-normalized events, and as field-pruned OCSF - repeated and graded for correctness against known ground truth. Every number here is measured, not modeled - using OCSF as the test variable, though the mechanism generalizes to any security-semantic normalization schema.
Other vendors also normalize to OCSF - but normalization that relies on AI agents/co-pilots introduces fragility because of the non-deterministic nature of AI. Axoflow normalizes autonomously and deterministically: the same security-semantic field mapping, every source, every run, without manual intervention. That determinism is what makes the cost reduction shown here reproducible in production, not just in a benchmark.
Raw logs can't be triaged correctly at any price.
No geo/intel/asset context → benign traffic gets flagged as hostile. OCSF's value is not cheaper tokens - it is making a correct, low-false-positive triage achievable cheaply.
Where enrichment lives determines what a correct triage costs.
OCSF moves enrichment from query time - paid on every alert - to ingest time, paid once. Across hundreds of alerts a day, that's the number that compounds.
Results at a Glance
One alert, 82 correlated logs, Claude Opus 4.8, agentic loop. Each tier in its best correct-capable configuration, 3 runs each, graded against ground truth:
| Configuration | Correct | $/Correct Triage | Turns | Total Tokens |
|---|---|---|---|---|
Raw + hight effort + discipline + thread-intel look up | $ 0.62 | 6 | 247K | |
OCSF (all fields) + medium effort + discipline | $ 0.48 | 6 | 218K | |
OCSF (pruned) medium effort + discipline | $ 0.28 | 6 | 135K |
And the finding that frames everything - raw without enrichment cannot be made correct at any price:
| Raw condition (NO Enrichment) | Runs | Correct |
|---|---|---|
Baseline (raw log) / any effort / disciplined / combined | 9 | 0 |
+ threat-intel look up | 3 | 3 |
Raw failed every no-enrichment run on false positives - flagging benign IPs as hostile - because raw logs carry no geo/intel/asset fields to separate the RU known-scanner from benign US traffic. OCSF carries them inline; raw must fetch them, and only then gets it right.
‍
Boundary Conditions
Unit of work | 1 security alert with 82 correlated log records (4 formats, ~20 each + duplicates) |
Formats | Cisco ASA firewall syslog · Windows Security 4625 (tab-delimited) · CrowdStrike-style EDR JSON · AWS CloudTrail JSON |
Model | Claude Opus 4.8, $5 / MTok in, $25 / MTok out |
Harness | Claude Code with default scoped read-only tools |
Tiers | raw (heterogeneous vendor logs) · OCSF curated (normalized, dedup'd, enriched, all fields) · OCSF pruned (only detection-relevant fields) |
Levels tested | effort (high vs medium), a "rapid-triage" discipline system prompt, and a threat-intel/asset lookup for the raw tier |
Grand truth | One RU known-scanner (198.51.100.23) brute-forces a DC, mints an AWS IAM key for a service account (privilege escalation), and runs a QakBot loader; four benign noise IPs must not be flagged |
Method | 3-4 repetitions per cell (agentic cost varies ±40% run-to-run); each run graded for correctness by an independent Opus panel against ground truth |
How the Alert Is Handled with Raw Logs
A detection engineer drops the correlated logs into a file and points the agent at it. From the actual run transcripts, raw triage proceeds:
- Write to file, then "parse and triage raw.log."
- Discover the formats - the agent runs head samples and finds four different formats mixed together.
- Try
jq- works on the CloudTrail/EDR JSON, dies on the ASA syslog and the tab-delimited Windows 4625. - Hand-roll a parser per non-JSON format - switch to
sed/awk/regex,write a pattern, get a partial match, re-read the fat raw line to fix field offsets, wrestle the priority header and duplicated ip/port (ip/port) tuples, retry. This dominated the loop (raw baseline ran 14-32 turns). - Dedup, correlate across formats, render a verdict.
And here is where raw fails:
with no enrichment, the agent cannot distinguish the malicious 198.51.100.23 from benign IPs that also touched the DMZ - so it either flags them all or mis-attributes. All 9 no-enrichment raw runs produced false positives; 0 were correct. To get it right, raw must additionally look up each IP/host/hash in a threat-intel source - extra turns to acquire what OCSF already carries.
Raw vs OCSF (curated) vs OCSF (pruned) - the Workflows
| Raw | OCSF (All fields) | OCSF (Pruned) | |
|---|---|---|---|
Parser work | hand roll sed/awk/regex/format | one qj, first try, all records | one qj, first try |
Enrichment | absent – must look up externally | inline | inline |
Per Record size | ~240 tok | ~180 tok | ~45 tok |
Turns to triage | 6 | 5 | 4 |
Correct without enrichment | No (0/9) | Yes | Yes (mostly) |
Failure mode | Over flags beingn IPs | - | over pruning can drop fields linking attack stages |
The two reduction tiers attack different things: OCSF normalization removes the parser-crafting and supplies the enrichment inline; field-pruning further shrinks the payload per record. Both shorten the loop - but pruning has a floor.
‍
Token & Cost Per Tier
Full investigation, default settings (4 runs/tier, mean)
| Tier | Turns | Total tokens | $/alert |
|---|---|---|---|
Raw | 20 | 1,119,121 | $1.52 |
OCSF (all fields) | 16 | 619,514 | $1.04 |
OCSF (pruned) | 11 | 480,446 | $1.00 |
Raw to OCSF at default settings: 45% fewer tokens, s 31% cheaper. Real, but modest - and erodable by a good prompt.
The metric that counts - cost to a correct triage (3 runs/tier, graded)
| Tier | Correct | $/correct | Turns | Total tokens |
|---|---|---|---|---|
Raw + hight + discipline + intel look up | $0.62 | 6 | 247,593 | |
OCSF (all fields) + medium + discipline | $0.48 | 5 | 218,227 | |
OCSF (pruned) medium + discipline | $0.28 | 4 | 134,510 |
- OCSF is 23% cheaper than raw per correct triage; pruned 54% cheaper - but pruned hit a fidelity floor: 1 of 3 runs missed the multi-stage chain. It produced no false positives, but under-called the attack.
- Raw's premium is the price of re-acquiring enrichment. Raw went 0/9 to 3/3 only once given a threat-intel lookup; it then costs 23-54% more than OCSF.
‍
Where Did the Tokens Go?
Across every tier, the cost is re-reading the accumulating transcript each turn, not the logs themselves:
| Tier (baseline) | Input (fresh) | Output | Cache/write | Cache/read | Read % |
|---|---|---|---|---|---|
Raw | 8,776 | 11,474 | 51,376 | 1,041,493 | 93% |
OCSF (all fields) | 8,700 | 13,676 | 37,941 | 559,198 | 90% |
OCSF (pruned) | 8,597 | 14,449 | 38,827 | 418,552 | 87% |
87-93% of all tokens are cache re-reads. Because this re-read cost grows with the number of turns, anything that shortens the loop attacks the dominant term directly. In the best-correct configs, fewer turns drop the read share to 78-83% and the totals to 135-248K.
‍
Possible Cost Levers
Measured token reduction vs the default baseline (factorial across tiers):
| Lever | Token/cost reduction | Correctness impact |
|---|---|---|
Tight “rapid-triage” system prompt | -69% | erodes raw to 0 correct (cheap-but-wrong) |
Effort=medium (vs. high) | -49% | neutral-4o-navigate on raw |
OCSF normalization (raw to curated) | -45% tok / -31% cost | preserves to correctness |
Field pruning (curated to pruned) | further ~22% |
The single biggest token reducer is the system prompt (-69%) - but it is correctness-blind. The same prompt that makes raw cheap makes it wrong: it dispositions fast on data it can't disambiguate, and over-flags.
Key finding:
The operation that contributes most to using fewer tokens while staying correct is OCSF normalization plus its inline enrichment. It is the only lever that lets the agent go cheap and reach the right verdict - because it removes the parser-crafting and hands the agent the geo/intel/asset facts it would otherwise have to spend turns fetching.
Get started with Axoflow
Ready to normalize your security data?
Axoflow normalizes to OCSF deterministically - same field mapping, every source, every run. No AI agents in the pipeline.