MyAgentStudio is a local workbench for building Claude Code subagents. You import existing .md agent files, edit them with AI assistance or directly, organize them into groups, and export them back to .md when you are done.
MyAgentStudio requires an account. Go to /login and enter your email and password.
If you do not have an account yet, ask the admin (the person who runs this deployment) for an invite code — or, from /login or /welcome, use the "Request access" link if you don't have one yet; the admin reviews your request and sends you a code. With a code in hand, go to /signup and create your account. Every new account shares its activity-log content with the admin by default — the first time you land on the workbench after signing up, a one-time popup lets you make it private instead; dismissing it leaves the shared default in place, and you can change your mind anytime from your Account page. See the Activity log section below for what this choice means.
When your session expires (default 7 days, may be shorter or longer on this deployment), you will be redirected to /login with your intended destination preserved — signing back in returns you to the page you were on.
If this deployment has Google sign-in enabled, a Continue with Google button appears on /login and /signup. It is a second way to prove who you are, not a second way to get in — an invite code is still required the first time you sign in with Google, exactly as with a password account. On /signup, the button stays disabled until you've entered a code; the activity-log privacy choice happens later, in the one-time popup described above, not on the signup page itself.
If you already have a password account and later sign in with Google using the same, Google-verified email address, MyAgentStudio links the two automatically — you land in your existing account, no second account is created, and no invite code is spent. Your original password keeps working afterward.
A few things worth knowing:
There are two roles:
Both roles have a single ⚙ Settings button in the Topbar, opening the Preferences modal — its sidebar shows Account and Activity log for everyone, plus LLM and Admin categories that only appear for an admin session.
Only the admin can generate invite codes. Open ⚙ Settings in the Topbar, pick Admin in the sidebar, and scroll to the Invite codes section. Click Generate to create a new code (you can add an optional label like "for Alice"). Copy the code and send it to the person directly — codes are displayed plaintext so you can re-read them if needed.
A code can only be redeemed once. Once redeemed or once the maxUsers cap is reached, the code is inert. You can revoke an unredeemed code from the same panel.
Or let them ask first. A visitor without a code can use "Request access" on /login, /signup, or /welcome instead of you generating one unprompted — they submit their name, email, and (optionally) how they heard about the platform. Their request shows up in the same Admin sidebar category's Access requests grid; Generate code there creates a code scoped to that email (it expires after the configured window, default 5 hours, and only that email can redeem it) and clears the request, or Dismiss just clears it without creating a code. Nothing is emailed automatically yet — copy the code and send it yourself, same as above.
Click ⇪ Import .md in the Library panel's action bar. A dialog opens.
You can either pick a .md file from disk or paste the file content directly into the text area. Both paths populate the same text area — once the content is loaded, you choose an import mode before submitting.
Structural (recommended, default) — the AI reads the full file content and reorganizes it into the canonical section structure (Role → Behavior → Guardrails → Output, plus any optional sections the file warrants). Use this for files from other tools, hand-edited files with nonstandard headings, or any file whose structure you want normalized.
Strict (verbatim) — the AI sees only heading text, never the body content. It classifies each existing heading into a canonical section key without touching the words. Use this when your file is already structured correctly and you want headings labeled without any rewriting.
Both modes share the same deterministic frontmatter parse. name, description, model, tools, and all other frontmatter fields are extracted directly from the YAML header in both modes — the AI never handles frontmatter.
name in the file matches one already in the platform, the file is imported as an update. The existing agent's sections and config are replaced; its edit history is preserved.| Error shown | What it means |
|---|---|
| "The .md file has no name in its frontmatter." | Add a name: line inside the --- block. |
| "Could not parse the .md file. Check its frontmatter format." | Malformed YAML (duplicate keys, tab indentation, unsupported nested objects). |
| "The AI import step failed. Try again." | The Anthropic API returned an error. Your pasted content is preserved — retry. |
Select an agent in the Library panel to open it. Type an instruction in the AI Chat panel at the bottom of the center column and press Enter (or click Send).
Chat proposes — it never writes directly. ✦ Prometheus (the chat agent) reads the agent's current description, sections, and config, and replies with a natural-language message plus a proposal: a card listing exactly what it wants to change. Nothing is written to the agent until you click Apply on that card.
Examples of instructions that work:
What Prometheus can and cannot propose:
Reviewing and applying a proposal: the card is collapsed by default (one line per changed part when expanded — description, each section, each config key), with a "show current" toggle per row to compare against what's there today before you commit. Click Apply to write every changed part in the proposal at once (there's no way to apply only part of it), or Discard to drop it. Sending a new chat message before applying or discarding also discards the pending proposal — only the latest turn's proposal is ever actionable. Apply is last-write-wins: if you've made no other changes since the proposal was returned (guaranteed by the lock below), there's nothing to conflict with.
Occasionally a proposal card shows a highlighted warning row — e.g. a section's proposed content dropped sharply in size compared to what's there today. This is a heads-up, not an error: some AI models (especially smaller or free ones) can truncate long content instead of returning it in full. Use the "show current" comparison to check the proposed content actually looks complete before applying; nothing stops you from applying anyway if it's a legitimate shortening.
Follow-ups remember the conversation: Prometheus sees your recent back-and-forth in the same session, not just the instruction you just sent — so "make that shorter" or "no, keep the tone but trim it" refers correctly to what you just discussed. This is dialogue only (your instructions and Prometheus's replies); it never resends a past proposal's actual content — that always comes from the agent's current, real state instead. How many prior messages are kept is admin-configurable (Chat history turns in System Settings, default 10). Client-only notices (dry-run/error/cancelled messages) are never included. This history exists only in your browser tab for the current session — it does not persist across a reload.
Cancellation: click the ✕ button, or close the tab. Nothing is ever written by the chat call itself — cancelling just stops waiting for a reply that would have produced a proposal, same as any other interrupted request.
Interaction lock: while a chat request is in flight, or while a proposal is pending review, every manual editor is disabled — section raw-edit, the name, and every config control (model/effort, tools, lists, JSON blocks). While you have an unsaved manual edit open, the Chat input is disabled. The three states (chat in flight / proposal pending / manual edit open) never overlap. A pending proposal survives a page reload (it's kept in your browser until you apply or discard it) and stays in sync across multiple tabs open on the same agent.
In the Visualization pane, each section is shown as a collapsible block. Click the header to expand or collapse it. With a section expanded, click the Edit button on the right of the header.
The section body opens as a monospace text area with its raw markdown content. Edit freely — the heading is not shown in the editor, only the body below it.
Click Save to write the change. The server checks that no other edit arrived since you opened the editor (optimistic concurrency). If it did, you will see a conflict notice with the current version number — reload and retry.
Click Cancel to discard your changes and close the editor without saving.
The Edit button is grayed out while a chat request is in progress, or while a chat proposal is pending review (see above).
The Library is designed to let you file an agent into any number of groups at once — a group is a label, not a folder, so one agent can appear under several group headings without being duplicated. This is built underneath but not yet switched on in this release: the Library shows a single flat list of every agent for now, with no group controls. This will be enabled in a coming update.
The panel on the right is a dock with two tabs, Raw and Share — Raw is the one open
by default and shows the current state of the selected agent as it would be written to a
.md file. This is a live preview — it updates after every save, whether from the AI chat
or a manual edit.
Frontmatter lines are dimmed; top-level section headings are highlighted.
Click Download at the top of the Raw tab to save <name>.md directly, then move it into your .claude/agents/ directory. Alternatively, select all text in the panel and copy it if you just want the content.
The export format is deterministic and semantically faithful: frontmatter keys are written in their original insertion order, YAML values are normalized (no type coercion, no added quotes beyond what is necessary for round-trip safety), and section bodies are written byte-for-byte as stored. Group memberships are platform metadata and are not written into the exported file.
The Share tab, next to Raw in the same right-hand dock, is where you hand an agent to someone else. Unlike a copy, a share is a live reference — whoever it's shared with always sees your current version, updated as you edit, never a stale snapshot. They can look, but never edit anything.
Two ways to share:
shr_…). Copy it and send it
however you like — email, chat, anywhere. Anyone who redeems it gets access. Disable
link kills it immediately and permanently: re-enabling later always issues a brand-new
code, never the old one back, so a leaked link is safe to shut off for good.Either way, the person appears under People with access, showing how they got in (added by you, or redeemed the link) and when. Click the × next to their name to revoke just that person — this is independent of the link: disabling the link doesn't remove anyone you've added by email, and removing a person doesn't touch the link.
What the recipient sees: the agent opens read-only — name, description, config, and
sections, with no edit controls anywhere. They get exactly two actions: Copy to me,
which forks an independent copy into their own library (their copy, their edits, no
connection back to yours), and Export, to download the same .md file you'd get from
the Raw tab. To redeem a code someone sent them, they use ⇱ Redeem share code in the
Library panel's Manage section, and the agent then shows up under a Shared with me
heading in their Library.
Click ⚙ Settings in the Topbar and pick Account in the sidebar (always visible, for both admins and users) to see your personal settings.
Log sharing with the admin. The consent toggle mirrors your current sharing status (on by default — see Activity log above): on = share your prompt and response content; off = private. You can flip it at any time. The change is not retroactive in either direction — past rows keep the consent value they were written with, and changing your preference only affects future calls.
Your signed-in email, role, and how you sign in (password, or Google with the linked email) are shown as read-only. There is currently no self-service way to link or unlink a Google account from this page.
API tokens (MCP access). The same Account page has a panel for generating Personal Access Tokens — the credential a console MCP client (Claude Code and similar tools) uses to read, pull, and push your agents from outside the browser. See the next section for how to use one.
MyAgentStudio runs an MCP (Model Context Protocol) server so a console/CLI client — Claude Code, or an equivalent tool that accepts a custom HTTP header — can list, read, pull, and push your own agents from your terminal. This is for console clients only. Claude Desktop's GUI connector is not supported (it requires a different authentication flow this server doesn't implement).
1. Generate a token. Go to Account → API tokens (MCP access) → New token. Give it a name (e.g. "laptop Claude Code") and pick a scope:
push_agent (see below).The token's full value is shown exactly once, right after you create it. Copy it immediately — MyAgentStudio never stores it in a form that can be shown to you again, not even to an admin. If you lose it, revoke it and generate a new one.
2. Add the server to your client. For Claude Code:
claude mcp add --transport http myagentstudio https://<your-myagentstudio-host>/api/mcp \
--header "Authorization: Bearer <the token you copied>"
3. Use it. Once connected, four tools are available:
| Tool | What it does |
|---|---|
list_agents |
Lists your agents (id, name, description). |
get_agent |
Returns one agent's full structured content — sections, config, and any validation flags. |
pull_agent |
Returns the same deterministic markdown the web UI's Export button produces. |
push_agent |
Pushes a markdown document up — creates a new agent, or updates an existing one if the name matches. Requires a write-scoped token. |
(Named pull_agent/push_agent, not "export"/"import," to match the way you'd think about
this from a terminal: pull the current version down, push your edited version back up.)
A natural round trip: pull_agent an agent → edit the markdown in your terminal (by hand, or by asking the console client's own model to revise it) → push_agent it back. That reuses the exact same import pipeline the web UI's Import dialog uses, including the same safety net — a snapshot is taken before and after an update, so a bad push is recoverable the same way a bad web import is.
What push_agent cannot do: there is no tool for editing a single section or config value directly — the only write is "push this whole document." A submitted document replaces the agent's sections to match what's in the file; a section that existed before but is missing from your document gets removed (its history is kept, but it's gone from the live agent). If you only want to tweak one section, pull first, edit that one section in the file, and push the whole file back — don't hand-write a partial document.
Why writes might be refused. Three independent switches all have to be "on" for push_agent to work: your token needs write scope, the server admin needs to have turned on MCP writes in Settings (off by default), and you need to be under your hourly AI-call limit (the same limit that applies to everything you do in the browser). If any of these is off, you get a clear, named error explaining which one — never a silent failure.
If your token leaks: revoke it immediately from the Account page (one click, takes effect instantly). Treat an MCP token like a password to your agent library — anyone holding it can do whatever that token's scope allows, with no browser session or second factor in the way.