Build the Asset Inventory Your Security Agents Need

TL;DR

Build the asset inventory for AI security agents around a traceable relationship: a business service has an owner, runs through identifiable deployments, contains specific software, uses particular identities, and depends on management and recovery systems. Attach observations and assessment requirements to those relationships rather than treating a hostname and a version string as a complete security record.

Keep discovery, authorization, assessment execution, and vulnerability applicability separate. A discovered asset is not automatically an approved target. A completed assessment does not establish coverage beyond its checks. A recently imported record may still describe an obsolete deployment.

The operating principle: every assessment must identify its target, its evidence, its permitted scope, and what remains unknown.

In This Article

Introduction

Example Enterprise receives a security advisory for the component behind its document-preview service. The release pipeline lists the proposed fixed version. The inventory still contains the older version. Both records were imported this morning.

Which one describes the running application?

The model cannot settle that question by choosing the more recent-looking record. The workflow needs to distinguish release intent from observed deployment state, identify when each observation was made, and determine whether the records refer to the same instance.

The previous installment separated model behavior from current evidence. This article builds the local evidence foundation: an illustrative inventory contract, a reconciliation process, and a coverage matrix that later installments will reuse. The organization, records, identifiers, and timestamps are synthetic. No corporate discovery, scanner execution, or deployment is performed here.

Define Responsibility Before Discovery

Start with one service and an explicit boundary. For Example Enterprise, the core boundary includes the document portal, its source repository, build path, container artifact, runtime host, and service identity. Register management and recovery dependencies as well, even when their assessment belongs to another team.

This is broader than a network sweep. CIS Critical Security Controls 1 and 2 distinguish enterprise-asset inventory from software-asset inventory. The former includes physical, virtual, remote, and cloud-connected assets; the latter addresses authorized and unmanaged software. Neither should be replaced by the output of a single assessment tool. CIS

For this design, maintain separate fields for lifecycle, assessment scope, and ownership. An active asset may be discovered but not yet approved for assessment. An approved asset may have no working assessment method. An ownerless asset should enter an accountable triage queue, not disappear from reporting or inherit whichever team discovered it.

Begin with authorized exports and supported inventory interfaces. An address found in a log, a certificate, or an application response is evidence of a relationship, not permission to interrogate the destination. Record third-party dependencies without automatically enrolling the supplier’s infrastructure as a target.

Reconcile Sources by Field, Not by Reputation

A configuration management database (CMDB) can remain authoritative for ownership while a runtime interface supplies deployment observations. Do not require one source to be authoritative for every field.

Use a field-level source map such as this proposed arrangement:

InformationPreferred evidence in the reference designLimitation to preserve
Service owner and criticalityService catalog and accepted ownership recordA discovered label is not owner acceptance
Resource existence and incarnationPlatform inventory and lifecycle recordsDesired configuration is not observed runtime state
Installed softwareAuthenticated package or supported platform inventoryEmbedded or unmanaged components may be missing
Build contentsBuild records and artifact-bound software bill of materialsBuild contents do not prove deployment
Identity relationshipsIdentity-provider and resource-policy recordsA role name alone does not establish effective permissions
Network exposureRouting and access-policy records, supplemented by approved observationsA public address alone does not establish a reachable vulnerable function

Each collector should also report its own scope and health: which account, tenant, cluster, or network boundary it queried; when collection ran; whether pagination completed; and whether access failed or the response was partial. Without that collection record, an empty result is ambiguous.

Preserve conflicting observations rather than applying unrestricted last-writer-wins updates. Resolve ownership conflicts through the service owner. Resolve deployment conflicts through fresh observations of the relevant runtime. A model may explain the discrepancy, but it should not silently decide which source is permitted to overwrite another.

Give Services, Deployments, and Software Different Identities

Keep EE-APP-001 as the stable identifier for the document-portal application. Give each deployment its own identifier, and retain separate resource identities for its hosts and execution instances. A replacement instance should not inherit the previous instance’s assessment merely because it reuses a name.

Kubernetes illustrates why this matters. Its documentation distinguishes names, which can be reused after deletion, from UIDs that distinguish object occurrences over a cluster’s lifetime. For a Kubernetes adapter, retain the cluster boundary and object UID alongside the readable namespace and name. Kubernetes

Treat hostnames, addresses, tags, and display names as aliases with validity periods. Merge records using source-native identifiers and explicit reconciliation rules within the correct tenant and environment. Keep uncertain matches pending rather than joining two customers’ resources because they share a private address.

The diagram shows the relationships the lab needs. These are proposed records, not discovered infrastructure.

Attach evidence, observation time, and relationship type to each edge. A dependency used to restore an application is different from one required for every request. The application owner should be able to find both without implying that a runtime scanner has assessed either.

For identities, record the issuer or directory boundary, stable principal identifier, owner, assigned permissions, relevant conditions, and the resources involved. Preserve whether effective access has actually been evaluated. Inventory credential identifiers, expiry, and rotation ownership where permitted, but not token values, passwords, or private keys.

Bind Software Evidence to What Is Actually Deployed

A software bill of materials (SBOM) describes components and their relationships. CycloneDX can represent direct and transitive dependencies and explicitly describe composition completeness. Preserve that completeness information: an incomplete SBOM must not become an assertion that an unlisted component is absent. CycloneDX

Associate the SBOM with its subject artifact, producer, generation method, and generation time. Then establish that the same artifact is deployed. Kubernetes documents that image tags can move while digests identify fixed image content. A scan of whatever a tag resolves to today cannot automatically describe the artifact that an older instance started with. Kubernetes

Reuse artifact-level results only when the digest, assessment method, and rule revision still satisfy the current requirement. That reuse does not renew runtime configuration, identity, or exposure evidence.

A digest is still not the whole runtime. In the inventory design, record configuration revisions and observations of mounted or subsequently added code separately. For multi-platform images, retain the relationship between the image index and the platform-specific artifact rather than assuming every digest denotes the same object. Kubernetes

Use Product Identifiers Without Inventing Matches

Package URL (PURL) encodes package identity through fields such as type, namespace, name, version, and qualifiers. Common Platform Enumeration (CPE) describes product classes, not individual installed instances. Use these identifiers where a supported mapping exists, while retaining the original supplier and package evidence. Package-URL: purl-spec

Neither identifier replaces the application, deployment, or resource ID. Do not generate an official-looking CPE from a product banner or assume two similarly named packages are equivalent. The fictional Example Renderer has no verified ecosystem mapping, so its PURL and CPE fields remain null in the lab fixture.

Retain distribution, release, architecture, and full package-version information where applicable. Red Hat’s backporting guidance explains that security fixes can be applied to older upstream versions and that version-only scanners can report false positives. Match the actual vendor package and advisory conditions rather than applying a universal string comparison. Red Hat Customer Portal

For embedded components and vendor appliances, record the enclosing product and supported release channel. A component match can identify a question for the vendor-supported assessment path; it does not authorize replacing an appliance’s internal package independently.

Make Observation Time Part of the Contract

The reusable schema separates an asset record from its deployment, component observations, relationships, and assessment records. A production persistence model should retain these histories separately and assemble a task-specific view when needed.

The following YAML illustrates a deliberately incomplete projection of EE-APP-001 after a deployment change. It shows decision-critical fields. An implementation should define and validate a complete JSON Schema for the inventory contract before admitting records.

schema_version: "0.1"
asset_id: EE-APP-001
boundary_id: EE-LAB
owner_team: document-services
business_service_id: EE-SVC-001

current_deployment:
  deployment_id: EE-DEP-002
  changed_at: "2026-11-18T08:00:00-06:00"
  observed_artifact_digest: null
  configuration_revision: null

component_observations:
  - component_name: Example Renderer
    version: "1.4.2"
    deployment_id: EE-DEP-001
    observed_at: "2026-11-16T09:00:00-06:00"
    ingested_at: "2026-11-18T08:05:00-06:00"
    evidence_ref: EE-EVID-COMP-001

inventory_quality:
  state: stale
  reasons:
    - component_evidence_precedes_current_deployment
    - current_artifact_identity_missing

applicability:
  advisory_id: LAB-ADV-001
  state: unknown
  reason: current_deployment_not_established

The component observation is historical evidence for EE-DEP-001, not evidence that EE-DEP-002 contains version 1.4.2. Its import time does not renew its observation time. The null digest is an intentional evidence gap, not a value to replace with a fabricated hash.

In a real implementation, populate these fields from approved sources and define freshness requirements by field and operation. A deployment event should trigger revalidation before reusing an older runtime observation, even when that observation remains within a nominal age limit. Ownership records may have a different review interval.

Successful use produces a view whose unresolved fields are explicit. Schema validation can check structure and permitted values; it cannot establish that a source is truthful, an approval is genuine, or a timestamp describes the present environment.

Reconciliation Must Preserve Failed and Missing Evidence

Run reconciliation after relevant events and on a schedule. Match observations to canonical identities, compare desired and observed state, evaluate freshness, resolve or retain conflicts, and identify new assessment work. Preserve a reference to the input snapshot and the reconciliation rule version so a later reviewer can reconstruct the decision.

A Fresh Import Contains an Old Deployment

Continue the synthetic EE-EVT-001 advisory workflow. The pipeline declares the candidate containing Example Renderer 1.4.3, while the historical component observation reports 1.4.2. Neither establishes the current running artifact.

Keep EE-FIND-001 at unknown applicability for the new deployment and request fresh deployment and configuration evidence. Do not mark it remediated because the pipeline lists the fixed version. Do not assert that the new deployment is affected solely because an older instance was affected. Preserve the prior finding and its history while recording the current uncertainty.

Once fresh evidence establishes the deployed component and the advisory’s relevant preview condition, the workflow can decide affected or not affected. EE-CHG-001 and EE-VER-001 remain linked to the finding, but inventory reconciliation alone cannot establish verification or closure.

Authentication Fails During Host Collection

In a separate failure fixture, the authenticated package collection for EE-HOST-001 fails. Record the failed attempt and retain the last successful observation with its original timestamp. Do not replace the component list with an empty array and interpret that as software removal.

A collector-wide permission failure needs a source-health incident as well as affected-asset gaps. Otherwise, hundreds of assets can appear to vanish while the real problem is one broken collection identity.

Use explicit retirement evidence or reviewed lifecycle reconciliation before retiring an asset. Preserve historical records and unresolved findings. A timeout, missing page, disconnected system, or silent source is not a deletion event.

Build the Coverage Matrix Around Required Assessments

The inventory answers what exists and what is known about it. The coverage matrix answers which assessments are required and which have usable results.

Make each requirement a versioned asset-and-profile pair. A profile defines the bounded assessment method, required authentication, evidence, and completion conditions. Keep the last attempt separate from the last successful assessment, and retain tool, rule-feed, check-set, target-revision, and evidence references when execution occurs.

The following matrix is a synthetic planning snapshot. Its states illustrate gaps; they are not results from executed scans. Profile names are local design identifiers, not claimed capabilities of an installed product.

TargetRequired profileEvidence neededIllustrative execution state
EE-REPO-001Source analysisExact commit and applicable rule-set resultNot run
EE-IMG-001Artifact package assessmentBound artifact digest, component inventory, check coverageUnavailable: artifact identity missing
EE-APP-001Deployment applicabilityCurrent deployment, component, and relevant configuration evidenceNot run: stale inputs
EE-HOST-001Authenticated package assessmentCorrect host identity, authenticated session, package observationsFailed: authentication
EE-ID-001Privilege reviewPrincipal, resources, grants, and applicable conditionsNot run
EE-MGMT-001Supported configuration reviewProduct/build and owner-approved configuration evidenceDeferred: approved access window required
EE-BACKUP-001Recovery configuration reviewRecovery administration and configuration evidenceNot run

Keep vulnerability applicability separate from execution state. An assessment can complete and find affected software. Another can fail while independent evidence already establishes that the asset is affected. A completed package check also does not establish that application authorization or business logic was tested.

Use distinct applicability values such as affected, potentially affected, not affected, and unknown. Remediated-and-verified belongs to the finding lifecycle. Risk acceptance and temporary mitigation need their own owner, evidence, and review or expiry conditions; neither should be stored as not affected.

Measure Coverage Without Removing Difficult Assets

For a defined reporting snapshot, use this local coverage measure:

Current assessment coverage is the number of required asset/profile pairs with current, complete evidence divided by all required in-scope asset/profile pairs. Multiply by 100 to express it as a percentage.

Require the result to match the relevant current artifact or configuration, meet freshness rules, satisfy required authentication, and cover the expected checks. An assessment with findings can count as completed coverage. Failed, unavailable, deferred, partial, and stale assessments remain outside the numerator but inside the denominator.

Document genuine scope changes and reviewed not-applicable decisions instead of changing the denominator silently. Report pending ownership or scope decisions separately, alongside collection gaps and newly discovered assets. Coverage over known inventory is not proof that discovery found the entire enterprise.

Protect the Inventory That Drives the Agents

Separate observation writes from ownership acceptance, scope approval, and policy administration. A collector may report an address; it must not convert that address into a permitted target. Store approval references in the inventory, but validate authorization against the policy authority when a job executes.

Give model-assisted analysis a filtered view of the assets and evidence required for its task. Restrict cross-tenant joins, sensitive topology, identity details, and evidence exports. Treat free-text descriptions and imported content as untrusted data, even when they arrive through an approved connector.

Apply the same inventory contract to optional adapters without pretending they provide equivalent coverage. Cloud resources, SaaS consent, serverless deployments, network devices, hypervisors, firmware, baseboard management controllers, storage, and AI tool servers need appropriate identity and evidence fields. Operational technology and fragile systems require owner-approved, safety-appropriate methods. Preserve unsupported and deferred coverage rather than prescribing a universal active scan.

Validate the Records Before Connecting the Model

Start with the synthetic records, then a reviewed export of one authorized service. Check identifier uniqueness within the boundary, reference integrity, observation timestamps, and whether every in-scope asset has an owner or an assigned ownership gap. Confirm that the coverage requirements include the management and recovery dependencies agreed for that service.

Exercise the stale-deployment and failed-authentication cases. Also replay a duplicate observation and a same-name replacement instance. The expected behavior is stable identity resolution without duplicate assets, preserved historical evidence, and no inherited clean assessment for the replacement.

Assign collection health and schema changes to the inventory platform owner. Application owners resolve deployment and service relationships; security engineering defines assessment requirements; the existing policy authority controls scope. Revisit the contract when a new asset class, collector, or assessment method changes what the fields mean.

Keep a recoverable inventory history and test restoring its records. After restoration, re-evaluate freshness and current authorization before dispatching work. A restored database should not make old observations or revoked permissions current again.

Conclusion

An asset inventory becomes useful to security agents when it explains more than what was discovered. It must connect an accountable service to identifiable deployments, software, identities, dependencies, and the evidence needed for each assessment.

Start with one service, preserve source and observation history, and keep failed or unavailable assessments visible. Expand the inventory only as ownership, identifiers, collection methods, and coverage requirements become explicit.

The next installment, Keep Security Agents Current with Trusted Advisories and Best Practices, builds the external evidence supply that will be matched against these local records.

Before asking an agent whether an asset is affected, establish exactly which asset, deployment, and observation the question refers to.

External References

Continue reading

Coordinate Security Scans Across Networks, Servers, Cloud, and Applications

Coordinate network, host, cloud, and application assessments while preserving authentication failures, scope limits, coverage gaps, and accountable next actions. Read the article

Leave a Comment