OCSF in practice
OCSF version drift: what a mapping pack costs per release
When I wrote up the ways a hand-maintained OCSF mapping fails, version drift was the fourth on the list, where every OCSF bump means re-reading the schema diff against each source mapping you maintain, and where teams I've worked with end up pinning to an old OCSF version to avoid the work, which then strands them when detection content vendors publish new rules against the newer schema (field-mapping anti-pattern). My own crosswalks are a small instance of the same habit, because the six I built against OCSF 1.8.0 for the six-schemas essay carry a version note saying that 1.9.0 shipped on 3 August 2026, that their Account Change column now points at a deprecated class, and that they stay 1.8.0 results until I re-score them, which as I write this they still are.
Neither essay put a number on what a release costs, so this piece does that for a different and smaller set of mappings, the lab's six-source fidelity corpus plus an identity-lifecycle mapping of one of those sources, Okta, re-scored against both 1.8.0 and 1.9.0 in a lab run on 2026-11-15. With the mappings held fixed, the 1.8.0-to-1.9.0 step changed one path out of 181 on the six sources, and the re-score pointed at two places I think are more worth knowing about, an identity activity enum that is renumbered across a class move (found in a comparison after the run, and not scored), and a vendor mapping that declares 1.9.0 while still emitting a class 1.9.0 deprecated (read from the code, with nothing run).
Reading time: about 12 minutes. Evidence tier: A for the OCSF 1.8.0 and 1.9.0 schema exports and changelog; B for the lab re-score (single host, agent-run and checked by a second agent) and for vendor documentation and code showing what a mapping declares; D for the 40-mapping reasoning in the close.

Release
What a release changes
OCSF 1.9.0 shipped on 2026-08-03, and its changelog lists no breaking changes, which holds structurally, since no class, attribute or enum value was removed between the 1.8.0 and 1.9.0 exports and nothing became newly required. It added user_management and role_management classes to consolidate identity lifecycle events, plus clipboard_activity and device_power_state_activity, and it added objects for AI-agent and identity telemetry, among them ai_agent, delegation, iam_role and attestation, with a new record_integrity profile and an ai_operation profile, already present in 1.8.0, that 1.9.0 extended and attached to the system, network, application and IAM base classes (OCSF changelog and schema exports, Tier A). The compatibility surface is the deprecation list, where account_change and user_access (User Access Management) are deprecated in favor of user_management.
The attribute side was counted by a lab script against pinned, hashed copies of the 1.8.0 and 1.9.0 schema exports, and an independent script reproduced it: two classes and 33 attribute slots across 26 distinct names carry a since: 1.9.0 deprecation marker, or 35 slots across 28 names with the OCSF profiles applied (Tier A for the schema, Tier B for the count). Six of those are the CPU fields on device_hw_info (cpu_bits, cpu_cores, cpu_speed, cpu_type and two architecture fields) folding into a new cpu_info_list array, six are DNS opcode, flag and packet-ID fields moving off the query and answer objects onto dns_activity, actor.app_name and actor.app_uid give way to the structured actor.application, and comment gives way to notes across seven finding classes. Each of the 33 markers also names its replacement in a machine-readable superseded_by field, which matters for the routine further down.
None of that breaks a mapping on the day of release, and that is worth a second look, because a deprecation that breaks nothing is the kind of change teams rarely schedule work for. The cost shows up later, when detection content written against user_management doesn't match events still landing in account_change, or when a downstream consumer starts reading the new structured field and finds it empty because the mapping still writes the deprecated flat one.
Baseline
The baseline being re-scored
Two lab mapping benches were pinned to OCSF 1.8.0, and this piece re-scores the first.
- The six-source fidelity corpus maps Okta System Log to Authentication (3002), CrowdStrike Detection Summary to Detection Finding (2004), PAN-OS TRAFFIC and Cisco ASA to Network Activity (4001), Cisco Umbrella to DNS Activity (4003) and Zscaler ZIA Web to HTTP Activity (4002). Across 251 documented fields, 148 land on a typed attribute, 33 cross a boundary (coerced) and 70 have no typed home, for 59% coverage and 41% lossy, ranging from 46% for Umbrella to 70% for CrowdStrike, and 23 of 31 named detections lose at least one field they depend on (Tier B; the mappings were written field by field against documented vendor schemas by the bench's agents).
- The pipeline normalization bench scored Tenzir 6.0.0's shipped Zeek mapping against a hand-built gold, again on 1.8.0. Its June figures have since been corrected by an erratum, and the re-score of that bench is in the companion piece on what "OCSF-native" delivers; nothing below depends on them.
The corpus's notes already record version lag in a mapping the bench couldn't score. The ZIA-to-OCSF integration that AWS documents on its CloudWatch pipelines source page for Zscaler targeted OCSF v1.5.0 when the bench was built, against the bench's own best-effort 1.8.0 mapping of the same logs, and the same page still said "supports OCSF schema version v1.5.0" on 2026-11-16, four minor versions behind 1.9.0 (AWS documentation, read 2026-11-16, Tier B for what the integration declares). I think that's a more useful frame for "lifecycle cost" than any single release diff, because what accumulates is the distance between the version your sources ship and the version your detections assume, and that distance grows by one every release you don't spend effort closing.
Measurement
The re-score
The re-score ran on 2026-11-15 (ocsf-1.9-rescore, lab commits aa918db and 2cf42f9; Tier B, single host). An agent session ran it against a pre-registration that the same agent froze beforehand and that I haven't reviewed, and a second agent then reproduced every number it could reach without Docker or the network. It ported the six-source corpus to a strict validator over the full 1.8.0 and 1.9.0 schema exports, one that fails on any path segment the schema doesn't define and reports every target carrying a deprecation marker, whatever release deprecated it. An earlier static check, which wasn't pre-registered, had already found the same four records listed below, so the six-source half of the re-score confirms a result that was known going in and shouldn't be read as an independent test.
| Source | Field | Mapped to | Strict finding | Flagged on |
|---|---|---|---|---|
| PAN-OS | src_model | src_endpoint.hw_info.model | Invalid: device_hw_info has no model | 1.8.0 and 1.9.0 |
| PAN-OS | dst_model | dst_endpoint.hw_info.model | Invalid: device_hw_info has no model | 1.8.0 and 1.9.0 |
| Zscaler | respcode | http_status | Deprecated since 1.1.0, use http_response.code | 1.8.0 and 1.9.0 |
| Okta | client.id | actor.app_uid | Deprecated since 1.9.0, use actor.application.uid | 1.9.0 only |
The six sources barely move. The two PAN-OS paths never resolved in either version, and the original validator accepted them because it stopped checking once a path descended into an object the bench hadn't transcribed, while the respcode target survived into a published bench because the same validator checked only that a path existed. The two invalid PAN-OS paths take the published 148 typed fields to 146 and coverage from 58.96% to 58.17%, while the Zscaler field stays counted as typed because a deprecated attribute still exists in the schema. The move to 1.9.0 then adds the Okta row and nothing else, so 1 of 181 typed and coerced paths drifts (181 as published, 179 of them valid) and no coverage figure moves, per source or in total. That figure holds the mapping fixed, so it counts what a release breaks and not what it newly makes mappable, and whether 1.9.0 gave any of the 72 unmapped fields a typed home is something this re-score didn't check. Counted across every release up to 1.9.0 instead of one step, 2 of the 179 valid paths sit on a deprecated attribute, though releases are uneven, with one attribute slot deprecated in 1.8.0 against 35 in 1.9.0 and 31 in 1.4.0, so I wouldn't read one step as a rate. Getting back to zero invalid and zero deprecated targets takes three mapping.py records on 1.8.0 and four on 1.9.0, and one named detection, Zscaler's HTTP error-rate monitoring, reads respcode.
One validator detail matters for anyone repeating this. The strict check applied all but two of the OCSF profiles at once (the two OS user profiles the server refuses to combine), and with the no-profile export 22 paths fail instead of 2. The 20 between them, on attributes such as device.*, firewall_rule.* and disposition, are valid only through a profile, and the mapping file never records declaring one, so they are false defects only if the emitted events list those profiles in metadata.profiles, which the bench doesn't say and which is a finding of its own.
Identity
The identity arm
The identity arm tested whether identity-lifecycle mappings carry more of a release's cost than the six sources do. It was built from Okta's 50 documented LogEvent fields for two event types, user.lifecycle.create and user.lifecycle.activate, mapped to account_change on 1.8.0 and to user_management on 1.9.0 by a scripted rule. The move changed the class (3001 to 3007), one activity value (Enable from 2 to 4), the two type_uid values derived from those, and the client.id target the six sources already share, so the identity arm changed five mapping decisions against the six sources' one, though the class move alone nearly guarantees a gap like that. The more informative question was whether any attribute path would move because of the class consolidation, and none did, with no field lost either (31 typed, 5 coerced and 14 unmapped before and after). So on this source the 1.9.0 cost is a class and activity-enum remap plus that one actor.app_uid deprecation.
The part I think matters most came out of a comparison made after the run and not scored. The activity enum is renumbered between the two classes, so that of the twelve named activities only Create (1) and Disable (5) keep their integers, and a migration that swaps class_uid and keeps the old activity_id would turn every Enable (2) into Update, every Password Change (3) into Delete, every Password Reset (4) into Enable and every Delete (6) into Lock. A path check passes that event, and OCSF's own server validator would only warn about it, and only when the event still carries the old activity_name beside the number, since the sibling string is optional, though the same validator would also warn that the event's class is deprecated (ocsf-server validator2.ex, read 2026-11-16; no such event was run through it). The schema answers part of the user_access question without a run, since all four of that class's activities renumber in user_management, Assign Privileges from 1 to 14, Revoke Privileges from 2 to 15 (now captioned Remove Privileges), Assign Role from 3 to 16 and Remove Role from 4 to 17 (Tier A). Beyond that I'd keep the scope as narrow as the test was, since it covers two Okta event types, maps no user_access event, includes nothing that wrote user_result, the one account_change attribute that user_management drops in favor of updated_user, and, because the procedure started from the 1.8.0 mapping and kept every path that still resolved, never asked whether a field could now land on one of the four attributes user_management adds.
Routine
Where the cost lands, and a routine for it
With the six sources nearly still, the cost concentrates in identity-lifecycle mappings, in vendor packs, and in the detections that read either, and what follows is the routine I'd run on each OCSF release to catch it, assembled from what the re-score had to do. I haven't run it as a procedure across releases, so it is a recommendation built from one migration and still untested as a process, and each step carries the finding that put it on the list.
Version lag · declared versus released
- Pin the OCSF version in every mapping artifact, and check whether a vendor pack's declared version and the classes it emits have moved together. Tenzir's Okta package on the library's main branch at
9949f753(2026-11-15, unchanged when re-read on 2026-11-16) declares OCSF 1.9.0 and still setsaccount_change(3001) foruser.lifecycle.*events, with activation on activity 2, which is the correct Enable for that class and is valid 1.9.0 because the class is deprecated and not removed. So this is a migration still pending and not a defect, read from the code without running it, and I'd treat it as an unscored observation; Tenzir's Zeek mapping, which the same re-score did run, emitted no deprecated path (companion piece). At the other end, the ZIA integration AWS documents still declared OCSF v1.5.0 on 2026-11-16. - Diff the deprecation markers between the pinned release and the new one with a script against hashed copies of both schema exports, and read each marker's
superseded_byfield for the replacement, which for 1.9.0 is present on every one of the 33 markers counted above. - Validate every target path against the export with the profiles your mapping declares in
metadata.profiles, failing on any segment the schema doesn't define, because the gap between the no-profile and all-profiles results above was 20 paths that need a profile the mapping file never states. - Report every deprecated target whatever release deprecated it, which is what would have caught the
respcodecase above when the bench was built. - Compare the activity enum integer by integer whenever a mapping moves class, which is the Enable-to-Update case above, and which my own six-schemas crosswalks need before their Account Change column moves to
user_management. - Run emitted samples through the OCSF server's validator and read the warnings as well as the errors, because that is where a deprecated class and a mismatched
activity_nameshow up. - Check whether the release gave any unmapped field a typed home, the half of the cost this re-score didn't measure.
- Re-run the fidelity scoring and every detection that reads a record the release forced you to change, which on the six sources means the Zscaler error-rate detection, and check rules written against
user_management, which match nothing on events still mapped to the deprecated class, the silent wrong answer case.
I'd expect none of those steps to be expensive once scripted, and two of them, the strict path check and the any-release deprecation report, would have caught the three defects the six-source bench carried before 1.9.0 existed, which is part of why I'd run them on a schedule instead of waiting for a release that announces breaking changes.
Bottom line
What the number would mean at 40 mappings
On six sources the measured 1.9.0 drift was one path out of 181, and getting to zero invalid and zero deprecated targets would take four mapping.py records, three of which were defects that predated the release. The forty source mappings in my field-mapping essay invite a multiplication, but I'd label any such figure Tier D and I don't think source count is the right thing to scale by, because the cost the re-score found sat in where a release moves classes and in packs whose declared version and emitted classes haven't moved together, and almost not at all in per-source attribute churn. So for a team with 40 mappings, the first numbers I'd want are how many of them land on a class the new release deprecates, and how many come from a vendor pack and which OCSF version each one declares, since those two counts would predict the work better than the total does.
Bottom line: on this evidence the cost of the 1.8.0-to-1.9.0 step was small and concentrated, with the corpus's whole deprecation debt across every release up to 1.9.0 at two paths in 179. The expensive mistake would be the silent one, an activity enum carried across a class move, while the thing I'd check first on any vendor pack is whether the version it declares and the classes it emits have moved together, because a path-existence check tells you about neither. The schema server already listed a 1.10.0 development line when the lab fetched 1.9.0 on 2026-11-09, which this re-score did not run against, though other lab benches already pin OCSF's main branch at 1.10.0-dev for AI-agent telemetry, and the identity arm covered two Okta event types and nothing that writes user_access or user_result, so the next measurement I'd want is an Entra ID audit arm through the same scripts, to see whether Okta's tidy result holds for a second identity source.