The browser tab is the last manual integration

Count the tabs open in your browser right now. Then count how many times today you copied something out of one and pasted it into another, the lead’s name from the CRM into the email, the invoice number from the inbox into the spreadsheet, the date from the contract into the calendar. Each of those copy-pastes was an integration running. You were the integration. You just didn’t get paid like an API.

We talk about software integrations as if they were a solved category, connectors, webhooks, an icon grid in a settings page. But the integration that actually moves your company through the day isn’t any of those. It’s the person alt-tabbing between four tools, holding the thread in their head, ferrying data across the gaps the connectors never closed.

The browser tab is the last manual integration, and it’s the one nobody put on a roadmap.

That’s the line this whole post orbits. Copy-paste is an API made of attention, and attention is the most expensive runtime you own. Here’s why the glue is human in the first place, why connectors never dissolve it, and what it takes to remove the person from between the tabs.

The glue was never in the software. It was in your hands.

Here’s the naive picture of how your tools work together. You have a CRM, an inbox, a calendar, a docs tool, a billing tool. Somewhere in a settings menu there’s an “Integrations” tab, and you’ve turned a few on. So the tools are connected. The work flows.

Now watch what actually happens when a deal moves.

The email lands in the inbox. You read it, decide it matters, and switch to the CRM to update the stage. The CRM doesn’t know about the email, so you summarize it by hand into a note. The deal now has a renewal date, so you switch to the calendar and type it in. The renewal needs a document, so you switch to the docs tool, find last quarter’s version, and copy the terms across. Four tools touched. Zero of them talked to each other. The thing that carried the data from one to the next, the thing that read, decided, summarized, and re-typed, was you.

That’s the part the word “integration” hides. The connectors moved a few fields. The judgment, the context, the carrying, that stayed in a human, switching tabs.

A connector moves a field. A person moves the meaning. The gap between them is the job.

And the gap is enormous. The connector can sync a name. It can’t read the email, decide the deal is at risk, know which document is the right one, and understand that the date in clause four is the one that bites. So the connector does the easy 10% and hands you the hard 90%, dressed up as “now your tools are connected.” You feel connected the way two islands feel connected because someone rows a boat between them all day.

Why connectors don’t dissolve the glue, they just move it

The obvious objection is: fine, so build more connectors. Wire every tool to every other tool. Sync everything. Then there’s nothing left to copy-paste.

People have been trying that for fifteen years. It doesn’t converge, and it’s worth being precise about why.

The first reason is combinatorial. Connect ten tools pairwise and you have forty-five connections to build, test, and maintain, and the eleventh tool adds ten more. The next reason is that a sync is a schema agreement, and schemas drift. One tool renames a field, another adds a required column, a third changes how it represents a date, and the connector that worked last month silently drops the thing you needed. The brittle part isn’t building the pipe. It’s that the pipe assumes two systems will agree forever, and they never do.

But the deepest reason is the one that matters most: most of what you copy-paste is judgment, not data. When you read the email and decide it’s the at-risk one, no field was synced, a decision was made. When you pick which document to copy the terms from, you used context that lives in no schema. A connector can move a value from box A to box B. It cannot decide that the value matters, that it belongs in box B, and that box B’s neighbor needs to know about it too. That’s not a sync. That’s reasoning. And reasoning was the part you were doing in your head, between the tabs, the whole time.

So connectors don’t remove the human glue. They thin it slightly and leave the expensive part exactly where it was. The bottleneck never disappears. It just moves, from “the tools can’t share a name” to “only a person can decide what the name means and where it should go next.”

Copy-paste is an API made of attention

Let’s name the thing precisely, because naming it is half the fix.

When you copy a value out of one tab and paste it into another, you are executing an API call. You are the runtime. Your eyes are the read. Your judgment is the transform. Your typing is the write. The clipboard is the payload. And the cost of that API call is paid in the one resource you can’t buy more of: your attention, spent at the moment you have the least of it to spare.

This API has terrible properties, and you’d reject any vendor who shipped it. It has no retry, miss a paste and the data is just gone. It has no logging, nobody can tell you later why the date in the calendar doesn’t match the date in the contract, because the only record of the transform was a thought you had on Tuesday. It has no idempotency, run it twice, get two leads, two events, two versions of the truth. It’s slow, it’s lossy, it runs only while you’re awake, and its throughput collapses the moment you’re tired or distracted or in a meeting. It is, by every measure an engineer would use, the worst integration in your stack.

And it’s the one your company runs on.

The naive response is to make the human a faster API: better keyboard shortcuts, a tidier inbox, a second monitor so you can see two tabs at once. That’s optimizing the boat. You row faster; you’re still rowing. The work, read, decide, carry, write, doesn’t shrink. You just do it with better posture.

The real response is to stop being the runtime. Not “give the human a faster way to copy-paste,” but “make the copy-paste not need a human.” Which means something has to sit underneath all the tools, see across them at once, do the reading and the deciding and the carrying, and only ask you when the judgment is genuinely yours to make. That something is not another connector. It’s a layer.

What replaces the glue: a layer that does the carrying

Here’s the shift, and it’s a shift in where the work lives, not in how fast it runs.

Think about your own computer for a second. You don’t write a connector between your text editor and your file system. They both sit on an operating system, and the OS holds the file, the clipboard, the process table, the shared state that every app reaches into. No app copy-pastes to another app. They all read and write the same underlying world. The OS is the integration, and it’s invisible precisely because it works.

A company doesn’t have that. A company has a dozen apps and a human standing in for the OS, holding the shared state in their head, ferrying it by hand, being the clipboard. The reason you alt-tab is that there’s no layer underneath the tabs that already knows what you’d copy and where it goes.

So you build the layer. Underneath the CRM and the inbox and the calendar and the docs, you put one thing that reads all of them, a company brain that holds the shared state the tabs never shared. When the email lands, the layer reads it, understands the deal is at risk, knows which document is the right one, sees the date in clause four. It does the carrying that used to live in your hands. The CRM gets updated, the calendar gets the date, the doc gets pulled, not because forty-five connectors fired, but because one layer saw the whole picture and acted on it.

And, this is the part that separates an OS from an automation, when a decision is genuinely yours, it speaks to you first instead of guessing. Not “I synced a field.” Rather: “This renewal is at risk and lapses Friday; I’ve drafted the outreach and updated the deal, want me to send?” The judgment you used to do between tabs gets surfaced as one decision, already prepared, instead of forty copy-pastes you had to remember to do.

The difference between the two pictures isn’t speed. It’s who holds the state. In the top picture, the shared truth of your company lives in a person’s short-term memory and gets re-typed all day. In the bottom one, it lives in a layer that doesn’t forget, doesn’t sleep, and doesn’t drop the paste when a meeting runs long. The human stops being the bus and starts being the driver.

Why this is the integration that actually matters

Step back and look at where the leverage is.

Every integration vendor competes on the easy 10%, more connectors, prettier sync logs, a bigger icon grid. None of that touches the 90% that’s still a person carrying meaning between tabs. The reason is that the easy part is a schema problem, and the hard part is a judgment problem, and for forty years we only had software that could do schemas. So we automated the field-copy and left the human to do the thinking-copy, and called the result “integrated.”

The browser tab is the last manual integration because it’s the one that needed judgment to remove, and judgment is the thing software just learned to do. That’s the whole reason this is possible now and wasn’t before. You can finally put a layer underneath the tools that reads like a person, decides like a person, and carries like a person, so the person doesn’t have to.

Suppose a typical operator spends, say, two hours a day not doing the work but moving the work, reading something here to re-type it there, reconciling the version in one tool against the version in another, being the API between systems that won’t talk. That’s not a small inefficiency to trim. That’s a quarter of a working life spent as glue. And it’s not the boring quarter. It’s the quarter that’s full of small judgment calls, which is exactly the quarter you’d want your best people spending on the company, not on the clipboard.

The turn: you were never supposed to be the integration

Here’s the part that isn’t about architecture.

The most capable person in most companies spends a real fraction of their day as a copy-paste runtime, and they don’t notice, because it feels like work. It feels like being on top of things. You touched every tool, you kept the data in sync, nothing fell through. That diligence is real, and it’s also a tax, and the cruelest thing about it is that it scales with how much you care. The more you hold in your head, the more of your head is held.

You became the integration layer because no layer would do it for you. That was never a good use of you. The point of removing the human glue isn’t to make the copy-paste faster, it’s to make it not yours, so the attention you were spending on carrying the work goes back to deciding the work. What to chase. What “good” means for the people you serve. Which renewal is worth a personal call. The judgment that’s genuinely yours, surfaced as a decision, instead of buried under forty pastes that any layer could do.

A connector moves a field. A person moves the meaning. The whole bet is that the meaning can finally move on its own, and that you get to stop being the boat.

---

That’s what we’re building at Apollo, not another connector in the icon grid, but the layer underneath the tabs that reads across your tools, does the carrying, and asks you only the questions that are actually yours. If you’ve ever caught yourself alt-tabbing to copy a date you’ll have to copy again tomorrow, you already know which integration was the last one left. It was you.