✦ Zenity is a Founding Member of ServiceNow's Control Tower Alliance

What HUMINT Taught Me About Trust in AI Agent Workflows

Portrait of John Travise
John Travise
•
Cover Image
Ask AI to

Since joining Zenity, I’ve been thinking about my earlier work in military human intelligence (HUMINT).

In HUMINT, a captured document might identify the location of a weapons cache or another important site. It could also be a false lead planted to send us into a trap. Recovering the document tells us where it was found; we still have to evaluate who produced it, who could have shaped it, and what corroborates its claims before acting.

Enterprise AI agents have a related problem. An agent reads a ticket, retrieves a document, or receives another agent’s output, then uses that content to choose its next action. Its credentials can be valid, its tools correctly configured, and the information driving the action can still be attacker-controlled.

That experience is why I pay attention to the source behind an agent’s instructions. Before acting on a captured document or a retrieved record, we need to understand how the information reached us and who benefits if we follow it.

How External Content Gains Internal Credibility

Consider a hypothetical workflow. A customer submits a support ticket containing malicious instructions. A triage agent summarizes it into a CRM record. Later, an operations agent reads that record and acts on instructions preserved in the summary.

The second agent retrieved the content from an internal system. That location says little about the trustworthiness of the original source. If the summary drops attribution, the downstream agent treats a customer submission as an internal directive.

This is information laundering: content gains apparent credibility as it passes through trusted systems, while its original source and uncertainty become harder to see. It becomes circular reporting when one underlying claim travels through several sources and gets mistaken for independent corroboration. In a multi-agent workflow, several summaries can all trace back to one attacker-controlled record.

Authentication can work correctly throughout, while the failure is in how information acquires authority as it moves between systems. The CRM record creates the same concern as the captured document: its location alone does not establish that its contents are reliable.

A Documented Example in Salesforce and Slack

Zenity Labs’ SalesBleed disclosure showed how an external submission can steer an agent operating inside enterprise systems.

An attacker placed malicious instructions in a Salesforce lead submitted through a Web-to-Lead form. When an employee asked Agentforce to review the lead, those instructions redirected the agent into posting phishing messages in Slack.

The chain combined a URL-redaction bypass with a Slack reply action that lacked user confirmation and correct invoker attribution. Salesforce addressed the reported issues, and Zenity Labs confirmed the fixes on September 21, 2026.

Several controls were involved: handling untrusted CRM content, filtering outbound URLs, requiring approval, and identifying who initiated a message. The agent’s reach into both Salesforce and Slack connected those weaknesses into a single attack path. What catches my attention is where the external lead gained authority: content supplied for review became instructions for an action in another system.

Authorization and Execution Context

Identity and access controls establish which resources an agent can use. Resource servers validate credentials, scopes, and policy when requests arrive.

Those checks also need to account for the circumstances of the specific action. Permission to read customer records and permission to post in Slack both serve legitimate tasks. A request to review a lead should not give instructions inside that lead the authority to start a phishing campaign.

For sensitive actions, the questions are:

  • What triggered the run?
  • Which sources influenced it?
  • Whose identity reaches the downstream service?
  • Did the requested action fit the approved task?

Answering these questions requires preserving context across retrieval, summarization, tool calls, and delegation. With the captured document, a report describing the suspected cache would still need to identify where that information came from and what had been corroborated. Otherwise, the next person could mistake the summary for a verified finding. An agent’s summary needs to preserve that same distinction between the source’s claim and an established fact.

Connecting Configuration to Runtime Activity

An execution trace is more useful when it can be compared with the agent’s configuration: owner, instructions, connected tools, data sources, and approval requirements. That comparison lets an investigator judge whether an action fits the agent’s assigned role and whether the identity behind it should have been able to take it.

An agent configured to summarize support requests might have access to both a CRM and email. Its permissions alone allow several legitimate workflows. Its assigned role is what makes exporting customer records during a ticket summary something to investigate. In the captured-document example, authority to investigate a location would not establish that the location was safe or that the source was reliable. Likewise, an agent’s permission to use a tool leaves a separate question: does the evidence in this run support using it for this action?

Configuration also shapes the response. An agent using an unnecessarily broad permission, an agent following malicious instructions, and an agent operating under an approval that no longer applies each call for a different correction.

In a security evaluation, I would ask the vendor to demonstrate that connection for one agent: its configured access alongside a session involving untrusted content, a sensitive tool call, and a handoff to another agent. This will show which context survives the handoff, which policy applies, and where enforcement occurs.

What I Would Ask AI Security Vendors to Demonstrate

Zenity Labs has helped expose how enterprise agents can be manipulated through the information they retrieve, including the SalesBleed attack described above. That research informs a product approach connecting agent discovery and configuration with runtime detection and enforcement on supported platforms. Working here has given me a practical view of what teams need to establish before trusting an agent with sensitive actions. The questions below are how I would put that approach to the test in a customer’s environment.

Start with the platforms where your agents actually run. For each one, the vendor should show what it can discover, what activity it can observe, and which actions it can prevent. An inventory entry, an execution trace, and an inline control are three different capabilities, and a vendor that has one will often describe it as if it were all three.

The distinction holds within a single product. Zenity’s Boundaries guidance describes inline enforcement on supported platforms and detection-only support for others, including ChatGPT and Gemini. A “kill switch” alone is insufficient. By the time someone stops a run, the agent may already have sent sensitive data or changed a production resource. Stopping further activity cannot undo those actions. Teams need to evaluate sensitive actions before execution and verify whether containment reaches tool calls already in flight, queued jobs, and delegated work.

A gateway observing isolated requests and responses may lack the context to establish whether Slack posting fits the agent’s assigned role or whether an instruction arrived in a lead form three steps earlier. Ask what configuration, session history, and source attribution it receives and retains. In HUMINT, apparently independent reports could still lead back to one source. In an agent workflow, several records or messages can carry the same attacker-controlled instruction. The demonstration should show whether the platform can trace that origin across the steps it observes.

Then test a complete workflow. Can the platform connect a sensitive action to external content retrieved earlier? Does attribution survive summarization or delegation? Can a policy block the specific tool call before execution while permitted work continues?

Also test an interrupted run. Tool calls already issued, queued jobs, and delegated tasks may have their own execution paths. The demonstration should establish what the control stops and what keeps running.

Carrying Source Evaluation Into Agent Workflows

The captured-document example gives me a straightforward way to test an agent workflow: introduce information that appears useful, retain the fact that it came from an untrusted source, and check what happens before anyone acts on it.

  • Can an agent distinguish a retrieved claim from an approved instruction?
  • Does a summary retain the source and its trust level?
  • Can a second agent verify that an approval applies to the action it is about to take?
  • Can the runtime enforce that check?

Teams can test these with a small workflow: an external ticket, an internal summary, and a downstream action requiring approval. Introduce malicious instructions at the ticket, follow them through the summary, and confirm the sensitive action stays blocked without valid approval.

For me, the connection to HUMINT is in that evaluation before action. A captured document pointing to a weapons cache could send people toward a false lead or a trap. A poisoned record can redirect an agent using legitimate access. In each case, the source and the evidence supporting the proposed action need to remain visible.

Applying Source Evaluation Before Agents Act

My HUMINT experience taught me to ask what evidence justified acting on a report. I bring that same question to agent security. As information passes through records, summaries, and other agents, teams need to retain its source, distinguish corroborated facts from unverified claims, and check that the next action serves the assigned task. That’s what I want to help customers put into practice at Zenity: controls that use this context before an agent takes an action with real consequences.

Learn more about how Zenity helps teams discover agents, assess their access, and enforce runtime policy.

All Articles

Secure Your Agents

We’d love to chat with you about how your team can secure and govern AI Agents everywhere.

Get a Demo