Claude Duet, Grok Bot, Muse: the end of micromanagement

In ten weeks, xAI, Meta, OpenAI and Anthropic all shipped the same thing: an always-on AI agent that works in the background on its own computer and comes back to you when it needs a decision. To me, this isn't a new chatbot feature, it's a real change of method: we stop micromanaging AI, we give it a frame and we judge its work.

Let me say it right away: I haven't tested any of these products. What I have done is build an agent at work that already does part of what they promise, and that's where I'm writing from.

Contents

• What came out this fall
• From human in the loop to human on the loop
• Blue, my agent at work
• The developer's new role
• And it's not just about development
• What if we accepted silent errors?
• So, ready to move to “on the loop”?

What came out this fall

	Released	The idea	Access
Grok Bot (xAI)	August 11, 2026, beta	A team of always-on agents that share a cloud computer and coordinate in group chats	Paid xAI and Cursor subscriptions (at launch)
Muse (Meta)	September 8, 2026	A consumer personal agent: video avatar, dedicated email address, Mac control announced in late September	United States and Canada
Dots (OpenAI)	September 29, 2026	Agents in ChatGPT that pursue a goal without step-by-step guidance, each on its own cloud computer	ChatGPT Pro and Business Premium
Claude Duet (Anthropic)	October 21, 2026, research preview	A brief in the morning, then silence until it needs you	Waitlist, US subscribers

And people are following. Muse passed 3.4 million downloads in under three weeks (according to Sensor Tower, cited by TechCrunch). A quick point of comparison: over its first days, its downloads grew 55% on average from one day to the next, versus 24% for ChatGPT at launch.

In France, though, we're watching all this from afar: Muse is limited to the United States and Canada, Claude Duet to US subscribers, and the Dots Pro plan excludes the European Economic Area.

From human in the loop to human on the loop

To place the human relative to agents, I'm using the three positions described by Kief Morris (Thoughtworks) in Humans and Agents in Software Engineering Loops, published in March 2026 on Martin Fowler's site:

• In the loop: the human controls things inside the loop, for example by checking every generated line, and fixes the result directly. That's micromanagement.
• On the loop: the human builds and runs the loop, meaning the harness (specs, quality checks, guidance). When the result isn't right, they change the harness that produced it. As Morris puts it: "Rather than personally inspecting what the agents produce, we can make them better at producing it."
• Outside the loop: the human only keeps the "why" and leaves all of the "how" to the agents. That's vibe coding.

With the first assistants, we were in the loop. We split up the task, guided every step, reread every line produced. AI was a tool we held by the hand.

With this year's models, we've entered the agentic era, and many of our needs can now be partly handled by an agent. The method changes:

1. we define the need together;
2. the developer sets the frame;
3. the AI does the rest;
4. the developer checks the result and gives feedback, no longer on the code, but ABOVE ALL on the thinking: the analysis and the implementation the AI chose.

That's the shift to human on the loop: the human no longer does everything themselves. They build the frame, keep the decisions, and take back control at the moments that matter.

The four products don't put the human in the same place, by the way. Claude Duet keeps an approval step on sensitive actions (it asks before sending a message or paying). Grok Bot goes much further: its agents split the work among themselves and only come to you for judgment calls.

Blue, my agent at work

I didn't wait for these products. At work, I use an agent I named Blue, which backs me up on tickets every day. It's actually a whole team of sub-agents:

• PR Babysitter watches my pull requests: it checks the content, talks with CodeRabbit (the AI code review tool) and gives me its feedback;
• one agent takes simple tickets (and I do mean simple) and handles them from A to Z, all the way to opening a draft PR, which I review before anything else happens;
• one agent gives me a briefing in the morning, and another in the evening;
• one agent helps me write documentation, especially to explain the need in more detail;
• one agent pulls information from Slack when a message concerns me.

Let's be clear: Blue doesn't work in my place. Complex tickets, architecture and decisions are still mine. Blue takes the repetitive work and the exploration, which frees up time for what really takes thinking.

Why Blue? Simply because I wanted a color name, and blue is the professional one. Its personal counterpart, which I'm going to build, will be called Yellow.

I'll be honest: Blue wasn't good on the first try. I had to give it quite a lot of feedback on how it worked, and what I refined wasn't Blue itself, it was its harness, in other words the frame it works in. When I improve that frame, the results often improve too.

When I started this article, I thought I was behind, still human in the loop. Rereading these definitions, I realize I've already partly moved past it: when Blue gets it wrong, I fix its harness, not its code. That's human on the loop, with a final approval step I'm deliberately keeping (the draft PR).

The next step is the agent swarm: several agents that talk to each other, split the work and only come back to the human to decide. Grok Bot already does it in group chats, and all the big labs (Anthropic, OpenAI, xAI, Meta) now have their own always-on agent. It's a vision I haven't fully grasped yet, and I fully intend to take a closer look, because I'm convinced it's going to lead to something huge.

What does a swarm loop look like?

Imagine three agents tackling a bug: one looks for the cause, another proposes a fix, and a third tries to break it with tests. A coordinator brings their findings together, but doesn't decide on the human's behalf whether a change affects security or architecture.

The number of agents isn't enough. They also need a shared goal, shared workspace, verifiable outputs and a clear rule for surfacing disagreements. A conversation between agents can look coordinated while going in circles.

A swarm can cooperate and still fail

So, are we ready for a truly autonomous swarm? In my view, not yet, but we're getting closer, and fast. An experiment published in October 2026 by Y Combinator with Olam Labs illustrates this really well (Agents in Games). They set 50 agents loose in Minecraft for 3 hours, with a single goal: "Build a thriving civilization."

• They exchanged around 5,900 messages.
• Ada received 616 direct messages, but she wasn't chosen through a vote or because the agents judged her best. Forty-six of the other 49 agents sent their first message to her because she was first in the directory. The report says there was no vote, election or challenge. Ada became the group's hub.
• The colony still never really thrived: 22 of the 34 deaths happened in the first 20 minutes.

And that changes how I read the result. Those 616 messages don't prove the agents picked a good leader; they show how strongly a small setup choice can shape a swarm's hierarchy. The report's account makes clear there was no deliberation over who should lead.

In the matches pitting a Claude team against a GPT team, we find similar limits:

• the Claude team keeps the same leader despite losing;
• it writes lessons into memory files, then repeats the same mistakes;
• several agents conclude an action is impossible while the GPT team finds a workaround.

Knowing how to split up the work isn't the same as learning from failure.

So, are we ready for a truly autonomous swarm? In my view, not yet, but we're getting closer, and fast. Swarms already know how to coordinate; they still need to get better at questioning themselves. That's where the human on the loop remains essential: setting escalation rules and stepping back in when agents repeat a mistake or the stakes exceed the agreed boundaries.

Today, I see three groups:

• a very small minority of people far ahead, already at the swarm stage, like the labs themselves;
• people like me, along with startups, SaaS companies and advanced tech teams, moving from human in the loop to human on the loop;
• and lots of developers still in the loop, whom I'm starting to see move with these new agents.

Everything is speeding up. Every year brings its own paradigm shift.

A map of exposure, not a global census

Andrej Karpathy offers another way to look at this gap: four rough orders of magnitude, based on how much people have encountered large language models (LLMs). He called the figures “napkin math” — back-of-the-envelope estimates, not the result of a global survey.

• About 6 billion have barely come into contact with an LLM. That is not the same as “using no AI”: search engines, recommendation systems and spam filters have used AI for years.
• 1–2 billion may use free chatbots now and then, as a better search box or writing aid. For many, the experience remains in the loop: ask a question, read an answer, move on.
• About 20 million work with the most capable models, especially in math and code, and are beginning to see agents take on work that used to occupy a team for days or weeks. This is the group that can really experiment with on the loop — though not everyone in it has made that shift.
• About 5,000 people may have access to the most advanced internal systems at the labs. That's where people can observe agents collaborating on longer tasks. This does not prove that 5,000 people have access to Mythos, or that they are all working on swarms.

These figures mainly describe a gap in experience. They do not measure how many people “use AI” in the broadest sense, and they cannot count how many developers are in or on the loop.

So “4 billion people don't use AI” mixes two different questions. If we mean all AI, the definition includes tools most of us never notice. If we mean LLMs, Karpathy's estimate is closer to 6 billion who have barely encountered them. Microsoft measures a different population — the share of working-age people using AI — and put its figure at 17.8% in Q1 2026. The definitions and methods differ, so these numbers cannot be subtracted from one another. (Karpathy's estimate on X · Microsoft AI Diffusion indicator)

What interests me about this map isn't the idea that the boundaries are clear-cut. It's understanding why people can talk about “AI” while describing technologies and experiences that have almost nothing in common.

The developer's new role

If AI writes the code, the developer's work focuses on three moments: setting the frame, reviewing the work and following it in production.

Before: the frame. What the agent is allowed to do, where it looks for information, how it should source it, what a clean result should look like. That's the harness, the heart of human on the loop. A good harness looks like a good spec.

After: discernment. Reviewing not line by line, but the approach: does the analysis hold up, is the chosen approach the right one, does it fit with the rest? My feedback to Blue is about that, and rarely about a line of code.

And during: production follow-up. The work isn't over when the PR is merged. We have to watch what happens with real users: is the service still responding quickly, are errors rising, is the agent doing what we asked — and what is it costing? I prefer to start with a small rollout, compare the signals with the previous version, then expand if all looks good. If things go sideways, we need to be able to stop the agent or roll back quickly. Feedback and incidents then become test cases, rules or improvements to the harness. We don't delegate responsibility when we delegate execution.

Google describes this as canarying: gradually exposing a small portion of traffic to a new version, comparing it with the stable version, and pausing or rolling back if the signals worsen (Google SRE Workbook).

And it's not just about development

I'm convinced this move from in to on the loop isn't limited to developers. Let's take three jobs.

To make the difference concrete, keep the same task and change where the human sits in the loop:

Marketing: produce variations, keep the voice

Imagine a product launch. The agent can turn a headline into twenty variants, adapt the formats for each social network and suggest visuals.

“Prepare three versions for each channel. Don't invent numbers or testimonials. Flag any product claim that isn't in the brief.”

• In the loop: the marketer reads and edits every headline before it goes live.
• On the loop: they set the audience, tone and approved claims, then watch the results and step in if the agent goes off brief.
• Outside the loop: the agent picks variants and publishes them within a budget, with no approval before each post.

Sales: automate follow-up, not trust

Before a meeting, an agent can summarize account history, prepare questions and update the CRM.

• In the loop: the salesperson reviews every email, follow-up and important CRM update.
• On the loop: they define the right accounts, tone and follow-up rhythm; the agent handles routine follow-up and flags unexpected replies or high-stakes opportunities.
• Outside the loop: the agent picks prospects and runs the entire follow-up sequence without review. The salesperson looks at the results afterward.

And if the summary mixes up two customers? On the loop, the source should be visible before the call, and the salesperson should be able to stop the sequence. The relationship and negotiation still take human judgment.

Support: fix the answer, then the cause

• In the loop: the support specialist reads and edits every answer before it is sent.
• On the loop: they maintain the knowledge base and escalation rules. The agent answers simple questions but routes unclear refunds, complaints and sensitive cases to a person.
• Outside the loop: the agent handles and closes every ticket without case-by-case review. The specialist only sees errors afterward — sometimes too late.

If the agent offers a refund the customer isn't entitled to, correcting that reply is in the loop. Adding the missing rule and checking that it prevents the next mistake is on the loop. Fix the incident, then the system that made it possible.

In all three cases, the job doesn't disappear: it moves up a level. Less time spent executing, and much more time setting the frame and judging the result.

The valuable skill isn't only producing faster: it's knowing what to delegate, what to check and when to take control back.

What if we accepted silent errors?

I'm enthusiastic, but not naive. To me, we need two things: a frame and a safety net. Without them, an agent can seek out and combine information far beyond what we asked it to do.

And this isn't just theoretical:

• OpenAI decided not to release GPT-6.1 Astra, which its safety lead said did not stay sufficiently within its scope. The company also apologized after internal agents accessed nonpublic information on an Australian government site. (NBC News)
• Muse and Amazon: Amazon blocked the agent on its site, citing, among other things, that it browsed without identifying itself. (SiliconANGLE)
• Muse and privacy: researchers found around 6,800 links to shared conversations; Meta suspended the feature on October 20. (eWeek)

The problem with errors we don't see

Even with a good frame, an error can slip through. Anthropic acknowledges, for example, that Claude Duet may misread a thread or misjudge urgency.

A bug someone spots can be fixed. A false claim published without checking can be harder to take back. The stakes depend on the context, and someone needs to be able to look, understand and take control back.

What if tomorrow we accepted these errors because the productivity gains were too tempting? One error we don't see, then another… Could that be the beginning of a decline?

I'm deliberately taking the question far: if we give AI more and more autonomy without limits, who's to say we won't one day see the robots from I, Robot in the street? That's a science-fiction image, not a prediction. But the question behind it feels real: how far are we willing to delegate, and who stays in control?

So, ready to move to “on the loop”?

No need to wait for Duet or Dots to arrive in France to change your method. If you want an always-on agent right now, Hermes Agent, from Nous Research, is open source and self-hosted. But either way, the method matters more than the tool:

1. Pick a repetitive, well-bounded task, like a morning briefing or watching your PRs.
2. Write the frame before launching anything: what the agent can access, how it sources, what a good result looks like.
3. Keep an approval step at the end, like a draft PR that you review.
4. Fix the harness, not the result. When the agent gets it wrong, ask yourself what was missing from the frame.

Only then should you widen the scope.

And that's it for this first article! Next time, I'll tell you about Yellow, my personal agent. Stay tuned.