AI Agents Can Now Run Your Photo Pipeline

On September 3, 2026, OpenAI released GPT-6 Astra, a model built to operate software on its own: filling out forms, navigating web pages, and driving multi-step tasks across a computer, not just answering questions about them. OpenAI's own co-founder called it a step toward AGI. Whether or not it earns that label, the direction is unmistakable.

It isn't a one-company story. Anthropic's Claude has been able to operate a computer since 2024. OpenAI's own Operator did the same starting in 2025. ChatGPT's agent mode merged both ideas into one product later that year. Astra is the latest, most capable entry in a pattern that's now several launches deep: AI systems that don't just tell you what to do, they go do it.

That shift changes what "built for AI" has to mean for every piece of software an agent might touch. A chat interface is fine for a person. An agent needs something else entirely: an endpoint it can call, a job it can start and check on, a result it can fetch when the work is done. Software that only exposes a prompt box and a download button is a dead end for an agent, no matter how good the model behind it is.

The part On-Model already got right

We covered this idea from the buyer side in The AI Infrastructure for Fashion Imagery: On-Model was built as infrastructure a retailer plugs into their pipeline, not a creative tool a person opens to make one picture. That distinction turns out to matter for an entirely different reason now. Infrastructure, by definition, is built to be called by something other than a person clicking through a UI. On-Model has had a REST API, async job IDs, webhooks, and batch processing since before "agentic AI" was a term anyone used. We didn't build that for agents. We built it because a production pipeline has to run unattended, and it turns out that's exactly the shape of interface an agent needs too.

Whether the caller is a person in the app, a script in a nightly cron job, or now an autonomous agent acting on a plain-language goal, the interaction underneath is identical:

Agent receives a goal
        │
Authenticate (Bearer token)
        │
Create or reuse a project
        │
Upload each product image  →  gets back a file_id
        │
Start a job — model swap / flat-to-model / packshot / garment recolor
        │
Watch progress (event stream or webhook)  →  status: completed
        │
Fetch results  →  finished image URLs
        │
Hand off to the PIM / DAM / storefront

Nothing about the API changes for an agent to drive it. That's the point.

What an agent actually calls

An agent framework doesn't read our docs, it reads a tool definition. Here's roughly the shape you'd register for the model-swap endpoint, built straight from the real request fields:

{
"name": "start_model_swap_job",
"description": "Swap an approved brand identity onto one or more uploaded product images and start an async job.",
"parameters": {
  "type": "object",
  "properties": {
    "identity_code": {
      "type": "string",
      "description": "The approved model identity to apply"
    },
    "project_id": { "type": "string" },
    "images": {
      "type": "array",
      "items": { "type": "string" },
      "description": "Uploaded file_id values"
    },
    "swap_options": {
      "type": "object",
      "properties": {
        "model": { "type": "string", "enum": ["auto", "onda", "nano_banana_2"] },
        "num_variations": { "type": "integer", "minimum": 1, "maximum": 4 },
        "use_anchor": { "type": "boolean" }
      }
    }
  },
  "required": ["identity_code", "project_id", "images"]
}
}

Call it, get back a job_id, and either poll it or let a webhook tell you when it's done. Everything else — flat-to-model, create-packshot, garment recolor — follows the same request-a-job, watch-it-run, fetch-the-results pattern. It's documented the same way whether the reader is a developer or the thing generating the request is a language model.

A Monday morning task

Say an ops lead tells their agent: "The autumn hoodie collection just landed. Swap it onto our Priya identity and get the Zalando and Shopify sizes ready before the standup." A capable agent doesn't need a person to translate that into clicks. It can:

1. Check the PIM feed for the new SKUs and pull the flat-lay images.
2. Upload each one and collect the file_id values.
3. Start a model-swap job with identity_code set to the brand's approved identity, use_anchor on so the model looks like the same person across the whole set.
4. Watch the job's event stream until every image reports completed.
5. Fetch the results, and either resize per marketplace spec on the same call or start a follow-up job with the right width/height for each platform.
6. Push the finished files back into the DAM and reply "done" with a link.

That's the same playbook a production coordinator runs by hand today, just executed by something that doesn't sleep between steps 2 and 5. Nothing in that sequence is speculative. It's six calls to an API that already exists.

Why this is where the whole category is heading

Computer-use agents are going to keep getting better at exactly the kind of tedious, multi-step, structured work that a content pipeline is made of: check the feed, process the batch, route the output, confirm it landed. That favors software built the infrastructure way from day one over software that only ever expected a person at the other end of the request. A prompt-box tool has nothing for an agent to hold on to. A system built around jobs, IDs, and status checks is exactly the surface an agent is designed to drive.

On-Model didn't have to become agent-ready. It already was, because we built it as infrastructure rather than a creative tool from the start. GPT-6 Astra doesn't create that fact, it just makes it newly relevant. As agents take on more of the operational work fashion teams currently do by hand, the platforms that already speak API, not just chat, are the ones an agent can actually pick up and run.

• API integration — endpoints, quick start, and code samples for wiring On-Model into a pipeline
• API documentation — authentication, full request/response shape for every job type
• The AI Infrastructure for Fashion Imagery — why we built On-Model as a pipeline, not a prompt box
• Five input types, one platform — the job types an agent (or a person) can start
• Try On-Model free — get an API token and start your first job in minutes