Agent Studio Open: A Local-First IDE for MCP and A2A Agents
Today we are introducing Agent Studio Open, an MIT-licensed, local-first IDE for the developers building tool-using agents.
The shortest description is this: Agent Studio Open turns a failed agent run into a replayable regression. It connects to MCP servers, inspects tools and schemas, records tool calls, imports traces, replays behavior, compares model outputs, runs A2A contract checks, and exports CI artifacts that protect the next release.
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 -> exportAgent Studio Open gives that loop a single surface.
The desktop app is the main experience. It is a keyboard-driven Tauri workspace with panes for connections, manifests, trace timelines, replay results, model comparison, exports, and settings. The CLI is for automation and CI. The browser edition is a reduced surface for remote transports, docs, demos, and travel workflows where installing a desktop app is not convenient. The VS Code materials are there for developers who want the same concepts close to code.
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 tool composer is schema-aware. It is meant for the moment when you want to ask: "Is the server wrong, or did the model call it wrong?" You can call the tool yourself, inspect the arguments, inspect the response, and save the result into a trace. That direct path matters because model behavior is only one part of the system. Many agent failures are ordinary integration failures wearing an AI label.
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 built for that same workflow. Developers can run prompts through configured providers, inspect streaming deltas, compare responses, and keep dry-run behavior available for local demos and CI surfaces that should not call a real provider. The product supports bring-your-own API keys. In the browser edition, provider keys are stored with browser constraints in mind, including passphrase-protected local storage paths where available.
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 open source because the debugging layer for agent reliability should be inspectable. If a tool is going to sit between a model and the systems it can call, developers should be able to understand its assumptions.
What Ships With It
The repository includes the desktop app, browser edition source, CLI, docs, launch assets, and a cookbook of sample MCP servers. The sample servers cover workflows such as filesystem risk, CRM refunds, calendar scheduling, vector search, read-only SQL, browser automation, support tickets, payments read-only access, feature flags, and docs search.
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, release gates, and enterprise controls. But the open product stands on its own. It is not a crippled trial for a hosted product.
The open-source 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:
- 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
