Four products, one bet

In September 2026, four teams shipped or leaked the same idea: you describe a goal, an agent does the work, and you review the result. Anthropic redesigned Claude Projects from a folder of sessions into a coordinator that spawns parallel worker threads. Meta's Muse topped the US App Store free chart in two weeks, running a consumer agent that books restaurants and fills forms. A leaked field in ChatGPT's client code, aeonId, hints that a persistent agent identity is coming. And an open-source project called treg is quietly building the piece the others need: a way for agents to call paid tools without holding the credentials.

These are different products for different audiences. They share a shape. An orchestrator, a set of workers, a memory, and a credential gateway. The pieces are converging fast enough that the pattern is now visible. Start with Anthropic, because it's the only one where you can see the machinery at work.

Claude Projects turns the folder into a conversation

The old Projects model was a folder. You divided a build into sessions, juggled handoffs, and stitched the results together yourself. The new beta replaces that with a conversation.

You open a project, state a goal, and attach a repo or some context. Claude scopes the request, delegates the work, coordinates parallel threads, reviews the outputs, and assembles the result. You steer from the main project chat or drop into individual threads to check details. The blog post describes the relationship as briefing a chief of staff.

The example that sticks: tell it to reduce your checkout p75 latency, the tail your slowest quarter of users experiences. Claude profiles each endpoint, tests optimizations, and opens PRs in parallel threads. Or connect the API, web, and mobile repos and ask it to retire a deprecated v1 endpoint. It creates a thread per repo, migrates the callers, runs the tests, opens the PRs, and tells you which ones need to merge first. That is delegation as a product, and it changes what a Claude session is for.

The operational details matter. Each thread is a full Claude Code cloud session on its own branch and copy of the repo. If two threads touch the same code, the overlap resolves as a merge conflict, just like any human PR. Threads can split further into subagents, loops, and workflows when a task is big enough. A shared memory spans the project, so Claude remembers that the release moved to Friday, why the export was dropped, or who to check with before touching the billing service. A library accumulates files and artifacts for the next task to build on.

Access is staged. The beta started with select Claude Pro and Max subscribers using cloud sessions in Claude Code, and the rollout widens from there. Web, desktop, Team, and Enterprise plans come after. One honest caveat in the announcement: several full sessions running at once means you'll hit usage limits faster. The UI now tracks project-specific usage, and you can pick different models and effort levels for the coordinator chat versus the worker threads.

Coordinators, threads, and merge conflicts

The architecture is the news here. Anthropic is shipping the pattern the others are circling: one coordinator, many workers, shared memory, and conflicts handled like code review rather than hidden.

Two details matter. First, the coordinator never edits code. It routes, reviews, and checks in. Second, merge-conflict resolution is the normal end state when parallel work overlaps. That's a more honest model than pretending an agent will never collide with itself.

Quick Take: the agent stack now has four layers (orchestrator, parallel workers, shared memory, credential gateway), and every product in this race is converging on the same architecture.

treg: the layer agents were missing

treg's README calls it "OpenRouter, but for agent tools instead of models." OpenRouter put hundreds of model providers behind one endpoint and one key. treg wants the same for tools: 3,000+ catalogued endpoints across 60+ providers, priced per call from a cent, no provider signup.

The problem is real. Agents need Semrush, Moz, Crunchbase, Apollo, and a dozen other services to do real work. Those subscriptions run $99 to $139 a month, sit behind signup walls, or have no public API at all. An agent that needs backlink data for one task shouldn't require a Semrush seat. treg carries those accounts and bills fractions of a cent per call.

Mechanically, it's a proxy that relays upstream API traffic and injects auth server-side. Callers never hold keys. Your agent points at one base URL with one token, searches the catalog by what it wants to do, reads the price, and calls. The hosted service is live at treg.to, and the whole thing self-hosts with a CLI and a sqlite-backed dev mode.

The credential ladder is the smart part. When a catalogued endpoint is called, treg checks in order: your team's own registered tool for that provider, a stored secret for that provider, a verified public route that needs no key, then treg's own key billed to the team's prepaid balance. Your own credential always wins, and calls using your own key are never metered. Connect a key you already pay for, and those calls stop drawing from the balance.

It goes further than the catalog. Register a vendor CLI like stripe, gh, or vercel, and teammates can run it without holding the key: treg run stripe -- get /v1/balance executes the binary with the org credential injected. Skills, defined as SKILL.md recipes plus their secrets and tools, register once and get shared across the team. An upload command scans a repo, matches keys in .env against ~80 known providers, and stages them for registration. An Enrich Arena lets you compare enrichment vendors side by side on cost and speed before you commit to one. For Claude users, an MCP surface exposes curated catalog endpoints and separates read calls from write calls, so the agent receives honest safety signals about side effects. And the out-of-balance response is an HTTP 402 carrying balance_micro and a topup_url, so an agent can act on it without reading prose. That's a tell that this was built for software, not just for humans with dashboards.

Catalog: 3,000+ endpoints across 60+ providers, from $0.01 per call. Replaced subscriptions: Semrush $139/mo, Moz $99/mo, Crunchbase $99/mo, Apollo $59/seat. .env recognition: ~80 known provider key patterns on scan. Agent-native billing: HTTP 402 with balance_micro and a topup_url, so the agent tops up on its own.

Muse proves consumers will pay

Meta launched Muse on September 8, 2026, for users 18 and older in the US and Canada, on iOS, Android, and the web. Muse is a personal agent that runs on a separate cloud virtual machine, driven by a model called Muse Spark. It executes network tasks: organizing email, filling forms, booking restaurant tables, building shopping lists. High-sensitivity actions, payments and message sends, require explicit confirmation. Raw credentials never reach the model.

The ramp was fast by any standard. Sensor Tower measured 730K downloads in the first five days. On day 10, Muse hit #1 on the US App Store free chart, ahead of ChatGPT and Claude. By day 13, total downloads were about 2.6M, roughly 1.5M on iOS and 1.1M on Android.

The comparison window is telling. Claude pulled about 400K downloads and Grok about 200K in the same post-launch period. ChatGPT drew 3.1M, but it launched globally; Muse only had the US and Canada. Even Meta's earlier AI apps grew more slowly.

The stock market read the same signal. The Monday after Muse reached #1, Meta shares closed up 11.43%, adding close to $200B in market cap in one session. That's investors concluding the $130-145B capex plan for fiscal 2026 is producing a consumer product people want.

Monetization is freemium: a free tier, then $20/month and $100/month tiers for higher quotas and task limits. Meta has said it wants transaction revenue, taking a cut when an agent completes a purchase. That part is planned, not live. The pressure points are visible too. Amazon blocked Muse on its retail site, saying the agent bypasses personalization and appears to fetch and store customer credentials and scrape account data. A preview of the trust questions coming to every agent that touches someone else's platform.

OpenAI is building a catch-up agent

OpenAI is in an unusual spot. The Information reports it is building features to counter Grok Bot and has discussed how to respond to Muse. A code-level leak gives a hint of the answer's shape. A field called aeonId appears in ChatGPT's client code, set alongside accountUserId. In the Android builds, aeonId sits near a field named memberAeonIds. The reading: in ChatGPT's data model, Aeon is a member entity with its own identifier. The name fits the positioning, aeon meaning "age" or "eternity" in Greek, an always-on colleague. A test description in the leaked code mentions protecting "aeon-like behavior," re-checking capability state at every sampling step instead of waiting for the next user turn. That is exactly what a long-running executor needs.

The awkward part for OpenAI: the pieces already exist. ChatGPT Work, launched in July, runs across apps, handles scheduled tasks, and keeps executing after you close the app, with Codex integrated. The report says OpenAI will repackage existing agent tech rather than build from scratch. The leak suggests the repackaged version gets a named identity you can hand work to.

OpenAI has reasons to move. ChatGPT passed 1B weekly active users this summer, but growth has slowed. The race has moved past model benchmarks. Grok Bot, out since August 11, gives you a cloud computer with persistent login state for Gmail, Notion, and legacy sites without APIs, plus a team of bots that coordinate in a shared chat. Anthropic's Claude Tag joined Slack channels as a member in June. Muse wants your chat app. Instinct, an invite-only startup that books restaurants over SMS and phone, quadrupled its valuation in a month. Four competitors, four entry points, all fighting for the same morning moment: the list of decisions an agent already made and wants you to confirm.

Product	What it is	Work model	Status
Grok Bot (xAI)	Always-on agent team with a shared cloud computer	Multiple bots in one chat, a chief-of-staff coordinating; bots log into services and keep state	Launched Aug 11
Meta Muse	Consumer agent on cloud VMs	Single agent completes whole tasks; hard confirmations on payments and messages	Launched Sep 8, #1 US App Store
Claude Code Projects	Conversation-shaped project workspace	Coordinator thread plus parallel worker threads on separate branches, PRs and tests, shared memory	Beta, expanding access
ChatGPT Work + Aeon	Persistent tasks inside ChatGPT	Codex-backed execution with cloud runtime; leaked aeonId suggests a named agent member	Work live, Aeon unannounced

What the community is saying

Real teams are already running these systems, and three experiences keep coming up.

The first thing I hit with Claude's parallel threads was the usage meter. Four worker sessions running at once moved it noticeably faster than anything I'd seen in a single chat. You get project-specific usage views and per-thread model and effort controls, but you have to set them deliberately. A migration I expected to be one session quietly became one full Claude Code session per repo.

The registry model won me over on the credential ladder. I registered my own Stripe key, and calls to anything I already pay for never touch the shared balance. When I ran an upload scan and watched it recognize ~80 provider patterns in my .env files, I stopped building one-off integrations. Searching the catalog by task instead of by vendor is how agent tooling should feel.

On Muse, my reservation is the trust moment. I like that payments and message sends need confirmation and that credentials never go to the model. But Amazon blocking the app over credential storage is a preview of platform risk, and I'm not convinced most users understand what they're authorizing when an agent holds their accounts open.

Common pitfalls

Building on this stack has a few predictable failure modes.

Running parallel agent threads like free compute. Every worker is a full session with its own model and effort setting. Claude's own announcement warns that projects can reach usage limits faster, and people who run them report the same. Set per-thread model and effort levels explicitly, and watch project-level usage before you fan out.

Giving the agent credentials without an approval gate. Muse's design is the reference: hard confirmations on payments and email, credentials kept out of the model's reach. Amazon blocked Muse partly over how it stores and scrapes account data. If you're building a consumer agent, build the confirmation step in from day one, because a platform will eventually force you to.

Owning integrations you could route through a gateway. Wiring up SEO, enrichment, ads, and social APIs one vendor at a time means holding a key ring that grows weekly. A relay proxy survives upstream API changes because it doesn't model the upstream. If a provider changes its contract, your proxy still passes traffic through.

Forgetting that coordination needs shared memory. Multi-threaded delegation without a shared context store means re-explaining project state in every thread. Claude Projects treats shared memory as a core feature for exactly this reason. If you're building orchestration, treat the memory store as part of the architecture, not a cache.

Self-hosting a tool registry without a persistent secret key. treg's docs warn that an empty TREG_SECRET_KEY mints an ephemeral key, and secrets won't survive a restart. Teams that skip this lose every registered credential the first time the server restarts. Set a real Fernet key and store it somewhere safe.

The shift has a single strategic fact underneath it: the moat is the approval list. The product that owns the confirmation step, where you approve or reject what an agent already did, owns the workflow. Grok Bot, Muse, Claude Tag, and the rumored Aeon are all fighting for that seat. The agent executes. The human still decides.

The bottom line

If you're building an internal orchestration layer for a team, adopt the coordinator-plus-threads pattern: one thread directs, workers run on their own branches, and overlapping edits resolve as merge conflicts. Shared memory across threads is the difference between a real project and a pile of sessions.

If you're shipping an agent that needs paid third-party tools, stand up a credential gateway instead of accumulating vendor accounts. Register team keys server-side so your agent holds one token, and make your own credentials take priority over shared ones. treg's hosted service or a self-hosted instance is a working starting point.

If you're launching a consumer agent app, plan for the trust bottleneck before you hit it. Hard confirmations on money and messages, no raw credentials to the model, and expect platform pushback. Amazon already blocked Muse over this, and OpenAI's Aeon will put the same questions in front of a billion ChatGPT users.