SandBase MA vs Claude MA vs DeepSeek Harness (2026)
Three-way comparison of SandBase Managed Agents, Claude Managed Agents, and DeepSeek Harness covering architecture, pricing, and data ownership.
TL;DR: SandBase Managed Agents is what you get if Claude Managed Agents was open-source, local-first, and model-agnostic. It offers CMA-compatible API surface you can run on your own hardware with any model. DeepSeek Harness takes a plugin-everything approach but lacks production runtime features. CMA remains the polished hosted option if you’re all-in on Claude and don’t mind vendor lock-in.
The Landscape in August 2026
The agent runtime space has split into three camps: hosted-proprietary (Claude Managed Agents), open-source-runtime (SandBase MA), and open-source-framework (DeepSeek Harness). Each makes fundamentally different trade-offs. This article breaks them down so you can pick the right tool for your stack.
For a deeper two-way comparison, see our DeepSeek Harness vs Claude Managed Agents analysis.
Architecture Overview
SandBase Managed Agents — open-source, CMA-compatible, model-agnostic.
Anthropic’s “Decoupling the brain from the hands” — the architecture behind CMA.
DeepSeek Harness — everything-is-a-plugin architecture with Cordis meta-framework.
Claude Managed Agents (CMA)
┌─────────────────────────────────────────────────┐
│ Anthropic Cloud │
│ │
│ ┌─────────┐ ┌─────────┐ ┌──────────────┐ │
│ │ Brain │──▶│ Hands │──▶│ Sandbox │ │
│ │ (Claude)│ │ (Tools) │ │ (Cloud VM) │ │
│ └─────────┘ └─────────┘ └──────────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────┐ ┌──────────────────┐ │
│ │ Dreaming│ │ Session State │ │
│ │(Memory) │ │ (Anthropic DB) │ │
│ └─────────┘ └──────────────────┘ │
│ │
└─────────────────────────────────────────────────┘
▲
│ HTTPS
│
[Your App / SDK]CMA decouples brain (model inference), hands (tool execution), and session management. This architecture dropped p50 TTFT by 60% and p95 by 90%. But everything runs on Anthropic’s infrastructure.
SandBase Managed Agents
┌─────────────────────────────────────────────────────┐
│ Your Infrastructure (localhost / k8s) │
│ │
│ ┌────────────────────────────────────────────────┐ │
│ │ SandBase MA Runtime │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌─────────────┐ │ │
│ │ │Loop Eng. │ │ /v1 API │ │ Console │ │ │
│ │ │(agnostic)│ │(CMA-compat)│ │(:3000 Web) │ │ │
│ │ └────┬─────┘ └──────────┘ └─────────────┘ │ │
│ │ │ │ │
│ │ ┌────▼─────────────────────────────────────┐ │ │
│ │ │ SQLite (agents│sessions│vaults│memory) │ │ │
│ │ └─────────────────────────────────────────-┘ │ │
│ └────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────┐ │
│ │ Sandbox Backend (choose one) │ │
│ │ • Local process │ │
│ │ • Docker (per-session containers) │ │
│ │ • Kubernetes (kubectl exec/cp) │ │
│ │ • Self-hosted worker queue │ │
│ └──────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────┐ │
│ │ Model Provider (choose any) │ │
│ │ • OpenAI • Anthropic • Ollama/vLLM │ │
│ └──────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────┘SandBase MA is a local-first runtime. You own the process, the data (SQLite), and the sandbox. The /v1 API is CMA-compatible, meaning you can point the Anthropic SDK at localhost and it just works.
DeepSeek Harness
┌─────────────────────────────────────────────┐
│ DeepSeek Harness │
│ │
│ ┌────────────────────────────────────────┐ │
│ │ Cordis Meta-Framework │ │
│ │ ┌────────┐ ┌────────┐ ┌───────────┐ │ │
│ │ │Plugin A│ │Plugin B│ │Plugin ... │ │ │
│ │ └────────┘ └────────┘ └───────────┘ │ │
│ └────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────▼──────────────────────┐ │
│ │ Session Log (append-only) │ │
│ │ Trajectory View │ │
│ └────────────────────────────────────────┘ │
│ │
│ Modes: Standard │ PTC │ Minimal │ Creative │
└──────────────────────────────────────────────┘DeepSeek Harness uses Cordis, where everything (model providers, tools, modes) is a plugin. It’s flexible but early-stage (v0.1 developer preview). No built-in sandboxing, no credential vaults, no production runtime primitives.
Comparison Table
| Feature | SandBase MA | Claude MA (CMA) | DeepSeek Harness |
|---|---|---|---|
| Hosting | Self-hosted (local, Docker, K8s) | Anthropic Cloud | Self-hosted |
| Model Support | Any (OpenAI, Anthropic, Ollama, vLLM) | Claude only | Any (via plugins) |
| API Compatibility | CMA-compatible /v1 | Native | Custom plugin API |
| Sandbox | Local process, Docker, K8s, worker queue | Cloud VM (or self-hosted) | None built-in |
| Pricing | Free (you pay model provider) | Tokens + runtime rate | Free (you pay model provider) |
| Data Ownership | Full (SQLite on your disk) | Anthropic-managed | Full (local append-only log) |
| Maturity | 559 stars, 127 commits, production-usable | Beta since Apr 2026, battle-tested infra | 18.5k stars, v0.1 dev preview |
| Extensibility | MCP toolsets, skill packages, YAML agents | Vaults, multiagent, scheduled deployments | Everything-is-a-plugin (Cordis) |
| Memory | SQLite-backed memory store | Dreaming (built-in memory synthesis) | None built-in |
| Session Management | Resumable SSE, replay/debug | Decoupled session architecture | Append-only trajectory log |
| CLI | init, start, list, reload, chat, template | API/Dashboard only | Basic CLI |
| License | Apache-2.0 | Proprietary | MIT |
When to Choose Each
Choose SandBase MA when:
- You need CMA’s API surface but can’t send data to Anthropic’s cloud
- You want to swap models without rewriting agent logic (today Claude, tomorrow GPT-5, next week a local Llama)
- You need sandbox isolation options beyond cloud VMs (Docker per-session, K8s pods)
- Regulatory or compliance requirements mandate data stays on-premises
- You want a single SQLite file you can back up, inspect, and version-control
- You’re already using the Anthropic SDK and want a drop-in local backend
Choose Claude Managed Agents when:
- You’re all-in on Claude models and want the lowest-latency hosted experience
- You need built-in multiagent orchestration and scheduled deployments without building infrastructure
- Your team prefers a managed service over running your own runtime
- The 60% TTFT improvement from decoupled architecture matters to your UX
- You’re okay with Anthropic-managed data and per-token + runtime pricing
Choose DeepSeek Harness when:
- You want maximum architectural flexibility through plugin composition
- You’re building a research prototype or creative coding tool, not a production service
- You want the largest community (18.5k stars) and expect rapid plugin ecosystem growth
- You need multiple reasoning modes (Standard, PTC, Minimal, Creative) out of the box
- You don’t need sandboxing, credential vaults, or production runtime features yet
For more context on DeepSeek Harness, see our developer preview breakdown.
Migration Path: CMA → SandBase MA
If you’re currently using Claude Managed Agents through the Anthropic SDK, migration is straightforward. SandBase MA exposes a CMA-compatible /v1 API. You change the base URL and you’re done.
Step 1: Start SandBase MA
npx managed-agents init
npx managed-agents start
# Runtime listening on http://localhost:3000
# API available at http://localhost:3000/v1Step 2: Point the Anthropic SDK at localhost
import Anthropic from "@anthropic-ai/sdk";
// Before: hitting Anthropic's cloud
// const client = new Anthropic();
// After: pointing at SandBase MA local runtime
const client = new Anthropic({
baseURL: "http://localhost:3000/v1",
apiKey: "your-local-api-key", // configured in SandBase MA vault
});
// Same API surface — create an agent, start a session
const agent = await client.agents.create({
name: "code-reviewer",
model: "claude-sonnet-4-20250514", // or "openai/gpt-4o" or "ollama/llama3"
tools: [
{ type: "file_read" },
{ type: "file_write" },
{ type: "shell" },
],
});
const session = await client.agents.sessions.create(agent.id, {
environment: "docker", // SandBase MA sandbox backend
});
// Stream responses with resumable SSE
const stream = await client.agents.sessions.stream(session.id, {
messages: [{ role: "user", content: "Review the PR diff in /workspace" }],
});
for await (const event of stream) {
if (event.type === "content_block_delta") {
process.stdout.write(event.delta.text);
}
}Step 3: Configure your model provider
In SandBase MA’s settings, configure whichever model vendor you want:
# .managed-agents/settings.yaml
workspace:
model:
vendor: anthropic # or: openai, ollama, vllm
model: claude-sonnet-4-20250514
endpoint: https://api.anthropic.com # or http://localhost:11434 for Ollama
sandbox:
backend: docker # or: local, kubernetes, worker-queue
memory:
enabled: true
backend: sqliteThe key insight: your application code doesn’t change. Only the runtime configuration does. This means you can test locally with Ollama, stage with GPT-4o, and run production with Claude, all without touching your agent logic.
FAQ
Can SandBase MA handle the same workloads as Claude Managed Agents?
SandBase MA targets the same workload profile: long-running agents with tool use, file manipulation, and code execution. The difference is you provide the compute. For latency-sensitive workloads, CMA’s decoupled architecture may still have an edge because Anthropic optimizes the full stack. But for data-sensitive or cost-sensitive workloads, SandBase MA running on your own GPUs or with cheaper model providers can be significantly more economical.
Is DeepSeek Harness production-ready?
No. It’s a v0.1 developer preview. It has no built-in sandboxing, no credential management, and no persistence layer beyond append-only session logs. It’s excellent for prototyping and research but you’d need to build production infrastructure around it. See our open-source agent framework comparison for alternatives.
What happens to my data with each option?
- SandBase MA: Everything in a local SQLite database. You own it, back it up, delete it.
- CMA: Stored on Anthropic’s infrastructure. Subject to their data retention policies.
- DeepSeek Harness: Local append-only logs. No structured persistence layer.
Can I use SandBase MA with models other than Claude?
Yes. SandBase MA is model-agnostic. Configure any OpenAI-compatible endpoint (Ollama for local models, vLLM for self-hosted, or OpenAI/Anthropic APIs directly). Your agent definitions stay the same regardless of which model backs them.
How does extensibility compare?
- SandBase MA: MCP toolsets, permission policies, skill packages, YAML agent definitions. Extend through standard interfaces.
- CMA: Built-in features (multiagent, scheduling, dreaming). Extend through Anthropic’s API.
- DeepSeek Harness: Everything is a Cordis plugin. Maximum flexibility, minimum guardrails.
Bottom Line
The agent runtime you choose depends on one question: where do you want the control boundary?
| Control | SandBase MA | CMA | DeepSeek Harness |
|---|---|---|---|
| Model choice | You | Anthropic | You |
| Data location | You | Anthropic | You |
| Sandbox infra | You | Anthropic | You (DIY) |
| Runtime ops | You | Anthropic | You (DIY) |
| Production features | Built-in | Built-in | Build yourself |
SandBase MA sits in the sweet spot: production-ready runtime features (sandboxing, vaults, memory, SSE streaming) without giving up control over your models, data, or infrastructure. It’s the open-source runtime layer that CMA’s architecture proved is necessary, now running on your terms.
Links: