Agentic Attribution of Cloud Resource Ownership

Tiltan Gilat, Gal Engelberg, Ariel Zadok, Leon GoldbergarXiv 2026 · arXiv

This paper introduces a novel approach to a persistent headache in cloud security: Ownership Attribution. When a security tool flags a vulnerability in a cloud resource, the first question isn't "how do we fix it?" but "who is responsible for this?"

Traditionally, organizations rely on manual tags or CMDBs (Configuration Management Databases), which are notoriously prone to going stale. This paper proposes an "agentic" architecture that moves away from declared ownership toward derived ownership, mining operational records to find the humans behind the infrastructure.

TL;DR

The authors present a multi-agent system that automatically attributes cloud resource ownership by analyzing "implicit" signals in audit logs, code history, and tickets. By profiling an organization's specific conventions offline and using parallel AI investigators online, the system achieves 92.1% weighted recall—nearly doubling the performance of general-purpose coding agents at roughly half the cost per unit of coverage.

What Problem Does This Paper Address?

In modern cloud environments, infrastructure is often ephemeral, created by automation, and managed across shared accounts. This creates an organizational context gap: security findings are orphaned because the "owner" field is either blank, outdated, or points to a generic service account.

The authors identify four core challenges in recovering this context:

  1. Scattered Signal (C1): Evidence is spread across Jira tickets, GitHub PRs, and AWS CloudTrail logs.
  2. Organization-Specific Conventions (C2): One company might use a team tag; another might encode the owner in the resource name.
  3. Multi-hop Links (C3): Finding an owner often requires jumping from a resource to a deployment stack, then to a repository, then to a specific pull request author.
  4. Relation Strength (C4): The person who built the resource is a "stronger" owner than someone who just mentioned it in a bug report.

Methods

The authors define ownership not as a single name, but as a set of entities (people or teams) categorized by five relation patterns of varying strength: Explicit owner, Direct work, Indirect work, Relies on it, and Peripheral.

Table 1: Relation patterns.

The proposed Agentic Reference Architecture operates in two phases:

  • Offline Profiling: AI agents analyze the organization's data to learn its specific "conventions." They generate signal procedures (reusable code lookups) and an ownership playbook (guidance for agents).
  • Online Investigation: When a resource needs attribution, a coordinator agent uses the pre-computed tools and spawns parallel investigator sub-agents to chase leads across different platforms (e.g., one agent checks Jira while another scans GitHub).

Crucially, the system separates judgment from guarantees. While LLMs decide where to look, deterministic code checks the conclusions against the raw records to ensure every claim is grounded in fact.

Figure 1: Agentic reference architecture: an investigation agent and its tools, one built offline, with an example at each step.

Datasets

The system was evaluated on a real-life production environment containing:

  • 100 AWS resources across 50 different types (S3 buckets, Lambda functions, etc.).
  • Data Sources: AWS resource inventory, CloudTrail audit logs (90 days), Jira (16,590 tickets), GitHub (10,005 pull requests), and identity providers like Okta and AWS Identity Center.

The evaluation used a "pooling" method from information retrieval, comparing the architecture's candidates against those of an unprimed baseline agent (Claude Code).

Key Insights and Ideas

  • Implicit vs. Declared: The most valuable ownership data isn't in the "Owner" tag; it's in the "work records" people leave behind as they build and change things.
  • Automation as Delegation: The system treats non-human identities (like CI/CD pipelines) as delegates. If a pipeline created a resource, the agent follows the trail back to the commit or ticket that triggered it.
  • Weighted Metrics Matter: Not all owners are equal. The evaluation uses "Weighted Recall" to prioritize finding the people doing "Direct Work" over those with "Peripheral" links.
  • Context Inference: By inferring what a resource belongs to (e.g., a load balancer named payments-api-prod belongs to the "Payments API"), agents can generate much more effective search terms for tickets and code.

Key Results

The architecture significantly outperformed the baseline general-purpose agent:

  • Coverage: Reached 92.1% weighted recall (vs. 54.8% for the baseline). It found a verified owner for 99 out of 100 resources.
  • Correctness: Achieved 86.6% weighted precision (vs. 77.4%).
  • Efficiency: The architecture delivered this superior coverage at 0.55 times the cost per unit of weighted recall compared to the baseline agent.
  • The "Direct Work" Gap: The biggest difference was in resources without an explicit owner. The architecture found 117 out of 123 "direct workers" in these cases, while the baseline found only 47.
Example 1: Comparison of attribution for three different resource types.

Limitations and Future Work

  • Single Organization: The current evaluation is limited to one organization and one cloud provider (AWS). The authors acknowledge that testing the "transferability" of the offline profiling to other organizations is a key next step.
  • Ground Truth: There is no "perfect" ground truth for ownership in these environments. The study relies on a "pool" of verified candidates, which might still miss some owners that neither system found.
  • Future Directions: The authors plan to extend the system to Azure and Google Cloud and integrate more data sources like on-call schedules (PagerDuty) and service catalogs (Backstage).

Summary updated

Abstract

Security tools raise findings across cloud environments, and AI agents now investigate and prioritize them. A finding is still resolved by people: it has to reach the people responsible for fixing it and accountable for the resource it concerns. Ownership is the organizational context that decides who that is. Where recorded, it is declared by hand in configuration management databases or owner tags and goes stale unless kept current; accounts are shared, and automation creates much of the infrastructure. The knowledge sits in work records, code history, audit logs and identity directories, encoded in each organization's own conventions. Recovering it poses four challenges: the signal is scattered across sources, none of them authoritative; the conventions that carry it differ between organizations; reaching an owner takes multi-hop links; and those related to a resource differ in the strength of their relation. We define ownership as a set of entities, people or teams, each related to the resource by one of five patterns ordered by strength. We present a reference architecture for agentic ownership attribution that derives ownership from these records instead of declaring it: it profiles an organization offline into tested signal procedures and an ownership playbook, then attributes each resource with a coordinator agent and parallel investigators, with confidence computed by rules. On 100 resources of 50 Amazon Web Services (AWS) resource types in one organization, we pool the architecture's candidates with those of an unprimed general-purpose agent and verify every evidence piece against the records. The architecture reaches 92.1% weighted recall and 86.6% weighted precision, against 54.8% and 77.4%, at 0.55 times the agent's cost per unit of coverage. The difference lies in people who build and change resources without an explicit owner, found through work records and code history.
BibTeX
@misc{gilat2026agentic,
  author = {Tiltan Gilat and Gal Engelberg and Ariel Zadok and Leon Goldberg},
  title = {{Agentic Attribution of Cloud Resource Ownership}},
  year = {2026},
  eprint = {2611.11340},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.11340},
}
Figure