SOAT vs LangChain / LangGraph

LangChain / LangGraph is an agent framework (MIT (LangChain, LangGraph); LangSmith and LangGraph Platform are commercial, self-hosted or managed). SOAT is agent infrastructure (Apache-2.0, self-hosted). Of the 15 capabilities the benchmark tracks, LangChain / LangGraph covers 5 natively and SOAT 12.

At a glance

	LangChain / LangGraph	SOAT
Type	an agent framework	agent infrastructure
License	MIT (LangChain, LangGraph); LangSmith and LangGraph Platform are commercial	Apache-2.0
Deployment	self-hosted or managed	self-hosted
Native capabilities	5 of 15	12 of 15
Last verified	2026-08-14	2026-08-14

Where each one leads

• LangChain / LangGraph has no native capability that SOAT lacks.
• SOAT is native where LangChain / LangGraph is not: identity & governance, observability, data & secrets, evaluation, multi-tenancy, declarative deployment, versioning & rollout.

What LangChain / LangGraph is

One stack from one vendor, rated together: LangChain for standardized model interfaces and the largest third-party integration catalog, LangGraph for durable stateful agent graphs, the LangGraph Platform Agent Server for assistants, threads, runs, and cron, and the commercial LangSmith for tracing and evals. The libraries are MIT and run wherever you host them; tracing, evals, and the hosted server are paid products. LangChain / LangGraph documentation.

Capability by capability

Agent runtime

Agent loop, sessions, and generation lifecycle.

• LangChain / LangGraph: Native. LangChain's agent abstractions on top of LangGraph's graph runtime, which executes stateful agent loops with durable execution and resumes from a checkpoint after a failure. (source)
• SOAT: Native. Agents, sessions, chats, and generations with full lifecycle tracking. (source)

Orchestration

Multi-step pipelines, workflows, and triggers.

• LangChain / LangGraph: Native. Graphs mix deterministic and model-driven steps for multi-step and multi-agent workflows, and the Agent Server exposes assistants, threads, runs, and cron jobs over HTTP. (source)
• SOAT: Native. DAG orchestrations, workflow state machines, durable tasks, and triggers (manual, webhook, schedule). (source)

Knowledge & memory

Documents, embeddings, semantic search, and recall.

• LangChain / LangGraph: Native. Vector store, retriever, and embedding abstractions over a large integration catalog, plus a cross-thread Store with optional semantic search. The storage engines are third-party, and neither library ships a document ingestion or chunking pipeline of its own. (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.

• LangChain / LangGraph: Native. Tool-calling abstractions and hundreds of third-party integrations; MCP servers connect through the separate langchain-mcp-adapters package. (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.

• LangChain / LangGraph: Partial. Real approval gates via interrupts, and the Platform accepts custom auth handlers with resource filters — but the handlers are yours to write, and there is no quota enforcement, policy language, or audit log. (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.

• LangChain / LangGraph: Partial. Deep tracing and monitoring through LangSmith, a separate commercial product enabled by an environment variable rather than part of either library. (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.

• LangChain / LangGraph: Absent. No managed file storage and no encrypted secrets store; persistence stops at checkpointers and the key-value Store, and credentials are the host application's problem.
• SOAT: Native. File storage over local/S3/GCS backends and encrypted secrets storage. (source)

Evaluation

Datasets, scorers, and eval-gated improvement.

• LangChain / LangGraph: Partial. Datasets, evaluators, and experiment tracking live in the commercial LangSmith product, with the open-source openevals utilities alongside it; nothing gates a deployment on a result. (source)
• SOAT: Native. Datasets, scorers, and scored runs; eval-gated promotion of agent versions. (source)

Channels

Built-in gateways to messaging platforms and UIs.

• LangChain / LangGraph: Via plugin. No first-party messaging gateway and no bundled chat UI — the Agent Server speaks HTTP, and Slack or Discord delivery comes from community integrations or the host application. (source)
• 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.

• LangChain / LangGraph: Via plugin. Sandboxed execution arrives as integration tools (E2B, Riza, Bearly) rather than a runtime either library operates. (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.

• LangChain / LangGraph: Native. interrupt() checkpoints graph state and pauses a node indefinitely; Command(resume=value) re-invokes the same thread. HumanInTheLoopMiddleware wraps that in an interrupt_on map of tool names with approve, edit, and reject decisions. (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.

• LangChain / LangGraph: Partial. Agent Server auth handlers can stamp owner metadata onto threads, runs, and assistants and filter reads by it, but there is no tenant or workspace object — the isolation is whatever those handlers implement. (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.

• LangChain / LangGraph: Partial. langgraph.json declares the graphs, dependencies, and environment of a single deployed application. There is no plan and apply step and no dependency graph across resources. (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.

• LangChain / LangGraph: Partial. Each assistant update creates a new version that can be promoted to active or rolled back; there is no canary rollout and no eval-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.

• LangChain / LangGraph: Via plugin. The separate Deep Agents package exposes a skills parameter for procedural memory whose skill files an agent can write and edit itself. Core LangChain and LangGraph have no equivalent — the Store persists data, not reusable skills. (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.