# Glaze Manual > Turn an idea into a real desktop app from a single prompt. The Glaze Manual is your complete guide to building, refining, and sharing apps with Glaze. This file contains the full Glaze Manual in markdown format for Large Language Models and AI assistants. ## Basics ### Quickstart Source: https://manual.glaze.app/basics/quickstart Description: Build your first Glaze app in minutes by chatting with the agent, then run it and share it with others. Last updated: 01 July 2026 New to Glaze? Start here. In a few minutes you'll download the app, build your first desktop app from a single prompt, open it, and share it with others. ##### Download Glaze Download Glaze for Mac, then open it and sign in to your account using **Google**, **Apple**, or **Email**. [Download Glaze](https://glaze.app) To start building, open **My Projects** and click **New Project**. This opens the Agent Chat, ready to start building your first desktop app. ##### Describe Your First App In the Agent Chat window, describe the app you want in plain language. The more you say about its purpose, the data it works with, how it should look, and the key actions it supports, the closer the agent gets right on the first try. > [!TIP] > **Example prompt** > > Build a drag-and-drop app that renames my screenshots and sorts them into folders by the date they were captured. Read the [Writing Effective Prompts page](https://manual.glaze.app/prompting/writing-effective-prompts) for how to write a great first prompt, or describe your problems to the agent and let it suggest an app idea to you. ##### Watch the Agent Build It The agent goes to work: it plans the app, writes the code, installs what it needs, and shows each step in the chat as it goes. For bigger ideas, turn on **Plan mode** to agree on the approach before any code is written. Read the [Plan & Build Modes page](https://manual.glaze.app/prompting/plan-and-build-modes) for the difference between planning and building. ##### Open Your App When the build finishes, your app opens in its own window just like any other desktop app. Try it out, click around, and see how it feels. You can find it again any time from the **My Projects** tab in the Glaze app. Read the [Running Your App page](https://manual.glaze.app/capabilities/running-your-app) for how running and previewing work. ##### Refine It, Then Share Want to change an aspect of your app? Send a follow-up message in the Agent Chat window, such as "make the timer red" or "add a sound picker", and the agent updates the app in place. When you're ready to share your app, **publish** it to the Store or share it with your team in the **Team Store**. Read [Iterating](https://manual.glaze.app/prompting/iterating) and the [Publish Apps page](https://manual.glaze.app/share/publish-apps) to go further. #### Next Steps You've built and shared your first app. Here's where to go to get more out of Glaze. - **[Writing Effective Prompts](https://manual.glaze.app/prompting/writing-effective-prompts)** — Write prompts that get you a great result on the first try. - **[What Glaze Can Build](https://manual.glaze.app/basics/what-glaze-can-build)** — Explore the kinds of desktop apps you can make with Glaze. - **[Capabilities](https://manual.glaze.app/capabilities/running-your-app)** — Menu bar apps, notifications, files, and other native features. - **[Publish Apps](https://manual.glaze.app/share/publish-apps)** — Publish to the Store or share an app with your team. ### Core Concepts Source: https://manual.glaze.app/basics/core-concepts Description: The core concepts behind Glaze, and what each part does to turn your ideas into real desktop apps. Last updated: 01 July 2026 Glaze turns a plain-language description into a real desktop app. Knowing the core concepts behind it, what each part does and how it fits with the rest, makes everything else easier to follow. Each one links to a dedicated page in the Glaze Manual for the full detail. #### Projects and Apps A **project** is something you build in Glaze. It lives in the **My Projects** tab, and it's where you go to create a new project, edit existing ones, or publish them. The **app** is what a project produces: a real desktop app that runs on your Mac, in its own window, and looks and feels like it belongs. Apps are **local-first**, so most keep working without an internet connection. When you publish an app to the Public Store or Team Store, the app is what you're sharing. In short, you work on a **project**, and the result is an **app**. See [Managing Your Projects](https://manual.glaze.app/basics/managing-projects) and [What Glaze Can Build](https://manual.glaze.app/basics/what-glaze-can-build). #### The Agent You build with Glaze by talking to the **agent** in **Agent Chat**. You describe what you want, and the agent plans the work, writes the code, installs what it needs, and opens the app, showing each step as it runs. You don't have to write any code yourself, though the code is yours. You direct the agent in plain language and it does the building. See [Agent Chat](https://manual.glaze.app/prompting/agent-chat). #### Prompts A **prompt** is a message you send the agent: a description of the app you want, or a change you want made. Prompts are how you steer everything, from the first build to the smallest tweak. The clearer your prompt, the closer the agent gets on the first try. See [Writing Effective Prompts](https://manual.glaze.app/prompting/writing-effective-prompts). #### Plan and Build The agent works in two modes: - **Build mode** makes changes directly. It's the default and the fastest way to iterate. - **Plan mode** settles on an approach with you before any code is written, which helps with bigger or riskier changes. Moving between them lets you go quickly on small things and think first on large ones. See [Plan & Build Modes](https://manual.glaze.app/prompting/plan-and-build-modes). #### Versions Every build is saved as a **version** iteration. You can look back at what changed and, if a change breaks something or heads the wrong way, **revert** to a version that worked. Nothing you build is lost, so you're free to experiment. See [Version History](https://manual.glaze.app/prompting/version-history). #### Credits **Credits** are what the agent spends to build and edit your apps. They're metered by how much work a request takes, so a quick tweak costs little and a build from scratch costs more. A few things never cost credits, including generating an app icon, reporting an issue, and running the `/upgrade` command. See [Credits](https://manual.glaze.app/account/credits). #### Sharing and the Store An app is yours privately in the **My Projects** tab until you decide to share it. When publishing, you choose how visible it is: - **Public Store**: Shared publicly with all Glaze users to discover and install. - **Team Store**: Available only to team members in the same Team. - **Unlisted**: Anyone with the link can install it, but it isn't listed on the Public Store. The **Store** is where you discover and install apps other people have built in Glaze. See [Visibility Levels](https://manual.glaze.app/share/visibility-levels) and [Publish Apps](https://manual.glaze.app/share/publish-apps). #### Integrations Apps can **connect to external services** like GitHub, Linear, and Slack, or any provider you set up yourself, so they can work with your real data. Connections are made securely, and access tokens are stored encrypted on your Mac, protected by the Keychain, never in plain text. See [Integrations Overview](https://manual.glaze.app/integrations/overview). #### How It Fits Together Put together, the flow looks like this: 1. You describe an app to the **agent** with a **prompt**. 2. The agent builds it, saving each step as a **version** and spending **credits** as it works. 3. Your **app** opens and runs locally on your Mac. 4. You refine it with more prompts, reaching for **Plan mode** on bigger changes and rolling back a **version** if you need to. 5. When it's ready, you **share** it through the Public Store, your Team Store, or a private link. ### What Glaze Can Build Source: https://manual.glaze.app/basics/what-glaze-can-build Description: Discover the kinds of real Mac apps you can build with Glaze, from personal tools to internal dashboards. Last updated: 01 July 2026 Glaze can build a wide range of real Mac apps, from quick personal utilities to polished tools you'd share with others. They use the same native features as any other app on your Mac, run local-first, and look and feel native rather than like a website in a window. #### What to Build Glaze shines when you have a specific job in mind and want a tool shaped exactly around it. The apps people build tend to fall into a few groups: - **Personal trackers** — Keep tabs on the things you care about: a habit or workout log, an expense tracker that charts a CSV you drop in, a reading queue, or a daily journal. - **Menu bar apps** — Always-on tools that surface what matters the moment it changes: a CI or build monitor, an on-call status light, a stock or crypto ticker, or a focus timer, a click away in the menu bar. - **Internal tools** — Software shaped around how your team works: a support console wired to GitHub and Slack, an on-call view pulling Linear issues, or a release tracker, shared privately to your Team Store. - **Workflow automations** — Apps that watch and act on their own: auto-rename and sort screenshots as they land, or batch-convert and compress files you drop onto a window. If you can describe the task, the agent can build an app for it. When you're not sure where to start, open **My Projects**, click **New Project**, and describe the problem rather than the solution. The agent can suggest an app idea back to you. #### Native Powers Your apps aren't web pages in a window. They're real desktop apps that can use the same native features as any other desktop app on your Mac. You ask for these in plain language, and the agent wires them up: - **Files and local data**: Read, write, and organize files, and keep their own data on disk so your work is there next time. - **Devices and permissions**: Use the camera, microphone, or location, asking macOS for permission the same way any app does. - **Notifications, menu bar, and tray**: Post system notifications, run from the menu bar, and show status in the tray. - **Windows and layout**: Open multiple windows, float a small utility on top, or use a frameless custom design. - **System integration**: Register global hotkeys, associate file types, and handle drag-and-drop to and from Finder. #### Local-First Glaze apps are **local-first**. They run on your Mac, in their own window, like anything else you've installed. The agent does its building work online, but most finished apps keep working without an internet connection, since your data lives on your machine rather than on a server you have to reach. An app only needs the network for the parts that genuinely depend on it, such as fetching the weather or connecting to an external service. See [Core Concepts](https://manual.glaze.app/basics/core-concepts) for how projects, apps, and the agent fit together. #### Worth Knowing Glaze is good at a wide range of desktop tools, but a few things are worth setting expectations on: - It builds **desktop apps**, not websites, mobile apps, or browser extensions. - The agent works best on focused, well-described apps. Very large or sprawling products are harder to get right in one pass, so it helps to build them up in steps with follow-up prompts. - Connecting to an external service depends on that service having an API you can reach. When something doesn't come out the way you expected, the fix is usually another prompt. See [Iterating](https://manual.glaze.app/prompting/iterating), and [Version History](https://manual.glaze.app/prompting/version-history) if you want to step back to an earlier version. #### Where It Runs Glaze builds **Mac apps** currently, so others will need Glaze to install the apps you've shared. Support for Windows and Linux is coming down the road. ### Glaze Dashboard Source: https://manual.glaze.app/basics/glaze-dashboard Description: Find your projects, browse the Store, manage installed apps, and start something new from your home base in Glaze. Last updated: 24 August 2026 The dashboard is the first thing you see when you open Glaze. It's home for everything you build: your projects, the Store, and where you create a new app. #### The Sidebar A sidebar runs down the left of the main window, with a search box at the top and four places to go: - **[My Projects](https://manual.glaze.app/basics/managing-projects)** — Everything you've created. Open, edit, rename, and manage your projects from here. - **[Store](https://manual.glaze.app/share/store)** — Discover and install apps other users have shared, or browse your private Team Store. - **[Installed Apps](https://manual.glaze.app/share/updates)** — Browse and manage all Glaze apps you have installed. - **[Creator Hub](https://manual.glaze.app/share/creator-hub)** — See how your published apps are doing, with installs, active users, Store conversion, and feedback. At the bottom of the sidebar is the **Account Menu**. Click your avatar to sign out, open **Settings**, Send Feedback, or join the Slack Community. See [Manage Account](https://manual.glaze.app/account/manage-account). #### My Projects **My Projects** is where your projects live. Each project shows its icon and name, and you can view them two ways using the toggle in the toolbar: - **List view** shows your projects in a column. - **Grid view** lays them out as a wall of icons. ![The My Projects tab in Glaze showing your projects](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-projects.png) ##### Detail Panel The **detail panel** gives you a full overview of an app's metadata. At the top of the detail panel is the app's icon (with a pencil button to generate or upload a new one) and its name, which you can edit in place. Below that, you will see more metadata, including: - **Created** and **Last Edited** dates - **Directory**: The project's folder on your Mac, which you can click to reveal in Finder - **Visibility**: Whether the app is **Unpublished**, on the **Public Store**, **Unlisted**, or shared with a Team - **Published Version** and **Last Published**: Shown once the app has been published to a Store. A toolbar at the bottom of the panel holds the actions you reach for most: ** Edit App** to open Agent Chat, ** Publish**, and a ** More…** menu with other actions. For what each of these does, see [Managing Your Projects](https://manual.glaze.app/basics/managing-projects). > [!NOTE] > When you publish an app, a small status dot appears on its item entry while it's being reviewed, with states like **Draft submission**, **Review in progress**, **Review passed with warnings**, or **Review failed**. See [Publish Apps](https://manual.glaze.app/share/publish-apps). #### Start a New Project The **New Project** button sits in the toolbar, and the shortcut `⌘` `N` does the same thing from anywhere in the app. When the button or shortcut is pressed, **Agent Chat** opens where you describe the app you want and the agent creates it. ![The Glaze agent ready to build an app in Agent Chat](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-agent.png) > [!TIP] > You can also set a global **Agent Shortcut** that opens the agent even when Glaze isn't focused. See [Settings](https://manual.glaze.app/basics/settings). Agent Chat opens in its own window, separate from the main Glaze window, so you can keep creating your app and the dashboard is accessible for other actions. See [Agent Chat](https://manual.glaze.app/prompting/agent-chat) for how the conversation works. #### Store The **Store** is where apps are shared and discovered by other Glaze users. Browse what others have published, install something that fits what you need, or find your team's private apps in the Team Store. When you create something worth sharing, you publish it here too. See [the Store page](https://manual.glaze.app/share/store) and [Publish Apps](https://manual.glaze.app/share/publish-apps). ![Public Store showing apps to discover and install](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-store.png) #### Settings Open **Settings** from the Account Menu at the bottom of the sidebar. Settings opens a separate window with tabs for **Account**, **General**, and any teams you belong to. The **General** tab is where you set the app's theme, agent shortcut, and how the keyboard behaves while you create. See [Settings](https://manual.glaze.app/basics/settings). The **Account** tab covers your profile, plan, and credits. See [Manage Account](https://manual.glaze.app/account/manage-account). ![The Account tab in Glaze Settings showing your profile, plan, and credits](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-settings-account.png) ### Managing Your Projects Source: https://manual.glaze.app/basics/managing-projects Description: Manage your apps from the detail panel to rename, change icons, archive, delete, move them between Macs, and open a project's source in your own editor. Last updated: 24 August 2026 Your projects live in the **My Projects** tab. Select one in the list and its details appear in a panel on the right, where you can find every action for managing the app and view its metadata. Every project is also a real folder on your Mac. By default they live together in a **Glaze** folder at `~/Glaze/`, with each project in its own subfolder named after the app. Inside a project you'll find a `sources` folder with the editable files that make up the app, and a `runtime` folder with the built output Glaze runs from. > [!NOTE] > If you used Glaze before your projects lived in `~/Glaze/`, they move there automatically the first time you sign in after updating. Your chats, permissions, and settings come along, and nothing changes about how your apps run or publish. #### Edit Icon Glaze generates an icon for every app, and you can change it any time from the detail panel or Agent Chat. 1. Click the pencil button on the app's icon in the detail panel or the app icon in Agent Chat to open **Edit App Icon**. 2. Click **Upload Icon** to use an image from your computer, or describe the icon you want and click **Generate** for a set of options. To guide a generated icon, drop an image onto the composer or attach a reference image. 3. Select the icon option you like and click **Save**, and your new icon then appears everywhere the app shows up. > [!TIP] > Generating an icon is free and never uses your credits, so regenerate as often as you like until you find the perfect icon for your app. #### Rename a Project In the detail panel, the project's name sits below its icon and is editable in place. Click the name, type a new one, and it **saves automatically when you click away**. You can also click the app name at the top of Agent Chat to rename it. > [!NOTE] > A project's description is set by the agent as it builds, and you can refine it when publishing. See [Publish Apps](https://manual.glaze.app/share/publish-apps). #### Archive and Restore Archiving is the tidy way to set a project aside without losing anything. From the detail panel, open the ** More…** menu and click ** Archive Project**. Archiving removes the app from your main projects list and from your Applications, but your project files stay on disk, so you can bring it back at any time. Archived projects gather in an **Archived Apps** section at the bottom of the list. To restore one, select it there and choose ** Recover**. It returns to your active projects exactly as it was. #### Delete a Project Deleting is permanent. From the ** More…** menu, click ** Delete Project**, then confirm in the dialog. Deleting **removes the project and cannot be undone**, so reach for **Archive** instead if there's any chance you'll want it back. > [!WARNING] > If you've published the app, deleting your local project does not remove it from the Store. The published version stays available there. To take it down, unpublish it first. #### Restore a Published App If you no longer have a published app's project on your Mac, whether it was deleted, or you're setting up on a new machine, you can pull it back down from the Store as a fresh local project. This works for anything you've published, since the Store keeps a copy of its source. A restored project starts clean: it comes back with your app's latest published source, but with a fresh chat, no agent memory, and no app data carried over from before. > [!NOTE] > Restoring gets you back to your published source, not a snapshot of the local project as you left it. Uncommitted local changes you never published aren't part of what comes back. #### Export and Import an App You can move a project between Macs, or hand it to someone directly, by exporting it to a file. - **Export**: Open the ** More…** menu and click ** Export Project…**. Glaze saves the project as a single `.glaze` file you can store or send. - **Import**: In the menu bar, choose **File -> Import Project…** and pick a `.glaze` file. The project is added to **My Projects**, ready to open and edit. > [!NOTE] > Exporting is a direct, file-based way to share a project. For publishing to the Store or sharing privately with your team, see [Publish Apps](https://manual.glaze.app/share/publish-apps). #### Open in Another Editor Because a project is a plain folder of real source files, you can open it in an external editor or coding agent and work on it there instead of, or alongside, Glaze's own Agent Chat. Each project ships with the instructions and Glaze skills an outside agent needs to understand it, preview changes, and package the result back into a Glaze app. In the Agent Chat toolbar, use the **Open With** action to open the current project's source. You can open a project in: - **Terminal** - **Finder** - **Cursor** - **VS Code** - **Zed** / **Zed Preview** - **Ghostty** - **ChatGPT** - **Conductor** #### Reveal Files in Finder To jump straight to a project's folder, click ** Reveal in Finder** from the ** More…** menu, or click the project's **Directory** path in the detail panel. Opening the folder lets you back up a project, inspect its files, or work with them in another tool. > [!NOTE] > The **Glaze** folder that holds all your projects lives at `~/Glaze/` by default. To keep it somewhere else, change its location in **Settings → General**. Glaze doesn't support cloud-synced or network locations for this folder. ### Settings Source: https://manual.glaze.app/basics/settings Description: Control how Glaze looks and behaves, from themes and the agent shortcut to keyboard behavior, text zoom, and custom instructions. Last updated: 24 August 2026 Settings is where you control how Glaze looks, how you summon the agent, and how the keyboard behaves while you build. To open Settings, click the avatar menu in the sidebar and choose **Settings**. #### Account The **Account** tab displays your profile (display name and avatar), your plan, and your credits. For more information about your account, see [Manage Account](https://manual.glaze.app/account/manage-account). ![The Account tab in Glaze Settings showing your profile, plan, and credits](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-settings-account-0.9.0.0.png) #### General The **General** tab holds your appearance, project, and agent options. **Appearance** sets the app's theme, **Projects Folder** sets where your projects live on disk, and the **Agent** section holds the agent shortcut, the keyboard behavior in Agent Chat, the text zoom and completion sound, and your custom instructions. ![The General tab in Glaze Settings with Appearance and Agent sections](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-settings-general-0.9.0.0.png) ##### Appearance Under **Appearance**, choose the **Theme** for the Glaze app: - **Auto** follows your Mac's system appearance, switching with it between light and dark. - **Light** and **Dark** keep Glaze in that mode regardless of your system setting. > [!NOTE] > This theme controls the Glaze app's own windows. It does not change the look of the apps you build or use from the Store. ##### Projects Folder **Projects Folder** is where Glaze keeps all your projects on disk, at `~/Glaze/` by default. Click **Change…** to pick a different location, or reveal the current one in Finder. Glaze doesn't support cloud-synced or network destinations for this folder. See [Managing Your Projects](https://manual.glaze.app/basics/managing-projects) for more on how projects are stored. ##### Agent Shortcut The **Agent Shortcut** is a global hotkey that opens the agent from anywhere, even when Glaze isn't focused. There's no default, so it's blank until you set one. - **Record**: Click **Record** and press the combination you want, such as `⌘` `⇧` `Space`. Glaze saves it the moment you finish pressing the shortcut. Press `Esc` while recording to cancel. - **Change or Clear**: Click the shortcut to record a new combination, or click **the clear button** to remove it. Once set, pressing the shortcut opens the agent and readies it for a new prompt. If the combination is already used by another app, Glaze flags it as invalid or in use, so you can pick a different one. ##### Send Message **Send Message** decides which key sends your prompt in Agent Chat: - **Return** (Default): `↵` sends the message, and `⇧` `↵` inserts a newline. - **Command Return**: `⌘` `↵` sends the message, and `↵` inserts a newline. ##### Follow-up Behavior When the agent is already running and you send another message, **Follow-up Behavior** decides what happens to it: - **Queue** (Default): Your follow-up waits and runs after the current work finishes. - **Steer**: Your follow-up interrupts the current run and steers the agent right away. Whichever you choose, press `⌘` `↵` to do the opposite for a single message. See [Iterating](https://manual.glaze.app/prompting/iterating) for when each is useful. ##### Text Zoom **Text Zoom** scales the typography and spacing of the whole Agent Chat feed, so you can make the conversation larger or smaller to suit your screen. It runs from 75% to 200% in 5% steps, with a default of 100%. - **Zoom out**: Click **the minus button** to shrink the conversation by one step. It's disabled at 75%. - **Zoom in**: Click **the plus button** to grow the conversation by one step. It's disabled at 200%. - **Reset**: Click **the reset button** to return to 100%. It's disabled when you're already at 100%. The percentage readout between the buttons shows the current zoom. Changes apply immediately, with no restart needed. You can also adjust the zoom directly from the Agent Chat window: press `⌘` `+` to zoom in, `⌘` `-` to zoom out, and `⌘` `0` to reset to 100%. ##### Completion Sound **Completion Sound** plays a sound when the agent finishes a task in Agent Chat. It's on by default, and turning it off will not play any sound from the agent. ##### Custom Instructions **Custom Instructions** are notes the agent includes in every session by default, such as a coding preference or a style you want across your apps. Click **Custom Instructions** to open the editor, write your instructions, and choose **Save**. They apply to new work going forward, so you don't have to repeat yourself in each prompt. #### AI Access The **AI Access** tab lists every app you've granted permission to use AI. For each app you can see its AI usage and daily cap, and you can revoke its access at any time. Revoking an app's access here and it stops using AI until you allow it again. Daily cap allows you to limit how many credits a Glaze app can use a day from your credit allowance for AI-powered features. You can increase or lower the cap depending on your use case, and each app receives its own individual daily cap of credits. An app is added to this list the first time you grant its AI permission prompt. For how apps use AI and how it's billed against your credits, see [AI](https://manual.glaze.app/capabilities/ai). #### Teams If you belong to one or more teams, each Team gets its own tab here for managing that team, and a **New Team** option lets you create one. See [Get Started with Teams](https://manual.glaze.app/team/get-started) for how Glaze Teams work. ## Prompting ### Agent Chat Source: https://manual.glaze.app/prompting/agent-chat Description: Prompt the agent in the composer to build your app, adding context, attaching images, annotating, and queuing follow-ups as it works. Last updated: 24 August 2026 **Agent Chat** is where you build your app. You write your prompts in the **composer** at the bottom, the agent responds and works in the same view, and a feed shows each step as it goes. From the composer you can add context, attach images, and line up follow-up messages while the agent works. ![Agent Chat with the agent working through a build](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-agent.png) #### The Composer Type your prompt in the composer and send it, or click the send button (the up arrow) to its right. While the agent is running, that same button becomes a stop button. See [Iterating](https://manual.glaze.app/prompting/iterating). ![The composer at the bottom of Agent Chat](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-agent-composer.png) > [!TIP] > Prefer a different key to send? You can change how the keyboard sends and steers your messages in **Settings**, under **Send Message** in the **General** tab. ##### Recall Past Prompts With the composer empty, press `↑` to bring back your previous prompt, and `↑` again to step further back through what you've sent. Press `↓` to move forward again. This is handy for resending a prompt with a small tweak. #### Choose a Model The composer has a **model picker** where you choose which model builds your app: - **Glaze Fast**: A leaner, faster option that uses fewer [credits](https://manual.glaze.app/account/credits). It's available on every plan, including Free. - **Glaze Smart**: Glaze's fuller workflow using our most capable models, for tougher builds. Glaze Smart is included with [Pro](https://manual.glaze.app/account/plans). - **Your connected Claude models**: Once you [connect a Claude subscription](https://manual.glaze.app/advanced/bring-your-own-subscription), models such as Opus, Sonnet, and Fable appear here too, and building with them uses your Claude subscription instead of Glaze credits. Your model choice is remembered **per project**, so each app keeps building with the model you picked for it until you change it. > [!NOTE] > Building with a connected Claude model is a **beta** feature and works a little differently from Glaze Fast and Glaze Smart. See [Bring Your Own Agent](https://manual.glaze.app/advanced/bring-your-own-subscription). #### Add Context Menu The **Plus** button to the left of the composer opens a menu where you add context to your next prompt. This menu contains: - **Plan**: Turn on Plan mode so the agent agrees on an approach with you before writing code. See [Plan & Build Modes](https://manual.glaze.app/prompting/plan-and-build-modes). - **Attachment**: Pick an image from your computer to attach as a reference. - **Integration**: Connect your app to an outside service. Choose **GitHub**, **Linear**, **Slack**, or **Other OAuth Provider** from the menu, and the agent sets up the connection as it builds your app. See [Integrations Overview](https://manual.glaze.app/integrations/overview). ![The Add Context menu open in the Agent Chat composer](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-agent-addcontext.png) #### Annotate Your App The composer has an ** Annotate** button for pointing at parts of your app you'd like to tweak or change, so the agent knows exactly what you mean instead of describing it. See [Annotate](https://manual.glaze.app/prompting/annotate). #### Attach Images Images are the fastest way to show the agent what you mean, whether it's a screenshot of something to fix, a design to match, or a mockup to work from. There are three ways to attach an image: - **Paste it**: Copy an image and paste it straight into the composer. - **Pick a file**: Open the Plus menu and choose **Attachment**, then select an image from your computer. - **Drag it in**: Drag an image from Finder onto the chat. Attached images appear as thumbnails above the composer. Click one to preview it, or remove it before sending. Combine an image with words for the clearest direction, such as a screenshot plus "make this button match the others." > [!NOTE] > For pointing at part of your **running** app rather than attaching a separate image, use the annotation tool. See [Annotate](https://manual.glaze.app/prompting/annotate). #### Queue Follow-Ups You don't have to wait for the agent to finish before lining up your next message. While the agent is running, type a follow-up and send it, and it joins a queue that runs after the current turn. ![A queued follow-up message above the composer in Agent Chat](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-agent-followup.png) Queued messages collect just above the composer under a **Queued** count. Hover one to reveal its controls: - ** Edit Message**: Pull the message's text back into the composer to change it. When you resend it, it returns to the queue in its original spot rather than the back. - ** Steer**: Move the message ahead so it runs next. - ** Delete**: Remove the message from the queue. To reorder the queue, drag a message by using **drag handle**, or focus the handle and use the arrow keys. Reordering is available once you have more than one message queued. This lets you think a few steps ahead while the agent works through the current step. > [!TIP] > Want your message to redirect the agent right away rather than wait in line? That's **steering**, and you can switch the behavior of the send key while the agent is busy. See [Iterating](https://manual.glaze.app/prompting/iterating). #### Your Draft Is Kept As You Work Your in-progress message stays put as you move around the chat, so a half-written prompt isn't lost if you glance at the feed or switch views. To clear a draft you've decided against, select the text and delete it. ### Plan & Build Modes Source: https://manual.glaze.app/prompting/plan-and-build-modes Description: Build mode changes your app right away while Plan mode agrees on an approach first, so you plan big changes and build small tweaks directly. Last updated: 06 July 2026 The agent works in two modes. **Build mode** makes changes directly, and **Plan mode** agrees on an approach with you before any code is written. Build is the default and the fastest way to iterate; Plan is worth reaching for on bigger or riskier changes. #### Build mode In **Build mode**, the agent reads your prompt and starts working right away: it plans the work, writes the code, installs what it needs, and runs the app, showing each step in the chat. This is the default, and it's the right choice for most prompts, especially small, clear changes where you'd rather just see the result. You don't have to turn anything on. Open a project, describe what you want, and the agent builds it in your app. #### Plan mode In **Plan mode**, the agent holds off on writing code. Instead it thinks through your request and proposes a plan: what it intends to do and how, laid out for you to read. Nothing changes in your app until you approve it. This is useful when: - The change is large or touches several parts of the app. - You want to confirm the approach before spending credits building it. - You're not sure the agent has understood the goal and want to check its thinking first. - A change is risky and you'd like to agree on the direction before anything moves. ##### Turn On Plan mode Click **the Plus button** in the composer and choose **Plan**, or press `⇧` `Tab` to toggle modes. A green **Plan** pill appears in the composer to show the mode is on. Then send your prompt as usual, and the agent responds with a plan rather than a finished change. ![The Add Context menu in the composer with the Plan option](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-agent-addcontext.png) > [!TIP] > `⇧` `Tab` flips between Plan and Build, so you can switch in a keystroke without reaching for the menu. To leave Plan mode, you can also remove the **Plan** pill from the composer. ##### Review and Approve a Plan When the agent finishes planning, it presents the plan in the chat and asks **"Would you like to approve this plan?"** You have a few choices: - **Approve it**: Choose **Yes, approve the plan** and **Confirm**, and the agent switches into Build mode and carries the plan out. - **Ask for changes**: Choose **Type what to change**, describe what you'd like different, then **Confirm**. The agent revises the plan and asks again. - **Dismiss it**: If you've changed your mind, choose **Dismiss** and the agent stops without making changes. Reading the plan first is the whole point of the mode, so take a moment with it. If anything looks off, it's better for credit usage to correct the plan than to build the wrong thing and redo it. ![The agent presenting a plan to review and approve in Agent Chat](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-agent-plan.png) > [!NOTE] > Approving a plan automatically switches you back to **Build mode**, so the agent can execute it. Your next prompt runs directly in Build mode unless you turn Plan mode on again. #### Switch Between Modes You're never locked into a mode. Switch with `⇧` `Tab` or **the Plus button** before sending a prompt, as often as you like. A natural rhythm is to plan the big, structural changes and build the small ones directly: 1. Turn on **Plan mode** for a significant new feature and review the plan. 2. Approve it, and the agent switches into **Build mode**, carries the plan out, and leaves you in Build mode. 3. Make a string of small tweaks directly in Build mode. 4. Reach for Plan mode again when the next big change comes up. ### Iterating Source: https://manual.glaze.app/prompting/iterating Description: Shape your app one focused prompt at a time, queuing what comes next, steering the agent mid-run, or rolling back a change that went wrong. Last updated: 06 July 2026 Building an app is a conversation, not a single command. You describe an initial version, see it run, then refine it with follow-up prompts until it's right. Each turn builds on the last, and you stay in control: steer the agent when it drifts, queue up what's next, or stop a run and head a different direction. #### Refine Across Turns After the agent builds, the best next step is usually to try it then send one focused change at a time. Small, specific follow-ups are easy for the agent to get right and easy for you to check. Each follow-up builds on everything so far, so you can speak naturally about the app you already have: - "Make the header sticky." - "Add a setting to change the accent color." - "The list feels cramped. Add more spacing between rows." You don't need to restate the whole app each time. Reach for [Plan mode](https://manual.glaze.app/prompting/plan-and-build-modes) when a follow-up is large or structural, and keep it in **Build mode** for quick tweaks. #### Provide Feedback When something isn't right, say what's wrong and what you want instead, as concretely as you can. The agent works from what you tell it, so the more specific your feedback, the better the fix. For instance, "The Save button is too far from the form. Move it directly below the last field" gives the agent far more to act on than "the layout is off." When a change is about a particular part of your running app, you can also point at it directly with the [Annotate](https://manual.glaze.app/prompting/annotate) tool instead of describing where it is. #### Steer or Queue While the Agent Works You don't have to wait for the agent to finish a turn before sending your next message. While the agent is running, what your send key does depends on the **Follow-up Behavior** setting: - **Queue**: Your message waits and runs after the current turn finishes. Queued messages collect above the composer under a count; hover one to **Send now** or remove it from the queue. - **Steer**: Your message interrupts the current turn and redirects the agent right away, so you can course-correct the moment you notice something heading the wrong way. The tooltip on the send button tells you which the key will do, and shows the shortcut for the other one, so you can queue with one key and steer with another. Choose your default under **Follow-up Behavior** in **Settings**. > [!NOTE] > Queue when you're lining up the next step and the current one is best for most cases. Steer when the agent is going the wrong way and you want to stop it sooner rather than let it finish. #### Cancel a Run To stop the agent mid-run, click **the stop button** in the composer (it replaces the Send button while the agent is running and the composer is empty). The current turn ends, and you can send a new prompt to try a different direction. Cancelling doesn't undo work the agent already finished. If a run left your app in a worse state, roll back to an earlier version. See [Version History](https://manual.glaze.app/prompting/version-history). #### Keep Iterating, or Start Fresh Most of the time, keep iterating; the agent handles a long back-and-forth well, and your history is there to roll back to. Consider a fresh start when: - A change broke something and the simplest fix is to **roll back** to the last good [version](https://manual.glaze.app/prompting/version-history) and re-prompt. - The conversation has drifted far from where you want to be. Type `/clear` to clear the chat history and start the conversation over (your app itself stays as it is). - You've been correcting the same misunderstanding repeatedly. Re-state the goal from scratch, more concretely, rather than patching turn by turn. For diagnosing when the agent has misread your intent, see [When the Agent Gets It Wrong](https://manual.glaze.app/prompting/writing-effective-prompts#when-the-agent-gets-it-wrong). ### Approvals Source: https://manual.glaze.app/prompting/approvals Description: Answer the agent's clarifying questions and approve any action before it runs, right in Agent Chat. Last updated: 08 July 2026 As the agent works, it sometimes pauses to check in with you. It might ask a clarifying question when your prompt leaves something open, or request your approval before completing a sensitive action. Both appear right in the Agent Chat, and the agent waits for your answer before continuing so nothing significant happens without your say-so. #### Clarifying Questions If your request is unclear, the agent asks rather than guesses. A question appears in the chat with a short list of options to choose from, so you can steer the work without breaking your flow. 1. Read the question and options. The agent states what it needs to know and offers a few options, each with a short description. For a single-choice question it suggests a sensible default, already selected, so you can move on quickly if it's right. 2. Choose the option you want. Some questions let you select more than one (you'll see "Select all that apply"). If none of the options fit, choose **Other** and type your own answer. 3. Choose **Confirm** to send your answer. If the agent asked a few questions at once, you'll step through them with **Continue**, then confirm on the last. To skip answering, choose **Dismiss**. > [!TIP] > Answering with a clear choice is faster than typing, but **Other** is there when your preferred answer isn't on the list. Use it whenever the options don't capture what you actually want. #### Permission Requests Glaze apps are **local-first**, and the agent works within your project. When a step would reach **outside** that project, the agent stops and asks before going ahead so nothing happens beyond your project without your say-so. You'll see a permission request when a step would, for example: - **Read or write files outside your project**, such as somewhere else on your Mac. - **Run a command that touches something sensitive** beyond the project folder. The request shows a short reason and, when there's one, the exact file path or command involved, so you can see precisely what's being asked. ##### Allow or Deny A permission request gives you two choices: - **Allow** lets the agent take that one action and continue. - **Deny** stops that action. The agent carries on without it, usually finding another way or telling you it couldn't proceed. > [!NOTE] > Each request is a **one-time** decision about that specific action. Allowing one step doesn't hand the agent open-ended access; the next sensitive action asks again. > [!WARNING] > Read what's being requested before you allow it. The reason and the path or command are there so you can decide with the full picture, especially when a step would write outside your project or reach the network. #### Approve a Plan In **Plan mode**, the agent settles the approach with you before writing any code. When it's ready, it presents the plan and asks **"Would you like to approve this plan?"** - Choose **Yes, approve the plan** and the agent switches into Build mode and carries it out. - Not ready to approve? Use the **Ask for changes or clarification** field to reply in your own words. If you ask a question, the agent answers and presents the same plan again so you can decide with a clearer picture. If you request a change, the agent revises the plan and shows the new version. Either way it holds off on building, and the plan card updates in place, so you can refine or ask as many times as you like before committing. Approving a plan is your checkpoint on bigger or riskier work: you agree on the shape of the change first, then let the agent build it. For when to plan first and when to build directly, see [Plan & Build Modes](https://manual.glaze.app/prompting/plan-and-build-modes). ![The agent presenting a plan to review and approve in Agent Chat](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-agent-plan.png) ### Annotate Source: https://manual.glaze.app/prompting/annotate Description: Point at any element in your running app to show the agent exactly what to change, instead of describing where it is in words. Last updated: 16 July 2026 Sometimes the fastest way to say what you want changed is to point at it. **Annotate** lets you mark up your live, running app, selecting the exact element you mean, so the agent knows precisely what you're talking about without you describing where it is in words. ![Annotating an element in a running Glaze app](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-annotate-usage.png) #### What is Annotate When you annotate, Glaze lets you pick an element directly in your running app: a button, a heading, a list row, a whole panel. Glaze captures exactly what you pointed at and sends that to the agent along with your message. Instead of "the small button in the top-right of the second card," you just point at it. Because the agent receives precisely which element you selected, it spends less effort guessing and more on the change itself. It also helps with credit usage since it has more context for the change you'd like to make. > [!NOTE] > Annotating becomes available once your app has been built at least once, since there needs to be a running app to point at. On a brand-new project, build something first, then annotate it. #### Start an Annotation With your app running, start annotating from the **Agent Chat** composer: 1. Click the ** Annotate** button next to the composer, or press `⌘` `.`. The button highlights to show annotating is active. 2. Move your pointer over your running app. Glaze highlights the element under it. **Click the one you want** to talk to the agent about. 3. **Add your instruction**, such as "make this bigger" or "use the accent color here," and send it. The agent gets your words plus the exact element you picked. To leave annotating without selecting anything, press `⌘` `.` again or click the button to turn it off. > [!TIP] > You can start annotating from your running app too, not only from the chat. However you begin, the selection lands in the same place: your next message to the agent. #### Fine-Tune with Inspector Once you've picked an element, you don't have to describe every visual tweak in words: you can nudge it directly. The annotation composer shows a ** Inspector** toggle that expands a panel of controls for the element you selected, with a live preview on your running app. From the Inspector you can adjust: - **Size**: Width and height, for image- and icon-like elements. - **Typography**: Font size, line height, bold, italic, underline, strikethrough, and text alignment. - **Padding**: Adjust the spacing on all sides at once, or expand it to set each side individually. - **Radius**: Adjust corner rounding, or expand it to set each corner individually. - **Text Color** and **Background Color**: Pick a color for either. Your changes preview on your running app right away, but they aren't permanent until you send. Glaze bundles them with your typed instruction and sends both to the agent together as a summary of the visual changes you made. > [!NOTE] > The Inspector isn't a separate tool: it's an extra panel inside the same annotation composer you use to point at an element and type an instruction. Point at the element, optionally open the Inspector to nudge its style, then send. #### Edit a Queued Annotation If you annotate while the agent is busy, that pin waits its turn in the queue, the same way a typed follow-up does. See [Queue Follow-Ups](https://manual.glaze.app/prompting/agent-chat#queue-follow-ups). You can change your mind before it runs: - **Edit it**: Hover a queued pin in your running app — the marker shows **pencil icon**. Click it to reopen the annotation panel with your comment already filled in. The send button becomes **Save**, so your edit updates the queued message in place, keeping its spot in the queue. - **Delete it**: In that same panel, click **Delete** to remove the queued annotation from the queue instead. Edits and deletions stay in sync with the queue in Agent Chat, so whichever surface you use, the two always match. #### When Annotating Beats Words Reach for annotation whenever the change is about a specific spot on screen and pointing is clearer than describing: - **Hard-to-name elements**: The third icon in a row, one cell in a grid, a label buried in a dense layout. - **Visual tweaks**: Spacing, size, color, or alignment of one particular thing. - **"This, not that"**: When several parts of the app look similar and you need to be sure the agent changes the right one. Plain prompts are still best for changes that aren't tied to one place, like adding a feature, changing behavior, or describing the app as a whole. Annotation and a written prompt work together: point at the element, then type what you want done to it. > [!NOTE] > Annotating is one of the tools for [Iterating](https://manual.glaze.app/prompting/iterating). It's also a quick way to show the agent exactly where a problem is when something looks wrong; see [When the Agent Gets It Wrong](https://manual.glaze.app/prompting/writing-effective-prompts#when-the-agent-gets-it-wrong). ### Version History Source: https://manual.glaze.app/prompting/version-history Description: Every change the agent finishes becomes a saved version, so you can experiment freely and roll back the moment a build goes wrong. Last updated: 06 July 2026 Every change the agent finishes is saved as a **version**. That means nothing you build is ever lost, so you can experiment freely and step back to a version that worked whenever a change heads the wrong way. ![The version history toolbar in Glaze](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-version-toolbar.png) #### How Versions Work Each time the agent completes a change to your app, it saves the result as a new version. Your latest version is labeled **Current**, and earlier ones count down from there: **v1** is your first version, then **v2**, **v3**, and so on. The list grows on its own as you keep prompting. There's nothing to save or commit by hand. > [!NOTE] > A version captures the whole app at that point, not just the files that changed. Rolling back restores everything to how it was, so you never end up with a half-reverted app. #### Open History Open version history from the toolbar at the top of **Agent Chat**. Click the ** Version History** button to bring up the version list. The button is available once you have at least one version, and it's disabled while the agent is still working on a change. The list shows your versions newest first, with **Current** at the top. Each row shows the description of what that version changed, so you can scan for the point you want to return to. If the history is long, type in the search box to filter by what changed or by a version's identifier. ![The version history dialog listing versions newest first](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-version-dialog.png) > [!TIP] > The descriptions come from the work the agent did, so clear, specific prompts give you a version history that's easy to read later. #### Roll Back 1. Click **the clock icon** in the Agent Chat toolbar to open **Version History**. 2. Select the version you want from the list. Selecting **Current** just closes the list, since you're already on it. Any earlier version opens a confirmation. 3. Glaze asks you to confirm before changing anything. Choose **Revert** to restore your app to that version, or **Cancel** to back out. 4. Your app is now restored to that version. Keep prompting from here, and new versions stack on top. #### Recover a Broken App If a prompt leaves your app broken or worse than before, you have two ways out. - **Keep correcting**: Often the best fix is to tell the agent what went wrong in a follow-up message. It can usually repair the issue in place without a rollback. - **Roll back**: If a change took the app somewhere you don't want, or several follow-ups haven't recovered it, return to the last version that worked and prompt again from there. This gives you a clean starting point instead of layering on top of a tangle. ##### Do I lose my newer work when I roll back? No. The versions you created after the one you're returning to stay in your history. Rolling back changes which version your app is currently on; it doesn't delete anything. You can switch back to a newer version at any time. ### Writing Effective Prompts Source: https://manual.glaze.app/prompting/writing-effective-prompts Description: What makes a strong prompt, what to include, and how to get back on track when the agent builds the wrong thing. Last updated: 06 July 2026 A **prompt** is how you tell the agent what to build. You don't write code or pick a framework; you describe the app you want in plain language, and the agent plans the work, writes the code, and runs it for you. The clearer your description, the closer the result is on the first try. #### Describe the Outcome Say what the app should do and how it should feel, not how it should work under the hood. The agent chooses the right approach for you, so you don't need to mention frameworks, libraries, or file structure. - **Good**: "A menu bar app that shows my next calendar event and counts down to it." - **Less helpful**: "A SwiftUI menu bar extra with a timer that polls EventKit every 30 seconds." The second prompt isn't wrong, but it spends your words on decisions the agent is happy to make. Lead with what you want to be true when the app runs. #### Include the Essentials A strong first prompt usually covers three things: - **Purpose**: What the app is for and the main thing it helps you do. - **The data involved**: What it reads, writes, or works with, such as files, a list you maintain, or a service it connects to. - **The look and feel**: Roughly how it should appear and behave, like a single window, a menu bar tool, a list with a detail pane, or a form. You don't need every detail up front. Cover the essentials and let the agent fill in sensible defaults; you can refine the rest in follow-up messages. > [!NOTE] > Not sure where to start? Describe the problem you're trying to solve and ask the agent to suggest an app for it. You can shape the idea together before any code is written. #### Start Simple Resist the urge to specify everything in one giant prompt. Ask for a focused first version, see it run, then add to it. Building in steps keeps each change easy to review and makes it obvious when something goes off track. A good rhythm looks like this: 1. **Describe**: Describe the core app and let the agent build it. 2. **Try it**: Open it and try the main flow. 3. **Follow up**: Send a follow-up for the next feature or fix. 4. **Repeat**: Keep going until it's what you want. See [Iterating](https://manual.glaze.app/prompting/iterating) for how to refine an app over multiple turns. #### Strong vs Vague The difference between a quick win and a few rounds of back-and-forth is usually detail. - **Strong**: "A habit tracker as a single-window app. I want to add habits with a name and an emoji, check them off each day, and see a grid of the last 30 days per habit." - **Vague**: "Make me a productivity app." The strong prompt names the purpose (tracking habits), the data (habits with a name and emoji, daily check-offs), and the look and feel (single window, a 30-day grid). The vague one can still produce something, but the agent has to guess at every decision, so the result is less likely to match what you pictured. If you only have a rough idea, that's fine; say so and let the agent suggest specifics you can react to. #### What the Agent Handles Well The agent is good at turning a clear description into a working app, choosing sensible defaults, and handling the technical parts you didn't mention. It can build common app shapes (a window with a list and detail view, a form, a menu bar tool, a dashboard) and wire up native capabilities like notifications, file access, and connections to outside services. Give it more direction when: - The exact layout or wording matters to you. Spell it out. - There are rules or edge cases it can't infer, like how to handle duplicates or what happens when a list is empty. - You're matching an existing style or design. Describe it, or attach a reference image. For bigger or riskier ideas, switch on **Plan mode** so you and the agent agree on an approach before any code is written. See [Plan & Build Modes](https://manual.glaze.app/prompting/plan-and-build-modes). #### When the Agent Gets It Wrong Sometimes the agent makes something other than what you pictured. That's usually a sign the prompt left room to guess, not that you're stuck. Getting back on track comes down to spotting when intent was missed, restating the goal clearly, and deciding whether to correct or start fresh. ##### Spot a Mismatch The agent reads your prompt literally, so a mismatch shows up in the result. Watch for: - The app does something **adjacent** to what you wanted, but not quite it (a list where you meant a grid, a window where you meant a menu bar item). - A detail you cared about is **missing**, because the prompt didn't mention it. - The agent **guessed** at something you left open, and guessed differently than you would have. - Each follow-up fixes one thing but **breaks another**, a sign the goal isn't fully shared yet. When you see these, the fix is almost always in the next prompt rather than in starting over. ##### Restate the Goal The most reliable fix is to say what you actually want in concrete terms. Describe the outcome, not the mistake. - **More effective**: "The dates should sort newest first, and the total at the bottom should update when I add a row." - **Less effective**: "That's not right, try again." Name the specific behavior, the data involved, and how it should look or act. The clearer the picture, the less the agent has to guess. This is the same "describe the outcome" habit from earlier, applied to a fix. ##### Point at the Problem Words can be slippery when the problem is visual: "the button at the top, no, the other one" is hard to land. When something on screen is wrong, point at it directly. Use the ** Annotate** button next to the composer to pick the exact element in your running app and send it along with your message. The agent gets a precise pointer instead of a description it has to decode, which removes a whole class of misunderstanding. See [Annotate](https://manual.glaze.app/prompting/annotate). > [!NOTE] > Annotating works best for layout, styling, and "this specific element" issues. For behavior and logic ("after I save, clear the form"), a clear written prompt is usually enough. If one prompt asked for too much and the result is muddled, it was probably too big for one shot. Break it into smaller, ordered steps: core structure first, then behavior and look. Smaller steps are easier to get right and verify, and keep your [version history](https://manual.glaze.app/prompting/version-history) clean for targeted rollbacks. ##### Correct or Revert? When a build goes wrong, you have two paths. Knowing which to take saves time. - **Keep correcting** when the app is mostly right and one or two things are off. A targeted follow-up is fastest, and you build on what's already working. - **Revert and re-prompt** when a change took the app somewhere you don't want, or when several follow-ups keep trading one problem for another. Roll back to the last version that worked and start that step again with a clearer prompt. > [!WARNING] > If you've sent three or four follow-ups and the app is drifting further from your goal, stop correcting. Roll back to a clean version and re-prompt. Layering fixes onto a confused build usually compounds the confusion. ##### The agent keeps misunderstanding the same thing. What now? Try changing how you describe it rather than repeating the same words. Point at the element with the ** Annotate** button, give a concrete example of the behavior you want, or break the request into a single small step. ##### A new prompt broke something that used to work. How do I recover? Tell the agent exactly what regressed ("the export button stopped working after the last change") so it can repair it. If that doesn't land, roll back to the version from before the change and re-prompt from there. See [Version History](https://manual.glaze.app/prompting/version-history). ### Advanced Prompting Source: https://manual.glaze.app/prompting/advanced-prompting Description: What advanced prompting adds, which techniques to reach for, and how to keep the agent on track through big or complex builds. Last updated: 06 July 2026 Once you've built a few apps, you'll want more control over the result. The techniques here help you steer bigger or more complex builds with precision, picking up where [Writing Effective Prompts](https://manual.glaze.app/prompting/writing-effective-prompts) leaves off. #### Spell Out the Details The agent fills any gap you leave with a reasonable guess. On a precise build, you want fewer guesses, so describe the shape of things before the agent has to assume them. - **Structure**: Say how the app is laid out: a sidebar with a detail pane, a single window with tabs, a grid of cards. - **Data**: Describe what the app works with and its fields. "A list of tasks, each with a title, a due date, and a done flag" beats "a task list". - **Edge cases**: Name the awkward states up front: what an empty list looks like, what happens on a long title, how errors are shown. Calling out edge cases early saves a round of follow-ups later, since the agent handles them in the first build instead of after you spot them. #### Reference a Look Style is easier to show than to describe. To steer the look, give the agent something to anchor on: - **Name a feeling or reference**: "Clean and minimal like a native macOS settings pane" or "playful, rounded, colorful" gives more direction than leaving it open. - **Point at an existing app of yours**: If you've already built an app with Glaze using the look you like, ask the agent to match its style. - **Attach an image**: Drop in a screenshot or mockup of the layout or styling you're after, and describe what to take from it. > [!NOTE] > Be specific about *what* to borrow from a reference. "Match the spacing and card style, but use my own colors" is clearer than "make it look like this", which leaves the agent guessing how literally to copy. #### Build in Stages For an ambitious app, don't try to land everything in one prompt. Guide the build in stages so each part is something you can check before moving on. 1. **Plan the approach first**: For a large or risky build, turn on **Plan mode** and agree on the approach before any code is written. This is where you catch a wrong assumption cheaply. 2. **Build the foundation**: Get the core structure and main screen working first, before any extras. 3. **Layer on behavior**: Add actions, state, and data handling once the shape is right. 4. **Refine and polish**: Tune the look, spacing, and edge cases last, when the rest is stable. Each stage is saved as a [version](https://manual.glaze.app/prompting/version-history), so if one step goes wrong you can roll back just that step rather than the whole app. #### Set Constraints Telling the agent what to avoid is as useful as telling it what to do. Constraints keep a precise build from drifting. `Add a settings window with a dark mode toggle. Don't change the main window's layout, and keep the existing color scheme.` Useful constraints to state explicitly: - **Leave this alone:**: "Don't touch the sidebar" protects parts that already work. - **Stay within these bounds:**: "Keep it to a single window" or "no external services" sets the scope. - **Avoid this approach**: "Don't add a database, just keep it in memory" steers away from over-building. > [!TIP] > If a previous prompt changed something you didn't want changed, add a constraint to the next one. A clear "don't" is often the quickest way to stop the agent repeating a mistake. #### Combine Context Your strongest prompts often combine more than one kind of context in a single message. The agent reads them together, so a screenshot plus a sentence of intent is far clearer than either alone. - **Image + instruction**: Attach a mockup and write what to build from it: "Build this layout, but make the list scrollable and pull in the data I'll paste below." - **Data + instruction**: Paste a chunk of data into the message and describe how to use it: "Here's a CSV of my expenses. Show them in a table sorted by date, with a running total." - **Reference + constraint**: Point at an existing app and bound the change: "Match the styling of my notes app, but don't copy its sidebar." ## Capabilities ### Running Your App Source: https://manual.glaze.app/capabilities/running-your-app Description: How a Glaze app runs, from the live preview to a real window you launch from the Dock or Spotlight. Last updated: 01 July 2026 A Glaze app is real, running software from the very first build. You watch it come together live as the agent works, and when it's ready it opens in its own window like anything else on your Mac, ready to launch, quit, and find again whenever you need it. #### Preview While the agent builds and edits, your app runs in a live preview that updates as the work happens. Make a change in the **Agent Chat** and the preview reflects it within moments. And because the preview is the app actually running, you can click around in it while the agent works. If something looks off, say so in Agent Chat and watch the fix land. #### Open the Finished App When the agent finishes, your app opens in its own window, with its own icon in the Dock. It is not a browser tab or a preview pane; it is the app itself. You can use the app just as you would anything you installed. You can reopen an app any time from **My Projects** in Glaze. See [Managing Your Projects](https://manual.glaze.app/basics/managing-projects). ![Open App button shown above the composer in Agent Chat](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/prompting/mac-annotate-composer.png) #### Where Your Apps Live Finished Glaze apps install into a **Glaze** folder inside your Applications directory. They show up in Spotlight like any other app, so you do not have to open Glaze first to launch one. #### Relaunch and Quit Your apps quit and relaunch like normal Mac apps: press `⌘` `Q` to quit, or close the window. When the agent ships a change, your app relaunches so you are always looking at the latest version. You can also reopen an app from **My Projects** whenever you want it back. #### Check the Agent's Work Because the live preview is the running app, the fastest way to check the agent's work is to use it: click through the flows, open the menus, and confirm a change landed the way you intended. When something looks off in a specific spot, point at it with ** Annotate** so the agent knows exactly which element you mean; see [Annotate](https://manual.glaze.app/prompting/annotate). If a change heads the wrong way and you want to step back, see [Version History](https://manual.glaze.app/prompting/version-history). ### AI Source: https://manual.glaze.app/capabilities/ai Description: Add AI to your Glaze apps with no API keys or setup requrired. Usage is billed to each user's own credits. Last updated: 10 August 2026 You can add AI-powered features to your Glaze app without any setup required to make it happen. There are no API keys to configure and no infrastructure to build or maintain, simply describe what you want in plain language and the agent wires the AI into your app. When a user interacts with any AI feature in an AI-powered app, the AI usage draws from their own Glaze credits, so the cost follows the person using the app, not the person who built it. [Introducing Glaze AI (YouTube)](https://www.youtube.com/watch?v=gjfnHbWzNj4) #### Add AI Features Ask the agent in Agent Chat for an AI feature the way you'd ask for any other feature or change, and it builds it into your app: - **Text generation**: Summaries, rewrites, drafts, answers, and other text an app produces on demand. - **Streaming responses**: Text that appears as it's generated, so a reply fills in live instead of arriving all at once. - **Image understanding**: An app that can read an image you give it, like describing a screenshot or pulling details out of a photo. - **Image generation**: An app that creates images from a description. You don't provide any keys or set up anything with model providers. The agent picks what an AI feature needs and builds it in, the same way it handles files, windows, and everything else your app does. #### Permission Prompt AI access is something each user grants individually per-app, not something an app turns on by itself. The first time an app tries to use AI, **Glaze asks for permission** with a prompt anchored over the app's window. It looks and behaves like the macOS prompts you already know, and it comes from Glaze rather than from anything the app's author built, so you can trust what it says. You grant or deny it right there: - **Grant** it and the app's AI features work from then on. - **Deny** it and the app keeps running; the features that needed AI are simply unavailable. An app can also check whether you've granted it AI access without triggering this prompt or using any of your credits, so it can adapt its interface to what's actually available instead of showing a feature that doesn't work. > [!NOTE] > On the Glaze Free plan, this first prompt may invite you to upgrade to Pro before you use AI if you do not have any credits remaining. If someone's credits run out while they're using an AI feature, Glaze shows the top-up flow for them so they can keep going. #### Publishing an AI-Powered App Apps that use Glaze AI can be published to the Public Store like any other app. On the Store, they display a **Uses Glaze AI** pill on their detail page, so people can see an app uses AI before they install it. See [Store](https://manual.glaze.app/share/store) for what a listing shows and [Publish Apps](https://manual.glaze.app/share/publish-apps) for how publishing works. #### Review and Manage Access Every app you've allowed to use AI is listed under **Settings -> AI Access**, where you can see each consented app's usage and daily cap, and you can revoke access at any time. > [!NOTE] > Caps are enforced against each person's own Glaze credits, so a popular AI-powered app never runs up a bill for the person who built it. See [Manage Account](https://manual.glaze.app/account/manage-account) for how credits and plans work. ### System Integration Source: https://manual.glaze.app/capabilities/system-integration Description: Your apps plug into macOS with deep system integration, reachable from anywhere you work. Last updated: 10 August 2026 When it helps, a Glaze app can reach beyond its own window into the rest of macOS: respond to a keystroke from anywhere, open the file types it owns, exchange files with Finder by dragging, and hand off to the browser or other apps. Ask the agent for any of these in plain language. #### Global Keyboard Shortcuts An app can register a **global hotkey**, a keyboard shortcut that works system-wide even when the app is not focused. This is how a quick-capture note or a clipboard tool springs open from whatever you are doing with a single keystroke. You choose the combination, and macOS routes it to your app no matter which app is in front. > [!WARNING] > A global shortcut is exclusive: if another app or macOS already uses the combination, your app cannot also claim it. Pick a less common chord if your first choice does not register. #### File Associations An app can declare itself the opener for certain **file types**, so opening a matching file in Finder launches your app, and the file shows your app's icon. A custom editor for a `.recipe` file or a viewer for a niche format becomes a first-class citizen of the system this way. #### Drag-and-Drop Apps can take part in drag-and-drop in every direction: - **Into the app**: Drop files from Finder onto a drop zone to import or open them. - **Out of the app**: Drag a generated or selected file from your app onto the desktop, into Finder, or into another app. - **Within the app**: Drag to reorder a list or move items between areas. This makes file-heavy workflows feel natural, with no dialogs required when a drag will do. See [Files & Data](https://manual.glaze.app/capabilities/files-and-data) for what happens to the files once they arrive. #### Deep Links and Custom Protocols Every app gets its own **URL scheme**, assigned automatically from the app's identity so a link anywhere on your system can open the app and take it to a specific place. Click a link in a different app and your app comes forward on the right screen. This is how apps tie into links from emails, web pages, and other tools, and it is the same mechanism that lets a browser hand control back to your app after signing in to a service. #### Hand Off to Other Apps Apps can also hand off to the rest of macOS: open a web address in your default browser, reveal a file in Finder, or open a project in an IDE. A "View on the web" button or a "Show in Finder" action is a small touch that makes an app feel connected to everything around it. #### Native Swift When an app needs deeper macOS integration than a plain web-based build can offer, the agent can add **native Swift** capabilities to it: using Apple frameworks directly, running continuous work in the background, or streaming live native data into your app as it happens. Ask for what you're after in plain language, for example a specific piece of hardware or system data you want your app to react to, and the agent adds the native code alongside the rest of your project. Apps built this way publish to the Store like any other Glaze app. > [!NOTE] > Building or editing a project that uses native Swift requires **Xcode 16.3 or later** installed on your Mac. ### Device Access Source: https://manual.glaze.app/capabilities/device-access Description: Your apps can tap into your Mac's hardware, and macOS asks your permission before any access. Last updated: 01 July 2026 Your apps may need access to hardware connected to a Mac: a camera for a photo, the microphone to record a voice note, the location for maps. Glaze apps can do this, and because they are real Mac apps, every such request goes through the same permission system that protects you across the whole system. #### What Apps Can Access Because Glaze apps are real Mac apps, they can request anything macOS keeps behind a permission prompt. That spans hardware access like the camera, microphone, and screen, your location, and personal data such as Contacts, Calendar, Reminders, and Photos. #### How Permission Prompts Work You are always asked for permission access by macOS before the app gets access. The first time an app tries to use the camera, microphone, or another protected feature, **macOS itself** shows a permission prompt. The request comes from the operating system, not from inside the app, so you can trust what it says. You grant or deny right there. Grant it and the feature works from then on. Because the choice is remembered, you are not asked again every time. #### When a Permission Is Denied Denying a permission does not break the app. A well-made Glaze app degrades gracefully: the feature that needed access is unavailable, and the app should explain that and keep working otherwise. If access to a specific permission is required, your app should explain why and direct users to **System Settings -> Privacy & Security** to grant permission. #### Privacy Expectations A few principles hold for every Glaze app: - **You consent first**: No protected feature is used until you have allowed it through the system prompt. - **Data stays local where it can**: Glaze apps are local-first, so what the camera captures or the microphone records stays on your machine unless the app has a clear reason to send it elsewhere. - **Access should be justified**: An app should only ask for what it genuinely needs, and the reason should be obvious from what the app does. ### Files & Data Source: https://manual.glaze.app/capabilities/files-and-data Description: Your apps read and write real files, keep data and settings on your Mac, and store secrets safely in the macOS Keychain. Last updated: 31 July 2026 Glaze apps are **local-first**: your data lives on your Mac, and most keep working offline. An app can read and write files, remember settings, store larger data sets, and keep secrets safe. You don't manage any of it, just describe what an app should keep and the agent picks the right storage. #### Read and Write Files Apps work with your real files, the foundation for tools like a notes app that saves to disk, a converter that turns one file into another, or a log viewer that watches a file change. The agent builds the file handling around what your app does. #### File Dialogs When an app needs you to pick a file or choose where to save one, it uses the **native macOS dialogs** you already know. They act and do what you would expect: - **Open** a single file, multiple files, or a folder. - **Filter** the picker to certain file types, so a photo app shows only images. - **Save** with a suggested name and starting location. #### Show File Icons & Thumbnails When an app lists your files, like a browser, converter, or organizer, it can show each one with its real **Finder icon** or a **Quick Look thumbnail**, the same preview you'd see in Finder for a document, image, or video. Just ask for it and the agent wires it up directly to macOS, so previews match what's actually on disk and stay quick even for a long list. #### Store Data For anything an app keeps between launches, Glaze puts the right kind of data in the right place: - **UI state**: Small, frequently-changing bits of interface state, like the last-selected tab, a sidebar width, or the current sort and filters. - **App data**: The substance of what your app holds, like your settings, the items in a list, or a history. It lives in the app's own data area on your Mac, separate from other apps. For relational data or very large sets, the agent reaches for a local database instead of plain files. > [!NOTE] > Because data is stored locally, your app's content stays on your machine and is available offline. The exception is a feature that sends it somewhere, like [Glaze AI](https://manual.glaze.app/capabilities/ai), which passes whatever it acts on to a model provider. See [Core Concepts](https://manual.glaze.app/basics/core-concepts) for what local-first means across Glaze, and [Privacy & Data](https://manual.glaze.app/account/privacy-and-data) for what leaves your Mac. #### Keep Secrets Some apps hold sensitive values: an API key, an access token, a password. These do not belong in ordinary settings. Glaze apps can use **secure storage** that encrypts them natively, protected by the macOS Keychain, and keeps them out of the app's plain data, so a token stays safe at rest. > [!TIP] > When an app connects to an outside service through a Glaze integration, the access token is handled securely for you. See [Integrations Overview](https://manual.glaze.app/integrations/overview). #### Large Files Apps can handle large content too, like big audio, video, images, or other document files. The agent keeps these responsive by serving the file in pieces rather than loading it all at once, and reaches for this automatically when your app needs it. See [Large Files & External Tools](https://manual.glaze.app/advanced/large-files-and-tools) for how it works and how to ask for it. ### Notifications, Menu Bar & Tray Source: https://manual.glaze.app/capabilities/notifications-menu-bar-tray Description: Your apps reach you through native notifications and can live in the macOS menu bar with their own icon, menu, and actions. Last updated: 06 July 2026 Your apps can reach you even when their window is closed. They can post notifications to Notification Center and live in the macOS menu bar with their own icon and menu. Ask the agent for any of this in plain language and it wires it up. #### Notifications Apps can send real macOS notifications, the kind that slide in at the top right and collect in Notification Center. A notification can carry a **title**, a **subtitle**, and a **body**, so you can say a CI failed, a timer ended, or a download is ready. You can also make them richer: - **Sound**: Play the default alert sound, a named system sound, or stay **silent**. - **Action buttons**: Add buttons right on the notification so the user can act without opening the app. - **Inline reply**: Let the user type a quick response directly from the notification, with your own placeholder text. - **Click handling**: Respond when the user clicks the notification, for example by opening the app to the right place. - **Urgency**: Mark a notification as low, normal, or critical. > [!TIP] > **Example prompt** > > When my pomodoro timer finishes, send a notification that says "Break time" with a "Start next session" button. ##### Manage Delivered Notifications Apps can also tidy up after themselves. They can look back over the notifications they have delivered that are still sitting in Notification Center, remove a specific one, clear them all, or clear a whole group at once. Related notifications can be **grouped** under a shared title, so a busy app does not flood Notification Center with separate banners. #### Menu Bar Apps can place an icon in the **macOS menu bar**. This is ideal for an app you want close at hand without a window taking up space, a clipboard tool, a quick-capture note, a status readout you glance at. Clicking the icon can open a **dropdown menu** that you fill out with: - **Menu items** that run an action when chosen. - **Submenus** for grouping related items. - **Separators** to divide a long menu into sections. - **Checkmarks** to show which options are on. - **Keyboard shortcuts** shown next to items. The menu bar icon can also show a **tooltip** on hover and respond differently to a left versus right click. #### Icons and Color Menu bar icons follow the macOS convention: provide an icon and the system renders it to match the menu bar, adapting between light and dark automatically. You can also use full-color images where it makes sense, and tint menu items to draw attention to a particular state. Lean on the system styling first so your app feels at home in the menu bar. ### Windows Source: https://manual.glaze.app/capabilities/windows Description: Take on any window shape, from standard and frameless to floating always-on-top, modal, or a transparent click-through overlay. Last updated: 06 July 2026 A window is the first thing anyone sees of your app, and Glaze apps are not limited to one plain shape. They can be a standard resizable window, a sleek frameless panel, a small always-on-top utility, a modal that focuses attention, or even a transparent overlay. You describe the feel you want and the agent sets the window up to match. #### Standard Windows By default your app gets a normal macOS window: a title bar with the red, yellow, and green traffic-light buttons, resizable edges, and a sensible starting size. The agent chooses an initial width and height that suit the content and sets a minimum size so the layout never collapses awkwardly. For most apps this is exactly right, and you do not have to think about it. #### Frameless and Custom-Chrome Windows For a more designed look, an app can drop the native title bar and use a **frameless** window where your own header runs edge to edge. The header can still be **draggable**, so the window moves when you drag the top of it, just without the standard bar. This is how apps get a clean, custom top area while still feeling like a proper window. #### Title Bar and Traffic Lights You have fine control over the title bar and the traffic-light buttons: - **Inset title bar**: Keep the buttons but blend the bar into your content for a modern look. - **Hidden title bar**: Remove the bar entirely for a frameless design. - **Repositioned or hidden buttons**: Move or hide the close, minimize, and zoom controls when your layout calls for it. These let an app match a specific aesthetic while keeping the controls people expect. #### Floating and Utility Windows An app can use a small **floating** or **utility** window that stays **always on top**, hovering above other apps so it is there when you need a glance, such as a timer, a mini player, a note. These are ideal for companions you want visible while you work in something else. #### Modal and Document Windows Apps can present a **modal** window, a child window that takes focus and sits in front of its parent until you deal with it, perfect for a confirmation or a focused task. They can also use **document-style** windows, where each open document gets its own window, the familiar pattern from editors and other document apps. #### Transparent and Click-Through Overlays For special effects, an app can use a **transparent** window with no visible background, showing only its content over whatever is behind it. Combined with **click-through**, where mouse clicks pass through the window to the app underneath, this enables overlays like an on-screen annotation layer or a heads-up display that floats above your desktop without getting in the way. #### Multiple Windows An app is not limited to a single window. It can open several at once, for example a main window plus a floating inspector, or a new window per document, so the layout fits how you actually work. > [!TIP] > You do not need the names of these window types to use them. Describe the window behavior you want and the agent picks the right setup for your app. ### App Icons Source: https://manual.glaze.app/capabilities/app-icons Description: Generate your apps own icon from a short description, refine it with reference images, or upload your own artwork. Last updated: 28 August 2026 Every app deserves a face. Glaze gives your project a custom icon from a short description. The icon is your app's identity, the image you see in the Dock when it runs and on its listing if you share it to the Store. You can manage the icon in the **Edit App Icon** dialog. Open it by clicking the app's icon in the Agent Chat toolbar, in the project's detail panel, or in the publish form. [How to Create a Great App Icon (YouTube)](https://www.youtube.com/watch?v=_7jquiKesEU) #### Generate an Icon In the **Edit App Icon**, describe what you have in mind in the composer, then press **Generate**. The more you say about the subject, the mood, and the colors, the closer the result lands. You can mention a concept, a motif, a palette, or a look and Glaze uses that as inspiration for your app's icon. Each generation gives you three variants to choose from. 1. Click any of the three to preview it at full size. 2. Steer the icon generation by saying what to change in the composer and **Generate** again. You can select an already generated icon as a base for further generations, or include up to three **reference images**, and Glaze takes their style into account. 3. Once you see an icon you like, click **Save** to set it as your app's icon. - To leave without changing the icon, click **Cancel**. > [!TIP] > **Example prompt** > > Hyper-realistic fluffy cat paw, warm golden-orange fur, pink toe beans and central pad, soft plush texture, white background, studio lighting. ![The icon generator in the Edit App Icon dialog](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/capabilities/mac-appicons-generator.png) > [!NOTE] > Generating an icon does not use your credits, so try as many as you like until one feels right. #### Upload an Icon If you'd prefer to use your own artwork, click **Upload Icon** and pick an image file. Glaze crops the image so it sits correctly, then shows a preview you can **Save**. You can still type a prompt to tweak an uploaded icon before saving. Once saved, your icon represents the app everywhere it appears: in the Dock and app switcher while the app is running, and on the app's Store listing if you share it. Updating the icon later is the same flow, just open **Edit App Icon** again any time. ## Integrations ### Integrations Overview Source: https://manual.glaze.app/integrations/overview Description: Connect your apps to GitHub, Linear, Slack, or any OAuth 2.0 service so they work with your real data, authorized when you run them. Last updated: 01 July 2026 By default, an app you build in Glaze works on its own. **Integrations** change that: they connect your apps to outside services like GitHub, Linear, and Slack so they can work with your real data as you. You add an integration while building, and the running app signs you in through **OAuth** the first time it needs that service, then reads your data and takes the actions you allow. > [!NOTE] > The access token the service hands back is stored encrypted on your Mac, protected by the **Keychain** rather than kept inside the app. See [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data) for how that's handled. #### Where Connections Start You add a connection from the **Agent Chat**. Click **the Plus button** to the left of the composer to open the Add Context menu, click ** Integration**, then pick the service you want to connect. See [Agent Chat](https://manual.glaze.app/prompting/agent-chat) for the rest of that menu. > [!NOTE] > Integrations are set up per project. Connecting a service in one app doesn't connect it everywhere, which keeps each app's access scoped to what it needs. #### Built-In Connectors Glaze includes ready-made presets for three popular services, so you don't have to register your own developer app or handle client credentials: - **[GitHub](https://manual.glaze.app/integrations/connect-github)** — Repositories, issues, and your GitHub identity. - **[Linear](https://manual.glaze.app/integrations/connect-linear)** — Read and update issues and projects. - **[Slack](https://manual.glaze.app/integrations/connect-slack)** — Read channels and send messages. #### Custom OAuth Need a service that isn't one of the presets? Click **Other OAuth Provider** under ** Integration** to connect any service that supports OAuth 2.0. You supply the provider's details and your own credentials, and the rest of the flow works the same way. See [Custom OAuth](https://manual.glaze.app/integrations/custom-oauth) to learn more. #### Extra Tools and Data with MCP OAuth connects an app to a service so it can act as you. **MCP** is different: it gives the **agent** extra tools and data sources to work with. Add an MCP server to a project and the agent can call those tools as it works, which is useful for pulling in documentation, querying a system, or reaching specialized capabilities. See [Model Context Protocol](https://manual.glaze.app/integrations/model-context-protocol) to learn more. #### Manage What's Connected Every connection can be reviewed, re-authorized, or revoked later. When a token expires or a connection breaks, you reconnect from the same place you added it. See [Managing Connections](https://manual.glaze.app/integrations/managing-connections) to learn more. ### Connect GitHub Source: https://manual.glaze.app/integrations/connect-github Description: Sign in with GitHub so your app works with your repositories, issues, and pull requests as you, authorized in the running app. Last updated: 02 July 2026 Connect **GitHub**, and your apps can work with your repositories, issues, and pull requests as you. The agent builds the app with GitHub wired in, and the app signs you in the first time you use a feature that needs it. It's the foundation for any app that needs to do something with your GitHub data. #### Connect GitHub You add GitHub to your app while building it. Signing in happens later, in the running app, and it's always you who authorizes it, never the agent. 1. In the **Agent Chat**, click **the Plus button** in the composer and click ** Integration**. 2. Select **GitHub** from the list of built-in connectors. Glaze uses a ready-made GitHub preset, so there's nothing to register and no credentials to paste. 3. Describe how you want to use GitHub in your app and the agent builds the feature. 4. The first time you use a feature that needs GitHub in your app, the app opens GitHub's authorization page in your browser. Sign in, review what's being requested, and approve. GitHub hands back to the app, which acts as you from then on. > [!NOTE] > The agent doesn't sign you in or hold your credentials. It builds the app with GitHub wired in; you authorize GitHub yourself, in the running app, the first time you use it. #### Permissions You Grant When you sign in, GitHub shows its OAuth authorization screen, which you approve before your app can use any of your GitHub data. If your app only reads public data, you may not need to sign in at all; GitHub asks you to authorize only when the app needs your identity, your private data, or the ability to act on your behalf. #### Use GitHub in a Prompt With GitHub added to your app, describe what you want in plain language and the agent builds it: - Show my open pull requests across all my repositories, grouped by repo. - Create a dashboard of issues assigned to me, with a button to open each on GitHub. - Let me file a new issue in a repository I pick from a dropdown. > [!NOTE] > GitHub is connected per project, so each app you build gets its own connection, which keeps each app's access scoped to what it actually needs. #### Manage the Connection To re-authorize or revoke GitHub access later, see [Managing Connections](https://manual.glaze.app/integrations/managing-connections). Your access token is stored encrypted on your Mac, protected by the Keychain, never in plain text. See [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data) to learn more. ### Connect Linear Source: https://manual.glaze.app/integrations/connect-linear Description: Sign in with Linear so your app reads and updates your issues, projects, and cycles as you, authorized in the running app. Last updated: 02 July 2026 Connect **Linear**, and your apps can work with your issues, projects, and cycles as you. The agent builds the app with Linear wired in, and the app signs you in the first time you use a feature that needs it. It's the foundation for any app that needs to do something with your Linear data. #### Connect Linear You add Linear to your app while building it. Signing in happens later, in the running app, and it's always you who authorizes it, never the agent. 1. In the **Agent Chat**, click **the Plus button** in the composer and click ** Integration**. 2. Select **Linear** from the list of built-in connectors. Glaze uses a ready-made Linear preset, so there's nothing to register and no credentials to paste. 3. Linear is now wired into this project. Describe what you want and the agent builds the feature on top of Linear. 4. The first time you run a feature that needs Linear, the app opens Linear's authorization page in your browser. Sign in, review what's being requested, and approve. Linear hands back to the app, which acts as you from then on. > [!NOTE] > The agent doesn't sign you in or hold your credentials. It builds the app with Linear wired in; you authorize Linear yourself, in the running app, the first time you use it. #### Permissions You Grant When you sign in, Linear shows its OAuth authorization screen, which you approve before your app can touch your Linear data. The agent requests only the access a feature needs, so a read-only dashboard never asks for write access, while a quick-entry tool asks for just enough to create what you describe. #### Use Linear in a Prompt With Linear added to your app, describe what you want and the agent builds it: - Show all issues assigned to me, grouped by their status. - Create a quick-capture box that adds a Linear issue in a team I choose. - List my team's current cycle with a way to move an issue to In Progress. > [!NOTE] > Linear is connected per project, so each app you build gets its own connection, which keeps each app's access scoped to what it actually needs. #### Manage the Connection To re-authorize or revoke Linear access later, see [Managing Connections](https://manual.glaze.app/integrations/managing-connections). Your access token is stored encrypted on your Mac, protected by the Keychain, never in plain text. See [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data) to learn more. ##### Can an app change my Linear data without me knowing? An app can only make changes if it was granted write access when you signed in, and changes happen through actions the app takes in response to you. If you want a read-only experience, tell the agent the app should only view your Linear data, not modify it. ### Connect Slack Source: https://manual.glaze.app/integrations/connect-slack Description: Sign in with Slack so your app reads channels and posts messages in your workspace as you, authorized in the running app. Last updated: 02 July 2026 Connect **Slack**, and your apps can work with your channels, groups, and messages as you. The agent builds the app with Slack wired in, and the app signs you in the first time you use a feature that needs it. It's the foundation for any app that needs to do something with your Slack data. #### Connect Slack You add Slack to your app while building it. Signing in happens later, in the running app, and it's always you who authorizes it, never the agent. 1. In the **Agent Chat**, click **the Plus button** in the composer and click ** Integration**. 2. Select **Slack** from the list of built-in connectors. Glaze uses a ready-made Slack preset, so there's no Slack app to register. 3. Slack is now wired into this project. Describe what you want and the agent builds the feature on top of Slack. 4. The first time you run a feature that needs Slack, the app opens Slack's authorization page in your browser. Choose the **workspace** you want to connect, review what's being requested, and approve. Slack hands back to the app, which acts as you from then on. > [!NOTE] > The agent doesn't sign you in or hold your credentials. It builds the app with Slack wired in; you authorize Slack yourself, in the running app, the first time you use it. #### Permissions You Grant When you sign in, Slack shows its OAuth authorization screen, which you approve before your app can read or post anything. The agent asks for only what a feature needs, so an app that just lists channels won't request message content, and a notifier asks for just enough to post. A connection is tied to the workspace you authorize; to use a different one, reconnect and pick it when Slack asks. #### Use Slack in a Prompt With Slack added to your app, describe what you want and the agent builds it: - Show my unread channels with the latest message in each. - Create a button that posts my standup update to a channel I pick. - Search my workspace for messages mentioning a keyword and list the results. > [!NOTE] > Slack is connected per project, so each app you build gets its own connection, which keeps each app's access scoped to what it actually needs. #### Manage the Connection To re-authorize, switch workspaces, or revoke Slack access later, see [Managing Connections](https://manual.glaze.app/integrations/managing-connections). Your access token is stored encrypted on your Mac, protected by the Keychain, never in plain text. See [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data) to learn more. ### Custom OAuth Source: https://manual.glaze.app/integrations/custom-oauth Description: Connect any OAuth 2.0 service with your own provider details, and your app signs you in just like a built-in preset does. Last updated: 06 July 2026 The built-in connectors cover GitHub, Linear, and Slack, but plenty of services aren't on that list. **Custom OAuth** lets you connect any service that supports **OAuth 2.0**. You supply the provider's details and your own credentials, and the connection then works the same way as a preset. #### When to Use Custom OAuth Reach for custom OAuth when the service you want isn't one of the built-in presets. If it **is** a preset, use that instead, since the preset hides the provider's credentials and saves you the setup. Use custom OAuth for everything else that signs users in with OAuth 2.0. #### Connect a Custom Provider 1. In the **Agent Chat**, click **the Plus button** in the composer, click ** Integration**, and select **Other OAuth Provider**. 2. In the provider's developer settings, create an OAuth application and add Glaze's redirect URL so the provider can hand the connection back. This is where you get the **client ID** the app will use. ```text https://www.glaze.app/api/oauth/callback ``` 3. Describe what the service requires, typically its **authorization URL**, **token URL**, your **client ID**, and the **scopes** the app needs. Some providers also require a **client secret**. The agent wires these into the app's OAuth service for you. 4. When you run the app and sign in, Glaze opens the provider's sign-in page in your browser. Approve the request, and the provider sends you back to finish the connection. #### What You Supply A custom connection needs the same pieces every OAuth provider defines. You'll usually find these in the provider's API or developer documentation: - **Authorization URL**: where the browser sends you to approve access. - **Token URL**: where the access token is exchanged after you approve. - **Client ID**: the identifier for your registered OAuth application. - **Scopes**: the specific kinds of access the app is requesting. - **Client secret**: only if the provider requires one. > [!WARNING] > A desktop app can't keep a client secret truly private. Prefer providers that support public clients with **PKCE**, the standard way for desktop apps to connect without a secret. Only add a secret when the provider requires it, and treat it as recoverable rather than confidential. #### Set Scope **Scopes** decide what the connected app can touch, so request only what a feature needs. The provider's docs list the scopes it supports and what each one allows. #### Test the Connection To confirm a custom connection works, ask the agent to build a simple read, like showing your profile or a small list, then run the app and sign in. The running app is what holds the OAuth access, not the agent, so the check happens in the app. A quick read tells you everything is wired up before you build a larger feature on top of it. If authorization opens but doesn't complete, check the client ID, the redirect URL, and whether the provider requires PKCE or a client secret. #### Where to Go Next Once your provider is connected, build with it the way you would any integration. See [Writing Effective Prompts](https://manual.glaze.app/prompting/writing-effective-prompts) to describe the feature, and [Managing Connections](https://manual.glaze.app/integrations/managing-connections) to re-authorize or revoke access later. Your access token is stored encrypted on your Mac, protected by the Keychain, never in plain text. Also see [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data) for more information. ### Model Context Protocol Source: https://manual.glaze.app/integrations/model-context-protocol Description: Add MCP servers to a project to give the agent extra tools, or expose your own app as an MCP server for other AI tools. Last updated: 23 July 2026 Integrations connect your **app** to a service. **MCP** connects the **agent** to one instead. The Model Context Protocol is an open standard for giving an AI agent extra tools and data to work with as it builds your app. #### What MCP Adds An MCP server exposes a set of **tools** and, sometimes, **data** the agent can use while it builds your app. Where an OAuth connection lets the finished app act with a service, MCP works one level up: it expands what the agent can do while it's working on your behalf. That's useful when you want the agent to: - **Read live documentation or references** for a library or API as it writes code. - **Query a system or database** to inform what it builds. - **Reach a specialized capability** that a particular MCP server provides. > [!NOTE] > MCP servers are scoped to a single project. They give the agent extra tools for that project and don't affect your other apps. #### Add an MCP Server 1. From **My Project**, open the ** More…** menu and click ** MCP Servers**. Alternatively, right-click the project or click **the ellipsis** in the Agent Chat to find this option. 2. Add the MCP Server entry under `mcpServers`, keyed by a server name, with the details that server needs. 3. Click **Save** to write the config file. 4. With the server added, the agent can call its tools while it works on your project. Describe what you want, and the agent reaches for the new tools when they help. ##### Configure a Server Each entry under `mcpServers` defines how its server is reached. Its **type** must be `stdio`, `sse`, or `http`: - **A server name** as the key, so you can recognize it in the config. - **A `stdio` server** is local: it declares a `command` to run, with optional `args`, `env`, and `cwd`. - **An `sse` or `http` server** is remote: it declares a `url` (http or https) and may include `headers`, such as an authorization token. Check the server's own documentation for the exact values it expects. The configuration is stored with the project in `.mcp.json`, so it stays with the app rather than needing set up again each time. #### Use It in a Prompt The agent calls a tool when your prompt makes it the obvious way to get something done. To make that more likely: - **Name the source in your prompt**: "Use the records from my database MCP server to seed the list" is clearer than hoping the agent reaches for it. - **Describe the goal, not the mechanics**: Say what you want built; let the agent decide which tool fits. - **Check the result**: If the agent didn't use a connected tool, say so and point it at the server explicitly. #### Expose Your App as an MCP Server Everything above connects the **agent** to an outside MCP server. The `/create-mcp-server` command runs the other direction: it turns your **app** into an MCP server that other AI tools can connect to, exposing your app's own data and actions as tools. Type **`/create-mcp-server`** in the Agent Chat composer. You can add free-text preferences after it, such as `/create-mcp-server read-only tools`, to shape what the server exposes. The agent then scaffolds a server around your app's own data and actions: - **A `stdio` server** by default: a local script that reads your app's data directory at runtime and exposes tools shaped around what your app stores. It works even while your app is closed. - **An `http` server** on request: an in-app server bound to localhost, for cases that need your app's live, in-memory state rather than just its stored data. It works only while your app is running. Before finishing, the agent runs a self-test, then gives you copy-paste install commands for Claude Code, Codex CLI, Cursor, or Claude Desktop. > [!NOTE] > This is separate from the Glaze agent MCP config mentioned above, where the agent connects to outside servers. If you'd like to use the server you just created as an MCP inside the agent, you can register it under `mcpServers` like any other, subject to the same approval step. #### MCP vs OAuth MCP and an OAuth integration solve different problems, and an app can use both. An **OAuth integration** connects your finished app to a service so the running app can act as you, reading and writing that service's data on your behalf. **MCP** works one level up: it connects the **agent** to extra tools and data while it builds, expanding what the agent itself can do as it writes your app. In short, OAuth extends your app's reach; MCP extends the agent's. ### Managing Connections Source: https://manual.glaze.app/integrations/managing-connections Description: Review, re-authorize, and revoke the service connections your apps use, with access tokens stored encrypted in your Mac's Keychain. Last updated: 06 July 2026 Once you've connected an integration, you'll want to keep an eye on how it's working in your app: checking what's connected, reconnecting when a token expires, and removing access you no longer need. #### Where Connections Live Connections are set up per project, so each app keeps its own. A connection lives inside the app the agent builds: the agent wires the service's sign-in and token handling into the app, but it never signs in itself. The running app is what signs you in, holds the connection, and lets you sign out again. To add a service or have the agent re-wire one, click **the Plus button** in the **Agent Chat** composer, click ** Integration**, then describe what you want. See [Agent Chat](https://manual.glaze.app/prompting/agent-chat) for more on that menu. #### How Tokens Are Stored When you sign in to a service, it hands back an **access token**. That token is what lets the app act as you, so it's stored encrypted on your Mac, protected by the **Keychain**, rather than inside the app or in plain files. The app reads it only when it needs to make a request on your behalf, and the agent never sees it. > [!NOTE] > Because the encryption key lives in the Keychain, your tokens are protected by macOS the same way your other saved credentials are. To learn what Glaze stores and how it's handled, see [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data). #### Refresh or Re-Authorize Access tokens don't last forever. Many services issue tokens that expire, and when the service supports it, the app refreshes an expired token automatically the next time it makes a request, so most of the time you won't notice. You'll need to **re-authorize** by hand when: - A token expires and can't be refreshed automatically. - You revoked access at the service and want to grant it again. - A feature needs broader access than the connection was first granted. To re-authorize, sign in to the service again from within the running app, the same way you first connected it, and approve the request in your browser. The new token replaces the old one. #### Revoke Access There are two sides to removing a connection: - **In the app**: Sign out of the service to delete the stored token from your Mac. The app can no longer act with that service until you sign in again. - **At the service**: Visit the provider's connected-apps or authorized-apps settings to revoke the access on their side too. #### Troubleshoot a Broken Connection If an app stops working with a service, the connection is usually the cause. Work through these in order: - **Re-authorize the connection**: Sign in to the service again from within the app and approve it in your browser. An expired or revoked token is the most common reason a connection stops working, and reconnecting issues a fresh one. - **Check access at the provider**: Make sure you haven't revoked the connection in the service's settings, and that your account there is still active. - **Confirm the app has the access it needs**: If a feature fails but others work, the app may need broader access than it was granted. Tell the agent in **Agent Chat** what the feature should do, and reconnect when the app asks for more. - **For a custom provider, recheck the details**: With a custom OAuth provider, confirm the client ID, redirect URL, and scopes are still correct. See [Custom OAuth](https://manual.glaze.app/integrations/custom-oauth). ##### Is signing out in the app the same as revoking at the service? Not quite. Signing out in the app deletes the token stored on your Mac, so the app can't use it anymore. Revoking at the service withdraws the authorization on the provider's side. For a complete removal, do both. ## Share ### Store Source: https://manual.glaze.app/share/store Description: Browse, search, and install apps other people have built in the Store, then update or remove them from your Mac later. Last updated: 24 August 2026 The **Store** is where you find apps other people have built and install them on your own Mac. You can browse a featured selection, filter by category, search by name, open an app to see what it does, and install it in a click, then update or remove it later just as easily. ![The Glaze Store showing apps to discover and install](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/basics/mac-store.png) #### Browse the Store Open the **Store** tab to see what's available. By default you land on the **Public** store with the **Featured** view, a curated set of sections that highlight apps worth a look. If you belong to one or more teams, a **switcher** is displayed on the toolbar. Toggle between **Public** and each of your teams to move between the open public store and your team's private one. See [Visibility Levels](https://manual.glaze.app/share/visibility-levels) for what each store contains. ##### Filter and Sort The dropdown on the right of the toolbar changes with the store you're viewing: - On the **Public** store, it's a filter. Stay on **Featured**, pick a **category** to narrow the list to one kind of app you're looking for, or choose **Remixable** to see every app you can build on. See [Remix](https://manual.glaze.app/share/remix). - On a **Team** store, it's a sort: **Recently Updated**, **Newest**, or **Most Downloaded**. #### Search To look for something specific, use the **search box** in the sidebar. As you type, the dropdown suggests matches grouped by where they live: your own projects, your teams, categories, and apps from the Public and Team stores. Pick a suggestion to jump straight to it, or open the full search to see every match. If you would like to see all published apps from a specific author, click the **Author** name on the Store's detail page to open that creator's profile. From there, sort their apps by **Most Downloaded** (the default), **Recently Updated**, or **Newest** to find what you're looking for. #### Detail Page Selecting an app opens its detail page, the full listing the author prepared when they published the app: - The app's name with a short tagline beneath it. - For selected apps, a wide **cover photo** at the top of the page with the name, tagline, and **Install** button laid over it, and a **Featured** badge in the top-right corner. - The metadata row with the **Author**, the app **Size**, a **Published** or **Updated** date, and an **Installs** count. The date reads **Published** for a brand-new app and **Updated** once there's been more than one version. This will also show the **Store** it came from if it was published to a team. - A **Uses Glaze AI** label if the app uses AI, so you know before installing that some AI features in the app draws on your own Glaze credits. See [AI](https://manual.glaze.app/capabilities/ai). - A **Remix** badge if the app is itself a remix of another app, linking back to the original where available. See [Remix](https://manual.glaze.app/share/remix). - **Screenshots** of the app in action. - A **What's New** section with the latest release notes, and a **Version History** link to see how the app has changed over time. See [Updates](https://manual.glaze.app/share/updates). - The **App Description** explaining what the app does in full. ![An app's detail page in the Glaze Store](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/share/mac-store-rayfm.png) #### Install an App Click **Install** on an app straight from the **Store**, or open its detail page. Once installed, the button becomes **Open**, and the app appears in the ** Installed Apps** tab in the sidebar, where you can launch it any time. It's also added to your `/Applications` folder. If you'd rather have your own editable copy of an app than just install it, choose **Remix** on its detail page to start a project from it. See [Remix](https://manual.glaze.app/share/remix). [Sending Feedback on Glaze Apps (YouTube)](https://www.youtube.com/watch?v=dfpPG7AuW6U) #### Leave Feedback Found a bug or have an idea to make an app better? Your notes go straight to the developer who built the app, and there's no category to pick, Glaze sorts that out for you. Open the **Share Feedback** dialog from either place: - **From the Store**: On the app's detail page, click ** Feedback** next to **Share**. - **From inside an installed app**: Use its **Feedback** menu (**Share your feedback**), its Dock menu, or, for menu-bar apps, the tray menu. If a window is open, Glaze first asks whether to attach a screenshot of it, choose **Attach Screenshot** or **Don't Attach**. Describe what you ran into or what you'd like to see, then add supporting detail if it helps: - **Screenshots**: Attach up to five images. Click **Add Screenshot** or drag and drop files in, then click one to preview it full size (arrow keys to step through) or remove it. - **Attach Logs**: Toggle this on to include that day's log files, giving the developer more to work with. It's off by default. - **Share My Email Address**: Toggle this on if you're open to the developer following up with you directly. It's off by default; when it's on, your email is included so the developer can reply. Your feedback, including your name, goes to the app's author, so leave out personal, health, or confidential details; sending it means you agree to the [Acceptable Use Policy](https://glaze.app/aup) (**Learn More** shows exactly what's shared). When you're ready, click **Send Feedback** (or press `⌘` `↵`), and Glaze confirms with a **Feedback Sent** toast. > [!NOTE] > If the developer ships a version that fixes what you reported, Glaze emails you to let you know it's resolved and links you to the new version. See [Publish Apps](https://manual.glaze.app/share/publish-apps) for how developers act on feedback. #### Update and Uninstall When an author publishes a new version of an app, the **Update** button shows on the app's Store detail page. You can also update apps you have installed from the ** Installed Apps** tab in the sidebar, where apps with updates available show in a separate **Updates Available** group. To remove an installed app, open the ** Installed Apps** tab, right-click the app, and click **Uninstall**. ### Remix Source: https://manual.glaze.app/share/remix Description: Get your own editable copy of an app from the Store, use another app as a reference while you build, or turn off remixing for apps you publish. Last updated: 10 August 2026 **Remix** turns an app from the Store into your own independent, editable project on your Mac. Instead of starting from a blank canvas, you begin from an app that already works, then take it in whatever direction you like. Your remix is a project of its own, so changes you make never touch the original, and the original's updates never overwrite your work. Remixing is a good starting point when you like how an app works and want to adapt it, learn from how it's put together, or use it as a base for something new of your own. #### Start a Remix You can start a remix from wherever you come across an app worth building on: - **From an app's detail page**: Open an app in the **Store** and choose **Remix**. - **From a context menu**: Right-click an app in the **Store**, in **My Projects**, or in your ** Installed Apps**, and choose **Remix**. The action appears once Glaze confirms the app can be remixed. - **From My Projects**: With no projects yet, the empty state offers a **Start by Remixing** composer to browse apps you can build on. - **When starting a new project**: A fresh Agent window shows a browsable grid of remixable apps to pick from. To see everything you can build on in one place, open the **Store** and choose the **Remixable** filter. See [Store](https://manual.glaze.app/share/store) for how filtering works. #### Remix an App When you remix a regular app, Glaze sets up a new project for you: - **Name it**: The project is named ` Remix` by default, up to 60 characters. The name field is focused so you can rename it right away. - **Setup runs**: A setup dialog shows its progress as Glaze grants access, downloads the app, builds it, and signs it. It stays open while setup runs and can't be dismissed until it finishes. - **If setup can't finish**: When something recoverable goes wrong partway through, Glaze leaves the project in **My Projects** with a **Retry** option so you can pick up where it stopped. When it's done, the remix is a project of your own in **My Projects**, ready to open and edit like any other. See [Managing Your Projects](https://manual.glaze.app/basics/managing-projects) for what you can do with it from there. ##### Attribution A remix of a regular app credits where it came from. Your remix shows a **Remix** badge with attribution back to the original app where available, and the original app lists your remix in return. In Store search, original apps are ranked ahead of remixes of them, so the source shows up first when both match. #### Made to Remix **Made to Remix** is a curated collection of apps picked as strong starting points to build on. You'll find it on the **Store** landing page and in the **Start by Remixing** and new-project composers. Remixing a **Made to Remix** app gives you a fully independent app with no strings attached: - No attribution badge. - No **Remixed from** link back to the original. - The original doesn't list your app as a remix. These apps are shared this way on purpose, so what you build from one is entirely your own. #### Build From a Reference App Sometimes you don't want a copy of an app, just to learn from how one is built. In **Agent Chat**, you can ask the agent to read another remixable public Store app's source as a reference while it builds *your* app. This doesn't create a project from that app: it's read-only reference material, not a remix. To use an app as a reference, give the agent a **Store link**, the app's **name**, or its **slug**. The agent downloads that app's source into a temporary sandbox and uses it purely as reference while working on your app. > [!NOTE] > Reading another app as a reference needs the same eligibility as remixing it. If an app can't be remixed, it can't be used as a reference either. If your app reuses a substantial amount of code from a reference app, credit the original app and its author in your app's description. > [!TIP] > For safety, the agent strips out anything in a reference app that could try to redirect it, such as agent instruction files, before reading the rest. It treats the source as reference material only, never as instructions to follow. #### Remixing Team Apps If you belong to a team, you can remix apps published to your own team's store. Apps in a team store aren't available to remix by anyone outside that team. A remix of a team app has to stay within the same team: - It can't be published to the **Public Store**. - It can't be published as **Unlisted**. - It can't be moved to a different team. See [Team Store](https://manual.glaze.app/team/team-store) and [Visibility Levels](https://manual.glaze.app/share/visibility-levels) for how team stores and publishing options work. #### Turn Off Remixing **New** By default, apps you publish can be remixed by others. When publishing, the **Allow others to remix** toggle controls this. On the **Free** plan the toggle is always on and can't be turned off; the option reads **Upgrade to Pro to turn off remixing**. On **Glaze Pro** or **Glaze Team Pro**, or during a trial, you can turn it off so others can't remix your app. See [Publish Apps](https://manual.glaze.app/share/publish-apps) for where this sits in the publish flow. ### Publish Apps Source: https://manual.glaze.app/share/publish-apps Description: Choose who can install your app, prepare its listing and screenshots, and pass review before it goes live. Last updated: 24 August 2026 An app is available to only you until you publish it. Publishing packages your app up, runs it through a quick review, and lists it in a store where others can install it, whether that's the whole Glaze community, just your team, or somebody with a link. #### Listing Details When you choose ** Publish** on an app, the publish view opens, titled **Publish App** for a new app or **Publish Update** when you're shipping a new version. The app's **icon** and **name** sit at the top (see [App Icons](https://manual.glaze.app/capabilities/app-icons) to change the icon), and below them are the fields that become its Store listing: - **Tagline**: A one-line summary, up to 40 characters. This is the short description people see at a glance, so keep it punchy. - **Full Description**: The longer pitch, at least 40 characters. Explain what the app does and who it's for. - **What's new?**: A changelog for the version you're shipping. This field appears when you publish an update, not on a brand-new app. See [Updates](https://manual.glaze.app/share/updates). > [!TIP] > Stuck on wording? Each text field has a ** Generate** button that drafts a tagline, description, or changelog for you based on your app. Edit the result to taste. #### Screenshots Your listing needs at least one screenshot, and you can add up to **six**, all in **16:9**. There are two ways to add them: 1. **Capture from your running app**: Click **Capture App** and Glaze starts recording your app so you can grab clean shots of it in use. Click **Stop Capture** when you're done. - The first time, macOS asks for **Screen Recording** permission; Glaze prompts you to **Open System Settings**, enable it, then restart Glaze. 2. **Add your own images**: Click the screenshot area or drag image files onto it to add pictures you already have from your computer. Reorder screenshots to put your best one first, since it leads the listing. Hover a screenshot and use **Remove Screenshot** to remove any you don't want. #### Publish To The **Publish to** section is where you pick where your app will be published: - **Public Store**: Anyone using Glaze can find and install your app. - **Your team's store**: Your app stays private to your team, and any member can install it. The Team Store is **free while it's in beta**. - See [Team Store](https://manual.glaze.app/team/team-store) for more information. - **Unlisted**: Your app isn't listed anywhere but anyone you send the link to can install it. Requires **Glaze Pro**. This section also has an **Allow others to remix** toggle, which lets people get their own editable copy of your app from the Store. It's on by default, and turning it off requires **Glaze Pro**. See [Remix](https://manual.glaze.app/share/remix) for what remixing does and how to turn it off. You can move a published app later with **Move to Store…**, and people who already installed it keep getting your updates. See [Visibility Levels](https://manual.glaze.app/share/visibility-levels) for the full breakdown of who can see what and how each option is gated. #### Submit and Review After completing your app's listing, click **Submit for Review**. Glaze runs automatic checks before your app goes live, confirming it runs and scanning the code for anything that needs your attention. Whatever the checks find comes back as a list of issues for you to review. The review runs wherever you publish your app, whether the Public Store, a team store, or an unlisted link. Glaze runs the review in the background and you can continue building apps or browse the dashboard in the meantime. ##### Pre-Upload Checks Before Glaze even submits your app for review, it checks your project's source for common problems that would otherwise turn into failed publishes, and flags them so you can sort them out first: - **Missing or outdated `package-lock.json`**: If your project's root lockfile is absent or out of date, Glaze offers a one-click action to update it for you (running `npm install --package-lock-only`) rather than failing the publish. - **Stray lockfiles from other package managers**: If Glaze finds leftover pnpm (`pnpm-lock.yaml`), Yarn (`yarn.lock`), or Bun (`bun.lockb`) files, it warns you and excludes them from the upload instead of failing. - **Forbidden files**: Files that shouldn't ship, such as `.env` or `.npmrc`, are flagged so you can remove them before publishing. These checks are about getting your app packaged cleanly. Most surface as warnings that Glaze handles for you; the rest point you at a quick fix before submission. ##### Read the Feedback When the review finishes, Glaze shows the outcome: - **Published successfully**: Your app is live on the chosen store, with no issues to address. - **Review passed with warnings**: Your app can go live, but Glaze flagged things worth a look. - **Review failed**: Critical issues were found that must be fixed before your app can be published. - **Publishing failed**: Something went wrong on Glaze and you should try again. Any issues appear in a **Detected Issues** panel, each tagged **Error** (must be fixed) or **Warning** (recommended). Expand an issue to read the detail and **Copy** it for reference or send to the Glaze Agent to fix. ##### Fix Issues Glaze can often fix flagged issues for you. In the Detected Issues panel, choose **Fix** on a single issue, or **Fix All** when there are several, and the agent works through them. Once they're resolved, submit again. If a review only raised warnings, you have a choice: address them and **Resubmit**, or accept them as-is and choose **Ignore & Publish** to publish your app anyway. ##### After the Review - After fixing errors, choose **Resubmit** to run the review again. - If publishing failed on Glaze's end, choose **Try Again**. Glaze also retries temporary server errors on its own before surfacing a failure, so a transient hiccup often clears without any action from you. - When an app publishes to the Public Store or a Team Store, choose **View in Store** to see your live listing. - For an unlisted app, choose **Copy Link** to copy its shareable link to your clipboard, then **Done**. > [!WARNING] > Cancelling a review doesn't throw away your work. Your listing details are saved as a draft, so you can pick up where you left off and resubmit when you're ready. #### Feedback From Users Once your app is live, anyone who installs it can send you feedback straight from its Store detail page. There's no inbox to keep an eye on: Glaze emails you each time someone leaves feedback including what they reported, any screenshots they attached, and, when they had the app installed and left **Attach Logs** on, that day's log files to help you track down the problem. See [Store](https://manual.glaze.app/share/store) for what people fill in on their end. Each email includes a **Implement with Glaze** link. Clicking it opens Glaze and shows the Agent Chat for the project, with a prompt already prepared to analyze the feedback, including any screenshots, and make a targeted fix. Glaze will also include the issue number (for example `#Kt399L-2`) and include the change in the next update's **What's New>?** changelog, along with automatically emailing the person who reported it to let them know it's resolved and links them to the new version. See [Updates](https://manual.glaze.app/share/updates) for how to publish a new version. #### Acceptable Use Whatever you publish has to follow the Glaze [Acceptable Use Policy](https://glaze.app/aup). Don't publish apps that are illegal, deceptive, infringe someone else's rights, or carry harmful or abusive content. Glaze can refuse to publish an app, or remove one that's already live, if it breaks these rules. You're responsible for what your app ships with: - **No secrets or private data**: Don't include API keys, credentials, or anyone's personal or confidential data in an app you publish, unless you have the right to share it. - **Tell people what they're installing**: If your app needs certain permissions or has limits worth knowing, note them in the listing so others can use it safely. The automatic review scans for exposed keys, personal data, and other risks, but it runs without human oversight, so treat its results as a starting point and give your app a final check yourself before publishing. To flag an app that breaks the rules, use the **Report** button in the **Store** or email [safety@glaze.app](mailto:safety@glaze.app). #### Share a Link Once an app is published as **Unlisted**, Glaze gives you a link to share it. On the screen that confirms your app is live, choose **Copy Link** to put it on your clipboard, then send it however you like. Anyone who opens it on a Mac with Glaze can install your app, even though it never appears in the Store or in search. #### Unpublish an App Changed your mind? From your app's menu in **My Projects**, choose **Unpublish App** and confirm to remove it from its store. To move an app to a different store instead of removing it, you don't have to republish. Select the app in **My Projects**, open the ** More...** menu, and click **Move to Store...** to open the **Move** dialog. Pick a new home from the list and confirm with **Move App**. ##### Why does my app need a review? Every app is checked first to make sure it compiles, runs, and is safe before anyone else can install it. That applies to every store, whether the Public Store, a Team Store, or an unlisted link. ##### Can I publish even if the review found something? It depends. **Errors** are critical and must be fixed before you can publish. **Warnings** are advisory, so when a review passes with warnings you can choose **Ignore & Publish** to go live, or fix them first and resubmit. ##### Can I publish and share an app outside Glaze? Not at this time. Publishing apps is only availble to the Public Store, Team Store, or to anyone with a link, and Glaze must first be installed before anyone can install your app. ### Visibility Levels Source: https://manual.glaze.app/share/visibility-levels Description: Publish to the Public Store, your Team Store, or an unlisted link, and move an app between them whenever you like. Last updated: 24 August 2026 Every app you build starts out private to you. When publishing, you decide how visible it is: Glaze offers three levels you can publish to. Each level differs in who can see the app and what plan it requires, and you can move an app between them after publishing. #### The Four Levels - **Public Store** — Anyone using Glaze can find and install your app in the Store. - **Your Team's Store** — Only members of your team can see and install the app. - **Unlisted** — **Anyone with the link** can install it. - **Private** — Not published to a Store. This is your app visible only to you in **My Projects**. ##### Public Store The **Public Store** is the public community store. Choose it and anyone using Glaze can find your app and install it. Like every published app, it goes through a publishing review before going live. See [Publish Apps](https://manual.glaze.app/share/publish-apps) for what the review checks and how to pass it. Publishing to the Public Store is available on every plan, including Free. See [Plans](https://manual.glaze.app/account/plans). ##### Team Store Teams have a store that's **private to your team**. Apps published there are visible to team members only, never to the public, which makes it the right home for internal tools. Your teams are listed in the **Publish to** picker when publishing an app, and it displays the team name and avatar so you can pick the correct one. Any member of a team can publish to the team store and install from it. The Team Store is **free while it's in beta**. See more about publishing to a [Team Store](https://manual.glaze.app/team/team-store) page. ##### Unlisted **Pro** **Unlisted** sits between public and private. Your app doesn't appear in the Store or in search, but **anyone with the link can install it**. It's the right choice when you want to send an app to specific people without listing it for everyone. > [!NOTE] > Unlisted publishing currently follows your own personal Glaze **Pro** plan rather than a team's plan. See [Plans](https://manual.glaze.app/account/plans). ##### Private **Private** isn't something you choose in the publish picker. It's the state of any app you haven't published yet. A private app lives in your **My Projects** tab and runs only on your Mac. The moment you publish it to any of the three levels above, it stops being private. #### Move an App Between Stores Published your app to one store and want it somewhere else? You don't have to republish again. Select the app in **My Projects**, open the ** More...** menu, and click **Move to Store...** to open the **Move** dialog. Pick a new home from the list and confirm with **Move App**. > [!NOTE] > Moving an app keeps your installers connected. Users who have installed your app will continue to receive updates from its new location without needing to reinstall. ### Updates Source: https://manual.glaze.app/share/updates Description: Ship a new version with release notes so your app's users know what changed. Last updated: 24 August 2026 Publishing an app isn't a one-time event. As you improve and add functionality to your app, you can ship new versions with release notes so people know what changed. #### Publish a New Version To publish updates to your app, repeat the same steps as the initial publish. The view and button update to ** Publish Update**. For details on listing fields, see [Publish Apps](https://manual.glaze.app/share/publish-apps). Each update creates a new **version** of your app, on top of the ones before it. Your listing always shows the latest, while the earlier versions stay on record so people can see how the app has evolved. #### Write What's New An update has one field the first publish doesn't: **What's new?**. This is your changelog, a short note about what changed in this version. It's what installers see when they update, so keep it readable: ``` - Added a dark theme - Fixed a crash when importing large files - Faster startup ``` > [!TIP] > Not sure what to write? The **What's new?** field has a ** Generate** button that drafts a changelog from your changes that you can edit before you publish. #### How Installed Apps Update People who installed your app don't have to go looking for updates. Glaze tracks the version each person has, and when you publish a newer one it surfaces in a few places: - ** Installed Apps tab**: Apps with a new version collect in an **Updates Available** group in the sidebar, and a dot on the tab flags that updates are waiting. - **App's Store detail page**: The install button changes from **Open** to **Update**. - **The app itself**: An installed app's own application menu, Dock menu, and, for menu-bar apps, its tray menu, offer **Check for Updates…**, which takes you into Glaze to check and update that install. Apps carry this action once they've been installed or updated after this release; an app still running an older host won't show it until it's reinstalled or updated once. From any of these spots, choosing **Update** brings the app up to the latest version in place, with no reinstall. When it finishes, Glaze confirms the update and offers **View Changelog** so users can read the "What's new?" changelog. This is how an update reaches everyone who has your app, whether it's in the Public Store, a team store, or shared as an unlisted link. #### Update Your Code with `/upgrade` There's a second, different kind of update: keeping the **code** of an app you're building current with the latest Glaze APIs. In **Agent Chat**, type `/upgrade` and the agent migrates your app to the latest Glaze APIs. Running `/upgrade` is **free** and doesn't use any credits. > [!NOTE] > These are two separate ideas. **Update** in the Store ships your published changes to other people. **`/upgrade`** in **Agent Chat** brings your own app's code up to date with Glaze itself. You don't run `/upgrade` to publish an app update. #### Recover a Stuck Review Publishing runs a review in the background, and an app can have only one review in progress at a time. If that review seems stuck, or you started a publish you'd rather not finish, you can cancel it: 1. Return to the app's publish view while the review is still running. 2. Click **Cancel Review**. A **Cancel Review Process** dialog confirms; click **Cancel Review** again to stop the run and free the app so you can publish again. 3. Your listing details are saved as a draft, so the publish view reopens with everything filled in. Adjust what you need and click ** Publish Update** (or **Submit for Review** on a first publish) whenever you're ready. > [!TIP] > Cancelling never throws away your listing. As the dialog notes, your submission details are saved as a draft so you can resubmit later. #### View Version History On an app's detail page in the Store, the **What's New** section shows the release notes for the latest version, and a **Version History** link opens the full list. The detail page also shows a **Published** date while an app has only one version, or an **Updated** date once there's been more than one, so you can tell at a glance how actively an app is maintained. ### Creator Hub Source: https://manual.glaze.app/share/creator-hub Description: See how your published apps are doing, with installs, active users, Store conversion, and feedback for each app in one place. Last updated: 24 August 2026 Once your app is live, **Creator Hub** gives you a clearer picture of how it's doing. It gathers the numbers that matter, installs, active users, Store conversion, and the feedback people leave, into one place, so you can see how a published app is landing and how each new version affects it. #### Open Creator Hub **Creator Hub** is an item in the sidebar of the main Glaze window, alongside **My Projects**, **Store**, and **Installed Apps**. It's visible to everyone who's signed in, so you can find it whether or not you've published an app yet. #### What It Shows **Pro** Creator Hub gives you a breakdown for each of your published apps, so you can track how a listing performs over time: - **Installs**: How many people have installed the app. - **Weekly active users**: How many people are actually using it week to week. - **Store conversion**: How often people who view your listing go on to install it. - **Feedback**: What people have sent you about the app. See [Store](https://manual.glaze.app/share/store) for how users leave feedback and [Publish Apps](https://manual.glaze.app/share/publish-apps) for how you act on it. The **installation chart** also marks the points where you published a new version, so you can line up a release with a change in adoption and see how an update landed. > [!NOTE] > Viewing the analytics is a **Glaze Pro** benefit. The **Creator Hub** sidebar item is visible to everyone, but opening it without Pro shows an upgrade prompt describing what the dashboard includes. See [Plans](https://manual.glaze.app/account/plans). #### Data for Every App Creator Hub shows real data for your published apps regardless of how many installs they have, so a newer app with only a handful of installs still gets a dashboard. Some individual metrics still need a little data before they can show a meaningful number, for example, weekly active users needs a full week to measure, and Store conversion needs enough views to compare against. Until then, those metrics show as empty or still gathering, and fill in as the data arrives. ## Account ### Plans Source: https://manual.glaze.app/account/plans Description: Discover the different Glaze plans, and manage your subscription from the Account tab. Last updated: 24 August 2026 Glaze offers **Free** and **Pro** for individuals, plus **teams** for organizations. Your individual plan lives in the **Account** tab in [Settings](https://manual.glaze.app/account/manage-account), where you can upgrade, manage billing, and check your credit balance. > [!NOTE] > For the latest Glaze plan prices and credit allowances, see the [pricing page](https://glaze.app/pricing) on the Glaze website. #### Individuals ##### Free You'll receive a one-time **Launch Welcome Pack** of credits to build your first apps, and installing and running apps from the **Public Store** is always free. There's no recurring allowance and no top-ups on Free, so building pauses once your balance reaches zero. Free accounts can't publish **unlisted** apps or buy credit top-ups. Upgrade to Glaze Pro to access these. ##### Pro Glaze Pro is a paid monthly subscription. It includes: - A recurring **monthly credit allowance**, with unused credits rolling over into the next month, so they stay valid for two months from when they're granted. - The ability to **buy top-ups** whenever you need more (see [Credits](https://manual.glaze.app/account/credits)). - **Unlisted publishing**: Share an app by link without listing it in the Store (see [Visibility Levels](https://manual.glaze.app/share/visibility-levels)). - **Glaze Smart**: Access to Glaze's most capable models in the composer's model picker, alongside the **Glaze Fast** option available on every plan (see [Agent Chat](https://manual.glaze.app/prompting/agent-chat)). The agent still pauses if you hit **zero** credits. Glaze Pro allows you to buy credit top-ups or wait for the next monthly refill instead of being stuck. #### Teams A **Team** lets you share Glaze with others in your organization through a private team store, separate from your personal plan. The **Team Store is free while it's in beta**, so any team can create a store and publish to it with no subscription. During the beta, building apps draws on **each member's own personal credits** — there's no pooled or per-team credit allowance. See [Teams](https://manual.glaze.app/team/get-started) and [Team Billing & Credits](https://manual.glaze.app/team/billing-and-credits). > [!NOTE] > Some per-member perks currently follow the person's own plan rather than the team's. In particular, **unlisted publishing** and **disabling remixing** appear to require a personal Glaze **Pro** subscription, rather than being granted by the team. #### Manage Your Subscription When you're on Pro, the **Account** tab shows **Manage Subscription**, which opens the billing portal. From there you can: - Update your payment method. - View and download invoices. - Cancel your subscription. If you cancel, you keep Pro until the end of your current billing period, then return to the Free plan. #### Compare Plans | | Free | Pro | Team | | --- | --- | --- | --- | | Credits | Launch Welcome Pack | Monthly allowance | Each member's own personal credits* | | Buy top-ups | ✗ | ✓ | Personal Pro only* | | Publish to Public Store | ✓ | ✓ | ✓ | | Unlisted publishing | ✗ | ✓ | Personal Pro only* | | Private Team Store | ✗ | ✗ | ✓ (free during beta) | * During the beta, teams have no separate plan: building uses each member's own personal credits, and per-member perks such as unlisted publishing follow the person's own Glaze Pro subscription. ### Credits Source: https://manual.glaze.app/account/credits Description: Credits track how much the agent does when building and editing your apps, with monthly allowances, top-ups, and free actions. Last updated: 24 August 2026 Credits are what the agent spends when it builds and edits your apps. The more work a turn involves, the more it costs. A quick tweak is cheap; building an app from scratch costs more. Credits track real usage rather than a flat per-message charge. You can always see your balance under **Credits** on the **Account** tab in [Settings](https://manual.glaze.app/account/manage-account), shown as the number of credits you have remaining. > [!NOTE] > For the latest Glaze plan prices and credit allowances, see the [pricing page](https://glaze.app/pricing) on the Glaze website. #### Your Allowance - **Free**: One-time **Launch Welcome Pack** of credits to get started. There's no recurring allowance, so building pauses at zero until you upgrade (see [Plans](https://manual.glaze.app/account/plans)). - **Pro**: Recurring **monthly credit allowance**. - **Team Pro**: Recurring **monthly credit allowance** for every member. #### Top-Ups **Pro** Need more before your next monthly refill? Top-ups are available on the **paid plans**. Go to **Settings -> Account** and click **Top Up** under **Credits** to pick a top-up pack. > [!NOTE] > In a team, members can't buy top-ups directly. Instead, you can **request a top-up** from your team's owners or admins. See [Team Billing & Credits](https://manual.glaze.app/team/billing-and-credits). When your balance **runs low**, Glaze shows a reminder near the agent composer with a quick action: **Top up** on Pro, **Get Pro** on Free, or **Request top up** on a team. If you reach **zero**, the agent pauses until you have credits again. On **Pro**, buy a top-up or wait for your next monthly refill; in a **team**, request a top-up from an owner or admin, or wait for the refill; on **Free**, upgrade to a paid plan. Either way, you can still **report an issue**; support reports work even at zero credits. #### How Long Credits Last How long credits stay valid depends on where they came from: - **Monthly allowance**: On Pro and Team Pro, unused credits roll over into the next billing month, so they stay valid for **two months** from when they're granted. - **Top-ups**: Purchased top-up credits are valid for **three months** from the day you buy them. - **Launch Welcome Pack**: The Free welcome credits are a one-time allocation, so they don't roll over or refresh. Credits aren't **refundable**, but they stay usable until they expire. #### Included Usage Several actions in Glaze will never cost credits, including: - **Generating an app icon.** - **Send Feedback** or using the `/issue-report` command in Agent Chat. - **Updating your app** using `/upgrade` to bring your app's code up to date with the latest Glaze APIs. > [!NOTE] > Building with a **connected Claude subscription** doesn't draw from your Glaze credit balance either. It uses your own Claude subscription instead, and is a separate **beta** feature. See [Bring Your Own Agent](https://manual.glaze.app/advanced/bring-your-own-subscription). ### Invite Friends Source: https://manual.glaze.app/account/invite-friends Description: Share your Glaze invite link and you and your friends each earn 50 credits when they subscribe to Pro. Last updated: 23 July 2026 Invite friends to Glaze and you both earn credits. When a friend you invited subscribes to **Pro** for the first time, you each get **50 extra credits** to spend on building and editing apps. You can open **Invite Friends** from the account menu in the sidebar of the Glaze window, or from the **Invite Friends** option in [Settings](https://manual.glaze.app/account/manage-account). #### Share Your Invite You will see a unique **invite code** and **invite link** (for example `https://glz.so/r/`) connected to your Glaze account. Share the link however you like, or use the built-in **Share on X** button to post with text already filled in. Once a friend joins Glaze through your link, the reward is credited automatically once they qualify. #### How You Earn Credits Both people receive **50 credits**, granted only when your invited friend pays their **first month's Pro subscription**. A few things to keep in mind: - The reward is tied to a friend's **first paid personal Pro subscription**. Free trials, renewals, and team subscriptions don't count. - You can't refer yourself, and each person can receive the invited-friend bonus **only once**. - You can earn the referrer bonus for up to **25 friends**. In your [Credits](https://manual.glaze.app/account/credits) history, these appear as **Friend referral bonus** (for you, the referrer) and **Referral welcome bonus** (for the friend you invited). > [!NOTE] > Referral credits expire **3 months** after they're granted, on both sides. #### Track Your Rewards Once at least one friend subscribes, the Invite Friends screen shows a running total, such as **2 friends subscribed · 100 credits earned**. > [!NOTE] > Glaze counts only successful, paid conversions. There's no list of who you've invited or whether they've signed up yet. If a friend's payment is fully refunded, the 50 credits from that invite are reversed on both sides. ### Manage Account Source: https://manual.glaze.app/account/manage-account Description: Update your Glaze profile, check your plan and credits, and sign in or out from Settings. Last updated: 31 July 2026 You can manage your Glaze account from **Settings**. Open it from the account menu in the sidebar of the Glaze window or from the menu bar, then select **Account**. #### Your Profile Your **Account** is where your profile lives. At the top you'll find your **avatar**, your **display name**, and the **email address** you signed in with. Your email is shown here for reference and can't be changed in the app. If you would like to change this, [get in touch with us](https://manual.glaze.app/contact-support). > [!NOTE] > Your display name and avatar are shown publicly when sharing apps to the Store, or when joining a team. ##### Avatar Click the pencil button on your avatar to open the **Change Avatar** dialog. Drag an image onto it or click to pick one from your Mac. **JPG, PNG, and SVG** files are supported. Choose **Save**, and your new avatar appears everywhere you show up in Glaze. > [!TIP] > Haven't set an avatar? Glaze falls back to your initial. If you signed in with Google, it will use the picture from that account. ##### Display Name Your name is how you appear across Glaze. Edit it by clicking the name under your avatar. The change **saves automatically when you click away**. ##### Links Under **Links (Optional)** you can add up to three profile links that are displayed on your public Store profile. There are three fixed slots, and you can fill in any or leave them blank: - **Website**: any valid URL (placeholder `website.com`). - **X**: a link to your X profile (placeholder `x.com/handle`). - **GitHub**: a link to your GitHub profile (placeholder `github.com/handle`). Like your display name, each link **saves automatically when you click away**. Glaze checks that your X and GitHub links are valid URLs for those sites. > [!NOTE] > The links you add appear on your public Store profile, the page people reach by clicking your name on an app's Store listing. Leave them all blank and nothing extra shows on your profile. #### Your Credits & Plan **Account** also shows your credits and subscription at a glance: - **Credits**: How many credits you have left, plus when your next monthly credits will arrive. Click **Show details** to break down each batch of credits and when they expire. - The **Account** row shows whether you're on **Free** or **Pro**, or **Team** plan, along with your renewal or expiry date. For the full details, see [Plans](https://manual.glaze.app/account/plans) and [Credits](https://manual.glaze.app/account/credits). #### See What's New To check what's new in Glaze, open the account menu at the bottom of the sidebar and choose **Changelog**. It opens the latest Glaze release notes in your browser, so you can see what shipped without leaving your current build. #### Sign In & Out You can sign in to Glaze with **Google**, **Apple**, or **Email**. If you use email as your sign in method, Glaze sends a 6-digit code to authenticate. To sign out, open the account menu at the bottom of the sidebar and choose **Sign Out**. You can also use **Sign Out** in the **Account** section of Settings. #### Delete Your Account To delete your account, [reach out to the Glaze team](https://manual.glaze.app/contact-support) for assistance. To learn what data Glaze stores and how it's handled, see [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data). ### Use Credits Efficiently Source: https://manual.glaze.app/account/use-credits-efficiently Description: Be specific, plan before building, annotate instead of explaining, and revert rather than patch to make every credit count. Last updated: 01 July 2026 Credits track how much work the agent does, so a few good habits go a long way. Most wasted credits go to the same place: a build that misses what you meant and has to be redone. Practicing good prompting habits keeps that from happening. #### Be Specific Up Front The surest way to spend fewer credits is to need fewer correction rounds. A vague prompt still builds something, but the agent has to guess, and you end up paying for follow-up after follow-up to add what you meant all along. A specific first prompt lands close on the first build. Cover the purpose, the data, and the look and feel in your opening prompt: - **Specific (one focused build)**: "A single-window expense tracker. Each entry has a date, amount, category, and note. Show a running total at the top, and let me filter by category and month." - **Vague (several paid rounds)**: "Make me an expense app." Both build something, but the second leaves the fields, the total, and the filter for you to add one paid round at a time. See [Writing Effective Prompts](https://manual.glaze.app/prompting/writing-effective-prompts). #### Plan Before You Build For anything substantial, use **Plan mode** to agree on the approach before the agent writes code. Talking through a plan costs very little, while building the wrong structure and unwinding it costs a lot, especially on multi-view apps where the foundation can use a lot of credits to change later. Open in Plan mode with something like: - **Try**: "Before writing any code, outline how you'd structure a client tracker with contacts, deals, and a dashboard, and let me confirm the approach first." Once the plan looks right, use Build mode to action the plan. See [Plan & Build Modes](https://manual.glaze.app/prompting/plan-and-build-modes). #### Point Instead of Describing When something looks off, **annotate the live app** or attach a screenshot instead of writing a long description. A wordy explanation is easy to misread, and a misread fix is another paid round. - **Costly**: "The button near the top, the blue one, no, the other one, make it smaller and move it to the right a bit." - **Cheaper**: Annotate the exact button and send "Make this smaller and align it to the right." Pointing hands the agent a precise target, so it changes the right thing the first time. See [Annotate](https://manual.glaze.app/prompting/annotate). #### Keep Requests Focused One change at a time is cheaper than a sprawling, do-everything prompt. When you bundle several unrelated changes and one goes wrong, you often re-run the whole request to untangle it. Smaller asks are easier for the agent to get right and easier for you to check. Instead of one overloaded prompt like "Add dark mode, fix the CSV export, add a settings page, and rename the tabs," send each change on its own: 1. "Add a dark mode toggle to Settings." 2. "The CSV export is missing its header row. Include it." 3. "Rename the **Home** tab to **Today**." You can queue these so they run back to back without waiting on each one. See [Iterating](https://manual.glaze.app/prompting/iterating). #### Revert Instead of Patching If a direction isn't working, **roll back** to a good version and re-prompt rather than stacking fix on top of fix. Layering corrections onto a confused build tends to compound the confusion, and every attempt costs credits. See [Version History](https://manual.glaze.app/prompting/version-history). When you've sent three or four follow-ups and the app keeps drifting, stop and roll back to the last version that worked, then re-prompt that step more clearly: - **Try**: "Starting from the working version, sort the table by newest date first, and keep the total at the bottom updated as I add rows." ### Glaze Privacy & Data Source: https://manual.glaze.app/account/privacy-and-data Description: What stays on the Mac, what Glaze sends to build an app, and what an app sends when it uses Glaze AI. Last updated: 29 July 2026 Glaze is **local-first**. Apps built with Glaze live and run on the Mac, and nothing about them is uploaded or synced silently. AI is where data leaves the machine, at two points. The agent sends prompts and the parts of a project it's working on to AI model providers to **build** an app, and an app with a Glaze AI feature sends whatever that feature acts on each time someone **runs** it. This page covers both, along with what Glaze stores, who it shares data with, and what it measures. #### What Stays on the Mac An author's apps, their data, project files, and chat history with the agent all stay on their Mac. Apps and their code live as files on disk, and chat history lives in a local database. None of it leaves the Mac on its own, and nothing is synced to the cloud in the background. > [!WARNING] > The agent acts on the author's Mac directly, creating, editing, and deleting files and running code with the access it's granted. Some actions are **irreversible**, so keep backups and review what gets approved. See [Approvals](https://manual.glaze.app/prompting/approvals). #### What's Sent to Build an App As the agent works, it sends what it needs to the Glaze AI service, which passes it to the model providers: the author's **prompt**, the **conversation so far**, the app's **description**, the **files it reads or edits**, the **output of the commands it runs**, and any **images or files attached**. The project isn't uploaded up front; code reaches the model as the agent opens it. The provider's API key stays on Glaze servers, never on the device. Glaze doesn't use prompts or content to **train or tune its AI models**, and inputs aren't kept once a response is generated. Three categories of things are kept, including: - **Uploaded files** that an app needs to run, so it keeps working. - **Feedback and issue reports**, which can include session context, like conversation history, memory files, and app logs. - A short **summary of prompts**, described under Analytics & Improvement below. What an author builds is theirs. **An app's code and content, and the output the models generate, belong to its author**, to use, distribute, or sell. The Glaze pieces an app ships with, like the runtime and SDKs, stay property of Raycast Technologies Ltd and come with a licence to use them, which is what lets the app run. #### What's Sent When Using Glaze AI An app with no [Glaze AI](https://manual.glaze.app/capabilities/ai) features sends nothing to AI. When an app does use Glaze AI, whatever that feature acts on **leaves the app** and goes to a model provider so it can generate a response: the text the user types in, the notes or records it summarizes, the file or image they hand it, and the instructions the app sends alongside them. That data is the user's, and anything the app stores but never sends to Glaze AI stays on their Mac. The request goes to the Glaze AI service, which passes it to the provider, and is the same path the agent uses. Glaze records only what it needs to meter the user's credits, such as which app ran the request and how much it used, never the prompt or the content sent, and as with the agent those requests aren't used to train or tune the models. ##### Custom AI Providers An author can also ask the agent to wire an app up to an outside AI service directly, using their own account and API key with that provider. This is separate to Glaze AI, and the protections above don't apply to it: - The requests go **straight from the app to that provider**, not through Glaze. Glaze can't see, meter, or limit them, and they don't draw on anyone's Glaze credits. - User data is handled under **that provider's terms and privacy policy**, which set their own rules on retention and training. - The credentials live in the app rather than on Glaze servers, and every user runs on the author's key. A desktop app can't keep a secret truly private, so treat any shipped key as recoverable and scope it as narrowly as the provider allows. #### Publishing & Installing Apps Publishing changes who's responsible. Once other people run an app, **its author handles their data**, not Glaze, and Glaze's Privacy Policy doesn't cover what the app does with it. If an app collects, stores, or sends anything about its users, including through a Glaze AI feature, telling them and having a lawful basis for it is the author's job. App authors are also responsible for making sure a published app carries no credentials, API keys, or personal data it shouldn't. Glaze may run apps through an **automated review** before publishing that looks for exposed keys, personal data, and other security risks, but it runs without human oversight and its findings and fixes are a safety net rather than a guarantee. Review the app before submitting it to the Store or sharing with others. See [Publish Apps](https://manual.glaze.app/share/publish-apps). From a user's side, permissions granted to an installed app go to **that app and its author**, not to Glaze, and Glaze doesn't monitor or endorse how a published app behaves. An app from the Store deserves the same scrutiny as any other app download. #### Sharing & Storage Glaze shares data only with the vetted service providers it relies on to run, like the AI model providers, cloud hosting, and **Stripe**, which processes payments so Glaze never sees or stores full card details. Each provider is bound by a contract that limits it to working on Glaze's behalf. The model providers also apply their **own terms** to the input they receive, which both authors and users accept when they use the agent or Glaze AI. Personal data is stored primarily on **servers in the United States**, with safeguards in place whenever it's transferred across borders, and it's kept only as long as it's needed to provide the service or until the account is deleted, whichever comes first. Glaze doesn't sell data or use it for ad targeting. #### Connections & Secrets When an app connects an outside service like GitHub, Linear, or Slack, the access token is stored encrypted on the Mac it's running on, protected by the **Keychain**, rather than in plain text. Connections can be reviewed or revoked at any time. See [Managing Connections](https://manual.glaze.app/integrations/managing-connections). #### Analytics & Improvement To improve Glaze, we collect **usage analytics** about both the Glaze app and the apps built with it, as described in the [Privacy Policy](https://glaze.app/privacy). These are **usage metadata only**, things like app identifiers, open and usage events, build type, and OS details; they don't include prompts, files, or the content of apps. Separately, Glaze keeps a short, model-generated **summary of prompts**, linked to the account that sent them, to help improve the service. > [!NOTE] > For the complete picture, including data retention and security, see the [Glaze Terms of Service](https://glaze.app/terms) and [Privacy Policy](https://glaze.app/privacy), or reach out at [privacy@glaze.app](mailto:privacy@glaze.app). ## Team ### Get Started with Team Source: https://manual.glaze.app/team/get-started Description: Bring your team into Glaze to build internal apps together and share them through a private Team Store. Last updated: 24 August 2026 A **team** brings the people you work with into Glaze, so you can share apps privately through a **Team Store** and keep billing in one place instead of on each person's personal account. Your own projects and Agent Chat stay personal; a team only adds a shared layer for sharing, billing, and membership. Teams are managed entirely from **Settings** in Glaze. Click the account menu at the bottom of the sidebar to find Settings. Each team you belong to appears in the Settings sidebar, listed by its name and logo. ![A team's settings in Glaze](https://fz1sd71lwhbqy6sh.public.blob.vercel-storage.com/glaze/images/team/mac-team-account.png) #### Create a Team 1. Open **Settings** then click ** Create Team**. 2. Enter a **Team Name**, and optionally add a **Team Logo** (a PNG, JPG, or SVG). 3. Click **Create Team** and you will see your **Team Settings**. Creating a team and inviting people is free, and the **Team Store** is free while it's in beta. See [Team Billing & Credits](https://manual.glaze.app/team/billing-and-credits) for how billing and credits work during the beta. #### Invite Members Once your team is created, invite the people you work with to build apps: 1. In **Settings**, choose your team in the sidebar and scroll to **Members**. 2. Click **Invite**, enter the team member's email address, and confirm. Glaze emails them an invitation. 3. The invitee opens the invitation and joins the team. If they don't have a Glaze account yet, they will be prompted to create one first, then join the team automatically. Invited people appear in the members list right away with a clock icon while their invitation is **pending**. For roles, expired invites, and removing people, see [Members & Roles](https://manual.glaze.app/team/members-and-roles). #### What a Team Gives You - **A private team store**: Publish apps that only your team can find and install, separate from the Public Store. See [Team Store](https://manual.glaze.app/team/team-store). - **Members and roles**: Invite people by email and decide who can manage the team. See [Members & Roles](https://manual.glaze.app/team/members-and-roles). - **Shared membership and billing**: The team keeps membership in one place. During the beta the Team Store is free, and building draws on each member's own personal credits. See [Team Billing & Credits](https://manual.glaze.app/team/billing-and-credits). - **Single Sign-On**: Let anyone with your company email domain join automatically once you verify the domain. See [Single Sign-On](https://manual.glaze.app/team/single-sign-on). #### Team Store Every team gets its own **team store**, a private collection of the apps your team builds and shares with one another. Only members of the team can browse and install from it, which is best to share apps like internal tools without appearing in the Public Store. See [Team Store](https://manual.glaze.app/team/team-store). #### What Stays Personal Joining a team doesn't change how you build with Glaze. Your **projects** and any apps you haven't shared stay yours alone; a team adds team store sharing and centralized billing on top. You can belong to more than one team, and each appears as its own tab in **Settings**. ### Members & Roles Source: https://manual.glaze.app/team/members-and-roles Description: Invite people by email, handle pending invitations, and configure each member's role in your team. Last updated: 06 July 2026 You can manage team members in the team's tab in **Settings**, under the **Members** section. From there you can invite people, see who's joined, change roles, check current credit balances, and remove members. Inviting and managing members is available to a team's **owners** and **admins**. #### Invite Members 1. In **Settings**, choose your team in the sidebar and scroll to **Members**. 2. Click **Invite**, enter the person's email address, and confirm. Glaze emails them an invitation to join the team, and you'll see a toast confirming it was sent. 3. The invitee opens the invitation and joins the team. If they don't yet have a Glaze account, they create one first then land in the team automatically. Invited people appear in the members list right away with a clock icon next to their name while their invitation is still **pending**. > [!NOTE] > Invitations **expire after 7 days**. An expired invite shows a red clock icon labeled **Invitation expired**, and the person can no longer use the original email to join until you send a fresh invitation ##### Pending and Expired Invitations For any invitation that's still pending or has expired, owners and admins can: - **Resend Invitation** to send a new email and reset the 7-day window. - **Cancel Invite** to withdraw it. The person is removed from the list and can't join with that invitation. Open these from the ellipsis menu or by right-clicking the row. #### Remove Members To remove someone who has already joined, click the ellipsis menu next to the member and click **Remove Member**. They lose access to the team and its shared apps immediately. They can rejoin only if you invite them again. > [!WARNING] > The team **owner** can't be removed, and their role can't be changed. To step away from a team you don't own, use **Leave Team** in the **Danger Zone** of the team's settings. #### Roles Every member has one of three roles: - **Member** uses the team to build, share, and install apps, and can request a credit top-up when running low. - **Admin** helps run the team day to day: inviting and removing people, changing roles, managing billing, and approving credit requests. - **Owner** sets up the team and has full control, including deleting it. The owner is the one role that can't be removed or reassigned. Owners and admins change someone's role from the row menu under **Change Role…**, switching between **Admin** and **Member**. ##### What Each Role Can Do | Action | Member | Admin | Owner | | --- | --- | --- | --- | | Build apps and use the agent | ✓ | ✓ | ✓ | | Publish to and install from the team store | ✓ | ✓ | ✓ | | Request a credit top-up | ✓ | ✓ | ✓ | | Invite, remove, and change roles | ✗ | ✓ | ✓ | | Manage the subscription and seats | ✗ | ✓ | ✓ | | Buy top-ups for members and approve requests | ✗ | ✓ | ✓ | | Set up Single Sign-On and the team domain | ✗ | ✓ | ✓ | | Edit team name and logo | ✗ | ✓ | ✓ | | Delete the team | ✗ | ✗ | ✓ | ##### What if the person I invite doesn't have a Glaze account? They follow the invitation in their email, create an account, and join the team as part of signing up. The invitation is tied to the email you sent it to. ##### Can someone be on more than one team? Yes. A person can belong to several teams at once, each with its own role, and each appears as a separate tab in their Settings. ##### How do I leave a team? Open the team in Settings and use **Leave Team** in the Danger Zone. You'll lose access to the team's shared apps and can only return if you're invited again. Owners delete a team instead of leaving it. ### Team Store Source: https://manual.glaze.app/team/team-store Description: Publish apps to a Team Store only your team can install from, and browse apps from other members. Last updated: 24 August 2026 Your **team store** is a private store inside Glaze that only your team can see. You can browse apps your teammates have created and install apps that fit your workflow. The difference is the audience, since everything published here stays within the team and is never listed publicly. Each team you join creates its own store alongside the Public one. #### Browse the Team Store Open the **Store** tab, then use the **switcher** on the toolbar to move from **Public** to your team. Pick a team to see only the apps published to its store. See [Visibility Levels](https://manual.glaze.app/share/visibility-levels) for what each store contains and which one is best for your app. The dropdown on the right of the toolbar sorts a Team Store by **Recently Updated**, **Newest**, or **Most Downloaded**. #### Search Use the **search box** in the sidebar to find a specific app. As you type, the suggestions are grouped by where they live, including your teams, so you can jump straight to a team app. On the public store, an app that belongs to a team carries a badge with the team's name and avatar, so it's clear at a glance where it came from. #### Detail Page Selecting a team app opens the same listing its publisher prepared, with a tagline, screenshots, a **What's New** section of release notes, and the full **App Description**. Because it came from a team, the metadata row also names the **Store** it belongs to. See [Store](https://manual.glaze.app/share/store) for the full breakdown. #### Install, Update, and Uninstall Installing from a Team Store works exactly like the public Store. Click **Install** and the button becomes **Open**, the app appears in the ** Installed Apps** tab in the sidebar, and it's added to your `/Applications` folder. When a new version is published, **Update** shows on the detail page and in the **Updates Available** group of the **Installed Apps** tab. To remove an app, right-click it in **Installed Apps** and choose **Uninstall**. See [Store](https://manual.glaze.app/share/store). #### Publish to the Team Store Any **member of the team can publish** to its store, regardless of role, while **only the team's members can install** from it, so people outside the team never see it. When you publish, pick your team in the **Publish to** picker, and after a review the app appears in the Team Store. To take a team app down later, choose **Unpublish App** from its menu. See [Publish Apps](https://manual.glaze.app/share/publish-apps). > [!NOTE] > The Team Store is **free while it's in beta**, so any team can publish to its store with no subscription. See [Team Billing & Credits](https://manual.glaze.app/team/billing-and-credits). #### Move an App Between Stores Already published an app and want it somewhere else? Move it without republishing. Find the app in **My Projects**, open its menu, and choose **Move to Store…**, then pick the **Public Store** or one of your teams' stores and confirm with **Move App**. See [Visibility Levels](https://manual.glaze.app/share/visibility-levels). > [!TIP] > **People who already installed the app keep getting updates** after a move. Moving changes where the app is listed, not the connection to existing installs, so your teammates' copies stay up to date. ### Team Billing & Credits Source: https://manual.glaze.app/team/billing-and-credits Description: Discover how team billing and credits work during the free beta in Glaze. Last updated: 24 August 2026 During the beta, the **Team Store is free** and a team has no separate subscription to manage. Building apps draws on **each member's own personal credits** — there's no pooled or per-team credit allowance, and no team top-ups, while the beta is running. Team membership and roles are still managed from **Team Settings** by anyone with the **Owner** or **Admin** role. > [!NOTE] > For the latest Glaze plan prices and credit allowances, see the [pricing page](https://glaze.app/pricing) on the Glaze website. #### During the Beta - Creating a team, inviting members, and publishing to the **team store** are all **free**. See [Team Store](https://manual.glaze.app/team/team-store). - Building apps uses **each member's own personal credits** — one person's usage never draws down another's. See [Credits](https://manual.glaze.app/account/credits). - There's no team subscription to start or manage while the Team Store is in beta. > [!NOTE] > Some per-member perks, such as **unlisted publishing** and **disabling remixing**, currently follow the person's own Glaze **Pro** plan rather than the team's plan. See [Plans](https://manual.glaze.app/account/plans). ##### Does the team or each member pay right now? The Team Store is free during the beta, so there's no team subscription to pay for, and building uses each member's own personal credits. See [Plans](https://manual.glaze.app/account/plans). ##### What happens to team credits during the beta? There's no pooled team credit allowance during the beta — building always falls back to each person's own personal credits. Owners and admins manage membership and roles from **Team Settings**. ### Single Sign-On Source: https://manual.glaze.app/team/single-sign-on Description: Verify your company email domain so anyone who signs up with it joins your Glaze team automatically as a member. Last updated: 02 July 2026 **Single Sign-On** in Glaze is automatic team join by **email domain**. Once you verify that your team owns a domain like `yourcompany.com`, anyone who signs up to Glaze with an email on that domain joins your team automatically as a **member**. Set up is limited to a team's **owners** and **admins**, from the team's tab in **Settings**. #### Set Up 1. In the team's tab in **Settings**, turn on **Enable Single Sign-On**. 2. Type your company's email domain, such as `yourcompany.com`, in the **Single Sign-On Domain** field. When you confirm, Glaze opens the **Verify Domain** dialog so you can prove you own it. 3. Glaze gives you a value to publish as a DNS TXT record for your domain: ``` glaze-verify= ``` Copy it and add it as a TXT record with your DNS provider. 4. Once the record has propagated, click **Verify Domain**. When it checks out, the domain gets a verified checkmark and SSO goes live. If Glaze can't find the record yet, it asks you to check the TXT record and try again, since DNS changes can take a little while to take effect. #### After Verification From then on, **new sign-ups on that domain join your team automatically** as members the moment they create their account. People who already have Glaze accounts aren't pulled in retroactively, so invite any existing teammates on Glaze using the **Invite** button under the **Members** section. > [!NOTE] > A domain can belong to **only one team**. If another team has already verified it, Glaze won't let you claim it. #### Change or Turn Off SSO - **Changing the domain** clears the previous verification, so you'll get a new token and need to verify the new domain before auto-join works again. - **Turning off Single Sign-On** stops new sign-ups on that domain from joining automatically. **Existing members stay on the team**. > [!WARNING] > This is domain-based auto-join, not SAML or SCIM, and it doesn't change how anyone signs in. Members still use Google, Apple, or an email code as usual. SSO only decides which team they land on. ##### Will people who already have accounts get added? No. Auto-join applies to new sign-ups on your verified domain. Invite anyone who already has a Glaze account from the team's **Members** section. ##### What role do people get when they join through SSO? They join as a **member**. Change role for anyone who needs to manage the team to admin afterward. See [Members & Roles](https://manual.glaze.app/team/members-and-roles). ##### Can I use SSO without using DNS? No. Verifying ownership through a DNS TXT record is required, which is why setup is limited to owners and admins who can manage your domain's DNS. If you'd rather not verify a domain, invite people by email instead. ### Team FAQ Source: https://manual.glaze.app/team/team-faq Description: Common questions about using Glaze at work, from where company data goes to what happens when you share an app with your team. Last updated: 30 July 2026 Common questions from teams building apps with Glaze at work, including the ones IT, Security, and Finance tend to ask. For everything Glaze collects and stores, see [Glaze Privacy & Data](https://manual.glaze.app/account/privacy-and-data). #### Where Your Data Goes ##### Our app connects to a company system. Where does that data go? The data goes straight from the Mac running the app to that service and back, whether it's a CRM like Salesforce, an ERP like NetSuite, a warehouse, or an internal API. Glaze isn't in the middle: the app calls the service directly, and the results it gets back are held locally, in the app's own data area on that Mac. They aren't routed through Glaze servers, and nothing syncs or backs up to the cloud in the background. Two things change that, both covered below: a feature that uses [Glaze AI](https://manual.glaze.app/capabilities/ai) or another AI provider to process data, and real data left in the project while the app is being built by the agent. ##### What gets sent to Glaze's servers? - **What the agent needs to build the app**, meaning prompts, the conversation, and the files and command output it works with, which go to the Glaze AI service and on to the model providers. - **Whatever a Glaze AI feature sends** while someone is running the app, by the same route. - **Account, billing, and usage metadata**, like which app made an AI request and how many credits it used. - **The app itself, if it's published**, meaning its source and the built app, not its data. Business-sensitive information an app fetches and stores locally is not on that list. #### AI Features ##### Our app uses AI on company data. What gets sent then? Whatever the AI feature implemented by the app author acts on. If it turns a set of records into a weekly summary, those records go to the Glaze AI service, which passes them to the model provider that generates the response. They aren't kept once the response comes back, and they're never used to train or tune models. **Glaze retains only the usage metadata it needs to meter credits, never the content itself.** ##### Can we build the same app without sending anything to a model? Yes. AI is opt-in and implemented per-feature in an app, and an app with no Glaze AI features sends nothing to a model. Charts, grouping, totals, and other everyday analysis are ordinary code that runs entirely on the Mac, so an app can avoid AI altogether unless you want the more powerful analysis or reports that models can provide. Where an app does use AI, each person running it grants permission for that app individually and can revoke it or cap its daily usage. See [AI](https://manual.glaze.app/capabilities/ai). #### Building & Sharing Apps ##### Does the agent see our data while it's building the app? It sees the project: the code, the files it opens, and the output of the commands it runs, all of which go to the model providers as it works. A real export sitting in the project folder is a file like any other, so the agent can read it and send it along with everything else. Keep production data out of the project while building. A short sample, synthetic rows, or a few anonymized records are enough for the agent to build against, and the app can connect to the real source when it runs. ##### What gets uploaded when we publish to the Team Store? Two things, for two different reasons. The app's **source**, meaning everything in its project folder, goes to Glaze's private storage so the automated review can scan it for exposed keys, personal data, and other security risks, and so the pipeline can compile it. The **built app** is what teammates download when they install it, and the source isn't shared with them. What isn't uploaded is the app's data or the credentials on the author's Mac, since everyone connects with their own. Files like `.env` are blocked too. Anything else sitting in the project folder is part of the source, a data file included, so check what's in there before publishing and treat the automated scan as a safety net rather than a guarantee. Team Store apps are visible only to the team. See [Team Store](https://manual.glaze.app/team/team-store) and [Visibility Levels](https://manual.glaze.app/share/visibility-levels). ##### If we share an app across the team, can people see each other's data? Not by default. Each person installs their own copy, connects it with their own credentials, and its data stays on their Mac. Glaze puts no shared store behind an app holding everyone's records, so sharing an app distributes the app itself, not its contents. An app author can build that deliberately, by wiring the app to an outside database or service so every copy reads and writes the same records. That's ordinary app code and Glaze isn't part of it: the data lives with whichever service was chosen, under that service's access rules. #### Integrations & Credentials ##### Where do the credentials for a connected integration live? Encrypted on the Mac, not on Glaze servers. Signing in happens in the browser, and the provider hands its response back through a Glaze callback URL that exists only to pass it to the app. For a service connected through [Custom OAuth](https://manual.glaze.app/integrations/custom-oauth), the app exchanges that response for a token on the Mac itself, and Glaze keeps no copy of it. Access can be revoked at the provider or in Glaze at any time. See [Managing Connections](https://manual.glaze.app/integrations/managing-connections). ##### Can we configure which integrations are available in Glaze? Not centrally. There's no team setting that limits which services an app can connect to, so anyone building one can use a built-in connector or any OAuth 2.0 provider they have credentials for. What a team can do is agree on a convention and ask app authors to favour particular integrations or OAuth providers in internal apps, so everyone connects to the same systems the same way. Connections are also per-project rather than team-wide, and it's the person running an app who signs in, so an app only ever reaches what they've granted it. See [Integrations Overview](https://manual.glaze.app/integrations/overview). #### Storage & Retention ##### Where does Glaze store the data it does hold, and for how long? Personal data sits primarily on servers in the United States, with safeguards whenever it's transferred across borders, and it's kept only as long as it's needed to provide the service or until the account is deleted, whichever comes first. Usage analytics are metadata only and never include prompts, files, or app content. See the [Privacy Policy](https://glaze.app/privacy). #### More Questions For anything about your team, contact [teams@glaze.app](mailto:teams@glaze.app). For privacy and data protection questions, contact [privacy@glaze.app](mailto:privacy@glaze.app), and for security questions, [security@glaze.app](mailto:security@glaze.app). You can also find Glaze's full contractual terms on our website: - [Terms of Service](https://glaze.app/terms) - [Privacy Policy](https://glaze.app/privacy) - [Acceptable Use Policy](https://glaze.app/aup) ## Advanced ### Editing Code Source: https://manual.glaze.app/advanced/editing-code Description: Open your app's source in an editor and change the code manually whenever you want fine control over a change. Last updated: 06 July 2026 The agent writes all the code for your app, and you shouldn't need to edit it yourself outside Agent Chat. The code is yours, however, so if you're comfortable with it, you can open your app's source and edit it manually. #### When to Edit Directly Hand-editing is for when you're confident working in code and want to make a change yourself. It's an option for fine control, but prompting the agent is the recommended way to change your app. You might open the source when: - You're confident making a specific change yourself and would rather do it directly. - You want precise control over exactly how something is written. - You want to see how the agent built something, to understand or learn from it. For everything else, prompt the agent. It knows the whole project, keeps your [version history](https://manual.glaze.app/prompting/version-history) intact, and won't leave the app in a half-broken state. See [Iterating](https://manual.glaze.app/prompting/iterating) for the recommended way to make changes. #### Open the Source Your app's editable source lives on your Mac in **Application Support**, at `~/Library/Application Support/app.glaze.macos.main/apps//.glaze-sources`, where `` is the app's own folder, named after the app plus a unique suffix (for example `my-app-local-a1b2`). Point your editor at that `.glaze-sources` folder to browse and edit the files directly. The agent reads from and writes to the same source, so what you see in your editor is exactly what the agent is working with. > [!TIP] > Because its name starts with a dot, `.glaze-sources` is hidden in Finder. Press `⇧` `⌘` `.` to show hidden files, or open the folder straight from your editor, which lists it regardless. > [!NOTE] > ** Reveal in Finder** in the project's ** More…** menu opens the built app itself, not the source, so head to the `.glaze-sources` folder above to edit your code. A Glaze app is a normal project on disk there: a renderer (the UI), a backend (the "main" process), and the files that tie them together. #### Pick Up Changes Once you've edited a file, your app needs to pick up the change. While the app is running in development, it reloads as you save, so small UI tweaks show up quickly. Larger changes, like new dependencies or backend logic, may need a fresh build, which the agent normally handles for you when it runs the app. If you're unsure whether an edit took effect, the simplest path is to ask the agent to run the app again. It rebuilds and relaunches from your current source. See [Running Your App](https://manual.glaze.app/capabilities/running-your-app). #### Stay in Sync You don't need to tell the agent that you edited a file. It reads the current source each time it works, so your changes are simply part of the project from then on. There's no separate "import my edits" step. It's still good practice to mention what you changed in your next prompt, so the agent builds on your edit rather than working around it. For example: "I tweaked the header spacing manually, please keep that and add a search box below it." > [!WARNING] > Manual edits are not saved as a [version](https://manual.glaze.app/prompting/version-history) on their own. A version is recorded when the agent makes a change. If you edit code directly and want a checkpoint, make a small follow-up prompt so the agent captures the current state. #### Revert an Edit If a manual edit breaks your app, you have two ways back: - **Roll back to a version**: If your edit happened after the agent's last change, rolling back to that version discards your manual changes and returns to the last known-good state. See [Version History](https://manual.glaze.app/prompting/version-history). - **Ask the agent to fix it**: Describe what you changed and what broke, and the agent can repair the file. Pasting any error you see makes this much faster. ##### Will editing code manually break things the agent can't fix? No. The agent reads your current source, and it can see and repair manual edits like any other code. If a change goes badly wrong, rolling back to the last version the agent made is always available as a clean reset. ##### Do I need to edit code to build a good app? Not at all. The agent does all the coding, and most people will never need to open the source. Hand-editing is an option for fine control, not a requirement. ### Subagents Source: https://manual.glaze.app/advanced/subagents Description: Watch the agent split a big build into tasks and hand self-contained pieces to focused specialists. Last updated: 06 July 2026 When you ask for a large app or change, the agent doesn't try to do it all in one leap. It breaks the work into smaller pieces, works through them in order, and shows its progress as it goes. You don't manage any of it directly, but understanding how it works helps you read what's happening during a long build and know when to step in. #### Break Up the Work Given a substantial prompt, the agent first decides on the pieces of work it needs to do, then tackles them one at a time. A "build me a habit tracker" prompt might become: set up the screens, add the data store, wire up the add-and-edit flow, then style it. Each piece builds on the last. This is why [Plan mode](https://manual.glaze.app/prompting/plan-and-build-modes) is useful for big asks. Planning first lets you see and agree on the pieces before the agent starts building them, so the work heads the right way from the start. #### Follow Progress You follow a build in the feed in [Agent Chat](https://manual.glaze.app/prompting/agent-chat), where the agent shows each step it takes, the files it touches, and the commands it runs. A task list at the top tracks how far along it is (**Task 2 of 5** while it works, then **5 of 5 Tasks Completed** when it's done), and you can expand it for the full checklist of what's done, working, and still to come. You don't have to watch every line; the feed is there for detail when you want it. If something looks off partway through, [steer](https://manual.glaze.app/prompting/iterating) the agent or stop it without waiting for the whole build to finish. > [!TIP] > While the agent works through a long build, you can queue follow-up messages so your next instructions are ready when the current work finishes. See [Agent Chat](https://manual.glaze.app/prompting/agent-chat). #### Delegate to Specialists For a large, self-contained piece, the agent can hand the work to a focused specialist, such as a frontend or backend architect, that does that one job and reports back before the main agent carries on. It's automatic: you don't set it up or direct it, and it keeps a big build organized. In the feed, a specialist shows up as a collapsible block labeled with the piece it's handling, its own progress and steps folded inside. Expand it for the detail, or leave it collapsed and follow the overall progress. #### For Longer Builds A few things follow from how the agent works: - **Big builds take longer and cost more.** More pieces means more work, which means more [credits](https://manual.glaze.app/account/credits). Planning first keeps this efficient. - **Progress is visible, not hidden.** You can always see what the agent is up to in the feed, so a long build never feels like a black box. - **You can intervene any time.** You don't have to wait for the agent to finish all its pieces. Steer it mid-build or stop it if it's heading the wrong way. See [Iterating](https://manual.glaze.app/prompting/iterating). - **Smaller asks stay simple.** A quick tweak is just done; the agent only breaks work into pieces when the size calls for it. > [!NOTE] > To keep big builds efficient and on track, agree on the approach first with [Plan mode](https://manual.glaze.app/prompting/plan-and-build-modes), then let the agent work through the pieces in [Build mode](https://manual.glaze.app/prompting/plan-and-build-modes). ### Bring Your Own Agent Source: https://manual.glaze.app/advanced/bring-your-own-subscription Description: Connect your Claude subscription to build with your own Claude models instead of spending Glaze credits, currently in beta. Last updated: 24 August 2026 **Bring Your Own Agent** lets Glaze work with the agents and models you already use. Connect your **Claude** subscription and you can build with Claude models such as **Opus**, **Sonnet**, and **Fable** from inside Glaze. This uses your own Claude subscription rather than **Glaze credits**, so your builds draw on the Claude plan you already pay for. > [!NOTE] > Bring Your Own Agent is currently a **beta** feature. Details may change as it develops. #### What You Need To connect Claude, you need a compatible, locally authenticated **Claude Code** subscription on your Mac. Glaze uses the Claude Code sign-in already on your machine, so there's nothing to paste into Glaze and no credentials to hand over. > [!NOTE] > Glaze doesn't read or store your Claude credentials. Your Claude sign-in stays with Claude Code on your Mac; Glaze builds through it without holding your login. #### Connect Claude You connect Claude once, in **Settings**, and it's then available in the composer's model picker across your projects. 1. **Install Claude Code** on your Mac if you don't have it yet. 2. **Sign in to your Claude subscription** in Claude Code. 3. In Glaze, open **Settings -> Account** and connect Claude. The **How to connect** dialog walks you through the same steps if you need them. Once connected, your Claude models appear alongside **Glaze Fast** and **Glaze Smart** in the composer's model picker. See [Agent Chat](https://manual.glaze.app/prompting/agent-chat) for how the picker works. #### How Usage Works - Building with a connected Claude model uses your **Claude subscription** instead of your **Glaze credits**, so these runs don't draw down your Glaze credit balance. See [Credits](https://manual.glaze.app/account/credits). - Your normal **Claude usage limits** still apply, just as they would when using Claude directly. - During the beta, building through your connected Claude subscription is **unlimited** on the Glaze side. #### Track Context Usage When you build with a connected Claude model, the `/context` command in [Agent Chat](https://manual.glaze.app/prompting/agent-chat) shows a breakdown of how much of the model's context is in use. As you approach the limit, Glaze surfaces controls for reviewing and compacting the context so a long session keeps room to work. #### If a Model Becomes Unavailable If a Claude model you've selected becomes unavailable, Glaze routes you to **Account Settings** to sort out the connection rather than quietly switching to **Glaze Smart** or **Glaze Fast** and spending your Glaze credits. You stay in control of which models a build uses. > [!TIP] > Prefer to build without connecting Claude? **Glaze Fast** and **Glaze Smart** work out of the box using Glaze credits. See [Agent Chat](https://manual.glaze.app/prompting/agent-chat) and [Plans](https://manual.glaze.app/account/plans). ### Custom Instructions Source: https://manual.glaze.app/advanced/custom-instructions Description: Set standing guidance or conventions once and the agent applies it across everything you build. Last updated: 06 July 2026 If you repeatedly ask the agent the same thing ("use a dark theme", "keep the UI minimal"), set it once as a **custom instruction**. It's standing guidance the agent applies across everything you create, included in every session so you don't have to repeat yourself. #### What They Are A custom instruction is a note about how you want the agent to work. It's not a one-off request like a prompt, but a default that applies across everything you build. The agent still does exactly what each prompt asks; your instructions just shape the choices it makes when a prompt doesn't specify something, like which style to default to or which conventions to follow. #### Set Them Up Open **Settings** -> **General**, and find **Custom Instructions** in the **Agent** section. Click it to open the dialog, type your guidance into the text box, then click **Save**. From then on, the agent takes it into account whenever it builds or edits an app. #### Good Uses Custom instructions work best for stable preferences that apply broadly: - **Tone and style.** "Keep copy concise and friendly", or "avoid technical jargon in anything the user sees." - **Look and feel.** "Default to a clean, minimal layout", or "prefer light mode unless I ask otherwise." - **Conventions.** "Use 24-hour time", or "label buttons with verbs." - **Defaults you always want.** "Add a settings screen to every app", or "include a keyboard shortcut to quit." If something is specific to one app, put it in a prompt instead. Custom instructions are for the things you'd otherwise repeat across many apps. #### Write Good Ones A few clear instructions work better than a long list. The agent weighs your guidance alongside every prompt, so the tighter and more concrete it is, the more reliably it lands. - **Be specific.** "Use rounded corners and generous spacing" beats "make it look nice." - **Keep it short.** A handful of preferences is easier to honor than a wall of rules. - **Avoid contradictions.** Conflicting instructions force the agent to guess. Prune anything that no longer reflects how you want to work. - **Revisit it.** As your taste settles, reopen the dialog and update it. It's not set in stone. > [!TIP] > If a preference matters for one app only, say it in your [prompt](https://manual.glaze.app/prompting/writing-effective-prompts) rather than as a custom instruction. Reserve custom instructions for what you want everywhere. ##### Do custom instructions apply to apps I've already built? They apply to work the agent does from the point you set them onward, including future edits to existing apps. They don't reach back and change apps retroactively on their own. ##### What if a prompt conflicts with my custom instructions? Your prompt wins for that request. Custom instructions are defaults; an explicit instruction in the moment takes priority over a standing one. ### Large Files & External Tools Source: https://manual.glaze.app/advanced/large-files-and-tools Description: Build apps that stream large video, audio, or datasets and call external command-line tools to get their work done. Last updated: 06 July 2026 Most apps handle modest amounts of data, and the agent takes care of that for you. Two kinds of app need a little more thought: those that move **large files** like video, audio, or big datasets, and those that lean on **external command-line tools** to do their work. Knowing how Glaze handles each helps you ask for the right thing and know what to expect. #### Large Files When an app loads a large file, *how* it gets there matters, because pushing a multi-megabyte file through the app's internal messaging is slow. Instead, the agent **streams** it: the UI requests the file directly and the backend serves it in pieces, the way a large image or video loads without stalling. You don't configure this. Just describe what you want ("let me preview large video files", "load this dataset and chart it") and the agent streams when the size calls for it. > [!TIP] > If an app feels sluggish loading a big file, tell the agent the files can be large. It can switch to streaming so the UI stays responsive instead of waiting for the whole file at once. #### Performance A few habits keep large-file apps feeling fast: - **Load on demand.** Fetch a file when the user opens it, not all of them up front. - **Show progress.** For anything that takes a moment, ask for a loading state so the app doesn't look frozen. - **Right-size what's bundled.** Files the app ships with should be optimized; files the user supplies are streamed at runtime. The agent handles this distinction, but it's worth naming if an app feels heavy. For everyday reading and writing of files, see [Files & Data](https://manual.glaze.app/capabilities/files-and-data), which covers the smaller end of the spectrum. #### External Tools Some capabilities, like converting media, live in mature command-line tools rather than being rebuilt from scratch, and a Glaze app can call those tools in the background and use their output. Ask for the capability in plain language ("convert these videos to GIFs"), or provide the agent with the name of a specific library you'd like to use. Either way, the agent installs the tool and wires the app to run it. #### Dependencies There are two kinds of dependency, and the agent manages both: - **Code libraries** are packaged with your app and install as part of building it. This is the common case and needs nothing from you. - **External command-line tools** are programs that live on the machine, often using tools like **Homebrew**. When an app needs one, the agent handles installing it and running it for you. #### Portability An app that depends on an external command-line tool needs that tool present to do its job. That has implications when you share the app: - **On your Mac**: Everything the agent installed is already there, so the app works. - **Published Apps**: The app may need to install or check for the tool the first time it runs on a user's Mac. The agent can add that handling for you, so the experience is smooth rather than a confusing failure. If you plan to share an app that uses external tools, tell the agent. It can make the app handle a missing tool gracefully, prompting to install it rather than breaking. Apps that stay fully self-contained (no external tools) are the most portable by default. ##### Why does my app stream large files instead of just loading them? Streaming serves the file directly to the UI in pieces, so it appears quickly and the app stays responsive. Loading a large file through the app's internal messaging all at once is slow and can make the UI hang, and not provide a great user experience. ##### Will an app that uses a command-line tool work when I share it? It can, but the tool needs to be present on the other person's Mac. Ask the agent to have the app install or check for the tool on first run, so sharing it works smoothly rather than failing silently. ## Resources ### Troubleshooting Source: https://manual.glaze.app/troubleshooting Description: Fix common Glaze issues, from a stuck agent to a blank app or a connection that stopped fetching data. Last updated: 31 July 2026 Building with Glaze should be a seamless experience, but you may run into the occasional issue while creating an app. Start with the troubleshooting steps below to clear up the most common ones, and reach out to the team for further assistance if something still isn't right. #### Common Issues ##### The agent is stuck or stopped responding Most temporary hiccups now clear themselves. If the agent hits a transient problem mid-run (a rate limit, the AI service being briefly overloaded or unavailable, a dropped network connection, or a timeout), it retries automatically instead of failing. You'll see a status line in the chat while it does, for example "Hit a temporary connection issue — retrying (2/4)…", and the run picks up where it left off once it recovers. If every retry is used up, the run shows an error with a **Try again** button. Click it and Glaze continues from where the run stopped, keeping the work it already finished, rather than starting the request over from scratch. (In the separate case where a run stops because it reached the maximum number of turns, you'll get a **Continue** button instead.) If the agent isn't showing an error at all but seems to have stalled mid-run, give it a moment first, since some steps (installing dependencies, building the app) take longer than others. If it's genuinely stuck, click the ** Stop button** in the composer to cancel the current run, then send your prompt again. A fresh attempt often gets past a one-off hiccup. ##### A run finished but the app is blank or won't open If your app opens to an empty window or doesn't appear at all, the run may have left it in a half-finished state. Go back to Agent Chat and tell the agent what you see, for example "the window is blank" or "the app didn't open". It can read what went wrong and fix it. If a recent change is what broke things, you can step back. Every change the agent finishes is saved as a version, so you can **roll back** to the last one that worked and try again from there. See [Version History](https://manual.glaze.app/prompting/version-history). ##### A request was too long or the run struggled with a large change Very large requests are harder for the agent to handle in one pass. If a prompt is rejected for being too long, or a run struggles with a sprawling change, the fix is usually to break it up. Ask for the core of the app first, then add features one follow-up at a time. Smaller, focused prompts are also easier to get right. See [Writing Effective Prompts](https://manual.glaze.app/prompting/writing-effective-prompts). ##### The agent says AI isn't available in my region Glaze now shows a clear message when AI access isn't available where you are, instead of a generic or misleading account error. A **Try again** button won't help here since resending the same request runs into the same regional block, so it isn't shown. If you think this is wrong, or your region's availability changes, [contact support](https://manual.glaze.app/contact-support). ##### A connection or integration stopped working If an app that talks to an outside service (like GitHub, Linear, or Slack) stops fetching data, the connection most likely needs to be re-authorized. Access can expire or be revoked on the service's side. Reconnect the integration, or provide new API keys, and the app should start fetching data again. ##### An app won't install or update from the Store Installing and updating requires you to be online, so check you're connected to an active internet connection first. If an install or update doesn't complete, try it again from the Store. If an app shows an **Update** but updating doesn't work, quitting and reopening Glaze usually clears it. ##### The agent won't open with my keyboard shortcut If your global **Agent Shortcut** doesn't open the agent, another app may already be using that key combination. Open **Settings** -> **General** and record a different shortcut. #### Try These First Before reporting an issue, a few general steps clear up most one-off problems: - **Tell the agent what you see**: For anything about how an app looks or behaves, the agent is the fastest fix. Describe the problem in Agent Chat and let it repair the app in place. - **Roll back a bad change**: If a recent change broke something that used to work, return to an earlier version rather than trying to patch forward. See [Version History](https://manual.glaze.app/prompting/version-history). - **Restart Glaze**: Quitting and reopening Glaze clears up the occasional glitch, especially around installs, updates, and connections. - **Check your connection**: Building, installing, updating, and any feature that reaches an outside service need the internet. Most finished apps run offline, but those steps don't, and neither do features that rely on AI. #### Still Need Help? If an issue still persists, the Glaze team is happy to help. See [Contact Support](https://manual.glaze.app/contact-support) for all the ways to get in touch with us. ### Contact Support Source: https://manual.glaze.app/contact-support Description: Get in touch with the Glaze team to ask questions, report bugs, request billing help, or join the Slack Community. Last updated: 06 July 2026 If you need help with Glaze, there are several ways to get in touch with the Glaze team. > [!TIP] > Sending feedback and reporting issues won't use your credits. #### Send Feedback To report a bug, request a feature, or share general feedback, open the **Send Feedback** form from either: - Click **Help → Send Feedback…** in the menu bar - Click the Account menu in the sidebar → **Send Feedback…** - Type `/issue-report` in **Agent Chat** In the Send Feedback form: 1. Choose a **category**: *Bug Report*, *Feature Request*, or *Other*. 2. Write a **description** of what issue happened or what feature you'd like added. 3. Optionally **attach files**: screenshots, recordings, or documents (up to 20 MB each). 4. If you're reporting a bug, tick **Attach logs from today** to include diagnostic logs. 5. Send it with the button or `⌘` `⏎`. Your Glaze app version and basic system info are added automatically, so you don't need to include them yourself. #### Rate a response Every completed agent response in the Agent Chat has a row of actions beneath it: - **Copy Response** - **Good Response** - **Bad Response** Clicking thumbs up or thumbs down opens a mini **Send Feedback** form where you can: - Pick a **reason** - For a thumbs down: *Incorrect code*, *Wrong behavior*, *Misunderstood request*, *Unnecessary changes*, *Incomplete*, *Too slow*, or *Error occurred*. - For a thumbs up: *Accurate code*, *Understood request*, or *Fast response*. - Add **additional Feedback** to explain more about what you'd like to share with the Glaze team. Submit with the **Send Feedback** button or `⌘` `⏎` and you can also open this form from the ellipsis menu in the Agent Chat toolbar. > [!NOTE] > When you rate a response, the contents of that chat are included so the Glaze team can see what happened. A thumbs down also attaches recent logs to help the team debug. #### Email Support Prefer email? Reach us at the address best relating to your query: - **General support, bugs, or billing:** [support@glaze.app](mailto:support@glaze.app) - **Teams:** [teams@glaze.app](mailto:teams@glaze.app) #### Slack Community Meet other builders, swap ideas, and share feedback in the Glaze Slack community. Join at [glaze.app/community](https://glaze.app/community).