All posts

The Human API

We spent decades putting business processes into software. The thing that connects those systems is still a person with twenty tabs open. That gap is the opportunity.

Illustration for: The Human API

Walk into almost any operations team and you will find the same scene. Someone has twenty browser tabs open: the ERP in one, the CRM in another, a supplier portal, a shared spreadsheet, an inbox, a ticketing queue. They copy an invoice number from one window, paste it into another, check a status, switch tabs, and paste again.

They are doing the job of an integration. They are a human API.

How we got here

Over the last few decades, companies did something remarkable. They took processes that once lived on paper and in people’s heads, and they put them into software. Finance got an ERP. Sales got a CRM. Support got a help desk. HR got a payroll system. Every function got a system of record built for its job.

What almost nobody got was a way for those systems to work together. Each tool was bought on its own merits, by a different team, at a different time. Integration projects were expensive, slow, and always one vendor update away from breaking. So the gap between systems was filled the way gaps usually are: by people.

Why it never went away

You might expect the human API to have shrunk as software matured. It hasn’t, for a few stubborn reasons:

  • The long tail. Most cross-system workflows are too small, too specific, or too rare to justify an integration project on their own. Together, they add up to an enormous amount of work.
  • No API at all. Partner portals, government sites, legacy desktop applications, and virtual desktops often have no programmatic access. The screen is the only interface.
  • Constant change. Fields get renamed, steps get added, vendors ship redesigns. Hard-coded integrations and brittle scripts break; people adapt.
  • Small judgments. Many steps need a moment of judgment — does this match, is this the right customer, does this look off? Traditional automation struggles with exactly those moments.

The most widely deployed integration layer in the world isn’t middleware. It’s people.

What changes with computer use

For the first time, software can operate other software the way a person does. Models can look at a screen, understand what is on it, and act: click, type, navigate, read the result, and decide what to do next.

That matters because the user interface is the one integration point that always exists. Every system, no matter how old or how closed, was built to be operated by a human through a screen. An agent that can use that screen doesn’t need a bespoke connector for every pair of systems. It can work across the stack a company already has.

The long tail — the part of work that was never worth integrating — suddenly becomes addressable.

Capability is no longer the hard part

It is now easy to produce an impressive demo of an agent filling out a form or booking a meeting. That is not the same as a company trusting an agent with its accounts payable queue.

The hard parts are the ones that separate a demo from a job done:

  • Finishing. Not 80% of a task with a messy handoff, but the whole thing, verified.
  • Trust. Scoped permissions, audit trails, predictable behavior, and clear escalation when something is genuinely ambiguous.
  • Fit. Working inside the software and security model a company already has, rather than asking it to change.

These are the problems we care most about, and they are where we think the most durable companies will be built.

Freeing people, not replacing judgment

The people doing human-API work are rarely the least valuable people in a company. Often they are the ones who understand how the business actually runs — which system is the source of truth, which customer is always a special case, which report everyone quietly double-checks.

Today, much of their day disappears into copy and paste. Agents that finish the job give that time back, and let people spend it on the judgment calls only they can make.

Why Emergent Core

This is why Emergent Core exists. We believe the next great software companies will be built by teams that retire the human API — not with another dashboard, but with agents that do the work, end to end, in the systems companies already use.

If you’re building this, we want to hear from you.

Previous post

Request for startups

Building computer-use agents? Let’s talk.

Send us a few lines about what you’re building, the workflow you’re starting with, and who it’s for.