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 updated. 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 AI company, working on the same problem, at the same time, without knowing about each other.

Here’s what that convergence means.

---

The Problem We Both Saw

Claude can code. That’s 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:

• Issue selection: which issue should the agent pick next? Priority? Readiness? Dependencies?
• Board management: moving cards between columns as state changes
• Branch strategy: creating branches, handling dependencies between issues
• Implementation: the actual coding (the easy part, ironically)
• Failure recovery: CI breaks, reviewers request changes, merge conflicts appear
• Merge safety: knowing when a PR is actually ready, not just green
• Sprint management: rolling over unfinished work, scoping to the current week
• Coordination: making sure multiple agents don’t step on each other

The model is the engine. But nobody had built the car.

This is the gap both of us saw. The AI can write code all day, but without a system to tell it which code to write, when to write it, and how to ship it safely, it’s just an expensive autocomplete that needs a human to push every button.

What I Built

I’ve written about the full architecture and implementation details separately. Here’s the short version.

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

The Implementer runs every hour. It scans a GitHub Projects V2 board for the highest-priority TODO issue in the current week’s milestone, ranks candidates by priority labels (p0 to p5) and spec quality, detects dependencies between issues, creates a branch, and hands everything to Claude Code CLI for a full autonomous session. Up to 500 turns over 90 minutes.

The Fixer runs every 30 minutes. CI failures, code review comments, merge conflicts. It gathers the full failure context and feeds it to Claude for autonomous repair. It only touches autoagent/* branches, never human work.

The Merger runs every 2 hours. It processes green PRs sequentially, because merging PR A can break PR B. Before each merge, Claude analyzes whether review feedback was actually addressed. Not keyword matching. Actual reasoning about whether the fix resolves the concern.

Two supporting workflows handle the rest: Board Sync keeps the project board accurate (PR opened → Ready for QA, merged → Done), and Week Rollover automates sprint management every Monday, creating milestones and carrying forward unfinished work.

The entire system is shell scripts and GraphQL queries. No framework, no SDK, no dependencies beyond gh, jq, and curl. After several weeks of running: 240 issues implemented, 232 PRs opened, 95% success rate.

What Anthropic Announced

Same day. April 8, 2026.

Claude Managed Agents is Anthropic’s answer to the same problem, but from the infrastructure side:

• Cloud-hosted Claude sessions running on Anthropic’s infrastructure. No runner to manage.
• Scheduled tasks via /schedule. Cron-based execution that runs even when your computer is off.
• Sandboxed execution. Isolated environments where Claude can write files, run commands, and iterate on work.
• Session persistence. Long-running sessions that survive disconnections, with checkpointing and error recovery.
• MCP tool access. Native GitHub, Sentry, Slack integration without shell scripting.
• Built-in orchestration harness. Tool routing, context management, failure recovery.

The architecture virtualizes three components: a Session (append-only log with durable context), a Harness (the loop that calls Claude and routes tool calls), and a Sandbox (the execution environment). Swap any implementation without disturbing the others.

This is genuinely impressive engineering. Sandboxed code execution, checkpointing, credential management, scoped permissions, end-to-end tracing. That’s months of infrastructure work, productized at standard API pricing plus $0.08 per session-hour.

Did I Get Sherlocked?

Partially. But the interesting part is which layer got Sherlocked.

Here’s the overlap:

Capability	Three-Body Agent	Claude Managed Agents
Run Claude on a cron schedule	GitHub Actions workflows	/schedule + Remote Tasks
Autonomous code implementation	Implementer workflow + CLI	Remote Tasks + GitHub MCP
Fix CI failures automatically	Fixer workflow	Remote Tasks (you write the prompt)
Sandboxed execution	GitHub Actions runner	Managed Agents sandbox
Session persistence	GitHub Actions logs	Built-in session storage
Notifications	Telegram integration (Slack, etc.)	Slack/GitHub MCP tools

Anthropic solved the infrastructure problem: How do I run Claude autonomously on a schedule with GitHub access?

That’s genuinely hard. And they productized all of it.

But here’s what Managed Agents doesn’t ship:

• Priority-based issue selection with spec quality weighting
• Dependency detection between issues (“Depends on: #123” → base branch on that PR)
• Multi-agent coordination: specialized workflows with deduplication and concurrency controls
• Sequential merge strategy with conflict-aware re-verification
• Review intelligence: Claude analyzing whether review feedback was actually addressed before merging
• Project board state machine (Todo → In Progress → Ready for QA → Done)
• Sprint automation: milestone creation, issue rollover, iteration management
• Safety boundaries: agents only touch autoagent/* branches, never human work

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.

Why the Same Day Matters

Agent infrastructure is being commoditized. Fast. Anthropic is building it. So is every major cloud provider. 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’re actually done (not just green), and keeping humans informed without keeping them involved.

That’s where the real work is now. And that’s what Three-Body Agent exists to figure out.

Complementary, Not Competitive

Here’s the punchline: Three-Body Agent could run on 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. Best of both worlds.

Anthropic built the platform. I built the workflow.

Try It

Three-Body Agent is MIT licensed on GitHub. Copy the workflows and prompts into your repo, update the prompts to your needs, configure your secrets, and let the three-body system do the rest.

For the full technical deep-dive, every workflow, prompt template, and design decision, see The Three-Body Agent: Orchestrating Agents with GitHub Actions and Claude Code.