Google’s Attack Warning: Limit What Your Agents Can Reach

▶ Watch the video version of this article
Your email-to-quote automation needs to read a request, look up a contact, and prepare a draft. It probably does not need permission to delete CRM records or change billing details. Google’s latest threat finding is a reason to check that difference now: faster automated attacks make the reach of each exposed credential more consequential.
The practical response is not to stop using AI agents. It is to make sure a compromised workflow can do less than an administrator can.
What Google found—and what it did not
Google Threat Intelligence Group (GTIG) reported that it found an exposed staging server hosting a multi-agent framework called exploit_agent. According to Google, the framework was set up to compare code around patch announcements, identify potential vulnerabilities, draft exploits, and execute them automatically—vulnerability discovery and exploitation “without a human in the loop.”
The Decoder’s report also covers Google’s finding; read Google’s report for the underlying account. The distinction from Google’s earlier reporting is the automated chain: not just assistance with scanning or an exploit, but a framework configured to move from examining a patch through attempting exploitation.
That is significant. It is also narrower than some headlines suggest. The finding does not establish how often exploit_agent succeeded, identify a number of organizations it compromised, or show that attackers used it to breach inbox-to-CRM automations. “Without a human in the loop” describes the reported discovery-and-exploitation workflow; it does not mean no person selected targets or directed other parts of an operation.
For a small business, the immediate lesson is about containment. You cannot control how an attacker develops an exploit. You can control whether the credential inside one of your automations can read a mailbox, send mail, export customer data, and alter payments—or only perform the task that automation actually needs.
Map one workflow before changing permissions
The fastest useful access review starts with one live workflow, not a company-wide spreadsheet. Record its trigger, every system it touches, the actions each connection can perform, and the point where a person approves an external action. Then compare those permissions with the actions the workflow is supposed to perform.
Take a customer-request workflow:
- An email arrives in a designated mailbox.
- The automation reads the request and finds the customer in the CRM.
- It prepares a quote draft.
- It notifies the owner.
- The owner reviews and sends the quote.
That description is not a permission map. “CRM access” could mean looking up one contact, editing every deal, or exporting records. Likewise, an email connection that reads requests might also be able to send messages as the mailbox owner.
Here is the artifact I would write down before touching a credential:
| Connection | Required action | Action to exclude | Check before release |
|---|---|---|---|
| Request mailbox | Read incoming requests | Send or delete mail | Review granted access; test a sample request |
| CRM | Look up the matching contact | Delete records or export the database | Inspect the connected app’s permissions |
| Quote tool | Create a draft for review | Change payment details or send the quote | Test with a dummy customer |
| Team chat | Post an owner notification | Administer the workspace | Confirm the integration’s actual role |
This is a target state, not a claim that every provider offers those exact controls. If a tool only offers a broad permission bundle, mark the row as unresolved. Do not label it “read-only” because the workflow happens to use only read operations.
The approval point matters just as much as the credential. A quote draft can be useful without being authorized to contact a customer. A message that says “change the bank details before sending” should not turn a read-and-draft workflow into a billing workflow. Treat incoming email content as data to evaluate, not instructions that can expand the agent’s authority.
Narrow the credentials at the provider, not just in the prompt
Prompt instructions such as “never send email” are not access controls. Restrict the connection in the provider’s authorization settings where possible, give the workflow its own identity where the platform supports it, and keep administrator credentials out of the agent’s environment.
Gmail makes the distinction concrete. Google’s Gmail API scope documentation recommends choosing the most narrowly focused scope an app needs. gmail.readonly permits viewing messages and settings; gmail.send permits sending email on the user’s behalf. gmail.modify includes reading, composing, and sending, while the full mail.google.com scope also permits immediate permanent deletion. Those are materially different grants for an automation whose job is to read requests.
Start by checking what is already authorized. Use your Google Account’s third-party connection settings to review the app’s access; Google Account Help is the place to check the current steps and what removing access entails. An existing grant does not automatically become a narrower Gmail scope; whether you can authorize narrower scopes depends on the app.
The same inspection principle applies beyond email. For a HubSpot connection, consult HubSpot’s official connected-apps guidance to find the current permissions information in your account. Read what the connection has, not what its name suggests it has.
When building your own integration, separate identities by job where the provider allows it. A request reader should not inherit the credential used to administer billing. Google Cloud’s guidance for agents similarly advises giving an agent its own identity and only the IAM roles needed for its tasks. This will not repair a vulnerable application. It can limit what an attacker can do with that application’s credential after a compromise.
Test the allowed action and the blocked action
A permission change is finished only when the intended workflow still runs and the unwanted action is denied. Use a dummy customer and a harmless request for the positive test; use a safe test environment or the provider’s permission-checking tools for the negative test. Do not probe production billing or customer records to prove a point.
For the email-to-quote workflow, the test record can be compact:
workflow: customer-request-to-quote-draft
trigger: designated_request_mailbox
allowed_result:
- read_sample_request
- find_dummy_customer
- create_quote_draft
- notify_owner
requires_human_approval:
- send_quote_to_customer
must_be_blocked:
- delete_crm_contact
- change_payment_details
evidence_to_save:
- authorized_permissions
- completed_draft_test
- denied_action_check
This YAML is documentation, not an enforcement mechanism. The provider’s scopes, roles, API keys, and application permissions must do the blocking. A test that merely confirms the agent chose not to delete a contact proves little about what its credential could do.
After changing access, run the normal path and record where it fails, if it fails. If a feature stops working, check the provider’s official permission guidance before deciding what access it requires. You can then choose a supported narrower connection, split the workflow, keep a manual step, or accept and document the broader grant while you evaluate alternatives.
Save the permission view and test results with the workflow documentation. When someone later edits the automation, they should be able to tell whether a new “send” or “update” permission was intentional rather than a quiet expansion of access.
Keep human approval where the consequence is external
Human approval is most valuable before an automation makes a consequential external change: sending a quote, changing payment details, or modifying a customer record. It is not a substitute for narrow credentials, but it is a second boundary when the next step depends on untrusted input.
In this example, the agent can assemble a draft from the email and CRM record. The owner can compare the draft with the original request and decide whether to send it. The agent should not gain billing administration merely because a customer email mentions payment terms.
That boundary also clarifies what an agent can safely decide on its own. Internal routing and draft preparation are different from communicating a price or changing where money goes. Google Cloud warns that an agent operating without approval is vulnerable to prompt injection and insecure tool chaining. Approval helps, but only if the reviewer can see the proposed action and its source—not just a generic “approve workflow” button.
Do the ordinary maintenance as well: patch software you run and review connections when a workflow changes. Google’s finding concerns automated exploitation; narrow credentials and visible approvals address the damage a compromised component might cause after an attacker gets in. They solve different parts of the problem.
Where bizflowai.io fits
I’m a senior engineer who builds AI automations for practical use. For a project like this, a useful security outcome would be a documented workflow with only the connections it needs, a visible approval point, and a test showing both what completes and what is blocked.
Want more like this?
The channel is intended to cover practical AI automation. Its address is not confirmed, so check the official channel listing before following a link that claims to represent it.
For the workflow in this post, start with the permission map above. Check each grant in the connected provider’s official settings, then test an allowed action and a blocked action before changing a live automation.
Frequently asked questions
Why do restricted permissions matter for business automations?
Restricted permissions can limit what an attacker can do if part of an automation is compromised. For example, a quote-drafting service with permission only to create drafts offers fewer actions than one sharing an administrator credential across the business. Restricting access does not fix the underlying vulnerability, but it can reduce the potential damage after exploitation.
How do I review the permissions in an existing automation?
Pick one live automation and record what triggers it, which systems it touches, what each connection can do, and where a person approves an external action. Check the actual permissions in each tool rather than relying on labels such as “CRM access.” Remove one unnecessary permission using the service’s supported controls, then safely test that the workflow still works and the restricted action is blocked.
When should I use human approval instead of an automated action?
Use a human approval step for an external action that the automation does not need to complete on its own. In the narration’s email-to-quote example, automation can read a designated mailbox, look up a customer, create a quote draft, and notify the owner. A person approves sending the quote, while changing payment details remains outside the workflow entirely.