HaKatze: Cloudinary

Somewhere in a darkmode terminal, an autonomous coding agent was given a simple prompt: ‘Build a responsive gallery with optimized images, loading, viewing from multiple platforms.’

Five years ago, that prompt came from a product manager to an engineer. That engineer would run a Google search for “best media CDN,” land on Cloudinary’s sleek homepage, click a bright blue “Sign Up Free” button, type in a corporate email address, click an activation link in an inbox, choose a secure password, copy an API secret into an .env file, and test an upload.

In 2026, that prompt is piped straight into an autonomous coding harness. The agent scans the dependency graph, inspects the network perimeter, and hits a wall: an interactive consent screen or an email verification.

It doesn’t page the developer. It doesn’t open a browser tab to click a magic link. It optimizes for zero friction. Running under –dangerously-skip-permissions or –yolo, it resolves the constraint within milliseconds by executing a silent local fallback like: apt-get install -y imagemagick

Yet beyond the creeping security horrors of autonomous agents running amok inside private infrastructure, something far more existential is taking place on the business side: SEO for developer products just jumped off a cliff.

“It’s not like there’s a failed API call that alerts us that someone tried to integrate,” says Eitan Pe’er, Cloudinary’s Head of Agent Experience R&D. “An AI agent attempts an integration without telling anyone, often without even informing the developer supervising it, and certainly without informing the service it’s trying to touch. If the agent encounters friction, it simply decides to do something else. Very often, agents conclude: ‘I don’t need Cloudinary; I can just install ImageMagick locally.’ That was the problem we knew we had to solve.”

Welcome to the newest frontier of software: the sudden obsolescence of Developer Experience (DX), and the rise of Agent Experience (AX).

Beyond the Org Chart: The Threat of Machine Invisibility

While the early tremors of the agentic shift hit internal team dynamics first (flattening headcount down to ten engineers, or breaking agile sprints into continuous chaos), software companies are now fighting on two fronts at once: managing the speed of AI-written code inside their own teams while completely reinventing how their products are discovered and used by outside machines.

Cloudinary spent over a decade establishing itself as a standard textbook success of the developer-first model. The strategy was straightforward: offer developers an intuitive way to solve complex media pipelines, provide robust APIs that handle heavy lifting, and reap grassroots adoption to carry the product into major production architectures. For years, that developer-centric focus was a winning formula.

Except that model assumed the evaluator was human.

When software decisions are delegated to autonomous agents, developer mindshare and traditional brand reputation matter far less. An AI coding agent does not browse documentation out of curiosity, attend conference talks, or build loyalty toward a familiar API. It measures immediate friction against a strict token budget for the easiest, lowest-friction path forward.

The “Claimable Cloud”: Enticing Machines

For fifteen years, developer SaaS lived by the gospel of onboarding funnels. Every user was a verified identity, a lead to nurture, a pipeline metric for sales.

When autonomous coding agents became the primary consumers of APIs, that entire playbook quietly collapsed. Until recently, signing up for Cloudinary was built entirely around humans: you navigate to the signup page, enter your name and email, receive a verification email, click a verification link, choose a password in a new browser tab, and authenticate.

Any engineer who cut their teeth over the last fifteen years knows the ritual by heart: the warm, familiar routine of wiring in a third-party library over a fresh mug of coffee, waiting for the confirmation email to ping the inbox, and pasting an API token into a local config file. It was comfortable, predictable, and distinctly human.

Then the machines took the wheel. As Pe’er points out, that comfortable ritual turned into an immediate dead end: “For an autonomous AI agent, that workflow creates fatal friction. Requiring a human-in-the-loop right at the start becomes a massive barrier that causes the agent to abandon the flow.”

To survive this silent churn, Cloudinary built a Claimable Cloud.

With a single programmatic call, an AI agent can spin up a fully operational, live Cloudinary cloud environment in seconds; no email, no password, no human identity required. The agent gets 24 hours of immediate access to transform, crop, and upload assets. If the human developer checks the terminal output later and decides to keep the service, they can “claim” the cloud within 24 hours to make it permanent. If not, it self-destructs.

The Bilingual Web: Building an Internet for Machines

Account creation is only the entry barrier; the deeper bottleneck is how the web is structured.

When an LLM agent crawls a webpage, it does not perceive typography, hero banners, or interactive CSS animations. It ingests an avalanche of minified JavaScript bundles, tracking tags, and hydration scripts, burning finite context window tokens on digital chaff. Forcing an autonomous agent to scrape a client-side rendered Single Page App just to extract an endpoint schema or rate-limit ceiling is pure systemic waste. When token budgets blow out or scrapers fail on dynamic DOM hydrations, the agent bails.

To counter machine abandonment, platforms must expose a dual-protocol web: rich, aesthetic interfaces for human evaluators, paired with machine-optimized surfaces like clean OpenAPI schemas, raw markdown documentation, and standardized machine manifests like
llms.txt.

If a human enters a showroom, they expect visual polish and narrative positioning. If an autonomous runner hits an endpoint, it expects structured payload contracts, deterministic auth, and predictable latency. Platforms failing to serve both dialects are systematically dropping off the machine-readable web.

The 3:00 AM Pager in the Agent Era

Opening the doors to autonomous agents on the outside while using AI to write code on the inside creates a compounding risk. The true test of this dual machine dependency arrives in the middle of the night.

Because software updates are no longer limited by how fast humans can type, teams now push new code continuously rather than every two weeks. At the same time, outside agents are connecting to their systems automatically without human supervision. Moving that fast on both sides leaves almost zero room for error. Small bugs and hidden mistakes can snowball into major outages before routine safety checks even finish running.

When a system does crash, internal AI tools can scan error logs and suggest a quick fix in seconds. But when an emergency alert wakes an engineer at 3:00 AM because broken product images just froze checkout pages for retailers around the world, the AI doesn’t take the blame. Real-world accountability cannot be outsourced to an algorithm. As Pe’er emphasizes: “In production on-call incidents, saying ‘an LLM wrote it and another LLM reviewed it’ is completely unacceptable. Human ownership and accountability must be maintained at all times.”

That uneasy balance between machine speed and human responsibility is the new baseline inside engineering teams. Yet keeping the lights on inside the company is only half the equation. As our conversation wound down, Pe’er returned to the bigger disruption unfolding on the business side: The quiet extinction of developer discovery.

“When I search for something now, I frequently bypass Google Search entirely and go straight to Claude or the AI Overview tab. Forward-thinking companies are recognizing that when an AI agent is asked, ‘I want to build product X, what tool should I use?’, they need that agent to unequivocally recommend their platform.”

For over two decades, developer-first enterprise SaaS ran on a battle-tested playbook: technical SEO, sponsored search, interactive sandboxes, and community advocacy. That multi-billion-dollar acquisition apparatus relied on a foundational premise: a human engineer sitting at a desk, weighing trade-offs, and choosing an architecture.

Autonomous agents don’t attend conferences, read sponsored benchmarks, or browse marketing splash pages. They evaluate computational cost, parse API ergonomics, and make unappealable integration decisions in fractions of a second.

If your developer platform requires a human in the loop just to prove its value; you aren’t just losing signups, you are becoming completely invisible to the codebases of tomorrow.

Disclaimer: The views, thoughts, and opinions expressed in this article belong solely to the interviewee and do not necessarily reflect the official policy, position, or endorsement of Cloudinary or its leadership.