betaFeedback

WorksComputer Science

The Limits of Information-Flow Control Enforcement for Agentic Systems

Abstract

Information-flow control (IFC) is a promising approach to enforce policy in agentic AI systems. However, IFC suffers from label creep, a phenomenon where monotonically increasing security labels propagate through a system and progressively limit its utility. Label creep in agentic AI systems can be mitigated using two major strategies: (1) improved system design and (2) label declassification. In this paper, we characterize how far system design alone can mitigate label creep in agentic systems. Specifically, we measure how system topology, scale, and agent composition affect utility loss and security enforcement cost proxies for conservative IFC enforcement in a stateful agentic system simulator. We develop a pipeline to systematically vary these features and measure their impacts on label propagation. Our results demonstrate strong associations between structural graph features and our IFC utility loss metric (up to a Spearman correlation ∣ρ∣|ρ| of 0.960.96) and show that system size and tool allocation substantially affect how labels propagate. These findings identify design choices to reduce IFC utility loss, but they also demonstrate that system design alone cannot fully prevent utility loss due to monotonic label propagation. This motivates the development of label declassification mechanisms that aid these design choices and diminish IFC utility cost.

Introduction

Advances in the capabilities of large language models (LLMs) have led to the emergence of agentic computing, a paradigm in which AI agents—LLMs augmented with tools and persistent memory—execute tasks within a system. Working alone or together, these agents perform useful tasks that require autonomous problem-solving. However, they can also be very harmful, as evidenced by the recent 2026 OpenAI-HuggingFace incident, where a collection of OpenAI’s agents performed unintended actions, communicated via shared channels, and exploited a vulnerability to infiltrate HuggingFace’s infrastructure [1].

The rapid adoption of AI agents to solve real-world tasks calls for stronger control mechanisms, especially for sharing information and using consequential tools. Information-flow control (IFC) provides a promising solution to this problem by controlling how security-labeled information flows through a system. In an agentic system, this could be used to authorize information sharing or prevent tool calls based on the security labels of the data accessed. However, to apply IFC efficiently to agentic systems, we need to better understand the challenges of doing so, specifically with respect to a phenomenon known as label creep, where once information is marked as sensitive, every operation that it contributes to will also output information marked sensitive [2]. This can harm the utility of the system, as the IFC policy will likely block many (possibly benign) operations on this sensitive data.

Traditional IFC systems reduce this utility loss through precise static tracking of information flows [2, 3], restructuring computations into smaller security compartments [4], and controlled declassification mechanisms that safely relax security labels [5]. Precisely tracking information flows through LLM-generated outputs remains challenging in agentic systems [6, 7]. This motivates two approaches for reducing label creep in agentic systems: modifying system structure to improve context isolation and developing mechanisms to declassify information. We focus on the former and ask: how much improvement can system design provide to IFC utility before declassification becomes necessary?

In this work, we investigate how the structure (arrangement of agents), size (number of agents), and composition (tool calls assigned to agents) of agentic AI systems influence IFC security enforcement cost and utility loss. We focus on these components because administrators have direct control over them, making our findings actionable. By abstracting these elements, we perform a systematic analysis on how varying these components can impact security and utility costs under certain tasks. From this analysis, we characterize the security-utility tradeoffs of IFC enforcement.

We model agent tasks and system topologies as graphs from which we derive features. We then design a pipeline capable of generating task configurations that cover a variety of possible scenarios of different complexities. We motivate the problem by demonstrating how excess IFC utility loss worsens with increasing task complexity, which we model as the number of tool calls used to complete a task. Holding the task size constant, we then measure how system topology, size, and composition affect security enforcement cost, modeled by the number of communication vectors that must be monitored, and utility loss, modeled by the fraction of tool calls that introduce or are executed with a high-sensitivity label. Our analysis spans 4 standard network topologies, 5 random topologies of different densities, over 9,000 abstracted tasks composed of a variable number of interdependent tool calls with different orderings, and 2 tool clustering paradigms. Our pipeline runs independently of any LLM, enabling fast analyses of how different agentic system structures impact IFC security and utility. Our analysis reveals that certain graph features are highly correlated with IFC utility cost (up to Spearman correlation ∣ρ∣=0.96|\rho| = 0.96) and that system density is inversely related to utility loss. We also show that using more agents in a system lessens label propagation, but at the cost of up to quadratic growth in the number of edges that must be monitored. Finally, we show that isolating sensitive tool calls to specific agents can be effective for reducing overall IFC utility loss. Our analysis shows that structural design choices can reduce utility loss due to label propagation, but they cannot completely prevent it, motivating the development of declassification mechanisms.

Contributions. This paper provides three contributions. First, we develop an abstract, graph-based framework for isolating the impacts of system design on security and utility in a conservative IFC system. Second, we characterize how task complexity, inter-agent connectivity, system size, and sensitive tool allocation affect IFC enforcement cost and utility loss. Third, we motivate the development of declassification mechanisms by demonstrating that even under our ideal structural baseline, structural improvements alone cannot reliably prevent utility loss due to label propagation.

Background

Information-flow control (IFC) is a method to ensure secure information flow by preventing leakage to forbidden outputs [8]. IFC can be used to protect confidentiality and integrity by preventing confidential or untrusted flows from reaching unauthorized or security-sensitive sinks [9]. IFC mechanisms commonly work by introducing a label—a tag indicating the information’s confidentiality and integrity qualities—to data at a source and then propagating this label through the system with the data [10]. IFC has been used to help secure agentic AI systems against prompt injection attacks [7, 11], and prior work has investigated improving IFC utility for agents by hiding sensitive data [7] and only propagating labels from influential data [6]. However, these systems do not systematically examine the impact of agentic system design on IFC utility and enforcement costs.

Preliminaries

System Abstraction. Agentic systems involve highly complex tasks composed of interdependent tool calls executed by various agents. To abstract this, we model agentic systems as the following. Each topology is represented as a bidirectional graph G=(V,E)G = (V, E), where VV is the set of all agents in the system and EE is the set of bidirectional edges through which the agents can communicate. For a system composed of nn agents, V={a1,…,an}V = \{a_1, \ldots, a_n\} and E⊆{{ai,aj}:ai,aj∈V,i≠j}E \subseteq\{\{a_i, a_j\}: a_i, a_j \in V, i \ne j\}. The exact configuration of edges in EE therefore dictates the topology. For the Star and Hierarchy topologies, additional routing agents are introduced (see § 4.1). Next, let T={t1,…,tm}T = \{t_1, \ldots, t_m\} be the set of mm tool calls in a task, and let TT be allocated as (Ta1,…,Tan)(T_{a_1}, \ldots, T_{a_n}), which provides each agent with a set of tool calls such that no tool calls are shared between agents. Following [12, 13, 14], we model a task as a directed acyclic graph (DAG) D=(T,D)D = (T, D), where D⊆T×TD \subseteq T \times T is the set of directed tool dependencies, with (ti,tj)∈D(t_i, t_j) \in D showing that tjt_j depends on the output of tit_i. Since tit_i and tjt_j may belong to different agents, we denote these connections between agents with tool dependencies as

C={{ai,aj}:i≠j,∃x∈Tai,y∈Taj with (x,y)∈D}.C = \{\{a_i, a_j\}: i \ne j, \exists x \in T_{a_i}, y \in T_{a_j}\text{ with }(x,y) \in D\}.

By including only the edges CC, we obtain a graph containing the direct inter-agent connections induced by the task, which we call Gmin⁡=(V,C)G_{\min} = (V, C). Gmin⁡G_{\min} provides an ideal structural baseline for each DAG: every cross-agent tool dependency can be communicated directly without routing through intermediate agents, while the graph contains no communication edges not induced by the task. Figure 1 shows an example of a task DAG, the corresponding Gmin⁡G_{\min} graph, and different tool call orderings for this task. Depending on the actual topology, the edges in Gmin⁡G_{\min} may not exist in the actual graph. In these cases, the resulting paths needed to transmit context between agents may be longer. This is a primary motivation for why varying topology may impact label creep: it directly impacts how

Figure 1. The task DAG, direct-communication baseline topology Gmin⁡G_{\min}, and possible task executions resulting from different tool orderings.

context is transmitted across graphs. The goal of an optimal topology is therefore to minimize the spread of context (and labels) for each system.

Information-Flow Control Assumptions. We model our system’s IFC behavior using the following assumptions. First, we assume that any tool tt can introduce a label ℓ\ell into the system at the point where tt is called. Second, we assume that labels can propagate in two ways: as context to another tool through a mapped dependency or as context being routed between agents. Third, we assume that the IFC system operates on the basis of conservative joins—that is, if an agent with a label ℓl\ell_l is exposed to a label ℓh\ell_h and ℓl⪯ℓh\ell_l \preceq\ell_h (i.e., ℓh\ell_h is at least as sensitive as ℓl\ell_l), the agent’s new label is ℓ=ℓl⊔ℓh=ℓh\ell= \ell_l \sqcup\ell_h = \ell_h. Fourth, we assume agents are stateful, so if an agent is exposed to context that contains a label—either through the result of a tool call or by routing labeled context to another agent—the agent will take the conservative join of that label with its previous label. Assuming stateful agents reflects the role of persistent memory in agents. Importantly, there is no mechanism in this system to declassify a label or prevent its transmission, leading to monotonically increasing label propagation.

Methodology

Our goal is to measure security enforcement cost and utility loss in agentic systems as they execute a variety of complex tasks. To do so, we abstract our system topologies and tasks using the formulas described in § 3. For experiment reproducibility, we outline our methods as follows. First, in § 4.1, we define the topologies used in this research, the task generation process, and label placement in tool calls. Then, in § 4.2, we define proxy metrics used to examine the graph structure, security cost, and utility loss of the system.

Structure

Topologies. We implement each system of nn tool-calling agents using four common graph topologies: Mesh, Star, Ring, and Hierarchy. In the Ring topology, order was determined via agent label (i.e., [1,n][1,n]). In the Star topology, an additional orchestrator agent was introduced as the hub. In the Hierarchy topology, agents were placed as leaves of a balanced tree with two main branches overseen by manager agents and a root managed by a supervisor agent. Only the nn tool-calling agents are assigned tool calls; the orchestrator, manager, and supervisor agents exist to route information in these topologies. We introduce six additional topologies to this system: the ideal topology for a task (specified by Gmin⁡G_{\min}) and five random topologies (ER) generated by the Erdős-Rényi model with connection probabilities (p∈{0.1,0.2,0.3,0.4,0.5})(p \in\{0.1,0.2,0.3,0.4,0.5\}) that continue sampling until the graph is connected and each graph is distinct.

Task Generation. We generate arbitrary agentic tasks as random dependency graphs. For a task composed of mm tool calls, we first generate a random DAG using the Erdős-Rényi model with p=2m+1p = \frac{2}{m+1}, meaning that the expected number of dependencies will be around mm. Next, we uniformly add each tool call in the task DAG to an agent’s tool set. Finally, we use this resulting task DAG to build Gmin⁡G_{\min}, which is the direct-communication baseline topology needed to complete the task. As a heuristic, we model task complexity as proportional to the number of tool calls used by a task.

Label Placement. We simulate a system where calling certain tools introduces a high-sensitivity label into the system. It is then added to the running context of the agent at the point where the tool is called. In our experiments, we use the set of low- and high-sensitivity labels Λ={ℓl,ℓh}\Lambda= \{\ell_l,\ell_h\}, with ℓl≺ℓh\ell_l \prec\ell_h and where ℓl⊔ℓh=ℓh\ell_l \sqcup\ell_h = \ell_h. We then use two different ways to introduce labels into the system via tool calls. The first is random placement: with a labeling budget of bb, we randomly mark bb tool calls with an ℓh\ell_h label and all others with an ℓl\ell_l label. This simulates scenarios in which any agent could execute a tool call that can introduce sensitive information into the system. The second approach is clustering tool calls with ℓh\ell_h labels to specific agents and assigning ℓl\ell_l to the remaining tool calls for the task.

Measurement

Graph Features. To compare agent topologies, we use the following features that capture graph interconnectedness and complexity. We use average shortest-path length, diameter, and density to measure graph structure and shape. We then use average betweenness centrality to measure routing through specific nodes in the graph and the clustering coefficient to measure how closely nodes are clustered in the graph. Precise definitions are given in Table 1.

MetricFormula
Average Shortest Path2N(N−1)∑u<vd(u,v)\frac{2}{N(N-1)} \sum_{u<v} d(u,v)
Diametermax⁡u<vd(u,v)\max_{u<v} d(u,v)
Density2MN(N−1)\frac{2M}{N(N-1)}
Betweenness Centralityb(v)=2(N−1)(N−2)∑s<ts,t≠vσst(v)σstb(v)=\frac{2}{(N-1)(N-2)}\sum_{\substack{s<t\\s,t\ne v}}\frac{\sigma_{st}(v)}{\sigma_{st}}
Average Betweenness Centralitybˉ=1N∑v∈Vb(v)\bar{b}=\frac{1}{N}\sum_{v\in V}b(v)
Clustering CoefficientC=1N∑v∈Vc(v),c(v)={2Tvkv(kv−1),kv≥2,0,kv<2.C=\frac{1}{N}\sum_{v\in V}c(v),\qquad c(v)=\begin{cases}\frac{2T_v}{k_v(k_v-1)},&k_v\ge2,\\0,&k_v<2.\end{cases}

Table 1. Graph Features for Agent Topologies

Security Metrics. We use the number of communication edges as a proxy for security enforcement cost. This simulates how networks with fewer connections are simpler to monitor and have fewer connections that could allow threats to propagate in unexpected ways. For a graph G=(V,E)G = (V,E),

S(G)∝∣E∣,S(G) \propto|E|,

where SS is the security enforcement cost.

Utility Metrics. Label propagation is damaging to utility because it increases the risk that certain tool calls will be quarantined or denied if they introduce or occur in a high-sensitivity state. We measure label propagation as a proxy for utility loss via the formula

L(τ,G)=# of high-sensitivity tool calls# total tool calls,\mathcal{L}(\tau,G) = \frac{\#\text{ of high-sensitivity tool calls}}{\#\text{ total tool calls}},

where L\mathcal{L} is the utility loss, τ\tau is the task DAG, and GG is the agent graph. Some inherently executed actions are unavoidable under this conservative IFC configuration, but the amount of avoidable utility loss is measured as:

Lexcess(τ,G)=L(τ,G)−L(τ,Gmin⁡).\mathcal{L}_{\mathrm{excess}}(\tau,G) = \mathcal{L}(\tau,G) - \mathcal{L}(\tau,G_{\min}).

Here, Lexcess\mathcal{L}_{\mathrm{excess}} tells us how much of the excess label propagation we see is a function of our specific topology, rather than the task, as Gmin⁡G_{\min} is the direct-communication baseline for τ\tau. In our experiments, we aim to find ways to minimize L\mathcal{L}, but we also measure Lexcess\mathcal{L}_{\mathrm{excess}} to determine how well a given topology performs in comparison to an ideal baseline.

Evaluation

We aim to answer the following research questions:

RQ1. How does task complexity affect IFC utility loss across agent topologies?

RQ2. Which graph features are most correlated with IFC utility loss?

RQ3. Does the number of agents in a topology affect IFC security enforcement cost and utility loss?

RQ4. Does sensitive tool allocation affect IFC utility loss?

Experimental Setup

We simulate task execution in each topology as follows. First, we run a topological sort on the task DAGs and process the tool calls in valid orders. Connected tool calls in the DAGs may also require routing between agents, which is always performed via the shortest path from one agent to the next. Next, tool calls that are not connected but are processed sequentially require a jump, either to the agent containing the tool call’s immediate predecessor or, if no such dependency exists, directly to the agent containing the tool call itself. The exceptions to this are the Star and Hierarchy topologies: in cases where there is no direct predecessor to the tool call, the jump is to the orchestrator or supervisor, respectively. Jumps do not pass context, but direct communications do. This context passing occurs from all immediate predecessors on which the current tool call relies. The context delivery order can also affect label propagation, so we vary it with the topological orderings to fairly sample executions. The full topological orderings and delivery options for these DAGs can be very large, so where exhaustive enumeration is not feasible, 10,000 ordering-delivery samples for each DAG are randomly sampled and used for the analyses. For consistency, we use a set of 1,000 task DAGs containing 20 tool calls for all experiments, except where otherwise noted.

Impact of Task Complexity

We begin with a motivating question (RQ1) for this research: How does task complexity affect IFC utility loss across agent topologies? In other words, will increasing task complexity (modeled as the number of interdependent tool calls) impact the utility loss more in some systems than others? Answering this indicates whether system design is a reasonable experimental variable to affect IFC utility loss.

To simulate increasing task complexity, we generate 500 DAGs each for tasks ranging from 4 to 20 tool calls. We then randomly mark one tool in each DAG as sensitive, run each DAG against our topologies populated with 5 tool-calling agents, and plot the results, shown in Figure 2. First, note that utility loss scales differently across topologies as task complexity increases. This observation motivates our central hypothesis that agentic system structure affects IFC utility. Second, excess utility loss increases with increasing task complexity. This indicates that as tasks use more inter-dependent tool calls, agent topologies that omit edges from Gmin⁡G_{\min} will diverge from the ideal label propagation rate.

Gross utility loss and excess utility loss with increasing task complexity

Figure 2. Gross utility loss and excess utility loss with increasing task complexity. Different topologies experience different levels of gross and excess utility loss, motivating this research. Mesh and Gmin⁡G_{\min} overlap.

RQ1 Takeaway

Figure RQ1.

Impact of Topology

From § 5.2, we see that graph topology does impact IFC utility loss. In this section, we examine why this occurs. In particular, we aim to answer RQ2: Which graph features are most correlated with IFC utility loss? To answer this, we experiment with how different topologies experience different rates of label propagation in the presence of varying tool sensitivity. Using the methodology and task DAGs described in § 5.1, we generate 10,000,000 simulated task runs on each of the 10 topologies composed of 5 agents. We then conduct a sweep across labeling budgets using the random labeling strategy from § 4.1 with b∈[4,20]b \in[4, 20]. Figure 3 presents the results of this sweep, with ER graphs with p∈{0.1,0.2,0.4}p \in\{0.1, 0.2, 0.4\} omitted for clarity. As the figure shows, there is clear stratification between the topologies in terms of both utility loss and excess utility loss. For example, at b=4b = 4, excess utility loss is approximately 5 percentage points for Star, 4 for Hierarchy, and 3 for Ring. Gmin⁡G_{\min} and Mesh both perform the best in this respect, which is expected since these graphs encode direct connections between all agents that must communicate. The remaining topologies demonstrate an interplay between connectedness, complexity, and label propagation.

Figure 3. Label budget sweep across topologies.

To better understand these relationships, we compute Spearman correlations across the nine topologies, pairing each topology’s structural features with its mean utility loss over the simulated task executions. Figure 4 shows these results. Since Gmin⁡G_{\min} is not a consistent topology (i.e., it varies based on the task), it is omitted from this analysis.

Figure 4. Spearman correlation ρ\rho between graph features and IFC utility loss for labeling budgets in [4, 10].

There exists a strong negative association between utility loss and density (ρ=−0.96\rho= -0.96), which is logical since density measures the fraction of possible direct links present, which can minimize label propagation by limiting routing through intermediate nodes. Conversely, there is a high positive association between utility loss and average shortest-path length (ρ=0.87\rho= 0.87 at b=10b = 10). This makes sense, as a smaller average shortest-path length indicates more nodes are closely connected, which also minimizes routing. These statistics help explain surprising phenomena. For example, the Ring topology exhibited greater utility loss than the sampled p=0.3p = 0.3 ER graph, which was denser (0.7 vs. 0.5) and had a shorter average shortest-path length (1.3 vs. 1.5). By contrast, the sampled p=0.5p = 0.5 ER graph had the same density as Ring (0.5), a similar average shortest-path length

(1.6), and similar utility loss. This correlation allows us to answer the research question.

RQ2 Takeaway: Interconnectedness metrics (especially density and average shortest-path length) are strongly correlated with IFC utility loss.

Impact of Agent Count

Next, we examine whether changing the number of agents in the topology impacts utility loss. Specifically, we examine RQ3: Does the number of agents in a topology affect IFC security enforcement cost and utility loss? We use the same setup as in Section 5.3, but instead of fixing the system at 5 agents, we vary the number of agents from 5 to 20. As before, tool calls—labeled or not—are assigned with uniform probability to each agent up to a budget. First, we study utility loss with an original labeling budget b=10b = 10. Figure 5 shows the results of these runs as solid lines. Observe that as we increase the number of agents, utility loss decreases while excess utility loss mostly increases for all topologies but the Gmin⁡G_{\min}, Mesh, and ER graphs. Besides Gmin⁡G_{\min}, these are also the types of topologies in which the number of edges increases quadratically with an increase in the number of agents. This suggests that the stronger utility improvement in these topologies is associated with their greater growth in direct connectivity.

Figure 5. Gross and excess utility loss by number of tool-calling agents with a sensitive tool budget b=10b = 10. Solid lines show random allocation. Dashed lines show clustered allocation.

However, as we increase the number of edges in the system, this also has a direct effect on our security enforcement cost. Figure 6 shows this plainly, demonstrating that increasing the number of agents in the system leads to utility improvements at an increased security enforcement cost. These results illustrate a security-utility tradeoff of using system design to improve IFC enforcement under our model.

Figure 6. Utility loss proxy vs. security enforcement cost proxy for tasks with 10 sensitive calls. Larger markers indicate more tool-calling agents.

RQ3 Takeaway: As the number of tool-calling agents increased, IFC utility loss decreased while the security enforcement cost proxy increased.

Impact of Tool Assignment

Finally, we analyze RQ4: Does sensitive tool allocation affect IFC utility cost? We examine whether isolating label-inducing tool calls to specific agents can minimize utility loss. In a real-world implementation, this requires assigning one agent with a set of high-sensitivity tool calls—for example, creating a dedicated banking agent that manages API calls to read and synthesize financial data. To perform this experiment, we repeat the tasks from Section 5.4, but when assigning tool calls to agents, we design it so that labeled tool calls cluster together in specific agents’ sets. The results are shown in Figure 5 as dashed lines.

Observe that although the clustered tool assignments follow a similar ordering in terms of best-to-worst utility loss as the random tool assignments, the utility loss statistics for the clustered tool calls uniformly beat their random counterparts. However, the clustered tool assignments also have higher excess utility cost statistics compared to their random counterparts, indicating that clustering sensitive tools improves the label propagation rates of the ideal graphs more than those of the non-ideal ones.

RQ4 Takeaway: Sensitive tool call clustering lowered utility loss but increased excess utility loss for non-ideal topologies compared to random allocation.

Discussion

System Design. Our experiments show that highly interconnected architectures are effective at combating label propagation. This is logical, as these architectures allow context to be routed directly from a source to a destination without touching any intermediate nodes. However, implementing highly interconnected structures is costly in terms of security enforcement. Our analysis shows that random networks that are sparser, such as the ER graph with p=0.3p = 0.3, can approach this performance without incurring the same security trade-offs. For example, before conditioning on connectivity, the ER graph with p=0.3p = 0.3 requires 70% fewer edges in expectation than a Mesh. Overall, our analysis indicates that by increasing interconnectedness in communication structure, we can create agent networks that resist IFC utility loss, but this must be balanced against security enforcement cost. Our experiments also suggest that increasing the number of agents in the system can reduce utility loss, as each of these agents’ contexts serves as a form of isolation against label creep. Finally, our results indicate that isolating sensitive tool calls to specific agents can reduce utility loss.

Future Work. Our simulations isolate the effects of agentic system structure on IFC utility loss; future work will measure these trends in real agent workloads. However, regardless of the structure used, utility loss is pervasive. This indicates there is a limit to using system design alone to mitigate utility loss related to label propagation. In our model, this limit is specified by Gmin⁡G_{\min}. As such, complementary mechanisms are needed to reduce utility loss beyond what is achievable through architecture alone. In future work, we will use lessons from this research to design declassification mechanisms like those in traditional IFC systems to safely declassify labels as they accumulate through the system.

Conclusion

In this measurement study, we examined how topology, system size, agent composition, and tool allocation affect security enforcement cost and utility loss in agentic AI systems. We also characterized which graph features are strongly associated with utility loss and highlighted the security-utility tradeoffs inherent in designing more interconnected systems. This work indicates that information-flow control enforcement in agentic AI systems can be improved by using systems that balance direct communication and context isolation. However, this work shows that there is a limit to how much utility improvement is possible using system design optimization alone. Future work will examine how to use this insight to design effective declassification mechanisms that faithfully preserve system utility while maintaining security guarantees in agentic AI systems.

Acknowledgments

The authors would like to thank Blaine Hoak and Yohan Beugin for editorial feedback and the anonymous reviewers for suggestions that helped clarify our results. This material is based upon work supported by PRISM, one of seven centers in JUMP 2.0, a Semiconductor Research Corporation (SRC) program sponsored by DARPA.

Artifact Availability

The source code and experimental artifacts are available at https://github.com/Grego3j/The-Limits-of-Information-Flow-Control-Enforcement-in-Agentic-Systems.

LLM Usage Statement

Generative AI was used to assist with the Python implementations of this research. LLMs were also used to conduct preliminary background research. Finally, LLMs were used to review the paper for grammatical and structural errors and suggest revisions. The research questions, experimental design, analysis, insights, and technical claims were developed by the authors.

References

Graph Features

N=∣V∣N=|V| and M=∣E∣M=|E|; d(u,v)d(u,v) is shortest-path length; σst\sigma_{st} counts shortest paths from ss to tt, and σst(v)\sigma_{st}(v) counts those paths passing through vv, excluding endpoints; and kvk_v is degree and TvT_v counts triangles containing vv.

References

  1. [1]OpenAI, “OpenAI—Hugging Face incident: Technical report,” OpenAI, Tech. Rep., Aug. 2026. [Online]. Available: https://cdn.openai.com/pdf/67869394-cb91-4c12-888c-5cbd85c7814c/OpenAI-Hugging-Face%20Incident-Technical-Report.pdf
  2. [2]A. Sabelfeld and A. Myers, “Language-based information-flow security,” IEEE Journal on Selected Areas in Communications, vol. 21, no. 1, pp. 5–19, Jan. 2003.DOI
  3. [3]A. C. Myers, “Jflow: practical mostly-static information flow control,” in Proceedings of the 26th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, ser. POPL ’99. New York, NY, USA: Association for Computing Machinery, 1999, p. 228–241. [Online]. Available: https://doi.org/10.1145/292540.292561
  4. [4]M. Vassena, A. Russo, D. Garg, V. Rajani, and D. Stefan, “From fine- to coarse-grained dynamic information flow control and back,” Proc. ACM Program. Lang., vol. 3, no. POPL, Jan. 2019. [Online]. Available: https://doi.org/10.1145/3290389
  5. [5]A. Myers and B. Liskov, “Complete, safe information flow with decentralized labels,” in Proceedings. 1998 IEEE Symposium on Security and Privacy (Cat. No.98CB36186), 1998, pp. 186–197.
  6. [6]S. A. Siddiqui, R. Gaonkar, B. Köpł, D. Krueger, A. Paverd, A. Salem, S. Tople, L. Wutschitz, M. Xia, and S. Zanella-Béguelin, “Permissive information-flow analysis for large language models,” Transactions on Machine Learning Research (TMLR), October 2025. [Online]. Available: https://www.microsoft.com/en-us/research/publication/permissive-information-flow-analysis-for-large-language-models/arxiv.org/abs/2410.03055
  7. [7]M. Costa, B. Köpł, A. Kolluri, A. Paverd, M. Russinovich, A. Salem, S. Tople, L. Wutschitz, and S. Zanella-Béguelin, “Securing AI agents with information-flow control,” arXiv, May 2025. [Online]. Available: https://www.microsoft.com/en-us/research/publication/securing-ai-agents-with-information-flow-control/arxiv.org/abs/2505.23643
  8. [8]D. E. Denning, “A lattice model of secure information flow,” Communications of the ACM, vol. 19, no. 5, pp. 236–243, May 1976.DOI
  9. [9]A. C. Myers and B. Liskov, “Protecting privacy using the decentralized label model,” ACM Trans. Softw. Eng. Methodol., vol. 9, no. 4, pp. 410–442, Oct. 2000.
  10. [10]W. Enck, P. Gilbert, S. Han, V. Tendulkar, B.-G. Chun, L. P. Cox, J. Jung, P. McDaniel, and A. N. Sheth, “Threat-Driven: An information-flow tracking system for realtime privacy monitoring on smartphones,” ACM Trans. Comput. Syst., vol. 32, no. 2, Jun. 2014. [Online]. Available: https://doi.org/10.1145/2619091
  11. [11]E. Debenedetti, I. Shumailov, T. Fan, J. Hayes, N. Carlini, D. Fabian, C. Kern, C. Shi, A. Terzis, and E. Tramer, “Defeating prompt injections by design,” in 2026 IEEE Conference on Secure and Trustworthy Machine Learning (SaTML). Los Alamitos, CA, USA: IEEE Computer Society, Mar. 2026, pp. 587–618. [Online]. Available: https://doi.ieeecomputersociety.org/10.1109/SaTML68715.2026.00040arxiv.org/abs/2503.18813
  12. [12]P. Yu, W. Liu, Y. Yang, J. Li, Z. Zhang, X. Feng, and F. Zhang, “Benchmarking LLM tool-use in the wild,” in The Fourteenth International Conference on Learning Representations, 2026. [Online]. Available: https://openreview.net/forum?id=yz7LF5vfpnarxiv.org/abs/2604.06185
  13. [13]Y. Shen, K. Song, X. Tan, W. Zhang, K. Ren, S. Yuan, W. Lu, D. Li, and Y. Zhuang, “TaskBench: Benchmarking large language models for task automation,” in Advances in Neural Information Processing Systems, A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang, Eds., vol. 37. Curran Associates, Inc., 2024, pp. 4540–4574. [Online]. Available: https://proceedings.neurips.cc/paper_files/paper/2024/file/085185ea97db31ae6bdac7497616fd3e-Paper-Datasets_and_Benchmarks_Track.pdfarxiv.org/abs/2311.18760
  14. [14]S. Kim, S. Moon, R. Tabrizi, N. Lee, M. W. Mahoney, K. Keutzer, and A. Gholami, “An LLM compiler for parallel function calling,” in Proceedings of the 41st International Conference on Machine Learning, ser. ICML’24. JMLR.org, 2024.arxiv.org/abs/2312.04511

Paper details

vlnc:W_hbvgesm7
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 5

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Generative AI, LLMs

View statement
Looking for related papers…
Contents