# Claude Developer Platform vs SOAT: Feature Comparison

> Claude Developer Platform and SOAT compared on 15 agent capabilities, 7 vs 12 native, each rating linked to its source.

# SOAT vs Claude Developer Platform

Claude Developer Platform is a managed agent platform (Proprietary, managed). SOAT is agent infrastructure (Apache-2.0, self-hosted). Of the 15 capabilities the [benchmark](/benchmark) tracks, Claude Developer Platform covers 7 natively and SOAT 12.

## At a glance

| | Claude Developer Platform | SOAT |
| --- | --- | --- |
| Type | a managed agent platform | agent infrastructure |
| License | Proprietary | Apache-2.0 |
| Deployment | managed | self-hosted |
| Native capabilities | 7 of 15 | 12 of 15 |
| Last verified | 2026-08-17 | 2026-08-14 |

## Where each one leads

- **Claude Developer Platform** is native where SOAT is not: code execution.
- **SOAT** is native where Claude Developer Platform is not: orchestration, knowledge & memory, identity & governance, evaluation, declarative deployment, versioning & rollout.

## What Claude Developer Platform is

Anthropic's agent stack on platform.claude.com: the Messages API and tool use, plus Managed Agents — versioned agent configs, per-session containers Anthropic provisions, an SSE event stream, MCP servers with vault-held credentials, skills, memory stores, and cron-scheduled deployments. Workspaces and the Admin API scope keys and resources; the control plane is Anthropic-operated, though tool execution can move to a self-hosted sandbox. [Claude Developer Platform documentation](https://platform.claude.com/).

## Capability by capability

### Agent runtime

_Agent loop, sessions, and generation lifecycle._

- **Claude Developer Platform: Native.** Managed Agents runs the loop on Anthropic's orchestration layer: a persisted, versioned agent config plus stateful sessions with an event stream, automatic context compaction, and prompt caching. ([source](https://platform.claude.com/docs/en/managed-agents/overview))
- **SOAT: Native.** Agents, sessions, chats, and generations with full lifecycle tracking. ([source](https://soat.ttoss.dev/docs/modules/agents))

### Orchestration

_Multi-step pipelines, workflows, and triggers._

- **Claude Developer Platform: Partial.** A coordinator agent delegates to a roster of subagents in parallel threads, and scheduled deployments fire sessions on a cron cadence — but there is no declarative multi-step pipeline or DAG the platform executes. ([source](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration))
- **SOAT: Native.** DAG orchestrations, workflow state machines, durable tasks, and triggers (manual, webhook, schedule). ([source](https://soat.ttoss.dev/docs/modules/orchestrations))

### Knowledge & memory

_Documents, embeddings, semantic search, and recall._

- **Claude Developer Platform: Partial.** Memory stores persist versioned text documents across sessions, mounted into the container as a filesystem the agent reads and writes. There is no document ingestion pipeline, embeddings endpoint, or semantic search — retrieval is file reads, grep, and the hosted web search tool. ([source](https://platform.claude.com/docs/en/managed-agents/memory))
- **SOAT: Native.** Documents with per-chunk embeddings, named memories, unified semantic search, and ingestion rules for PDFs, images, and audio. ([source](https://soat.ttoss.dev/docs/modules/knowledge))

### Tools & integration

_Tool calling, MCP, providers, and webhooks._

- **Claude Developer Platform: Native.** Client-side tool use with strict schemas, Anthropic-hosted server tools (web search, web fetch, code execution), remote MCP servers declared on the agent, and HMAC-signed webhooks for session state changes. ([source](https://platform.claude.com/docs/en/managed-agents/mcp-connector))
- **SOAT: Native.** HTTP, MCP, client, and agent-to-agent tools; model routes with failover; webhooks; any LLM provider. ([source](https://soat.ttoss.dev/docs/modules/tools))

### Identity & governance

_IAM, guardrails, approvals, quotas, and audit._

- **Claude Developer Platform: Partial.** The Admin API manages org members, five org roles, workspace membership, and API keys; per-tool permission policies gate execution and session budgets cap spend. Authorization is workspace-scoped rather than a per-resource policy language, and there is no configurable guardrail model — content safeguards are built into the models. ([source](https://platform.claude.com/docs/en/manage-claude/admin-api))
- **SOAT: Native.** AWS-inspired IAM, actors, scoped API keys, guardrails, human approvals, quotas, and an append-only audit log. ([source](https://soat.ttoss.dev/docs/modules/iam))

### Observability

_Traces, activity, usage, and failure queues._

- **Claude Developer Platform: Native.** Every session exposes a replayable event history with model-request spans and per-request token usage, a live Console trace view, plus the Usage and Cost API and the Compliance API activity feed. Webhook delivery is best-effort — three attempts, then dropped, with no dead-letter queue to inspect. ([source](https://platform.claude.com/docs/en/managed-agents/observability))
- **SOAT: Native.** Traces of every tool call and model response, activity feed, usage/cost tracking, and an exceptions queue. ([source](https://soat.ttoss.dev/docs/modules/traces))

### Data & secrets

_File storage and encrypted secrets._

- **Claude Developer Platform: Native.** The Files API stores inputs and captures session outputs, and vaults hold credentials the sandbox never sees: MCP OAuth tokens refreshed automatically, and environment-variable secrets substituted into outbound requests at egress with a per-credential host allowlist. ([source](https://platform.claude.com/docs/en/managed-agents/vaults))
- **SOAT: Native.** File storage over local/S3/GCS backends and encrypted secrets storage. ([source](https://soat.ttoss.dev/docs/modules/files))

### Evaluation

_Datasets, scorers, and eval-gated improvement._

- **Claude Developer Platform: Partial.** An outcome states what done looks like and a separate grader scores each iteration against a rubric, looping until it passes or hits max_iterations. That is per-session grading, not a dataset and scorer API, and nothing gates a version promotion on it. ([source](https://platform.claude.com/docs/en/managed-agents/define-outcomes))
- **SOAT: Native.** Datasets, scorers, and scored runs; eval-gated promotion of agent versions. ([source](https://soat.ttoss.dev/docs/modules/evaluations))

### Channels

_Built-in gateways to messaging platforms and UIs._

- **Claude Developer Platform: Absent.** No gateway for developer-built agents to Slack, WhatsApp, Telegram, or Discord, and no embeddable chat UI; integrations reach the agent through the API or MCP. Anthropic ships first-party Slack surfaces for its own Claude apps, which is a different thing from a channel gateway an agent you define can be bound to.
- **SOAT: Absent.** Surfaces are REST, MCP, CLI, and SDK — no built-in gateways to messaging platforms like Slack, WhatsApp, or Telegram.

### Code execution

_Sandboxed code or terminal runtimes for agents._

- **Claude Developer Platform: Native.** Every session gets an isolated container where bash, file operations, and code run, and the Messages API exposes code execution as a hosted server tool. A self-hosted sandbox moves that execution to infrastructure you control via an outbound-polling worker. ([source](https://platform.claude.com/docs/en/managed-agents/permission-policies))
- **SOAT: Absent.** Tool types are HTTP, MCP, client, and agent-to-agent — no built-in sandboxed code or terminal runtime.

### Human-in-the-loop

_Pausing a run for human approval, then resuming it._

- **Claude Developer Platform: Native.** A tool carrying the always_ask permission policy pauses the session at the call, which idles awaiting a tool-confirmation event; the reply allows or denies, and a denial message is surfaced back to the agent so it can change approach. ([source](https://platform.claude.com/docs/en/managed-agents/permission-policies))
- **SOAT: Native.** Approvals are a first-class human-decision queue with frozen evidence, and guardrails classify each tool call so risky actions pause for a decision. ([source](https://soat.ttoss.dev/docs/modules/approvals))

### Multi-tenancy

_Projects or workspaces scoping resources and permissions._

- **Claude Developer Platform: Native.** Workspaces scope API keys, rate limits, spend, and agent resources — agents, sessions, vaults, and memory stores all belong to one workspace — with membership and roles assignable per workspace through the Admin API. ([source](https://platform.claude.com/docs/en/manage-claude/workspaces))
- **SOAT: Native.** Projects are multi-tenant namespaces scoping every resource, with IAM policies and quotas enforced per project. ([source](https://soat.ttoss.dev/docs/modules/projects))

### Declarative deployment

_Templates that provision agent resources as one stack._

- **Claude Developer Platform: Partial.** Agents and environments are checked in as YAML and applied from CI with the ant CLI, using a version field for optimistic concurrency. Each resource is applied on its own — there is no dependency-graph plan and apply over a stack, and no teardown that unwinds what a failed apply created. ([source](https://platform.claude.com/docs/en/cli-sdks-libraries/cli/quickstart))
- **SOAT: Native.** Formations provision providers, memories, tools, agents, orchestrations, and webhooks from one template, resolving refs into a dependency graph with tracked operations. ([source](https://soat.ttoss.dev/docs/modules/formations))

### Versioning & rollout

_Agent versions, canary rollout, gated promotion._

- **Claude Developer Platform: Partial.** Every agent update creates an immutable, append-only version, and a session pins one by number — so rollback is pinning new sessions back to a known-good version while running sessions keep theirs. There are no aliases, no traffic split for a canary, and no gated promotion. ([source](https://platform.claude.com/docs/en/managed-agents/agent-setup))
- **SOAT: Native.** Every config change is archived as an append-only agent version, with canary rollout to a slice of traffic and eval-gated promotion. ([source](https://soat.ttoss.dev/docs/tutorials/agent-versioning-and-canary-rollout))

### Skill learning

_Agents authoring reusable skills from their own experience._

- **Claude Developer Platform: Partial.** Skills are versioned resources an agent can read, and a read-write memory store lets it record learnings that later sessions mount — but promoting experience into a published skill version is a step you drive through the Skills API, not a loop the platform runs. ([source](https://platform.claude.com/docs/en/managed-agents/skills))
- **SOAT: Absent.** Memories and knowledge store retrievable context, but agents do not author or refine reusable skills from their own experience.

## How this is rated

Each rating comes from the public documentation linked beside it: **Native** is built in, **Via plugin** needs an add-on, **Partial** covers part of the capability, **Absent** is not offered. Every solution side by side is on the [benchmark](/benchmark). A rating that is out of date is a bug: [open an issue](https://github.com/ttoss/soat/issues).