---
title: "Build and iterate"
description: "The Studio create form, the live playground, and the Settings drawer — from first idea to a deployed agent you keep refining."
---

This page covers the build loop in [Studio](/studio/): create an agent, test it in the playground, and iterate through the Settings drawer.

## The create form

**New agent** opens a single form that takes you from idea to deployed agent in one submit.

### Starter templates

Six chips above the instructions — Trip planner, Meeting-prep assistant, Customer FAQ answerer, Study coach, Social media copywriter, Meal planner. One click fills the instructions with a curated, complete example and proposes a matching name. Every word stays editable, and a chip never silently replaces text you typed: if you've written your own instructions, Studio asks before overwriting them.

### Instructions

The agent's system prompt — who it is, what it does, how it behaves. Instructions are optional: leave them blank and your agent runs Guuey's generic default prompt.

**Draft it for me** expands a one-sentence description (up to 500 characters) into full instructions you can refine. If the textarea already holds a short line, it's reused as the seed; drafting over instructions you typed (other than the seed itself) asks first, same rule as the template chips.

### Name

Required, up to 100 characters. Templates propose one, with a **Shuffle** button that cycles the template's alternatives. Once you type a name yourself, Studio stops suggesting over it. Untitled agents otherwise take their name from the first line of the instructions as a starting point.

### Model

Three plain-language tier cards, all running Anthropic models on the Claude Agent SDK:

- **Thinking** — deepest reasoning for complex work; slower, costs more.
- **Balanced** — great quality at everyday speed. Recommended, and the default.
- **Fast** — snappiest replies at the lowest cost.

An **Advanced** section exposes the real axes: provider (Anthropic, OpenAI, or Google), model, and framework (Claude Agent SDK, OpenAI Agents SDK, or Google ADK). Each framework runs its provider's models, so the two layers can never disagree — switching provider or framework also selects that provider's default model. An Advanced pick outside the tier vocabulary deselects the cards and shows a "custom" note; clicking a card switches back.

### Superpowers

Capabilities beyond text:

- **Generative UI** is checked by default: your agent replies with interactive screens — cards, forms, live surfaces — rendered right in the chat via the default `mcp.ggui.ai` server. Protocol depth lives in the [ggui docs](https://docs.ggui.ai).
- The catalog rows below preview Guuey-hosted integrations from the [Integrations directory](/studio/#integrations), with the same honest availability badges — entries that aren't attachable yet render disabled.
- **Advanced: add an MCP server by URL.** Bring your own server: a name, an `https://` URL, and optional request headers. Validation catches duplicate names, non-HTTPS URLs, and secret values pasted as literals — the same checks the server runs, so the form can't submit something the platform would reject. Servers that need an account sign-in aren't supported in Studio yet — deploy those with the [CLI](/cli/). Built an MCP server others could use? A **Submit it for listing** link beneath the server list opens the submission form for the [Integrations directory](/studio/#integrations).

Submit with **Create my agent**: Studio creates the agent, triggers its first deploy, and opens the playground.

## The playground

Each agent's playground is a phone-framed chat simulator wired to the real deployed agent — messages stream in live over the same endpoint your users reach, and conversation history is kept server-side, so a reload restores the thread. **New chat** starts a fresh conversation. Tool calls render expanded in the transcript — the playground is deliberately a debug view of what your agent is doing, not a polished end-user skin.

The header shows an honest deployment chip that updates on its own while a deploy is in motion:

| Chip                   | Meaning                                                                                                |
| ---------------------- | ------------------------------------------------------------------------------------------------------ |
| **Checking…**          | Studio is resolving the latest deploy's status.                                                        |
| **Starting…**          | A deploy is queued, building, or rolling out.                                                          |
| **Live**               | Deployed and reachable — chat away.                                                                    |
| **Deploy failed**      | The latest deploy failed; the error shows in the chat column, with a **Try again** for no-code agents. |
| **Status unavailable** | Studio couldn't fetch the status — the agent may still be fine.                                        |
| **Not deployed**       | No deployment in flight or serving.                                                                    |

Until the agent is live, the composer stays disabled with an honest hint rather than a chat that goes nowhere. Once live, the header also links **Your agent's page ↗** — the standalone page every deployed agent gets (see [Share and publish](/studio-share/)) — and **Open in Platform ↗**, the app's detail page in the [console](/console/).

After your first successful chat turn, a one-shot nudge points you at sharing.

## The Settings drawer

**Settings** edits the same fields as the create form — instructions, name, model, superpowers — seeded from what's actually deployed. Edits stay local until you press **Deploy changes** (**Deploy**, on an agent that's never deployed); **Discard** reverts to the live version. Unsaved edits survive an accidental close or navigation within the tab — the drawer restores them with a "Restored your unsaved edits" notice.

Studio only edits what it can safely own. Agents it can't, get an honest hand-off instead of an editor:

- **Built with code** — edit in your repo and redeploy with the [CLI](/cli/).
- **Instructions in project files** — a CLI-managed project whose prompt lives on disk; edit it there.
- **Unreadable configuration** — edit from the CLI.

Everything a Studio edit doesn't own — CLI-authored fields like runtime caps, hosted MCP entries, environment config — rides through untouched: Studio overwrites only the fields its form shows.

## Repo-managed agents

Agents reconciled from a repo with `guuey agent apply` show a **Managed by <repo>** chip in the playground header (the tooltip names the repo, commit, and path). The Settings drawer carries a standing warning that instructions, model, and tools are managed from that repo — the next `guuey agent apply` will overwrite changes made here — and your first edit is held behind an **Edit anyway?** confirmation. Confirm once and the drawer edits freely until you close it; reopen it with a clean form and the first edit is guarded again, while restored unsaved edits come back unguarded.

Going the other way, `guuey pull` ejects a Studio-built agent's live definition into a local `guuey.json` so you can check it into a repo and manage it as [agents as code](/agents-as-code/) from then on.

Next: [Share and publish](/studio-share/).