The shape of human-agent work is converging

June 15, 2026

Everything in AI is still changing fast, but we're starting to see agentic systems, and the way human teams work with them, converging on similar patterns. You can almost squint and glimpse what the future will look like.

My evidence comes from two things I've been doing for the past six months:

My conclusions are two-fold, split into the agent end and the human end.

First, on the agent end: the big thing we'll need to get used to for the coming years, is that AI agents are entirely different organisms from humans. Their anatomies are different, they behave differently, and are subject to totally different physics. Honestly, they might as well be from another planet.

And here's the thing: if you don't live and work with them, you won't get this.

Second, on the human end: the best products will hide all this complexity from users. They'll anthropomorphize AI agents, so that people feel like they just talk to someone human-like, and everything just happens.

Note: most of the credit goes to Jiquan Ngiam (JQ), who's a student of Andrew Ng, was employee #1 at Coursera, early team at Google Brain, and is now cofounder/CEO of MintMCP. It was while we sat together in his office, building agents into Slack and fixing bugs, that I had that moment where everything came together in my head.

JQ pointed at a specific diagram in Anthropic's recent engineering post, Scaling Managed Agents, to show what that converged shape looks like.

Architecture from Anthropic's Scaling Managed Agents post.

Here is the thing that struck me about the Anthropic diagram: it is built almost the opposite way from how a human is wired.

A human brain is self-contained. Your reasoning, your memory, your sense of what you're doing right now, and your hands are all fused into one organism. You don't fetch your memory from somewhere else. You don't lose your tools when you lose your train of thought. It's all one thing.

The converged agent architecture pulls all of that apart on purpose. The brain (the LLM, wrapped in a harness, dispatched by an orchestration layer) is separated from the hands (the tools and the file system). It's separated from the place where work actually executes (isolated sandboxes spun up on demand). And, most counterintuitively, it's separated from memory itself.

The agent's memory doesn't live inside the brain. It lives outside, in an append-only session log that records every step as it happens, so that if the brain process dies mid-task, a fresh one can boot, read the log, and pick up exactly where the last one stopped.

This is genuinely strange when you think about it. There's nothing "human-like" here, despite our tendency to make them so. It really is a different kind of organism.

And it gets stranger the harder you push on it.

If the intelligence holds nothing in its own head, and any fresh brain can boot, swallow ten years of logs and shared context in a single read, and instantly know everything that ever happened, then ask the obvious question: what actually makes this agent different from that one?

They're the same intelligence (same LLM call and harness) reaching into the same memory, summoned fresh at every session. So really, this isn't like a team of distinct colleagues at distinct desks that you work with. It's closer to a hive mind.

One intelligence, called up anywhere, with instantaneous access to the entire knowledge-base. Honestly sounds more like those alien civilizations that invade Earth in scifi movies.

Whether an "agent" turns out to be a durable thing (a name, a memory, a role you can point to) or just a transient slice of one larger intelligence aimed at a job for a few minutes, is genuinely unsettled. The architecture doesn't obviously need identities at all. That's not a small uncertainty. It's a hole where one of the most basic nouns in this whole field is supposed to be.

And it is complex. But the complexity is not gratuitous. It is the price of making agent work reliable, recoverable, and safe, which is precisely the problem a company like MintMCP exists to govern: who can do what, which agent can see which system, and a record of every action taken. The complexity has to live somewhere. The whole design is about making it live in a stable, governed place instead of leaking everywhere.

At the user end, I see the shapes converging too, towards radical simplicity — and humanity.

The interface becomes: you use whatever channel you already use. A chat box. WhatsApp. iMessage. Slack. A voice call. You talk to the agent the way you'd talk to a sharp colleague, and the work just happens.

Two things matter about that, input and output.

Systems of record in orgs get stale and drift pretty quickly because input is a massive problem. It requires constant human energy: please remember to key into the system, please. Once AI agents solve input, by literally reaching into your Slack and emails and even voice conversations, and capturing everything, fixing typos and putting them into the right files, humans can focus on human: relationships and thinking.

And this isn't a someday thing. You can watch it happen in the market right now.

At the records layer, a whole new class of CRMs is being built on a single premise: you should never have to feed the system again. Attio, Day.ai, Lightfield. The old pitch was "a nicer place to type your notes." The new one is "the CRM fills itself," by watching your email, your calendar, your calls, and assembling the records on its own. The legacy CRM quietly made you the data-entry clerk for your own relationships. These new ones fire you from that job.

One layer down, at the raw capture of conversation, the same wave is hitting the meeting recorders: Granola, Otter, Fireflies, Fathom. a16z's David Haber just published a piece titled "Everything Is Recorded Now", and the title is the whole argument. Recording your meetings flipped from a thing you opt into, to the default you'd have to opt out of. As Haber puts it: "This wasn't debated. It just happened." Granola, he notes, now has better context on a16z's culture and how its partners actually think than almost any other tool they use, because it's been in the room.

Now here's the part I find most telling. Notice how many companies in this one narrow lane are all taking off at the same time. A dozen strong teams hitting escape velocity in the same category, in the same year, is never a coincidence. It's the signature of a huge, long-suppressed demand finally breaking loose.

Capture was always the most valuable unglamorous problem in software, and it stayed unsolved for decades, because the only known fix was "ask humans to be disciplined forever," and humans never are.

AI is the first thing that actually dissolves it. The instant the cost of capture falls to zero, the dam breaks, and everyone who was standing at the wall pours through at once.

Sometimes the crowd isn't noice, it's signal.

Now output. You say "build me the deck for Tuesday's meeting using these materials, in this style," and minutes later a 95-percent-right deck appears in the chat. Not a description of the deck. Need to produce a compliance report in three languages, by assembling docs and logs over 15 BUs? Just say the word, and it'll be done by the time you get back from lunch.

Put both halves together and you get a single command that crosses many systems at once: "Pull this client's file from the CRM, check our latest email threads, grab the assets from the spring campaign, build a fresh variant, then send it to Rich for review."

One sentence. Work happens across four systems. The user never sees a single one of them.

Btw #2: radical simplicity is the goal, but there's still tons of UI/UX innovations to be made.

For instance, we're in the early days of generative UI: Need to choose between eight brand color and font combinations first? Surely you can't do that via pure text chat. So fine, the agent spins up a little voting interface right there, you click, and your click triggers the next set of actions.

The interface isn't a fixed product you learn. It's generated on demand, fitted to the one thing you're doing, and thrown away after.

This is not just happening in vibe-coding. Two recent learning apps I've tried (Oboe, Wondering), for instance, both "vibe-UI'd" learning interfaces: depending on what course I wanted, and where I was in the learning journey, it spun up either interactive diagrams, or quizzes, or essay tests and other formats, all on the spot.

Here's the objection, and it's a good one. If you just say it and it just happens, how do you know it did the right thing? Did it pull the right client? Parse the right number? Radical simplicity at the input creates a blind spot at the output, because the buttons and screens you deleted were also how you used to check the work.

This is exactly why the winning version of this happens in a shared space, and why I keep coming back to Slack.

I watched team MintMCP work this way: humans and agents in the same channels, pinging each other like colleagues. My Github threw back an error. JQ frowned, and immediately pinged Dan in Slack to investigate. 3 minutes later, Dan gave a diagnosis, proposed a fix, JQ said "yeah looks about right go for it", and Dan made the fix. Minutes later, I refreshed and it worked.

Dan is an agent of course.

Here's the architecture that JQ and MintMCP shared in a recent webinar:

A Taiwan startup told us their small team began working this way, and realized that the humans pinged their AI agents ten thousand times in the first month.

That's not a demo. That's internal product-market fit.

(Dan Shipper of Every called out this same human-plus-agents-in-Slack pattern recently on Lenny's podcast, so I don't think I'm seeing things.)

The reason it works is not that Slack is trendy. It's that the work happens out in the open. In Slack you can see every step the agent takes, in a chain: which tool it called, which data source it read, which website it browsed. And underneath, MintMCP keeps a granular log of everything done, by humans and agents alike. The magic is not a black box. You can replay it.

99% of people doing that work will never touch the complexity that makes it possible, and neither will they want to. They won't know what a harness is, or that the agent's memory lives in an append-only log, or that a sandbox got spun up and torn down to run their request. They'll just talk to the AI like they'd talk to a brilliant, tireless colleague, and decks get built, CRMs get updated, emails get drafted.

This gives you a sense of who wins also. Teams that are at the same time capable of wrangling agent-end complexity AND achieving user-end simplicity, will do incredibly well this decade.

This is very hard. Living in agent orgs vs living in human orgs are two different worlds. I haven't met many people or companies who can excel at both. But if you can, the new world will be yours.

Sources: