---
title: "AgentForger: One Link Forges an AI Insider in Your Org"
description: Zenity disclosed AgentForger, a ChatGPT Workspace Agents flaw where one phishing link forged a persistent AI insider. OpenAI fixed it in four days.
canonical: https://lukeocodes.dev/agentforger-one-link-forges-insider
type: article
locale: en_GB
published: 2026-07-27T00:00:00.000Z
modified: 2026-07-27T00:00:00.000Z
authors:
  - Luke Oliff
section: AI
tags:
  - AI
  - Security
  - Opinion
feed: https://lukeocodes.dev/rss.xml
search: https://lukeocodes.dev/search.json?q={query}
schema:
  - "@context": https://schema.org
    "@graph":
      - "@type": Organization
        "@id": https://ably.com/#organization
        name: Ably
        url: https://ably.com
      - "@type": WebSite
        "@id": https://lukeocodes.dev/#website
        url: https://lukeocodes.dev
        name: Luke Oliff
        alternateName: lukeocodes
        inLanguage: en
        publisher:
          "@id": https://lukeocodes.dev/authors/luke#person
        description: Personal blog and writing by Luke Oliff — developer relations, voice AI, developer experience.
        potentialAction:
          - "@type": SearchAction
            target:
              "@type": EntryPoint
              urlTemplate: https://lukeocodes.dev/blog/search?q={search_term_string}
            query-input: required name=search_term_string
      - "@type": Person
        "@id": https://lukeocodes.dev/authors/luke#person
        name: Luke Oliff
        url: https://lukeocodes.dev/authors/luke
        description: Staff engineer and Staff Tech Lead for Developer Experience at Ably. Writing about developer relations, AI, and the voice industry, from the UK.
        mainEntityOfPage: https://lukeocodes.dev/authors/luke
        givenName: Luke
        familyName: Oliff
        image: https://lukeocodes.dev/authors/luke.jpg
        jobTitle: Staff Tech Lead, Developer Experience
        worksFor:
          "@id": https://ably.com/#organization
        sameAs:
          - https://www.linkedin.com/in/lukeocodes
          - https://github.com/lukeocodes
          - https://bsky.app/profile/lukeocodes.dev
          - https://x.com/lukeocodes
          - https://hashnode.com/@lukeocodes
          - https://dev.to/lukeocodes
        knowsAbout:
          - Developer Relations
          - Developer Experience
          - Voice AI
          - Text-to-Speech
          - Answer Engine Optimisation
          - Search Engine Optimisation
          - Open Source
          - Developer Tooling
          - API Design
          - Speech-to-Text
          - Voice Agents
          - Community Building
        knowsLanguage:
          - English
        nationality: British
        alumniOf:
          - "@type": Organization
            name: The Open University
  - "@context": https://schema.org
    "@graph":
      - "@type": Organization
        "@id": https://ably.com/#organization
        name: Ably
        url: https://ably.com
      - "@type": Person
        "@id": https://lukeocodes.dev/authors/luke#person
        name: Luke Oliff
        url: https://lukeocodes.dev/authors/luke
        description: Staff engineer and Staff Tech Lead for Developer Experience at Ably. Writing about developer relations, AI, and the voice industry, from the UK.
        mainEntityOfPage: https://lukeocodes.dev/authors/luke
        givenName: Luke
        familyName: Oliff
        image: https://lukeocodes.dev/authors/luke.jpg
        jobTitle: Staff Tech Lead, Developer Experience
        worksFor:
          "@id": https://ably.com/#organization
        sameAs:
          - https://www.linkedin.com/in/lukeocodes
          - https://github.com/lukeocodes
          - https://bsky.app/profile/lukeocodes.dev
          - https://x.com/lukeocodes
          - https://hashnode.com/@lukeocodes
          - https://dev.to/lukeocodes
        knowsAbout:
          - Developer Relations
          - Developer Experience
          - Voice AI
          - Text-to-Speech
          - Answer Engine Optimisation
          - Search Engine Optimisation
          - Open Source
          - Developer Tooling
          - API Design
          - Speech-to-Text
          - Voice Agents
          - Community Building
        knowsLanguage:
          - English
        nationality: British
        alumniOf:
          - "@type": Organization
            name: The Open University
      - "@type": BlogPosting
        "@id": https://lukeocodes.dev/agentforger-one-link-forges-insider#article
        headline: "AgentForger: One Link Forges an AI Insider in Your Org"
        alternativeHeadline: "AgentForger: One Link Forges an AI Insider in Your Org"
        description: Zenity disclosed AgentForger, a ChatGPT Workspace Agents flaw where one phishing link forged a persistent AI insider. OpenAI fixed it in four days.
        datePublished: 2026-07-27T00:00:00.000Z
        dateModified: 2026-07-27T00:00:00.000Z
        url: https://lukeocodes.dev/agentforger-one-link-forges-insider
        mainEntityOfPage: https://lukeocodes.dev/agentforger-one-link-forges-insider
        inLanguage: en
        author:
          - "@id": https://lukeocodes.dev/authors/luke#person
        isPartOf:
          "@id": https://lukeocodes.dev/#website
        keywords: AI, Security, Opinion
        articleSection: AI
        abstract: Zenity Labs disclosed AgentForger this week, a vulnerability in OpenAI's ChatGPT Workspace Agents that let a single phishing link create, authorise, publish, schedule, and execute an autonomous AI agent inside a victim's organisation.
        speakable:
          "@type": SpeakableSpecification
          cssSelector:
            - .post-tldr
            - h1
        image: https://lukeocodes.dev/og.png?h=AgentForger%3A+One+Link+Forges+an+AI+Insider+in+Your+Org&d=Zenity+disclosed+AgentForger%2C+a+ChatGPT+Workspace+Agents+flaw+where+one+phishing+link+forged+a+persistent+AI+insider.+OpenAI+fixed+it+in+four+days.&e=Writing
        wordCount: 1378
        timeRequired: PT7M
        publisher:
          "@id": https://ably.com/#organization
      - "@type": BreadcrumbList
        itemListElement:
          - "@type": ListItem
            position: 1
            name: Home
            item: https://lukeocodes.dev
          - "@type": ListItem
            position: 2
            name: Writing
            item: https://lukeocodes.dev/blog
          - "@type": ListItem
            position: 3
            name: "AgentForger: One Link Forges an AI Insider in Your Org"
            item: https://lukeocodes.dev/agentforger-one-link-forges-insider
---

[Luke Oliff.](/)

- [Blog](/blog)
- [CV](/cv)
- [Uses](/uses)
- [User manual](/user-manual)
- [Living with ADHD](/living-and-working-with-adhd)
- [RSS](/rss.xml)

[Luke Oliff · Writing](/blog)

# AgentForger: One Link Forges an AI Insider in Your Org

Jul 2026 · [AI](/blog/category/ai) · 7 min read · [Luke Oliff](/authors/luke)

**TL;DR:** Zenity Labs disclosed AgentForger this week, a vulnerability in OpenAI's ChatGPT Workspace Agents that let a single phishing link create, authorise, publish, schedule, and execute an autonomous AI agent inside a victim's organisation.

Zenity Labs [disclosed AgentForger](https://labs.zenity.io/p/agentforger-part-1-chatgpt-cross-site-agent-forgery) this week, a vulnerability in OpenAI's ChatGPT Workspace Agents that let a single phishing link create, authorise, publish, schedule, and execute an autonomous AI agent inside a victim's organisation. The agent inherited the employee's identity, reused their pre-authorised connectors (Outlook, Gmail, Slack, Teams, Drive, SharePoint), disabled its own approval gates, and polled the attacker's inbox for new instructions every five minutes. OpenAI patched it in four days. No evidence it was exploited in the wild.

The fix was fast. The class of vulnerability is not going away.

![Traditional CSRF forges one unintended request. AgentForger forges an entire autonomous system: the link triggers the Builder, which creates an agent, attaches connectors, disables approvals, publishes, schedules, and runs, all without further user interaction.](/blog/agentforger-one-link-forges-insider/csrf-vs-agentforger.png)

### How AgentForger actually worked

ChatGPT's Workspace Agents Builder lives at `chatgpt.com/agents/studio/new` and accepts two URL parameters: `template_name` and `initial_assistant_prompt`. Under normal use, building an agent is interactive. You pick a template, write instructions, review connector permissions, set approval gates, test in Preview Mode, and publish. Multiple points where a human is supposed to be in control.

Zenity found that `initial_assistant_prompt` wasn't just placed into the prompt field. It was auto-submitted and executed. An attacker could embed a full instruction set in the URL, and the Builder would carry it out the moment the page loaded in the victim's authenticated session. No further clicks needed after the initial one.

The payload in Zenity's proof of concept told the Builder to connect all previously authorised connectors, set every permission to "Never ask", create schedules offset by five minutes so the agent runs twelve times an hour, check Outlook for emails from the attacker with "TASK" in the subject, execute whatever the email says using connected apps, and email results back. Then it told the Builder to make the agent live.

One click. The victim sees a ChatGPT page load. In the background, a fully operational agent is now running under their name with their access, taking orders from someone else.

### What the forged agent could do

[Part 2 of Zenity's write-up](https://labs.zenity.io/p/agentforger-part-2-the-autonomous-insider) demonstrates the blast radius. Once the agent was live, the attacker sent TASK emails and got results back. The demonstrated capabilities:

The agent mapped the organisation by pulling data from Outlook, Slack, Teams, Drive, SharePoint, and Calendar. It returned people, roles, Slack channel IDs, active projects, recurring meetings, and workstreams. That's the kind of internal context an attacker normally builds over weeks of lateral movement, returned from a single emailed assignment.

It found an M&A term sheet, a board presentation flagging missed revenue targets and planned layoffs, and a company-wide employee export with compensation data. It searched Slack for messages containing "pass:" and found a database username and password pair, emailed in plain text to the attacker.

It sent Teams messages from the victim's account asking colleagues to confirm an SSO rollout on an attacker-controlled login page. It prepared a $242,500 wire transfer approval request. It created calendar invites with attacker-controlled attendees. All of it looked like normal internal activity from a trusted employee.

### Why this is a new class of problem

The instinct is to file this under "CSRF, patched, move on." I think that undersells it.

Traditional CSRF makes the victim's browser perform one unintended action. AgentForger made the unintended action be the creation of an entire autonomous system. The agent had tools, approvals, instructions, a schedule, and access to already-authorised connectors. It persisted without the victim needing to click again or keep a tab open. Michael Bargury, Zenity's CTO, put it well: "This isn't a forged request, it's a forged insider."

The root cause was two things combining. First, the Builder treated a URL parameter as executable input without confirmation, which is a classic CSRF-adjacent mistake. Second, the same natural-language prompt that created the agent could also disable the security controls meant to govern it. The mechanism intended to require human approval for sensitive actions could itself be turned off by the instructions being executed. Zenity calls this the "lethal trifecta": untrusted input, access to private data, and an exfiltration path, all handed to a build tool that constructs an agent with the guardrails already off.

That second piece is the structural one. Every agent platform that lets natural-language instructions modify security-relevant configuration has this shape of vulnerability latent in it. The specific URL parameter is gone, but the design pattern (agents that can configure their own permissions through the same interface that configures their behaviour) is everywhere.

### What security tooling can't see yet

I wrote about the [Hugging Face incident](https://lukeocodes.dev/guardrails-locked-out-the-defenders) last week, where the problem was that guardrails helped the attacker and blocked the defender. AgentForger is a different failure mode but the same gap: existing security tools are built to watch users and endpoints. An AI agent is neither. It operates under a real user's identity, through legitimate platform APIs, on a schedule, and every action it takes looks like normal authenticated work.

Your SIEM sees an Outlook send event from a known employee. Your DLP sees a Drive access from a known session. The agent is invisible because it isn't a new principal in any system your security stack models. It's a ghost wearing a badge it was handed at creation.

The Gartner prediction that over 40% of agentic AI projects will be cancelled by 2027 cites governance and operational discipline as the causes. AgentForger is a concrete example of what ungoverned agent creation looks like when someone hostile finds the seam. The platform assumed the user intentionally created, approved, scheduled, and launched the agent. That assumption is the vulnerability, and it's an assumption every agent platform currently makes.

### What to actually do about it

OpenAI's fix was to remove the `initial_assistant_prompt` parameter from the URL. That stops this specific attack. It does not stop the class.

If your org uses ChatGPT Workspace Agents (or any agent platform with connector access and scheduling), the questions worth asking this week: Can you inventory every agent running under employee identities? Can you see what connectors each one has and what approval settings are configured? Do you have alerting on agent creation events, not just agent actions? Is there anything in your stack that distinguishes "employee did a thing" from "agent running under employee's name did a thing"?

For most teams the answer to all four is no, and that's the real finding here. The vulnerability is patched. The visibility gap is not.

### FAQ

#### What is AgentForger and how was it discovered?

AgentForger is a vulnerability in OpenAI's ChatGPT Workspace Agents disclosed by Zenity Labs in July 2026. It allowed a single phishing link to create an autonomous AI agent inside a victim's organisation without further user interaction. The agent inherited the victim's identity and pre-authorised app connectors. Zenity reported it to OpenAI via Bugcrowd on June 4, 2026, and OpenAI fixed it by June 8 by removing the affected URL parameter.

#### Has AgentForger been exploited in the wild?

No. OpenAI patched the vulnerability within four days of disclosure, and Zenity states there is no evidence of exploitation in the wild. The disclosure was published in late July 2026 after the fix was confirmed.

#### How is AgentForger different from a normal phishing attack?

Traditional phishing tricks a user into performing one action, like entering credentials. AgentForger's single click created a persistent autonomous system that continued operating indefinitely without further victim interaction. The forged agent ran on a five-minute schedule, took new instructions via email, and could perform reconnaissance, data theft, credential harvesting, and internal phishing across all connected enterprise apps.

#### Which organisations were affected by AgentForger?

Any organisation using ChatGPT Workspace Agents where employees had previously authorised at least one connector (Outlook, Gmail, Slack, Teams, Google Drive, or SharePoint) was potentially vulnerable before the June 8 patch. The attack required the victim to be logged into ChatGPT and to click a malicious link.

#### What should security teams do in response?

Audit your agent inventory: identify every Workspace Agent running under employee identities, check connector permissions and approval settings, and establish alerting on agent creation events. The specific vulnerability is patched, but the broader gap (security tools that cannot distinguish agent actions from user actions) remains unaddressed on most enterprise stacks.

[← Newer: OpenAI Presence: Voice Agents You Can't Self-Serve](/openai-presence-voice-agents)

[All posts](/blog) →

## Search this site

`GET https://lukeocodes.dev/search.json?q=<words>` returns matching posts as JSON, each with its page URL and its markdown URL. Add `&limit=<1-50>` for more than 10. How it works: [/blog/search](https://lukeocodes.dev/blog/search.md).

```sh
curl "https://lukeocodes.dev/search.json?q=developer+relations"
```

---

© 2026 Luke Oliff. Posts live at the root of this site.

- [GitHub](https://github.com/lukeocodes)
- [LinkedIn](https://www.linkedin.com/in/lukeocodes)
- [X](https://x.com/lukeocodes)
- [Bluesky](https://bsky.app/profile/lukeocodes.dev)
- [Email](mailto:luke@lukeoliff.com)
- [RSS](/rss.xml)

## Cookies

This site sets one analytics cookie, from Google Analytics, and only in a browser that accepts the cookie banner. A client that does not run scripts sets no cookies, so there is nothing to accept or decline here.

[Cookie policy](/cookies)
