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 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.

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)
• SOAT: Native. Agents, sessions, chats, and generations with full lifecycle tracking. (source)

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)
• SOAT: Native. DAG orchestrations, workflow state machines, durable tasks, and triggers (manual, webhook, schedule). (source)

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)
• SOAT: Native. Documents with per-chunk embeddings, named memories, unified semantic search, and ingestion rules for PDFs, images, and audio. (source)

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)
• SOAT: Native. HTTP, MCP, client, and agent-to-agent tools; model routes with failover; webhooks; any LLM provider. (source)

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)
• SOAT: Native. AWS-inspired IAM, actors, scoped API keys, guardrails, human approvals, quotas, and an append-only audit log. (source)

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)
• SOAT: Native. Traces of every tool call and model response, activity feed, usage/cost tracking, and an exceptions queue. (source)

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)
• SOAT: Native. File storage over local/S3/GCS backends and encrypted secrets storage. (source)

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)
• SOAT: Native. Datasets, scorers, and scored runs; eval-gated promotion of agent versions. (source)

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)
• 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)
• 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)

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)
• SOAT: Native. Projects are multi-tenant namespaces scoping every resource, with IAM policies and quotas enforced per project. (source)

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)
• SOAT: Native. Formations provision providers, memories, tools, agents, orchestrations, and webhooks from one template, resolving refs into a dependency graph with tracked operations. (source)

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)
• 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)

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)
• 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. A rating that is out of date is a bug: open an issue.