Where the API Stops

I set out to publish through the API. An hour later I was watching an agent click buttons in a dashboard, one at a time, like a person who’d never heard of an API.

Same job. Same afternoon. Two completely different ways of talking to the same company.

I didn’t plan that. I planned the clean version.

---

The Clean Version

The job was small and boring: a weekend’s worth of short videos — dozens of reels from a volleyball tournament — to publish across three Instagram accounts I run, paced out over a couple of weeks.

There are tools for this. Schedulers that do exactly this, for a few dollars a month. I dismissed them in about a minute.

Not because they’re bad. Because they decide what I’m allowed to do. The feature I want is either in the product or it isn’t, exposed the way they chose to expose it or not at all. For a one-off, that’s a fine trade. For something I’ll run again next month, and the month after, the ceiling is the whole problem.

So I went to the API instead. Meta’s Graph API publishes reels directly. No middleman deciding what’s possible.

This is the part where I’m supposed to quote Marc Benioff. “API is the new UI.” He’s been saying it about agents — that the browser stops mattering, that software gets consumed through its API and its tool contracts, not its screens. He means it as a pitch: let agents drive our platform, headless.

I read it one step meaner. If the API is the real surface, then the polished UI was never the value. It was the gate. You don’t have to consume the SaaS through an agent. You can skip the SaaS.

That was the bet. Own the surface. Build the client myself, now that an agent makes building the client cheap.

The bet was half right.

---

What I Said the War Looked Like

A few months ago I wrote that every agent system is quietly making one of two bets. Teach the machine to operate interfaces built for humans — read the screen, click the button, fill the form. Or rebuild the interface so the machine never has to pretend — structured APIs, published tool contracts.

I framed it as an industry-scale standoff. One company builds robots to push carts through a grocery store designed for people. Another builds a lights-out warehouse so no one pushes anything. Both real. Both funded. Neither winning outright. The whole field drifting, unevenly, toward the machine-native end.

That was true at the altitude I was looking from. Companies, sectors, decade-long bets.

Here’s what I didn’t see from up there.

The standoff I’d been describing between companies turned out to fit inside a single pipeline. I didn’t choose a side. I used both, in the same job, in the same hour — because the API only covered half of it.

The bifurcation isn’t a fork in the road that an industry walks down. It’s a seam that runs through individual work. And the seam sits exactly where one vendor’s API coverage happens to stop.

---

The Native Half, and Its Tax

Publishing the videos through the Graph API was the easy promise and the slow reality.

The promise: a documented endpoint, structured calls, no DOM to fight. The reality: before any of that worked, I had to get a token that could reach three accounts at once.

That turned into the longest stretch of the whole build. Meta has two authentication paths — one for single accounts, one for a business managing many — with different scopes, different hosts, different token exchanges. My first setup mixed them. I’d built against the wrong one and had to tear it down and start over with a non-expiring system-user token issued through the business account.

Then the accounts had to be claimed as managed assets. Then each one needed a one-time human login to authorize publishing — a gate you cannot script, by design, because it exists to prove a human controls the account.

Dozens of turns. A full architectural pivot. A redirect-URI error that sent me sideways for a while.

This is the tax the machine-native path always carries, and the part I conveniently underweighted when I was the one drawing the map. The API is clean once you’re inside. Getting inside is a negotiation with someone else’s idea of how their platform should be set up.

(If you want the working version of that negotiation rather than the reflection on it, I wrote up the multi-account setup step by step — the auth-path trap, the manual gates, and the publish call that quietly double-posts.)

---

The Half Meta Never Built

Here’s where the clean version broke.

Several of those setup steps have no API at all. Claiming the accounts, walking the business-manager permission screens, ticking the boxes that grant the app access — Meta exposes none of it as an endpoint. The only interface that exists is the one built for a person.

So I did the thing I’d written about other people doing. I pointed the agent at the browser and told it to operate the dashboard like a human.

And it was exactly as advertised in the part of my own argument I’d treated as a footnote: unilateral, and brittle. Unilateral because it needs no one’s permission — no API key, no partnership, no waiting for Meta to build anything. Brittle because the dashboard is a single-page app with custom-rendered controls and no stable handles to grab.

The agent tried to flip a set of permission checkboxes. Six times. They were drawn in a way that gave it nothing to hold onto. I stopped it, reached over, and checked them myself in about ten seconds.

When I mapped the two paths in March, I asked whether splitting effort across both meant neither would ever get finished. I treated it as a worry about industry investment.

In the pipeline, it stopped being a worry and became a fact. The native path stalled at the setup gate. The mimicry path stalled at the checkboxes. Neither finished on its own. A human reached in and closed the seam between them — twice — and only then did the job run.

---

The Tax I Didn’t See Coming

There’s a second tax, and it’s the one I’d least want to admit.

After the first batch started posting, the same video went out three times. I traced it: the publish call to Meta was returning success while the post quietly failed, so my code thought the item still needed posting and ran it again on the next pass. I rewrote the logic to treat that case as terminal, reconciled the queue against what was actually live, and declared the duplicate problem solved.

It wasn’t.

A separate review pass — an agent reading the committed code, not the running system — found a different way to post twice. The scheduler could fire on its hourly timer at the same moment I triggered a manual run, both reading the same queue before either wrote back, both building a post for the same video. My fix never touched that path. I’d solved the duplication I found and felt finished, which is a different thing from solving duplication.

I built the client to escape a SaaS that decides what I’m allowed to do. What the SaaS was also quietly doing was absorbing both of these taxes — the setup negotiation, the concurrency edge case — so I never met them. Owning the surface means owning the surface. All of it.

---

Where the Line Actually Is

So I’d revise what I told you in March.

The civil war isn’t mainly a contest between companies picking a side. That’s the version you can see from a distance, and it’s real, but it’s not where the decision lives. The decision lives inside individual jobs, and it isn’t really a decision. It’s a boundary you discover at runtime: API where the vendor built one, browser where they didn’t, a human stitching across the gap where neither holds.

That boundary moves. Every endpoint a company ships pulls a little more of the work to the native side. Every new dashboard-only feature pushes a little back. “API is the new UI” is true right up to the edge of whatever the vendor decided to expose this quarter — and then you’re a person clicking buttons again, or you’re paying an agent to be one.

The interesting question isn’t which side wins. It’s how much of any given job still falls in the seam — and whether the thing closing it, for now, is still me.

I don’t think it stays me. But it was me this week.