AgentScope Studio: a local trace viewer for AgentScope, now read-only

What AgentScope Studio was built to show

Running an agent locally produces a stream of events that is hard to read in a terminal: which model was called, how many tokens went into the prompt, which tool was invoked, what came back. AgentScope Studio exists to put that stream on a screen. The README describes it as a local visualization toolkit for developers working with AgentScope, and lists five areas: project management through Projects and Runs, a chatbot-style runtime view for interacting with an agent as it runs, OpenTelemetry-based trace visualization for LLM calls and token usage, evaluation-oriented analysis, and a built-in Copilot called Friday.

The intended user is a developer iterating on a single agent or a multi-agent setup, not an operator running production traffic. The toolkit is local by design, which is why the connection is configured from the Python side rather than through a hosted account. If your debugging loop currently consists of printing responses to stdout, this is the category of tool that replaces it.

How the Python process and the studio connect

The mechanism is a URL handshake. Your AgentScope application is given a studio_url when it initializes, and the studio process listens on that address and receives what the application emits. The README gives exactly this example in the QuickStart section:

import agentscope

agentscope.init(
    # ...
    studio_url="http://localhost:3000"
)

# ...

Port 3000 is the address used in that snippet. Once the initializer has the URL, the application's runs are attributed to a project in the studio, which is what the Projects and Runs model is for: one project groups many runs so you can compare them rather than reading a single execution in isolation.

The tracing layer is OpenTelemetry, and the repository topics list opentelemetry and tracing alongside agent and multi-agent. That choice matters for adoption: the studio is not inventing a proprietary trace format that only it can read. The npm package also depends on @opentelemetry/api, and the package is structured as an npm workspace with separate client and server packages, with a tRPC server and an Express server in the dependency list. The build script compiles the client, then the server, then copies packages/app into dist/app. In other words, the running binary is a Node server plus a bundled front end, not a static page.

Installing AgentScope Studio from npm

The README lists two prerequisites before anything else: Node.js 20.0.0 or higher and npm 10.0.0 or higher. Docker is listed as optional, for Docker deployment. If you use nvm, the README notes that running nvm use will switch to the version recorded in the repository's .nvmrc file. Check your versions first:

node --version  # Should show v20.x.x or higher
npm --version   # Should show 10.x.x or higher

The recommended installation is global, followed by the as_studio command, which the package.json maps to ./bin/cli.js:

npm install -g @agentscope/studio

# Start AgentScope Studio
as_studio

If you would rather work from the source tree, the README's From Source path clones the repository, installs dependencies, and runs the development script, which package.json defines as running the client and server workspaces concurrently:

git clone https://github.com/agentscope-ai/agentscope-studio
cd agentscope-studio
npm install

# Start in development mode
npm run dev

For containerized deployment the README does not inline the steps; it points at docker/README.md in the repository. The first real use after starting the studio is the Python snippet in the previous section: point studio_url at the running instance, run your agent, and the run should appear under a project in the studio interface.

The archive notice is the headline, not a footnote

The README opens with an archive notice, above the logo and everything else. It states that AgentScope 2.0 now ships a built-in Web UI as part of its Agent Service, a FastAPI backend with a pre-built frontend in examples/web_ui, and that the built-in UI covers agent reasoning, tool calls and multimodal content over a unified event stream, plus multi-session isolation, Agent Team orchestration, permission and human-in-the-loop control, IM channels for Feishu and Discord, MCP and Skill Hub management, session persistence and task scheduling. On that basis the notice says AgentScope Studio is no longer maintained as a standalone tool, recommends migration to AgentScope 2.0, and says the repository will remain available in read-only mode and will be archived soon.

This is the most important fact about the project, and it changes how you read every other section. The last push to the repository was on 2026-09-02, and the most recent release listed is v1.0.9 from 2026-03-06. The repository is not archived yet, but its own documentation says it is heading there. Treat feature descriptions as a description of what exists, not of what will keep being fixed.

Where the standalone studio stops being the right tool

The obvious failure mode is starting something new on it. If you are beginning an AgentScope project now, the README's own recommendation is AgentScope 2.0, and the built-in Web UI there covers the runtime visualization and trace inspection that Studio was built for. Installing a global npm package that its maintainers describe as no longer maintained, to get capabilities that ship with the framework you are already using, is work you do not need to do.

A second constraint is the runtime. The engines field requires Node.js 20 and npm 10, and the README repeats that as a prerequisite. On a machine pinned to an older Node LTS, the global install is not a drop-in. Docker is the escape hatch the README offers, with the details in docker/README.md rather than the main file.

A third is the boundary of the tool itself. The README describes it as a local visualization toolkit for developers. It is not presented as a hosted service, a production monitoring product, or a replacement for a general observability backend. The OpenTelemetry integration means traces exist in a standard shape, but the README does not document retention, alerting, multi-user access control, or what happens under concurrent load. The README also does not document a rollback path or a data migration step for moving existing Projects and Runs into AgentScope 2.0; that silence is worth noting if you have accumulated runs you care about.

AgentScope 2.0's built-in Web UI versus the standalone studio

The real alternative is not a third-party product. It is AgentScope 2.0 itself, and the difference is architectural rather than cosmetic. The standalone studio is a separate Node process installed from npm and pointed at by a studio_url in your Python initializer. The 2.0 Web UI is described in the archive notice as part of the Agent Service: a FastAPI backend paired with a pre-built frontend in examples/web_ui, driven by a unified event stream.

That shift moves the visualization inside the framework boundary. Instead of a URL handshake between your agent process and an external viewer, the service that runs the agent also serves the interface. The notice lists capabilities the standalone studio did not claim in its own README: multi-session isolation, leader-worker orchestration with task planning, permission and human-in-the-loop control, IM channels, MCP and Skill Hub management, session persistence and task scheduling. Some of those, like IM channels and task scheduling, are not visualization features at all. They are service features that happen to share the same UI.

If you are evaluating the two on tracing alone, the standalone studio's README is the more specific document: it names OpenTelemetry semantic conventions as a documentation topic and frames tracing as LLM calls, token usage and agent invocations. The 2.0 notice frames tracing as part of a broader event stream. Which is better for your case depends on whether you want a narrow trace viewer or a service console.

Licence and the cost of staying on the standalone studio

AgentScope Studio is released under Apache License 2.0, as stated in the README and in the LICENSE file at the repository root. That is a permissive licence, and the README's licence section says nothing beyond naming it. For the practical question of whether you can run this inside a company, the licence identifier is the first thing to hand to whoever reviews dependencies, not the last. Nothing here is legal advice; the point is that the answer is written down and short.

Upgrade cost is the harder number. The README's news section records that the project was open-sourced in 2025-08, and the release list shows v1.0.7 in 2025-12, v1.0.8 in 2026-01 and v1.0.9 in 2026-03. Then the archive notice. So the standalone line had a short active window. Moving to AgentScope 2.0 is not a patch bump on this repository; it is a change of framework version and a change of where the UI lives. The README does not describe a migration script or a compatibility shim, and it does not say whether the studio_url initializer argument still exists in 2.0. Budget for reading the 2.0 documentation rather than for running an upgrade command.

Editorial conclusion

Adopt AgentScope Studio only if you are pinned to an AgentScope 1.x codebase and need its Projects, Runs and trace views today; the README states the repository will be archived and that AgentScope 2.0 ships a built-in Web UI in examples/web_ui. Do not start a new project on it. Before installing, confirm your Node.js is at least 20.0.0 and npm at least 10.0.0, and check whether AgentScope 2.0 already covers the tracing views you need, because the README says this standalone tool is no longer maintained.

Frequently asked questions

Official sources

1. agentscope-ai/agentscope-studio on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases