August 19, 2026
How AI agents evolved: five rungs from a text box to a workforce
Raw API, agent library, code harness, personal OS, team OS. Each rung turns the one below it into a component, and the gaps between them shrank from two years to nine months.
TL;DR
- AI products are not getting better in place. They keep jumping to a new rung of the stack, and each jump turns the rung below it into a component.
- The first two jumps took about two years each. The last two took nine months and eight and a half.
- We are standing on rung four: an always-on agent that belongs to one person. OpenClaw has ~387,000 stars proving the demand for it.
- Rung five is the company — many humans, one shared workforce, one memory. OpenAI, Anthropic and xAI all sell the language for it. None of them ships it as the default product.
- The tell that a rung is coming: the vocabulary breaks first. It broke on 11 August, when xAI shipped a single-pilot crew and described it as a team.
Disclosure before anything else: I build OpenLabor, which is a bet on rung five. Read the map knowing where I’m standing.
The vocabulary breaks before the product arrives
On 11 August, xAI launched Grok Bot. Within a day I watched three separate people call it “the new Grok CLI.”
It isn’t. The Grok CLI is Grok Build, which shipped in May and is xAI’s answer to Claude Code — a terminal agent that reads your repo, edits files, runs tests, retries. Grok Bot is a fleet of always-on agents with their own cloud computer that sign into Zendesk and update your CRM.
Same vendor, same four letters, eleven weeks apart, and they solve problems in different departments.
That confusion is the useful signal. When a field moves inside one layer, the words hold — everyone knew what “autocomplete” meant for a decade. When the words stop working, something moved up. Today “agent” covers an API call, an IDE plugin, a terminal loop, a Telegram bot on a VPS, and a company workforce that has not shipped yet. Five products, one word.
So here’s the ladder those five products are standing on, and where the climb goes next.
The five rungs
| Rung | What it actually is | Examples |
|---|---|---|
| 5 — Team OS | Shared AI employees, company memory, many humans | OpenLabor, OpenAI Workspace Agents (preview) |
| 4 — Personal agent OS | One operator, always on, chat apps, cron, memory | OpenClaw (Nov 2025), Hermes (Feb 2026), Grok Bot (Aug 2026) |
| 3 — Code harness / AI IDE | Repo loop: read, edit, run, retry | Cursor (2023), Claude Code (Feb 2025), Codex, Grok Build (May 2026) |
| 2 — Agent library | You build the loop yourself | LangGraph, CrewAI, AutoGen |
| 1 — Model + raw API | Text in, text out. No files, no loop, no memory | Claude API, OpenAI API, xAI API |
A rung does not arrive on one morning. It opens with a first product and stays open for years — Cursor in 2023 and Grok Build in 2026 are the same rung, three years apart. What matters is when the rung starts.
Where the climb sped up
Date the first product on each rung and put the gaps side by side.
About two years, about two years, then nine months, then eight and a half. That is not a curve bending down, it is a cliff. Some of the drop is capability: models got good enough for multi-day work, and that is the point where a second person starts asking to share the agent. Most of it is that each rung makes the next one cheaper to build. Whoever ships rung five is not writing a model, a tool loop or a channel layer. Those exist. They are writing the org chart on top.
What each jump does to the layer below is the same move every time: it turns yesterday’s product into today’s component.
| Rung arrives | What it demoted |
|---|---|
| Agent library (2022–23) | The raw API became a function call inside somebody’s graph |
| Code harness (Claude Code, Feb 2025) | The library became optional — the harness ships its own loop |
| Personal OS (Nov 2025) | The harness became a tool the assistant calls for hard code |
| Team OS (now) | The personal OS becomes the runtime under a company product |
This is why the “who wins” arguments are usually pointless. Claude Code did not kill LangGraph by being better at graphs. It made the graph invisible. The next rung does that to the one under it, on schedule.
It also means the layers nest rather than compete. Hermes calls Claude Code for a hard refactor instead of trying to replace it. OpenLabor runs an OpenClaw-style heartbeat underneath. Grok Bot will borrow from Grok Build for its engineering bots.
Where we actually are: rung four
This is the layer that left the repo. The agent lives on a VPS, talks on Telegram or Slack, keeps memory, runs on cron, and stays up when the laptop closes.
| OpenClaw | Hermes | |
|---|---|---|
| First public | 24 Nov 2025 (as Clawdbot) | 25 Feb 2026 |
| Stars, Aug 2026 | ~387,000 | ~232,000 |
| License | MIT | MIT |
| Design target | ”Single operator”, stated in the README | Self-improving personal agent |
| Strength | Reach, channels, skill registry | Compounding memory, faster to useful |
| Weakness | Security surface, setup load | Raw code polish below Claude Code |
387,000 stars is one of the largest counts on GitHub, on a product built for an audience of one. That number is the demand signal for the whole rung, and it arrived in nine months.
The stack that actually runs in the wild today:
Human
└─ OpenClaw or Hermes (life, memory, schedule, chat)
└─ Claude Code / Codex (the hard code)And here’s the ceiling that pushes everyone to the next rung. If that operator is out, nobody else can task the agent. No second seat, no shared memory, no handover. Every hour of setup is trapped with the person who did it. That’s the internal owner problem, now baked into the runtime.
I watch companies try to climb over that ceiling instead of accepting it, and the attempt fails the same way each time. A founder installs OpenClaw, it works, the team asks for access, so they share the instance. The gates for that do exist — sender pairing, per-channel isolation, allowlists that scope tools to a requester — but they are configuration the operator writes and maintains by hand, one trust boundary at a time. The project’s own guidance is to run a separate gateway per trust boundary, which across a team means standing up and patching one agent per person. That is a second job, so it does not get done. The instance ends up back with the two or three founders who accept a shared blast radius, and everyone else goes back to asking them. That is a single-operator design behaving exactly as designed with four people in front of it.
The leading indicator: read Grok Bot as a signal, not a product
What shipped on 11 August, in beta:
- Each bot gets its own cloud computer. Work continues with the laptop shut.
- Bots sign into real apps, including tools with no clean API. Computer use is the wedge.
- You message a bot like a coworker. It comes back for approval.
- You can run many at once. A “chief of staff” bot manages specialists.
- Show it a workflow once; it saves a routine and repeats it on a schedule.
Pricing, as published:
| Plan | Price | What it buys |
|---|---|---|
| Cursor Ultra | $200 / month | The bot’s computer, tool login, scheduled routines |
| SuperGrok Heavy | $300 / month | Highest usage tier |
| Cursor Teams Premium | $120 / seat / month | SSO, billing, skill marketplace, analytics |
Read the price sheet, not the marketing copy. Teams is $120 per seat; the two plans that actually carry the bots are personal, at $200 and $300. That is power-user pricing, and “Teams” here means admin controls and a shared marketplace. The hero user is still the person who already knows how to delegate to an agent.
So Grok Bot is a personal workforce in the cloud, sold as seats. One skilled human, a crew of bots. That is rung four with much better hardware.
The product is a single-pilot crew. The copy is already selling the company. Three things in it are early versions of what rung five needs:
- Computer use as the default integration. No API, no MCP server, no connector waiting on a vendor. The agent signs in and clicks. Within a year this stops being a feature and becomes an expectation at every layer.
- The agent’s own machine. Once the work lives on infrastructure instead of a laptop, “who else can reach it” becomes a permissions question rather than a physics question. That is the door to multi-human.
- The vocabulary. “Teammate.” “Chief of staff.” xAI is describing rung five and shipping rung four, which is what a vendor does one rung before it climbs.
Keep the three xAI products straight while you watch, because the press releases won’t help:
| Product | Date | Layer | One line |
|---|---|---|---|
| Grok | 2023– | Model + chat | The LLM and the chat surface |
| Grok Build | May 2026 | Code harness | Terminal agent for a repo |
| Grok Bot | 11 Aug 2026 | Personal OS + crew | Always-on bots with a cloud PC |
What rung five has to have
A team OS is not “we have several agents.” Seven properties, and this is the checklist to hold every launch against for the next eighteen months:
- Many humans in the same work, not many agents under one human.
- Shared company memory that survives the person who leaves.
- Named roles with skills on day one, not an empty bot the champion must invent.
- One champion configures; everyone else consumes with zero setup.
- Permissions — who may task whom, who may see what.
- A shared surface where a coworker can watch a run, redirect it, or take the thread.
- Missions that run with no prompt — cron, heartbeat, standing goals.
Score today’s field against it and the rung is visibly under construction:
| Product | Verdict | Why |
|---|---|---|
| OpenAI Workspace Agents | Closest structure | Shared org agents, but inside ChatGPT, mostly reactive, admin still operates |
| Grok Bot | Adjacent | Crew of always-on bots, one pilot |
| Claude Cowork | No | Desktop agent over files and Gmail. Solo context. Compared it here |
| Cloudflare OS | Same slogan, opposite product | Self-serve workbench the company operates itself |
| Dust | Partial | Multiplayer over company data. Answers and workflows, not employees on missions |
| Lindy, Relevance, CrewAI | No | The user draws the graph. Builder tools, not a workforce |
Shared agents exist now. An operated shared workforce doesn’t, as a default product from any lab.
What lands next
Predictions, so you can mark them wrong later.
Computer use goes everywhere, fast. Grok Bot proved a bot that clicks through a UI beats a bot waiting on an integration roadmap. Expect it at every layer within a year, including inside code harnesses that currently stop at the repo boundary.
Per-seat pricing starts breaking. A seat prices a human’s access to software. It cannot price an agent that works overnight while nobody is logged in. Watch for the shift to usage, work completed, or company-wide contracts — the same argument as token count is the new headcount, arriving on the invoice.
The labs ship org-shared agents as a default, not a preview. OpenAI Workspace Agents is the closest structure that exists today, and it is still a ChatGPT-silo agent an admin operates. When it leaves preview with Slack and a real org memory, rung five has its first mass product, inside one vendor’s walls.
The word “multiplayer” gets worthless by spring. Y Combinator put Multiplayer AI on the Fall 2026 RFS, with the Docs-beat-Word and Figma-beat-Photoshop argument attached. Labels follow funding. The seven properties above will still work when the label doesn’t.
And then rung six, which nobody can name yet. If rung five is agents shared across a company, the honest question is what sits above a company. Agents that transact with another company’s agents — procurement talking to sales with no human in either seat — is the shape people will start describing in 2027. Treat that one as speculation. The nine-month cadence says we find out soon enough.
Where I could be wrong
Three ways the climb stalls at rung four.
Security says no. A shared agent holding standing access to the CRM, the inbox and the repo is one prompt injection away from a very bad afternoon. Real isolation per employee and per user is the answer — on our side, a separate Cloudflare container and a sandboxed tool surface per AI employee — and it is an engineering bill, not a settings page. A company that reads that risk and decides two founders with personal agents is enough has made a defensible call.
The personal OS is enough for most companies. Under roughly fifteen people, a champion with an agent and a shared doc may beat a workforce product outright. Rung five earns its place from the queue standing behind that champion. If that queue is shorter than I think it is, the rung is a much smaller business than it looks.
The labs bundle it. If shared org agents ship inside the tool a company already pays for, the standalone version is left with regulated buyers and model-agnostic buyers. Everyone else takes the checkbox.
How to read the next launch
Three habits that survive whatever gets renamed next quarter.
Ask which rung, before asking which product. Most of what gets announced as an upgrade is a lateral move on the same rung. A genuine climb reads differently: it makes something you used to configure disappear.
Count humans, not agents. Fifty bots under one pilot is still rung four. The question that separates the rungs is how many people task the same agent without configuring anything first.
Date the first product, not the category. Rungs open years before they fill. Cursor opened rung three in 2023 and Grok Build joined it in 2026. If you want to know how fast the field is moving, measure openings.
If twenty people who will never configure an agent can task the same employee, in one memory, with the champion out of the middle — that’s rung five. If one skilled person runs a crew of bots on a cloud PC — that’s rung four, and it’s where almost everyone is standing today.
Nine months before Grok Bot, rung four barely existed. 387,000 people starred it anyway. That is the pace to plan against.
If you want to know which rung your own operation is standing on, and what to move first, that’s the audit I run. See the consulting page or book a 30-minute call.
— Yoann
Star counts, prices and dates are August 2026 snapshots. Sources: xAI’s Grok Bot and Grok Build announcements, the OpenClaw and Hermes repositories, and YC’s Fall 2026 RFS.