Agent Studio Open is a local-first toolkit for developers building tool-using agents, with an inspectable source repository, an MIT license, desktop release artifacts, and companion CLI packages. The desktop release is now at 0.2.0, a macOS Apple Silicon build whose release notes report Developer ID signing and notarization. Companion CLI packages are published separately.
The shortest description is this: Agent Studio Open helps turn an agent trace into an inspectable regression artifact. The CLI supports live transport checks, selected tool and provider operations, trace import, deterministic fixture replay, A2A validation, risk scanning, and exports. The desktop app is strongest at discovery, local trace review, fixture-based replay, and export. Direct live tool execution and provider comparison are not represented as complete across every UI surface.
That loop sounds obvious once you have it. The problem is that many agent teams still do not.
Agent development has moved faster than agent debugging. Teams can wire a model to tools in a day. They can expose an MCP server, add a few prompts, ship a manifest, and watch the model call functions. But when the system fails, the workflow often falls back to screenshots, copied JSON, notebook cells, log files, and a message in Slack that says "can someone reproduce this?"
The failure may be simple. The model passed a string where the schema expected an object. A tool returned a partial result. A remote server changed a field. A planner chose the wrong tool. A provider upgrade changed argument style. An A2A agent card claimed a capability that the implementation did not satisfy. A trace existed somewhere, but nobody could replay it in a way that survived the next commit.
That is the gap Agent Studio Open is built to close.
The Agent Debugging Loop
Tool-using agents need a workflow that is closer to software engineering than prompt tinkering.
The developer should be able to connect to a server and see the actual manifest. They should be able to inspect tool schemas, resources, prompts, server logs, and risk findings before asking a model to call anything. They should be able to compose a tool call directly, validate the arguments, and see the raw request and response.
When a run fails, the trace should become a durable artifact. The developer should be able to save the session, redact secrets, export a card for review, replay the tool calls with deterministic fixtures, and add assertions that say what must stay true. If a future model, server, prompt, or schema change breaks that behavior, the regression should fail in CI instead of appearing again in a customer workflow.
That is the core loop:
connect -> inspect -> call -> record -> replay -> compare -> export
Agent Studio Open brings those stages into one project, while keeping surface-specific limitations visible.
The desktop app is the main local review experience. It is a Tauri workspace for connections, manifests, trace timelines, replay fixtures, exports, and settings. The CLI carries the broader automation surface. The browser and VS Code materials are reduced or early workflows and should not be read as feature-parity claims.
We are not trying to replace every agent framework. We are building the debugging and regression layer that sits next to them.
Built for MCP Servers
MCP has given developers a common way to expose tools, resources, and prompts to models. That common layer is valuable, but it also creates a new reliability surface. A server can have a valid-looking manifest and still surprise the model or the developer at runtime.
Agent Studio Open starts with server inspection. You can connect to local stdio servers from the desktop app or CLI, and to remote HTTP, SSE, and WebSocket transports where appropriate. The app reads the manifest, displays tools, resources, and prompts, and keeps the raw protocol details visible enough that a developer can debug the actual contract rather than a simplified marketing view of it.
The CLI can exercise supported tool calls against user-supplied servers. The desktop composer exposes schemas and request structure, while complete live execution in the main app remains an integration boundary. That distinction matters because discovery, validation, fixture replay, and live execution prove different things.
Agent Studio Open also includes MCP risk scanning. The goal is not to shame useful tools. The goal is to make dangerous surfaces visible: broad filesystem access, network claims, package metadata gaps, unclear permissions, unsafe names, or behavior that deserves review before a model is given access. Risk findings can be exported and included with the rest of the agent regression bundle.
Built for A2A Agents
Agent-to-agent systems need contracts too. If an agent card claims a capability, a consuming system needs a way to validate the claim against transcripts and expected behavior.
Agent Studio Open includes A2A card inspection and contract-test flows. You can validate an agent card, load transcripts, run checks, and export results as JSON, Markdown, or JUnit. This is intentionally practical. A2A support should not be a dashboard that only looks correct in a demo. It should produce artifacts that a repository can review and a CI system can fail.
The same philosophy applies across the product: traces and tests should outlive the interactive session.
Trace Import, Replay, and Model Comparison
Many teams already have traces. They may come from OpenTelemetry GenAI spans, Phoenix exports, OpenAI-style event streams, local replay files, or custom logs. Agent Studio Open can ingest the formats we see teams using and normalize them into a local trace store.
That store is not a hidden cloud dependency. It is local. It is designed for search, replay, export, and review. Trace payloads stay on the user's machine unless the user explicitly exports them.
Replay is the important part. A trace that cannot become a test is mostly a postmortem. Agent Studio Open treats a trace as the beginning of a regression case. Tool outputs can be captured, assertions can be attached, and the result can be exported into a GitHub Action or JUnit report. A failed tool call becomes a fixture. A flaky agent run becomes a testable case. A model upgrade becomes something you can compare against a baseline.
Model comparison is available through supported CLI/provider paths and existing trace stores. Dry-run behavior remains available for local demonstrations and CI paths that should not call a provider. Provider use requires user-supplied credentials, and the browser edition has a narrower trust and capability boundary.
Local-First by Default
The trust model is simple: Agent Studio Open should be useful without an AuraOne account.
Telemetry is off by default. Crash reporting is opt-in. Trace payloads are local unless explicitly exported. Provider keys are user-owned. The desktop app is the primary surface for local stdio servers and localhost OTLP receiver flows. The browser edition intentionally has narrower capabilities because a browser should not pretend to have the same local process and filesystem access as a desktop app.
This boundary is part of the product, not a footnote. Agent developers routinely work with internal schemas, customer workflows, proprietary tools, and sensitive traces. They should be able to inspect the code, run locally, disable network behavior, and choose exactly what leaves the machine.
Agent Studio Open is intended to be inspectable because the debugging layer for agent reliability should not be a black box. If a tool is going to sit between a model and the systems it can call, developers should be able to inspect its assumptions, source revision, license, runtime boundary, and released artifacts.
What Ships With It
The repository includes the desktop app, browser edition source, CLI, docs, launch assets, and sample MCP servers. Compatibility depends on the selected transport, server behavior, optional dependencies, and the surface being used.
The CLI uses the agentstudio command name. It supports connection checks, recording, replay, comparison, risk scanning, A2A validation, trace import, model calls, OTLP receiving, sidecar health checks, and export commands. It is designed to be pipe-friendly and to emit JSON where automation needs it.
For CI, Agent Studio Open can produce GitHub Actions, JUnit reports, PR comments, trace cards, Phoenix JSON exports, and AuraOne intake bundles. The export path is explicit so teams can review what is being shared before anything leaves the local environment.
The docs include quickstarts, concepts, MCP and A2A cookbook material, OTEL ingest guidance, provider key handling, CLI reference, browser edition notes, VS Code guidance, architecture notes, privacy details, sandbox guidance, and troubleshooting.
Why AuraOne Is Building This
AuraOne works on the layer where evaluation, specialist review, regression testing, and release decisions meet. Agent Studio Open fits that direction because agent reliability is quickly becoming a release problem.
A model calling tools is not just answering a prompt. It is taking action through interfaces that can create tickets, query databases, schedule meetings, request refunds, inspect files, run commands, or coordinate with other agents. The old evaluation habit of reading a final answer is not enough. The path matters. The tool call matters. The schema matters. The state change matters. The replay matters.
We want developers to have a local tool that makes those details visible. We also want the resulting artifacts to connect naturally to larger systems when a team reaches that point: hosted collaboration, expert review, launch checks, and enterprise controls. But the open product stands on its own. It is not a crippled trial for a hosted product.
The local-first contract is important: if you are one person debugging an MCP server on a laptop, Agent Studio Open should still be worth installing.
What to Try First
Start with a small MCP server. Connect to it in the desktop app or with the CLI. Inspect the manifest. Pick one tool and call it directly. Record a failing or interesting run. Export a replay case. Add one assertion. Generate a GitHub Action. Then make a change that should break the behavior and confirm the regression catches it.
That is the moment the product is built around.
You do not need a perfect agent architecture to benefit from that loop. You need one tool call that matters and one failure you do not want to debug twice.
Agent Studio Open is for the developers who are ready to treat agent behavior as something they can inspect, replay, and protect.
Canonical links:
- Current release: Agent Studio Open v0.2.0
- CLI package: auraone-agent-studio-open on PyPI
- Product page:
/open/agent-studio-open - Docs:
/resources/docs/agent-studio-open - Quickstart:
/resources/docs/agent-studio-open/quickstart - Cookbook:
/resources/docs/agent-studio-open/mcp-cookbook - CLI reference:
/resources/docs/agent-studio-open/cli-reference
A read-only example build of the workbench runs at agentstudio.auraone.ai to show the interface.