Anthropic Built an Agentic OS in Claude Code: The Architecture Breakdown & Open-Source Alternative
If you spent the last 6 months hand-building an agentic OS with memory layers, brand context, and team permissions on top of LLMs, Anthropic just validated your vision by integrating their own native version into Claude Code Projects. Here is how their orchestrator and sub-threads work, where closed cloud models fall short, and how to run a private, multi-model Agentic OS locally.
What is Anthropic's New Claude Code Projects Agentic OS?
Claude Code Projects (Agentic OS) is Anthropic's native multi-agent orchestration architecture released for Claude Code. Unlike legacy Claude Projects (which were isolated chat sessions with manual file attachments), the new architecture transforms a project into a single long-running orchestrator conversation that does not perform code edits directly. Instead, Claude acts as a team lead, delegating tasks to autonomous background cloud sub-threads running on isolated branches.
Each sub-thread automatically inherits shared project context, a synchronized memory.md decision log, loaded skills, plugins, and background Retrieval-Augmented Generation (RAG) to prevent hitting the 200,000-token context wall. Additionally, Team and Enterprise tiers receive organizational permission gates (view-only vs edit access).
From Isolated Folders to Autonomous Delegators: What Changed?
For the past year, anyone using Claude Projects for engineering hit the same frustrating structural hurdles. You created a project folder, uploaded documentation (style guides, brand guidelines, API references), set project instructions, and began chatting. But every chat was an isolated island:
- •Isolated Chat Silos: Session A could not communicate with Session B; decisions made in one thread were completely invisible to others.
- •The Context Wall: As codebases grew, loading all files into prompt context rapidly exhausted the 200k token limit, forcing users to prune files or manually reset conversations.
- •Manual Orchestration: The developer had to act as the human coordinator, manually running one task, opening a new tab for task two, and pasting results back and forth.
- •Single Delegator Orchestrator: One master conversation acts as the team lead. Claude directs the work, deciding when to spin off background threads.
- •Cloud Sub-Threads on Git Branches: Sub-tasks execute autonomously in remote cloud sandboxes and keep running even after you close your laptop.
- •Unified
memory.md& Library: Decisions, architecture choices, and generated artifacts persist across all threads automatically.
The 4 Architectural Pillars Powering Claude Code Projects
1. Orchestrator + Sub-Thread Delegation
As Anthropic states, "Threads do the work, Claude directs the work." You brief the top-level orchestrator with a high-level goal (e.g., "Implement OAuth2 authentication and migrate unit tests"). Rather than running tools directly in the primary conversation, Claude evaluates open threads, determines if an existing branch can handle it, or spawns a new cloud sub-agent with its own dedicated scratchpad.
2. Shared memory.md & Brand Context Layer
Every spawned sub-thread automatically pulls in the project repositories, custom instructions, and a shared memory.md document. This file captures historical decisions, naming conventions, and constraints. When Thread A changes an API response schema, that decision is logged so Thread B does not build against stale contracts.
3. Background Project RAG (Context Window Pruning)
To prevent context degradation near the 200,000-token threshold, Anthropic introduces a background Project Knowledge Search Tool. Instead of brute-force stuffing every repository file into the active attention window, it dynamically searches and injects only the necessary passages, returning to full context only when total tokens drop below safety margins.
4. Team Permissions & Enterprise Governance
Transforming Claude from a personal tool into a team operating system. Team and Enterprise plans gain organization-wide sharing, email-based invites, and distinct permission levels: Read-Only members can inspect agent decisions and outputs without triggering tool mutations, while Edit members can direct orchestrator goals.
5 Reasons Why Hand-Built / Local Agentic OS is NOT Dead
While Anthropic's product validates the "Agentic OS" thesis, their closed, proprietary implementation introduces severe friction points for professional engineering teams:
Because Claude Code Projects run entirely in Anthropic's remote cloud containers, they cannot see your local filesystem, run native scripts against local hardware, or interact with private databases hosted on localhost:5432 or inside secure company VPCs without complex tunneling.
Every sub-thread spawned by the orchestrator runs full LLM inference loops in the cloud. For simple tasks (like renaming an interface or formatting a file), running multiple cloud sub-threads rapidly burns through monthly usage tiers, rate limits, and expensive token budgets.
What happens when you want to use Google Gemini 2.0 Flash for low-latency searches, OpenAI GPT-4o for complex JSON validation, or free, private open-weight models (like DeepSeek R1 or Llama 3) via Ollama? Claude Code Projects only supports Anthropic models.
In the initial Claude Code Projects rollout, the top-level orchestrator conversation cannot directly invoke Model Context Protocol (MCP) servers. External tool execution is delegated exclusively into isolated sub-threads, introducing architectural friction when the main planner needs immediate data lookup.
Real enterprise agent systems require company-specific knowledge graphs, strict deterministic phase state machines (preventing wild infinite loops), custom human-in-the-loop approval gates before destructive terminal commands, and private AST code editing engines. A generic UI cannot replace a dedicated codebase harness.
Feature Matrix: Claude Code Projects vs Smoke Monkey Harness
Compare Anthropic's proprietary cloud agentic OS with Smoke Monkey Harness—the open-source, local-first TypeScript agent runtime that gives you complete architectural ownership.
Execution Runtime
Runs entirely on Anthropic cloud containers. Cannot directly access local development servers, private localhost databases, or hardware devices.
Executes natively on the developer’s local machine or self-hosted Docker runner with direct access to local files, git history, and shell environments.
Model & Provider Agnosticism
Locked to Claude 3.5 Sonnet / Opus. Requires active Claude Pro, Team, or Enterprise subscription ($20 - $30+/user/month).
Unified provider abstraction. Seamlessly swap between Anthropic, Google Gemini, OpenAI, or 100% free local models like DeepSeek & Llama 3 via Ollama.
Orchestrator & Sub-Threads
Top-level conversation acts as orchestrator, spinning off sub-threads on isolated git branches in the cloud.
Isolated subcontexts with dedicated memory trees, automated AST patch verification, and 6-phase state machines (explore → plan → edit → verify → recover → complete).
Local Shell & AST Code Editing
Limited to cloud sandbox capabilities; cannot run your native Mac/Linux terminal scripts or local daemon background processes.
Direct local execution of run_command, git diff/status/commit, surgical chunk replace_file_content, and multi-replace file editing.
Persistent Memory & Context RAG
Auto-syncs memory.md across project sessions and uses background cloud RAG to prune prompt context near 200k limits.
Persistent session stores, rule/skill markdown discovery, and zero-token context compaction that prevents context-window bloat.
Model Context Protocol (MCP)
Main top-level orchestrator cannot directly access external MCP servers; only individual spawned threads can invoke connectors.
Ships with a built-in MCP stdio server. Connect all 24 tools and subcontexts directly into Claude Code CLI, Cursor, Windsurf, or Antigravity.
Human-in-the-Loop Permissions
Organizational access controls (Read-Only vs Edit), but limited runtime permission gating before destructive terminal or file modifications.
Deterministic permission guards: ask_permission for bash commands, confirm before destructive file writes, and streaming interactive prompts.
License & Cost
Proprietary SaaS product. Burns expensive Anthropic API/subscription tokens for all orchestrator and sub-thread steps.
Zero runtime dependencies, free open-source MIT license, zero monthly platform fees, runs on your own API keys or free local offline models.
Building Your Own Local Multi-Model Agentic OS with Smoke Monkey
With Smoke Monkey Harness, you do not have to wait for Anthropic to add local file access or pay monthly team seat fees. In under 20 lines of TypeScript, you can instantiate an agent runtime featuring:
import { createAgent, createSubcontext } from 'smoke-monkey-harness';// 1. Initialize your local Agentic Orchestratorconst orchestrator = createAgent({workspacePath: process.cwd(),provider: 'anthropic', // or 'openai', 'gemini', 'ollama'model: 'claude-3-5-sonnet-latest',maxLoops: 30,permissions: {run_command: 'ask', // The Three Pauses: pause before executing shell commandsreplace_file_content: 'allow', // Surgical AST code replacementsmanage_context: 'allow', // Background RAG and memory synchronization},});// 2. Delegate a sub-task into an isolated subcontext (equivalent to Claude cloud threads)const workerContext = createSubcontext({name: 'auth-migration-branch',inheritMemory: true, // Auto-syncs memory.md and agent instructionsisolatedGitBranch: 'feature/auth-oauth2',});// 3. Run the autonomous engineering loopconst result = await orchestrator.run({task: 'Audit the authentication module, migrate to OAuth2 PKCE, and verify test suite passes.',subcontext: workerContext,});console.log('Task Status:', result.status);console.log('Memory Updated:', result.memoryDelta);console.log('Git Diffs Created:', result.summary.filesModified);
Understanding Claude Code Projects & Agentic Architectures
Will Claude Code Projects replace open-source agent frameworks like Smoke Monkey Harness?
No. Anthropic’s update provides an opinionated cloud SaaS workflow specifically for Claude subscribers. However, production software engineering requires direct access to local developer machines, private VPC databases, multi-model flexibility (mixing Gemini, OpenAI, and local Ollama), deterministic loop guards, and complete privacy without recurring subscription costs. Smoke Monkey Harness provides the low-level, zero-dependency runtime to build tailored agentic systems with total sovereignty.
How does memory.md differ from subcontext memory in Smoke Monkey?
In Claude Code Projects, memory.md is a shared markdown document updated across threads. In Smoke Monkey Harness, memory is managed via structured hierarchical subcontexts. When an agent learns a rule or diagnoses an error during the recover phase, the memory delta is persisted to session storage and selectively retrieved via local hybrid RAG, ensuring zero token waste in future task iterations.
Can I use Smoke Monkey Harness tools directly inside Claude Code?
Yes! Smoke Monkey Harness ships with a native Model Context Protocol (MCP) stdio server (smoke-monkey-harness-mcp). You can attach it to Claude Code CLI with a single command: claude mcp add smoke-monkey npx -y smoke-monkey-harness-mcp. This gives Claude Code direct access to Smoke Monkey’s 24 engineering tools and deterministic subcontexts.
What happens when Claude Code cloud sub-threads hit an error?
In Claude Code, sub-threads use typical ReAct prompting. If the model encounters an unexpected terminal failure, it may loop or hallucinate workarounds, burning cloud tokens. Smoke Monkey Harness enforces a deterministic 6-phase state machine with an explicit recover phase and automated loop guards that cap retries, diagnose linter output, and pause for human confirmation before runaway loops occur.
Ready to Own Your Agentic Operating System?
Don't lock your software engineering pipeline into closed proprietary clouds. Install Smoke Monkey Harness today and build deterministic, multi-agent workflows across Claude, Gemini, GPT-4o, and local models.
npm install smoke-monkey-harness • MIT License • Zero Dependencies