Almost sherlocked by Anthropic

On April 8, 2026, I released Three-Body Agent. An autonomous development pipeline that picks GitHub issues, implements them with Claude, fixes its own CI failures, merges green PRs, and keeps the project board honest. No human in the loop.

The same day, Anthropic announced Claude Managed Agents. Cloud-hosted autonomous Claude sessions with sandboxed execution, scheduling, and GitHub integration.

A solo dev and a frontier lab, working the same problem at the same time, without knowing about each other.

Here is what that convergence means.

The problem we both saw

Claude can code. That has been true for a while. But “Claude can code” and “Claude ships features autonomously” are separated by a mountain of orchestration that nobody talks about.

To go from a GitHub issue to a merged PR without a human you need a queue (which issue should the agent pick next, with what priority, with what dependencies). You need branch and merge discipline, with rebasing for downstream issues. You need failure recovery for CI breaks, review feedback, and merge conflicts. You need a notion of “actually ready” that is more than “the green check turned green.” You need sprint management so the work scopes to the current week. You need coordination so multiple agents do not step on each other.

The model is the engine. Nobody had built the car. That is the gap both of us saw. Without that layer, an agent is an expensive autocomplete that needs a human to push every button.

What I shipped

Three-Body Agent is six GitHub Actions workflows that form a self-regulating pipeline. The name is borrowed from the orbital mechanics problem: three systems in constant gravitational pull, each producing stable results that none could achieve alone.

The Implementer runs every hour. It picks the highest-priority TODO issue in the current week’s milestone, ranks candidates by priority labels and spec quality, detects “Depends on: #N” relationships, and hands the work to Claude Code CLI for a 500-turn, ninety-minute session. The Fixer runs every thirty minutes, gathers the full context of any failure (CI logs, review comments, merge state), and asks Claude for a patch. The Merger runs every two hours and lands PRs that have actually cleared the gates, with Claude reading the conversation to confirm review feedback was addressed.

The whole thing is shell and GraphQL. No framework, no SDK, no dependencies beyond gh, jq, and curl. After several weeks: 240 issues implemented, 232 PRs opened, 95% success rate. The full architecture is documented in the Three-Body Agent deep dive.

What Anthropic shipped

Claude Managed Agents is the same problem solved from the infrastructure side. Cloud-hosted Claude sessions running on Anthropic’s metal. Cron scheduling via /schedule that fires even when your computer is off. Sandboxed execution with file write and shell access. Sessions that survive disconnections, with checkpointing. Native MCP tool access for GitHub, Sentry, Slack. A built-in orchestration harness that handles tool routing, context, and recovery.

This is real engineering. Sandboxed code execution, checkpointing, credential management, scoped permissions, end-to-end tracing. Months of infrastructure work, productized at standard API pricing plus a session-hour add-on.

Did I get sherlocked?

Partially. The interesting question is which layer.

Anthropic solved the infrastructure problem: how do I run Claude autonomously, on a schedule, with GitHub access, in a sandbox? They did it well, and they shipped a clean product around it.

What Managed Agents does not ship is the workflow layer that sits on top: priority-based issue selection with spec-quality tiebreaks, dependency detection between issues, multi-agent coordination, sequential merging with conflict-aware re-verification, review intelligence before merge, project-board state machine, sprint rollover, safety boundaries that keep agents off human branches.

Managed Agents gives you a Claude session that can do anything. Three-Body Agent gives you a pipeline that knows what to do, when to do it, and how to coordinate doing it safely.

Managed Agents is the engine. Three-Body Agent is the self-driving car around it.

Why the same day matters

Agent infrastructure is being commoditized. Fast. Anthropic is building it; every major cloud provider will too. Within a year, “run Claude on a cron with GitHub access” will be table stakes.

The value is moving up the stack. Running an agent is the solved part. The unsolved part is making agents work together without stepping on each other, knowing when they are actually done (not just green), and keeping humans informed without keeping them involved.

That is where the real work is now. It is where Three-Body Agent exists.

Complementary, not competitive

The punchline is that Three-Body Agent could run on top of Managed Agents.

Replace the GitHub Actions cron triggers with /schedule. Replace the runner environment with a managed sandbox. The workflow logic stays identical: the priority ranking, dependency detection, sequential merging, board state machine.

Or run both: Managed Agents for the Claude sessions, GitHub Actions for the orchestration. The model and the loop are separate concerns. Each layer can be the best version of itself, and you do not have to pick.

Anthropic built the platform. I built the workflow on top.