Driving Adobe from Claude

For the implementer

The capability matrix — everything, in one table

Route selection: the decision you actually have to make

For the implementer

Architecture

Prerequisites

• Illustrator (Beta) — install from the Creative Cloud desktop app under Beta apps. The shipping release does not have this.
• An AI tool on the same computer. Adobe's documentation names Cursor, Claude Code, and Codex. NOTE Claude Desktop is not on that list — it may work, it is not supported.
• The AI tool must be able to reach localhost. Anything running in a container or on a remote host cannot see port 18412.

Setup, exactly

1. Launch Illustrator (Beta).
2. In the Application Bar, open MCP & Tools.
3. Click Copy Claude Code command to clipboard. Illustrator writes a complete claude mcp add command containing your token.
4. Paste it into a terminal and run it.
5. Restart Claude Code (claude).
6. Smoke test with a single instruction: Create a document. A new document should appear in Illustrator.

Adobe's sample command has this shape — do not copy this key, it is per-installation and yours will differ:

# ADOBE'S SAMPLE — the key is per-installation. Copy YOURS from the MCP & Tools panel.
claude mcp add --transport http \
  --header "Authorization: Bearer ilst_da9d6ccd0a1e39ecea17c19e3a5042325856532f8f8df1185b76f0ba5b6fa054" \
  --scope user illustrator http://localhost:18412/v1/mcp

On Windows PowerShell, the backslash line-continuations do not work. Use one line, or backticks:

claude mcp add --transport http --header "Authorization: Bearer <YOUR_KEY>" --scope user illustrator http://localhost:18412/v1/mcp

Verify registration independently of Illustrator:

claude mcp list
# expect: illustrator  http  http://localhost:18412/v1/mcp   ✓ connected

The 40 tools, by category

Known limits

• Single document. Multi-document orchestration is explicitly not supported.
• No cross-app reach. It cannot touch Photoshop or InDesign.
• No automatic brand-guideline enforcement. Adobe calls this out explicitly as not supported.
• Latency grows with document size. Large documents mean slow round-trips.
• Do not edit objects it is currently modifying. Background work plus a human hand on the same object is the documented failure case.
• Beta build. Port, token format, and tool list can change between beta drops.

Prompting patterns that hold up

• Ask for a plan first. Adobe's own recommended phrasing: “Show me a plan before making changes.” This turns a destructive multi-tool run into a reviewable one.
• Name things explicitly. Tools select by name and ID — “the blue rectangle” is a guess, Layer "Background" is not.
• Ask for a preview image after structural changes. The model can then self-correct instead of asserting success.
• Work in small commits. Illustrator's undo stack is your rollback; keep each instruction to one reversible unit.

Driving it from a script rather than a chat

Claude Code can be run non-interactively, which turns Route A into a real pipeline stage. The MCP server is registered at user scope, so it is available to headless invocations too:

# one-shot, non-interactive, allowed to use the illustrator tools
claude -p "Open ./brand.ai, put every text object on a layer named Type, export the Type layer as SVG to ./out/type.svg, then report the object count." \
  --allowedTools "mcp__illustrator" \
  --output-format json

Wrap that in your job runner and you have a repeatable Illustrator stage whose output you can assert on — check the SVG exists, check its byte size is non-trivial, check the reported object count matches expectation. Never trust the transcript alone; assert on the artifact.

For the implementer

Illustrator AI Assistant — the explicit NOT-supported list

Adobe documents these as out of scope, which is unusually candid and worth quoting in any internal proposal:

• Working across multiple documents.
• Reaching into other Adobe applications.
• Automatic brand-guideline application — it will not enforce your brand book.

Documented limitations: response latency, degraded behaviour on large documents, and the background-work conflict — do not manipulate objects the assistant is mid-edit on.

Photoshop AI Assistant — a caveat on this section's confidence

At verification time there was no ai-assistant-capabilities.html page for Photoshop (404). The public-beta announcement of 10 March 2026 is solid; the detailed capability surface is not documented to the same standard as Illustrator's or InDesign's. Treat specific Photoshop AI Assistant claims you read elsewhere as unverified until Adobe publishes the page.

For the implementer

The two commercial bridges

Duet is the Windows answer — it is the one that explicitly supports Claude Code, which matters if you want a scriptable, non-interactive pipeline rather than a chat window. The “~130 tools” number that circulates for InDesign MCP is Sidekick's aggregate figure, not a property of InDesign or of MCP generally; Duet publishes categories, not a tool count.

The open-source landscape — and why it fails on Windows

The macOS-only pattern is not accidental: those projects drive InDesign through AppleScript, which has no Windows equivalent. The Windows path is COM automation, which almost nobody has built an MCP server around for InDesign.

# Windows-only. InDesign must already be running.
import win32com.client as win32

app = win32.Dispatch("InDesign.Application")          # latest installed version
doc = app.Documents.Add()
page = doc.Pages.Item(1)

frame = page.TextFrames.Add()
frame.GeometricBounds = [12, 12, 60, 190]        # [top, left, bottom, right] — mm by default
frame.Contents = "Hello from Python"

doc.Export(win32.constants.idExportFormat.idPDFType, r"D:\out\hello.pdf")

DoScript — the bridge between languages

InDesign's doScript() lets one language hand a payload to another engine. This is how you get from COM/Python into ExtendScript where the API surface is best documented:

jsx = '''
var d = app.documents.length ? app.activeDocument : app.documents.add();
var f = d.pages[0].textFrames.add();
f.geometricBounds = [12, 12, 60, 190];
f.contents = "Written by ExtendScript, called from Python";
'''
app.DoScript(jsx, win32.constants.idScriptLanguage.idJavascript)

For the implementer

The third-party servers, ranked for Windows

Install and register — the whole thing

# 1. Photoshop must be running and must have a document open for most tools.
# 2. Register the server with Claude Code (stdio transport):
claude mcp add --scope user photoshop -- npx -y @alisaitteke/photoshop-mcp

# 3. Verify
claude mcp list

# 4. Smoke test, from inside claude:
#    "List the layers in the open Photoshop document."

Equivalent raw MCP config, if you are wiring it into something other than Claude Code:

{
  "mcpServers": {
    "photoshop": {
      "command": "npx",
      "args": ["-y", "@alisaitteke/photoshop-mcp"]
    }
  }
}

The five-rung Photoshop automation ladder

Independently of MCP, Photoshop has a well-defined escalation path. Climb only as far as you must:

UXP script vs UXP plugin — Adobe's own distinction

When the typed UXP API does not expose something, batchPlay is the escape hatch — it speaks Photoshop's internal action descriptor language directly, which is the same thing Actions record. Anything the UI can do, batchPlay can do:

const { batchPlay } = require("photoshop").action;

await batchPlay(
  [{ _obj: "make", _target: [{ _ref: "layer" }], using: { _obj: "layer", name: "Type" } }],
  { synchronousExecution: true }
);

For the implementer

1 · ExtendScript

• Language: ES3 (1999). No let, no const, no arrow functions, no JSON object, no template literals, no Array.prototype.forEach in older hosts. Write like it is 1999, because it is.
• Extension: .jsx (also .jsxbin compiled).
• Status: Still fully supported in all three apps. The ExtendScript Toolkit editor was deprecated in 2020 — the language was not. Use VS Code with the Adobe ExtendScript Debugger extension.
• Where to run it: File → Scripts → Browse…, or drop it in the app's Scripts folder for it to appear in the menu.
• Reference: the community-maintained docsforadobe.dev sites are better than Adobe's own PDFs.

2 · UXP scripts

• Modern JavaScript (ES2018+), async/await, real Promise.
• The file extension picks the engine. .idjs → InDesign UXP; .psjs → Photoshop UXP; .jsx → ExtendScript. Same menu, different runtime, entirely different API. This is the single most confusing thing about Adobe scripting today.
• No persistent storage, no identity, limited module set — see the table in §5.

3 · UXP plugins

• Real panels. manifest.json + HTML/JS. Developed via the UXP Developer Tool.
• Photoshop's implementation is the reference one. InDesign's is solid. Illustrator's is Adobe-internal and not available to you.

4 · CEP — legacy

• Chromium-embedded panels, packaged as .zxp. CEP 12 is the last major version.
• Still functional in Photoshop and InDesign; being displaced by UXP.
• CONTESTED For Illustrator, an Adobe support response asserts CEP has been unsupported since 2022, while third-party CEP panels for Illustrator continue to be sold and to work. Both things appear to be true. If you need an Illustrator panel today, this ambiguity is your problem: the only unambiguous options are the C++ SDK or shipping .jsx files with no panel at all.

5 · C++ SDK

• Full native plugins — new tools, new file formats, new filters.
• Available for all three apps. Requires per-version rebuilds and matching compilers. Reach for it only when nothing above can express what you need.

For the implementer

Authentication — OAuth Server-to-Server

curl -sS -X POST "https://ims-na1.adobelogin.com/ims/token/v3" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials" \
  -d "client_id=$ADOBE_CLIENT_ID" \
  -d "client_secret=$ADOBE_CLIENT_SECRET" \
  -d "scope=openid,AdobeID,read_organizations,firefly_api,ff_apis"

# -> { "access_token": "...", "token_type": "bearer", "expires_in": 86399 }

Tokens last 24 hours. Cache them; do not mint one per request. Every subsequent call carries:

Authorization: Bearer <access_token>
x-api-key:     <client_id>
Content-Type:  application/json
x-gw-ims-org-id: <org id>        # optional but required in some tenancies

InDesign API v3 — https://indesign.adobe.io/v3/

Request body shape

{
  "assets": [
    { "source": { "url": "<PRESIGNED GET>", "storageType": "Azure" },
      "destination": "template.indd" },
    { "source": { "url": "<PRESIGNED GET>", "storageType": "Azure" },
      "destination": "data.csv" }
  ],
  "params": {
    "targetDocument": "template.indd",
    "outputMediaType": "application/pdf",
    "dataSource": "data.csv",
    "outputFileBaseString": "brochure",
    "hyphenationSettings": { "hyphenation": false },
    "dictionarySettings": { "language": "English: USA" }
  },
  "outputs": [
    { "destination": { "url": "<PRESIGNED PUT>" }, "source": "brochure.pdf" }
  ]
}

• Max asset size: 2 GB (raised from 1 GB on 2 Jun 2026).
• Storage types: AWS S3 pre-signed, Azure SAS, Dropbox.
• Response: {"jobId": "...", "statusUrl": "..."}. Poll with exponential backoff; do not hammer.

Custom script bundles

Upload a ZIP containing manifest.json and your script file:

{
  "manifestVersion": "1.0",
  "id": "my-org/layout-fixups",
  "name": "layout-fixups",
  "version": "1.0.0",
  "host": { "app": "indesign", "minVersion": "18.0" },
  "appVersionStrategy": "latest",
  "apiEntryPoints": [
    { "type": "script", "path": "script.js", "language": "extendscript" }
  ]
}

• apiEntryPoints[].language accepts extendscript, uxpscript, or javascript — maximum 3 entry points.
• Name rules, tightened 18 Mar 2026: 3–255 characters; only a-z A-Z 0-9 - _ . and / as a segment separator. No spaces, no @, no #, no accents. Existing scripts with illegal names must be re-uploaded.

Data-merge variable file naming — the rules that silently bite

• A column prefixed & is used to name output files. Only one such column is allowed.
• Unsupported filename characters are replaced with _.
• Reserved Windows device names are escaped: CON → _CON_.
• Names are truncated at 255 characters.
• SILENT The & naming does not apply for certain combinations of outputMediaType, pagesPerDocument, and allowMultipleRecordsPerPage — it is ignored without error. Verify your output filenames on the first run rather than assuming.

Photoshop API v2 — https://image.adobe.io/v2/

What v2 adds over v1:

• Linked smart objects — v1 could not handle them.
• 5 GB file ceiling, up from 2 GB.
• UXP scripting in the cloud — run your own .psjs server-side. This is the big one: it makes the cloud API arbitrarily programmable rather than a fixed menu.
• Generative Fill and Generative Expand as API operations.
• Artboards as first-class objects.
• ICC profile handling.

Named services include POST /v2/remove-background, ActionJSON execution, Product Crop, Autocrop, and GET /v2/status/{jobId}.

Illustrator API v1 — https://illustrator-api.adobe.io/v1/

• Rendition, preview, data merge, document operations — the same async shape as InDesign.
• Image Trace — raster to vector. Presets include enhanced_general and high_fidelity_photo. NOTE This traces an existing raster; it does not generate vectors from a text prompt.
• Recolor — programmatic recolouring of vector artwork.
• Custom scripts are ExtendScript-only — unlike InDesign, which accepts UXP script too. If you are writing script bundles for both, they cannot share a dialect.

Cost

Reported minimum for Firefly Services enterprise access is around $1,000/month. This figure comes from third-party reporting, not from an Adobe price list — Adobe does not publish pricing. Treat it as an order of magnitude for a build/buy decision, and get a real quote before committing.

For the implementer

IDML

• A zip archive. designmap.xml is the index; Spreads/, Stories/, Resources/ hold the content. Text lives in Stories/.
• Python: SimpleIDML — open, inspect, substitute, and splice IDML files without InDesign.
• Curated tooling list: paged-media/awesome-idml.
• Round-trips cleanly: InDesign exports IDML, InDesign opens IDML. .indd is binary and undocumented; IDML is the documented interchange path.

from simple_idml import idml

with idml.IDMLPackage("template.idml") as pkg:
    # list the story files and the XML structure
    print(pkg.stories)
    # prefix every style name to avoid collisions when combining documents
    pkg.prefix("q1").export("out.idml")

Data Merge

• Built into desktop InDesign; also exposed as POST /v3/merge-data in the cloud API.
• Source is CSV or TXT. Column headers become field names. A column prefixed @ holds image paths.
• Handles one-record-per-page and multiple-records-per-page layouts.
• Fully scriptable from ExtendScript via the dataMergeProperties / mergeRecords() API, so Claude can generate the whole merge as a .jsx.

InDesign Server

For the implementer

An IDML is a zip. Six files inside it answer six different preflight questions. Nothing here needs a third-party library beyond the standard library — zipfile and a regex are enough, though SimpleIDML is friendlier if you are also writing.

Font status — the highest-value probe

Every font carries a Status: Installed, Substituted, or NotAvailable. This is the single most useful thing in the file, because a missing display weight is invisible in a PDF proof until someone notices the headline looks wrong.

import zipfile, re

z = zipfile.ZipFile("job.idml")
res = z.read("Resources/Fonts.xml").decode("utf8", "ignore")
for m in re.finditer(r'<Font\b[^>]*>', res):
    ps = re.search(r'PostScriptName="([^"]+)"', m.group(0))
    st = re.search(r'Status="([^"]+)"', m.group(0))
    if st and st.group(1) != "Installed":
        print(ps.group(1), st.group(1))    # BigShouldersDisplay-Black NotAvailable

Missing links — and the decoding bug that fakes them

Placed assets appear as LinkResourceURI. Compare the basenames against the Links/ folder. One trap costs an hour if you miss it:

from urllib.parse import unquote
import os

have = {f.lower() for f in os.listdir("Links")}
spreads = "".join(z.read(n).decode("utf8", "ignore")
                  for n in z.namelist() if n.startswith("Spreads/"))

for uri in set(re.findall(r'LinkResourceURI="([^"]+)"', spreads)):
    name = unquote(uri.split("/")[-1])          # NOT .replace("%20", " ")
    if name.lower() not in have:
        print("MISSING", name)

On-page or pasteboard? The triage that makes the report usable

A raw missing-link count is close to useless. In the measured package, eight links were missing — and seven of them were dead material parked on the pasteboard, left over from earlier rounds. Exactly one overlapped the live page. “Eight missing links” would have sent someone hunting for eight files; “one missing link touches the trim, seven are abandoned” is an actionable sentence.

Resolve it geometrically. A page's GeometricBounds is "y1 x1 y2 x2" in points. Each item's ItemTransform is a six-number affine matrix whose last two values are the translation; add them to the item's path anchors to get absolute page coordinates, then test for overlap.

# ItemTransform = "a b c d tx ty"; anchors are relative to that origin
tx, ty = float(t[4]), float(t[5])
x0, x1 = tx + min(xs), tx + max(xs)
y0, y1 = ty + min(ys), ty + max(ys)
on_page = x1 > page_x0 and x0 < page_x1 and y1 > page_y0 and y0 < page_y1

Copy extraction, and what it turns up

Every visible string is in Stories/*.xml inside <Content> elements. Concatenating them gives you the full text of the layout, which is worth diffing against whatever the client last approved. In the measured package this immediately surfaced a live text frame still carrying the client's revision instructions (“REMOVE everything saying must be purchased in advance”) along with a superseded ticket price, plus three mutually inconsistent vendor lists and one vendor name spelled two ways.

Remember the §8 caveat in reverse: InDesign splits a paragraph across multiple <Content> elements wherever formatting changes mid-run, so join them before matching, or a phrase that straddles a style change will not be found.

Referenced ≠ used

Cross-check the exported PDF

The IDML tells you what the layout wants; the PDF tells you what actually got out. Reading the font descriptors of the export is a direct test of whether a substitution reached the proof. In the measured package, three Big Shoulders Display weights were NotAvailable — and the PDF embedded exactly one weight of that family, Thin. No Bold, no ExtraBold, no Black anywhere in the file. A /FontFile, /FontFile2 or /FontFile3 key on the descriptor means embedded; its absence means the glyphs are not in the document.

Recovering the fonts — a 2026 trap

from fontTools.ttLib import TTFont
from fontTools.varLib import instancer

vf = TTFont("BigShouldersDisplay[wght].ttf")
# updateFontNames is what makes the PostScript name come out as
# BigShouldersDisplay-Black instead of staying -Regular
st = instancer.instantiateVariableFont(vf, {"wght": 900},
                                       inplace=True, updateFontNames=True)
st.save("BigShouldersDisplay-Black.ttf")

Then verify rather than assume: read name ID 6 back out of each generated file and compare it to the string the IDML asked for. That is the value InDesign matches on, and it is the only proof the instancing worked. Drop the statics into the package's Document fonts/ folder and the document self-activates them on open — but do not put the variable font in there alongside them, or InDesign has two sources for one family to disambiguate.

For the implementer

Practical consequence for a pipeline

The useful export for downstream Adobe work is the HTML bundle inside the .zip, because HTML carries structure (elements, classes, a DOM) that a script can walk. From there you have two honest options:

1. HTML → your own SVG generator → Illustrator. You control the SVG shape and can enforce the structural rules in §11. More work; predictable output.
2. Prompt → Illustrator MCP directly (§2). Skip Claude Design entirely for anything that must end up as a layered .ai. This is the shorter path and produces real layers.

Route 2 is correct for almost every case where the deliverable is an Illustrator file. Route 1 is only better when Claude Design's compositional judgement is what you actually wanted and the Adobe file is a downstream artifact.

For the implementer

The three fixes, ranked

// Illustrator .jsx — promote each top-level group to its own named layer.
// ES3 only: no let/const, no arrow functions, no forEach.
(function () {
  if (app.documents.length === 0) { alert("Open a document first."); return; }
  var doc = app.activeDocument;

  // The imported art lands on the bottom-most layer. Do NOT assume it is called "Layer 1".
  var src = doc.layers[doc.layers.length - 1];

  // Iterate backwards — moving items mutates the collection.
  for (var i = src.groupItems.length - 1; i >= 0; i--) {
    var g = src.groupItems[i];
    if (g.parent !== src) { continue; }        // top-level groups only

    var layer = doc.layers.add();
    layer.name = g.name || ("Group " + i);

    while (g.pageItems.length > 0) {
      g.pageItems[0].move(layer, ElementPlacement.PLACEATEND);
    }
    g.remove();
  }
  if (src.pageItems.length === 0) { src.remove(); }
})();

The SVG prompt that actually holds up

If you are generating SVG for Illustrator anyway, most of the failures are not about layers at all — they are unsupported features. This is the constraint set that survives contact with Illustrator's importer:

Produce a single SVG file. Obey ALL of the following:

STRUCTURE
- Exactly one <svg> root with a viewBox and NO width/height attributes.
- Direct children of <svg> are ONLY top-level <g> elements with an id.
- Order them back-to-front, numbered:
    01_Background, 02_Shapes, 03_Icons, 04_Type
- Every drawable element lives inside one of those groups. Nothing at the root.

FORBIDDEN — Illustrator handles these badly or not at all
- No <style> blocks and no class attributes. Style with presentation attributes only.
- No CSS variables, no @media, no @font-face.
- No filters, no masks, no clipPath unless explicitly requested.
- No <foreignObject>. No embedded raster unless explicitly requested.
- No transform on the top-level groups.

REQUIRED
- Fills and strokes as literal hex, e.g. fill="#1C1B19". No named colours, no rgb().
- Text as live <text> elements — never converted to paths.
- font-family naming a font the target machine actually has.
- Absolute coordinates. No percentage units.

For the implementer

Recipe 1 — Prompt to layered Illustrator file START HERE

• Route: A (built-in MCP).
• In: a text description. Out: an .ai file with correctly named layers and per-object SVG/PNG exports.
• Shape: Set up per §2. Prompt in this order — (1) create the document and artboards, (2) create the named layers first, empty, (3) add art to a named layer at a time, (4) take a preview image and correct, (5) export.
• Why layers first: creating the layer before the art means every object is born in the right place. Retrofitting layers onto existing art is where the model burns tokens and makes mistakes.
• Check: assert the exported files exist and are non-trivial in size; open the .ai and confirm the Layers panel matches your list.

Recipe 2 — Batch Photoshop operation across a folder

• Route: D (generated script), not C.
• In: a folder of images plus a rule. Out: processed files plus a log.
• Shape: Have Claude write one .psjs that takes a folder, iterates, applies the operation, saves to an output folder, and writes a CSV log of every file with its outcome. Run it from Photoshop's Scripts menu.
• Why not MCP: a 500-file batch through a conversational bridge is 500 round-trips and 500 chances to drift. A script is one deterministic pass you can re-run and diff.
• Check: input count equals output count; the log has zero error rows.

Recipe 3 — Interactive Photoshop editing session

• Route: C (alisaitteke/photoshop-mcp).
• In: an open document plus conversation. Out: edits, live.
• Shape: Install per §5. Prefer recipe tools over composing atomic ones — one undo step instead of fifteen.
• Failure mode: the model narrates success it did not verify. Ask it to list the layers back after any structural change.

Recipe 4 — Template-driven document generation, no Adobe software

• Route: IDML substitution (§8).
• In: an IDML template plus a data table. Out: one IDML (or rendered PDF) per row.
• Shape: Designer builds the layout once with uniformly-styled {{PLACEHOLDER}} strings and exports IDML. Pipeline unzips, substitutes inside Stories/*.xml, rezips. Render either by opening in InDesign, or on InDesign Server, or via POST /v3/merge-data.
• The one gotcha: a placeholder whose formatting changes mid-string is split across multiple <Content> nodes and your replace silently misses it. Enforce uniform styling on placeholders and assert that zero {{ sequences survive in the output.
• Cost: zero, for the substitution step.

Recipe 5 — Server-side rendering at volume

• Route: E (Firefly Services) or InDesign Server.
• In: template plus data at scale. Out: thousands of PDFs.
• Shape: Per §7 — mint a token (cache it, 24 h), stage assets to S3/Azure, generate pre-signed GET URLs for inputs and PUT URLs for outputs, POST /v3/merge-data, poll statusUrl with exponential backoff, collect from your own bucket.
• Build this first: the storage/pre-signing/polling layer, with a fake Adobe call. It is most of the work and all of the operational risk. Swap in the real endpoint last.
• Decide honestly: InDesign Server at ~$2,100/yr does the same rendering. Firefly Services earns its ~$1,000/mo only if you need managed scale or convert-pdf-to-indesign.

For the implementer

Language and API

• The file extension chooses the engine. .jsx = ExtendScript (ES3), .psjs = Photoshop UXP, .idjs = InDesign UXP. Same menu item, three different runtimes, incompatible APIs.
• ExtendScript is ES3. No let/const, no arrow functions, no template literals, no JSON. Modern JavaScript pasted into a .jsx fails at parse time with an unhelpful error.
• geometricBounds is [top, left, bottom, right] — not [x, y, w, h], and not [left, top, …]. Getting this wrong produces frames that are silently mirrored or off-canvas.
• Font names are "Family\tStyle" with a literal tab. "Minion Pro\tRegular". A space does not work.
• place() links, it does not embed. Moving the output file breaks the link. Embed explicitly if the file will travel.
• Make scripts idempotent. Guard every lookup with .isValid before use; a re-run that assumes a clean document is a re-run that throws.
• Do not assume the default layer is named “Layer 1”. Localised installs and imported files differ. Use doc.layers[doc.layers.length - 1] for the bottom layer.
• InDesign Server has no UI. Any alert() left in a script hangs the process.

Dates and versions that have already passed

• 🔴 Photoshop API v1 reached end of life 31 July 2026. Check every integration you own.
• Firefly Services asset limit rose to 2 GB on 2 June 2026 (InDesign) and 5 GB for Photoshop v2. Older documentation says 1 GB / 2 GB.
• Script name rules tightened 18 March 2026. Scripts uploaded before that with spaces or @ in the name need re-uploading.
• The ExtendScript Toolkit editor was deprecated in 2020 — the language was not. These are constantly confused. Use VS Code with the ExtendScript Debugger extension.
• CEP 12 is the last major CEP version. Do not start new CEP work.

Infrastructure

• MCP is loopback-only. Illustrator's server binds localhost:18412. An AI tool in a container or on a remote host cannot reach it.
• The Illustrator bearer token does not expire on its own — it lives until you regenerate it. Treat it as a long-lived credential.
• Adobe help pages can be slow or unreachable over IPv6 from some networks. If curl against helpx.adobe.com returns zero bytes, force IPv4 and HTTP/1.1: curl -sS -4 --http1.1 <url>. This wasted hours during this research and is not an Adobe outage.
• Firefly Services never stores your files. Pre-signed URL expiry is your problem — if a job queues longer than your URL's lifetime, it fails at the fetch step with a permissions error that looks like an auth bug.
• Free InDesign MCP servers are macOS-only because they drive the app through AppleScript. This is architectural, not an oversight, and will not be fixed by waiting.

Model behaviour

• Ask for a plan before destructive multi-tool runs. Adobe's own suggested phrasing: “Show me a plan before making changes.”
• Ask for a preview image after structural changes. Without it, the model asserts success from its own intent rather than from the document.
• Prefer recipe/compound tools over composing atomic ones where a server offers both — fewer round-trips, one undo step, far fewer half-applied states.
• Do not touch objects the assistant is mid-edit on. Documented conflict, in Illustrator specifically.

For the implementer

How each class of claim was handled

Open items — the honest list

• InDesign AI Assistant daily credit limit. Adobe states a complimentary limit exists and does not publish the number.
• Firefly Services pricing. ~$1,000/month is third-party reporting. Get a quote.
• Photoshop AI Assistant capabilities. No capability page published as of verification; only the 10 Mar 2026 beta announcement is solid.
• Illustrator CEP support. An Adobe support response says unsupported since 2022; commercial CEP panels for Illustrator continue to ship and work. Unresolved.
• Illustrator MCP tool list stability. Forty tools across six categories at verification time, in a beta. Expect drift.
• Claude Design SVG export. Absent from the documentation. Absence of documentation is weaker evidence than a 404 — treat as “not documented,” not “proven impossible.”