The upload step in every AI creative tool you have reviewed was doing security work nobody assigned it. Adobe's MAX preview on 10 November 2026 removes it: an outside agent will act inside the running application, on the native project file on the user's own machine, with the layers and sequences left editable. Nothing ships until a private beta in early 2027 — which is exactly long enough to notice that your allowlist, your audit trail and your undo were all attached to a file transfer that will no longer happen.
At a glance
Two separate things were shown at MAX and they are easy to conflate. The in-app Creative Agent is Adobe's own assistant, already in beta inside the apps. The local MCP integrations are the ones that matter here: third-party agents, acting locally.
| Item | What it is | Status as announced |
|---|---|---|
| Local MCP integrations | Outside agents act inside Photoshop, Illustrator, Premiere and After Effects, on native project files on the user's machine | Previewed 10 November 2026; private beta stated for early 2027 |
| Editability guarantee | Layers in Photoshop, vectors in Illustrator, bins and sequences in Premiere survive the agent's work | Adobe's own framing of the preview |
| Supported agents | Which clients may connect | Not named by Adobe; press reporting mentions ChatGPT, Claude and Gemini as the intended kind |
| Creative Agent (in-app) | Adobe's own assistant, reaching Premiere and Illustrator | Separate feature, in beta now; the Photoshop version in the beta app |
Read the status line carefully
A previewed integration with a stated beta date is a roadmap, and roadmaps slip. There is no Adobe MCP server to install today, no published tool surface to review, and no permission model to evaluate — so any claim about how it will behave, including the ones below, is reasoning about a shape rather than testing a product.
The shape is still worth reasoning about now, for one practical reason: the decisions it forces are decisions about your environment, and they take longer than a beta cycle. Deciding which agent clients your designers may point at a running Photoshop is a procurement and policy question, not a configuration one.
The upload was load-bearing
Every cloud-AI creative workflow has the same five steps: the user picks a file, a copy goes up, something happens, a new file comes back, the user accepts or discards it. Four separate controls were hanging off step two without anyone designing it that way.
Egress inspection. The transfer was a network event with a destination host, which is the unit your egress policy and your DLP both speak. A local agent driving a local application generates no such event — the file never leaves, so nothing in egress control sees the work happen. That is a privacy improvement and a visibility loss at the same time, and the two do not cancel.
Scope. "Which file" was answered by the user picking one. In the new shape the subject is whatever document is open in the application, which is a selection in a running process rather than a path. A rule written in terms of directories cannot express it, which is the ambient authority problem in its purest form: the agent gets whatever the application can currently do, to whatever it currently holds.
Undo. Discarding a returned file is a perfect undo — the original was never touched. Editing in place makes undo whatever the application happened to record, which for a long agent-driven session may be a history stack deep enough to be useless, or a sequence of steps the app coalesced. Undo and reversibility is the design problem; the point here is that the free version of it just went away.
Audit. A service-side record existed because a service was involved. Now the actions happen in a desktop app under the user's own identity, which is the attribution gap in third-party agents logging in as your users, moved onto a workstation.
The editability promise is the actual product
The most quoted line from the preview is also the most technically interesting: layers in Photoshop, vectors in Illustrator, bins and sequences in Premiere are preserved. That is not a nice-to-have, it is the reason this shape exists at all.
Generative tools that return a flattened render are useless in a professional pipeline, because the next person in the chain needs to change the thing. Preserving structure means the agent is operating the application's real object model — creating layers, setting properties, moving clips — rather than producing pixels. Which tells you what the tool surface has to look like: granular, typed operations against document objects, not a render(prompt) endpoint. That is the tool granularity question, and the granularity that makes the output editable is the same granularity that makes a review diff possible.
It also creates the review problem. A diff between two flattened images is something a human can see at a glance. A diff across a layer tree or a Premiere sequence — twelve properties changed on four layers, two clips retimed — is a structured change that nobody has a viewer for. Expect the first real complaint about this feature to be that approving the agent's work requires opening the document and hunting.
Which agent you point at it becomes a real decision
Adobe has not said which clients will be supported, and press coverage frames it as the general-purpose assistants. Assume for a moment that it is any MCP client. Then the security properties of this feature are not Adobe's to determine — they are a property of whichever agent the user installed, and of whatever that agent reads.
The reason that matters: an agent driving Photoshop over local MCP is also, usually, an agent that reads email, fetches web pages, or opens shared documents. Content from those channels is untrusted input, and this feature gives it a new sink — not data exfiltration, but actuation on a file the user has not saved. "Make the logo bigger" and "flatten every layer and save" are the same kind of call from the application's point of view. The layered defence is unchanged from prompt-injection defence; what is new is that the blast radius includes an hour of someone's unsaved work.
And the server itself is a local MCP server, with the properties every local MCP server has: no identity to check, and a transport whose security depends on choices the packager made rather than ones you made. We wrote that up as a runbook in local MCP servers on the endpoint, which is where the inventory and allowlist work belongs.
What to do before early 2027
Three things, none of which require the beta to exist.
- Decide the unit of permission now. If it is not a file path, write down what it is — application, document class, project, or nothing at all. Teams that skip this will default to "whatever the designer installed", which is a decision too.
- Get the client inventory done. Which MCP clients are on your creative workstations, at what version, is a question you can answer this week, and the answer does not change when Adobe ships. It is the control that everything else depends on.
- Ask for the review surface, loudly, while it is still a preview. The thing this feature most needs and least obviously has is a legible record of what the agent changed in the document. Vendors build what beta customers ask for, and the window for asking is open exactly now.
The broader pattern is worth naming, because Adobe will not be the last. A desktop application with a local MCP server is a new category of agent target: high-value, stateful, unsaved, and outside every boundary your agent controls were built on. The protocol made it a two-week integration for the application vendor. It does not make it a two-week governance problem for you.
FAQ
Can I try this today?
No. The local MCP integrations were previewed on 10 November 2026 with availability stated as private beta in early 2027. Adobe's in-app Creative Agent is a different feature and is in beta now, with the Photoshop version in the Photoshop beta app.
Is editing in place more dangerous than uploading a copy?
It is better for confidentiality and worse for recoverability and for visibility. The file not leaving the machine removes a real exposure; it also removes the network event your DLP was watching, the pristine original you could fall back on, and the service-side log you could read afterwards.
Does this mean any agent will be able to drive Photoshop?
Unknown — Adobe has not published the supported-client list or the permission model. If it is open to MCP clients generally, then the feature's safety properties depend on which agent the user installed rather than on Adobe, which is the main thing worth asking about during the beta.
How is this different from the computer-use agents that already click around Photoshop?
A computer-use agent manipulates pixels on screen and is blind to the document model, so its output is whatever the clicks produced. An MCP integration addresses the application's objects directly, which is why the layers survive — and why the operations are reviewable in principle, if someone builds the viewer.
We have no creative apps. Does any of this apply to us?
The specific integration does not; the shape does. Any desktop application that exposes a local MCP server puts an agent inside a process holding unsaved state under the user's identity, and the controls that stop working are the same ones in each case.
Further reading
On this wiki:
- Local MCP servers on the endpoint — the inventory, allowlist and transport rules this needs.
- Ambient authority — why "whatever is open" is the hardest scope to write a rule for.
- Undo and reversibility — what replaces discarding the returned file.
- Tool granularity — why preserving layers forces a typed, granular tool surface.
- MCP security anti-patterns — the server-side mistakes to check for when the beta opens.
- Blast radius — measured in documents here, not directories.