AgentScope 2.0 vs LangChain: An Engineering Comparison

AgentScope 2.0 and LangChain can both build a tool-using Agent. That fact does not help much with framework selection. The useful questions are how each framework represents state, where workflow control lives, what happens when a run is interrupted, and how much of the production stack your team wants from one ecosystem.

This comparison is for engineers who already know the basics of LLM calls, tool schemas, retrieval, and streaming. It compares AgentScope 2.0 with the current LangChain Agent API and the LangGraph runtime beneath it. Comparing AgentScope only with the langchain package would miss much of LangChain's execution model.

AgentScope's official release page lists the 2.0 release line, while its documentation covers ReActAgent, state and session management, pipelines, planning, tracing, and evaluation. LangChain's documentation describes create_agent as a higher-level Agent API built on LangGraph. LangGraph provides persistence, durable execution, streaming, and interrupts. APIs in both projects continue to change, so check the linked documentation before copying an example into production. AgentScope releases, AgentScope documentation, LangGraph overview

The short answer

AgentScope 2.0 is a good candidate when a Python team wants Agent concepts presented as one coherent toolkit. Its main path uses explicit objects such as ReActAgent, Toolkit, memory, formatter, pipeline, and plan modules. State management, AgentScope Studio, OpenTelemetry tracing, and a native evaluation package sit close to those abstractions.

LangChain is a good candidate when a team wants a wide integration surface or expects to model production control flow explicitly with LangGraph. create_agent offers a short entry point, middleware customizes the loop, and the returned Agent already runs on LangGraph. Teams can move down to StateGraph when the workflow needs visible nodes, edges, checkpoints, and interrupts. LangSmith adds a connected platform for tracing, evaluation, and deployment.

Neither choice removes the need to design tool boundaries, approval rules, evaluation data, or failure recovery.

A shared reference problem

Consider a research assistant with this job:

1. Search for sources related to a question.
2. Extract claims and keep the source URL with each claim.
3. Store current task progress so the run can resume.
4. Ask for approval before publishing the report.
5. Return a structured report with findings and citations.

The model and search API can be identical in both implementations. The difference is how the application organizes the loop and everything around it.

Core development model

AgentScope 2.0

AgentScope begins with an Agent object. Its built-in ReActAgent receives a model, formatter, toolkit, and memory. A Msg carries the sender name, role, content, and metadata. The framework treats Agent, memory, toolkit, and related modules as stateful objects that can participate in nested state save and restore. AgentScope key concepts, AgentScope ReActAgent

The code tends to read like object composition:

agent = ReActAgent(
    name="Researcher",
    sys_prompt=research_prompt,
    model=model,
    formatter=formatter,
    toolkit=toolkit,
    memory=memory,
)

result = await agent(user_message, structured_model=ResearchReport)

This approach is direct when your design revolves around named Agents that exchange messages and own their working state.

LangChain and LangGraph

LangChain begins with models, tools, middleware, and create_agent. The Agent loop is compiled onto LangGraph, so it can be invoked as a runnable or inserted as a node in a larger graph. Short-term memory lives in Agent state, and middleware can inspect or change model calls, tool calls, state, prompts, and output handling. LangChain Agents, LangChain middleware

The higher-level path is compact:

agent = create_agent(
    model=model,
    tools=[search_sources, publish_report],
    middleware=[approval_middleware],
    response_format=ResearchReport,
)

result = agent.invoke({"messages": [user_message]}, config=thread_config)

When the flow becomes more specific, the same Agent can sit inside a StateGraph beside deterministic nodes. That gradual move from a prebuilt loop to an explicit graph is one of the stack's main design choices.

Models, formatters, and provider differences

AgentScope separates the chat model from the formatter that turns AgentScope messages into provider input. That makes prompt formatting visible, which is useful for multimodal messages and multi-agent conversations where sender identity matters. It also means model and formatter compatibility is something the developer must understand. AgentScope model documentation, AgentScope messages

LangChain normalizes model access through chat model integrations and standard message types. init_chat_model and provider packages reduce the amount of application code needed to switch providers. Provider-specific behavior still leaks through in structured output, tool calling, streaming, and token accounting, so changing a model is never completely free.

Choose based on the models you actually plan to run. A framework's total integration count matters less than whether your providers, authentication method, streaming mode, and deployment environment are well supported.

Tool design and execution

AgentScope's Toolkit registers Python functions, builds schemas from signatures and docstrings, groups tools, and executes tool calls. It also supports MCP tools and built-in functions. Tool execution middleware can inspect input, change output, enforce authorization, retry, cache, or skip execution. In the current documentation, this middleware wraps Toolkit execution rather than every part of the Agent loop. AgentScope tools, AgentScope middleware

LangChain tools can also be defined from Python functions or coroutines. The Agent runtime supports sequential and parallel calls, retry handling, and dynamic tool selection. Middleware can filter registered tools from state or runtime context, and it can register and execute tools discovered at runtime. This is useful when tool availability depends on a user's permissions or an MCP server. LangChain Agents

For ordinary static tools, both frameworks are sufficient. LangChain currently exposes broader loop-level middleware, while AgentScope's Toolkit makes tool grouping and Agent-owned tool state easy to see.

State, sessions, and persistence

AgentScope uses StateModule as a shared state mechanism. Agent, memory, long-term memory, and Toolkit can register state that is saved and restored together. Session objects can persist an application's state, including nested modules. This model suits applications where a session maps naturally to a group of stateful Agent objects. AgentScope state and session management

LangGraph persists graph state as checkpoints grouped into threads. A checkpoint can support conversational memory, resuming after failure, human review, replay, and forking from an earlier state. The graph must use a checkpointer, unless Agent Server manages persistence for the deployment. LangGraph persistence

The practical difference is the unit you think about:

• AgentScope asks which objects own state and how a session saves them.
• LangGraph asks what the graph state contains and when execution checkpoints it.

The object model is comfortable for an Agent-centered application. Checkpointed graph state gives more explicit control over long-running workflows and recovery paths.

Short-term and long-term memory

AgentScope provides in-memory conversation memory and a long-term memory interface. Its documented long-term memory modes let application code manage retrieval and recording, let the Agent call memory tools, or allow both. A mem0-backed implementation is available. AgentScope long-term memory

LangChain Agents keep conversation history in state. LangGraph checkpointers carry thread-scoped state across turns, while stores are used for data that must live across threads. LangChain middleware can summarize or trim messages when context grows.

Both approaches still require a memory policy. The framework can store and retrieve data, but your application must decide what deserves to be remembered, how it expires, and how a user can remove it.

Structured output

AgentScope's ReActAgent accepts a Pydantic model through structured_model; the parsed result is available in the returned message metadata. This fits naturally with its message abstraction. AgentScope structured output

LangChain's create_agent accepts a response schema through response_format. It can use provider-native structured output when the selected model supports it and fall back to a tool strategy otherwise. The result is placed in the Agent's structured response state. LangChain structured output

For the research assistant, both can return a validated ResearchReport. Provider support and failure behavior matter more than the surface syntax. Test missing fields, invalid citations, and retry limits with the model you will deploy.

Workflow control and planning

AgentScope provides small workflow building blocks rather than requiring one graph abstraction. Its pipeline module includes sequential and fan-out execution, while MsgHub broadcasts messages among Agents. Routing and handoffs can be built with structured output or tool calls. Its plan module gives a ReAct Agent tools for creating, revising, pausing, and restoring a task plan. The documented plan executor currently runs subtasks sequentially. AgentScope pipelines, AgentScope planning

LangGraph makes control flow a first-class graph. Nodes perform work, edges choose what runs next, state reducers merge updates, and checkpointing records progress. LangChain middleware covers many changes inside the standard Agent loop. A custom graph is appropriate when the workflow mixes deterministic steps, branching, parallel work, subgraphs, and resumable interrupts.

This leads to a useful distinction:

• AgentScope is concise when orchestration can be expressed as Agents, message exchange, routing, pipelines, or a plan notebook.
• LangGraph is clearer when the topology itself is a major part of the application and needs to be inspected as code.

Do not build a graph merely because the library supports one. A normal Agent loop is easier to maintain when the task does not need custom routing.

Multi-agent systems

AgentScope has multi-agent concepts near the center of its message model. Sender names, multi-agent formatters, MsgHub, concurrent Agents, routing, handoffs, and debate examples support systems where several named Agents communicate. AgentScope workflow documentation

LangChain documents several multi-agent patterns: subagents exposed as tools, handoffs through state changes, skills loaded on demand, routers, and custom LangGraph workflows. Its own guidance also notes that one Agent with the right tools may solve a task without multi-agent coordination. LangChain multi-agent documentation

AgentScope offers a more direct vocabulary for conversational groups of Agents. LangGraph offers more control when coordination is a state machine or a graph with parallel branches. In either framework, multiple Agents add latency, token use, and more failure paths. Use them when context isolation, parallel work, or separate ownership gives a measurable benefit.

Human approval and safety controls

AgentScope can implement approval through human-in-the-loop steering, hooks, tool middleware, and application workflow code. Toolkit middleware is a clear place to block or rewrite a sensitive tool call. Agent hooks provide additional extension points around Agent behavior. AgentScope middleware, AgentScope hooks

LangChain provides HumanInTheLoopMiddleware for tool calls. It can interrupt selected actions and allow a reviewer to approve, edit, or reject them. The graph state is checkpointed so the run can resume after the decision. Production use requires persistent checkpoint storage. LangChain human-in-the-loop

LangChain has a more standardized documented path for resumable tool approval. AgentScope gives the developer flexible hook and middleware points, but the application may need to define more of the approval lifecycle itself. For regulated or high-consequence actions, prototype the pause, persistence, reviewer UI, timeout, and audit record before selecting a framework.

Extensibility

AgentScope can be extended through base classes for Agents, models, formatters, memory, and storage. Hooks customize Agent behavior. Toolkit middleware wraps tool execution. The explicit formatter layer is helpful when a provider or multi-agent prompt requires custom message conversion.

LangChain uses integration packages, runnables, tools, state schemas, and middleware. Middleware hooks can run before or after model calls and wrap model or tool execution. LangGraph offers a lower-level extension point because any runnable or normal function can become a graph node.

LangChain gives more places to intervene in the default loop. AgentScope has fewer layers to learn for its standard ReAct path, although a heavily customized formatter or Agent subclass can still become framework-specific code.

Tracing and evaluation

AgentScope tracing uses OpenTelemetry. It includes tracing for models, tools, Agents, and formatters, can display traces in AgentScope Studio, and can export to OTLP-compatible backends. Its evaluation package includes sequential and Ray-based evaluators, persistent result storage, benchmark abstractions, and integration with OpenJudge graders. AgentScope tracing, AgentScope evaluation

LangSmith provides tracing, datasets, offline experiments, online evaluation, and deployment services. LangGraph Studio supports graph development and inspection. LangSmith evaluation can score curated examples before deployment and production traces after deployment. It is a separate platform rather than a requirement for running the open-source LangChain and LangGraph libraries. LangSmith evaluation, LangGraph overview

AgentScope's OpenTelemetry foundation is attractive when your organization already has an OTLP backend or wants to keep tracing portable. LangSmith is a more connected experience when the team wants traces, datasets, experiments, and deployments in one product. Check hosting and licensing requirements before treating either operational path as free infrastructure.

Serving and deployment

AgentScope 2.0 presents local, serverless, and Kubernetes deployment as part of its production story, with Agent-as-a-Service APIs, sandboxing, and observability integrated into the 2.0 line. The exact deployment choice depends on the runtime components and infrastructure your application uses. AgentScope repository, AgentScope Runtime archive notice

LangGraph applications can run inside a normal Python service. The LangSmith deployment stack also provides Agent Server, which manages assistants, threads, runs, persistence, and a task queue. Cloud and self-hosted options exist, while self-hosted platform features have their own infrastructure and licensing requirements. LangSmith Agent Server, self-hosted LangSmith

Framework selection should not depend on deployment diagrams alone. Build a small service and test cancellation, restart recovery, concurrent runs, secret handling, trace export, and horizontal scaling in your own environment.

Ecosystem and team fit

LangChain has Python and JavaScript or TypeScript libraries, a large catalog of model, vector store, retriever, and tool integrations, and a stack that spans LangChain, LangGraph, Deep Agents, and LangSmith. That range helps teams that already use its integrations. It also creates a naming and package boundary that new maintainers must learn.

AgentScope is Python-centered and presents a more concentrated Agent development model. It includes MCP and A2A support, Agent skills, multi-agent utilities, planning, RAG, tracing, evaluation, and tuning-related features in its ecosystem. A team that prefers explicit Agent objects may find the code easier to follow.

Do not turn ecosystem size into a score. Review the ten integrations your project needs, then build one end-to-end path. Maintenance cost comes from the parts you use, not the parts listed on a website.

Selection guide

Choose AgentScope 2.0 for a serious prototype when most of these statements are true:

• The team writes Python and thinks in terms of named, stateful Agents.
• Message identity and multi-agent conversations are central to the product.
• Built-in planning, pipelines, AgentScope Studio, and OpenTelemetry tracing match the desired workflow.
• The team prefers an integrated Agent toolkit over assembling several LangChain ecosystem packages.

Choose LangChain with LangGraph when most of these statements are true:

• The project depends on integrations already maintained in the LangChain ecosystem.
• The workflow needs explicit branching, checkpointed state, durable resume, or graph composition.
• Resumable human approval is a core requirement.
• The team wants Python and JavaScript or TypeScript options, or plans to use LangSmith for tracing, evaluation, and deployment.

Run a short proof of concept before committing. Implement the same research assistant in both frameworks and measure task success, code needed for recovery, trace quality, cold-start and steady-state latency, token use, and the effort required to change one workflow rule. That comparison will be more useful than a generic feature checklist.

Sources

• AgentScope documentation
• AgentScope releases
• LangChain Agents
• LangChain middleware
• LangChain multi-agent systems
• LangGraph overview
• LangGraph persistence
• LangSmith evaluation