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:
- Scattered Signal (C1): Evidence is spread across Jira tickets, GitHub PRs, and AWS CloudTrail logs.
- Organization-Specific Conventions (C2): One company might use a
teamtag; another might encode the owner in the resource name. - 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.
- 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.
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.
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-prodbelongs 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.
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