Skip to main content
Memo ships a remote MCP (Model Context Protocol) server on every plan — including Free. Connect it once and your AI agent can read your brand, search your assets, run your Workflows, and prepare on-brand image or video generations that only you can confirm. Open Help → Connect your agent in Memo to find the connection instructions.

​
In four steps

  1. Add Memo to your agent. Copy the command or the address for your agent.
  2. Sign in and approve. Your browser opens once. No keys to copy.
  3. Ask for something. Try “list my brand kits”. The agent sees the same workspaces you do, with your role.
  4. Approve each generation. The agent shows the price first. Nothing spends credits until you confirm.
If you belong to more than one workspace, the approval page asks once which workspace the agent should use, and the agent keeps working there without asking again. It also remembers the Studio project and the Brand Kit you last worked with, across calls and across sessions, so a follow-up request lands in the same project and brand; each estimate still names where the output will be filed. To move, just say so — “switch to the Acme workspace”, “file this in the summer campaign project” — and the agent remembers the new choice through set_context, which also clears a remembered project or kit. whoami shows what the agent remembers under context, and under capabilities which features are on in your workspace. One rule sits above memory: anything the agent does on your open Studio tab — reading what you have open, editing a scene, opening a brief, running it — follows that tab, even when the tab is on another workspace. If an agent connected before this existed still asks which workspace to use, reconnect Memo once in the host and the approval page will ask. Tools that act on a project (get_project, add_project_file, create_project_folder, move_generations, the brief tools) may leave project_id out: the agent uses the project of your open Studio tab, else the one it remembers, and says which it chose. get_studio_context reports the workspace of your open tab and the same memory block whoami shows. In the app, the Connected Agents card at the bottom of the sidebar opens the agent picker: choose Claude, Cursor, Codex, Grok Bot or another MCP client down the left, follow its three steps and copy its command or address. For Claude, a short video above the steps shows every click in the Claude app, from Settings to connected: press it to watch it large. The ✕ hides the card until the next time the app loads; the picker’s commands stay on the Connect page, which Try it now on the What’s new card opens after your first generation, and under Help → MCP & API. If an agent stops answering, check its error message below. Reconnect once for an expired sign-in; if a fresh connection still fails, report it so we can investigate.

​
Connect

The server lives at:
1

Add the connector

  • claude.ai: Settings → Connectors → Add custom connector → paste the URL above. A first prompt: “List my brand kits, then make a product shot in our spring palette.”
  • Claude Code: claude mcp add --transport http memo https://app.memo.solutions/api/mcp/mcp, then /mcp and Authenticate. A first prompt: “Read our brand kit, then make three 1:1 product shots for the launch and file them in the launch project.”
  • Cursor: save { "mcpServers": { "memo": { "url": "https://app.memo.solutions/api/mcp/mcp" } } } as .cursor/mcp.json. A first prompt: “Find our spring references and make a 16:9 hero from them.”
  • Codex: codex mcp add memo --url https://app.memo.solutions/api/mcp/mcp. A first prompt: “List my brand kits, then plan a three-card carousel for the launch.”
  • Grok Bot: Memo is not in its Plugins catalog yet. Open Settings → Plugins and add a custom server named Memo with the URL above, or tell any Bot “Add a custom remote MCP server called Memo at https://app.memo.solutions/api/mcp/mcp” and save the card it shows. The sign-in is shared by every Bot on the account. A first prompt: “List my brand kits, then draft three post ideas in our voice.”
  • Other MCP clients: add a remote MCP server with the same URL.
2

Sign in

The connector uses OAuth — a browser window opens on app.memo.solutions, you approve the connection, and the agent gets scoped access to your workspace. No API keys to copy.
3

Try it

Ask your agent “What’s in my brand kit?” or “What’s my Memo credit balance?” — if it answers, you’re connected.

​
What your agent can do

Tools are grouped by job:
  • Find anything — one search across your whole workspace by meaning, not keywords: saved inspirations, past generations, and brand assets in a single sweep (“that moody rooftop clip from the summer campaign”).
  • Your library — list your Collections, open one as a visual thumbnail grid right in the chat, read its taste profile and keywords, search every saved image (semantically, once your library is indexed), and read any image’s AI analysis, tags, and the comments your team left on it (read only: an agent never posts in a thread).
  • Organize the library — create, rename, and delete Collections; write or refresh a collection’s taste profile after reading it; file images into them one by one or in bulk by tag; save new images from URLs, chat uploads, or finished generations — every save is auto-titled and described by AI so it lands searchable.
  • Read the brand — list and read Brand Kits (voice, rules, colors, fonts), semantic search over kit photography and assets, and fetch any logo, photo or finished generation as an inline image with get_asset_file when the agent needs the pixels themselves (see below).
  • Generate — browse the model catalog with live credit prices, prepare image or video generations, run saved Workflows. Every generation is estimate-first.
  • Name and re-find — generations can carry an agent-chosen name (label), and search_generations finds past outputs by name or prompt in any later session, ready to reuse as references.
  • Skills — read, create, and update reusable playbooks your team has saved — plus Memo’s official starter pack (including the cinema production playbooks: scene testing, acting direction, staging maps, cinematic prompting, and the naming discipline), available read-only in every workspace.
  • Build the brand — create kits, add colors/fonts/rules (scope a rule to a kit collection with collection_ids or to a subject or handle with subjects so it rides only generations that use those assets, mark a rule strictness: prefer when it should yield to the prompt; get_kit_collection lists what applies), import logos, photography, and characters (including drag-and-drop upload of images and videos straight from the chat, from a computer or a phone), and promote a finished generation into a named brand asset in one call. Every asset carries a handle (char_mika, loc_flat2) that prompts and brief scenes use as @char_mika.
  • Build a film’s world — while you talk a scene, ad or short film through, the agent can turn it into a Cinema Kit: it writes the production bible (story, characters, locations, props, camera, voiceover lines), adds each character to the Cast, files location, prop and blocking-map images with their handles and descriptors, adds continuity rules, revises the bible as the story changes, and writes each part’s prompt with the Timed Prompts skill. The cinema-kit-builder skill is the full playbook.
  • Read the brand book — attach a brand guidelines PDF to a kit, read its pages and text layer with the agent’s own eyes (printed hex codes and typeface names arrive as ground-truth text), and cut logos and photos straight out of the book into named kit collections. The brand-book-intake skill is the full playbook — “set up this brand from the attached guidelines” is a one-ask job.
  • Workspace — check who’s signed in, list and create Studio projects, file generations into the right project, see plans and credits, and where the last 30 days of credits went by kind of work (images, videos, website scans, web data).
  • Work on the open project — get_studio_context tells the agent which project, brief and scene you have open in Studio and what is selected on the canvas. create_brief plans a brief from scratch and can name the Brand Kit whose rules should ride every scene (brand_kit_id, also accepted by run_brief), get_brief reads the whole brief. update_brief_scene, add_brief_scene, remove_brief_scene, reorder_brief_scenes and set_scene_references change it; open_brief and focus_canvas move your view; run_brief presses Generate on the connected generators after you approve the estimate, for the whole brief or for the scenes you name (scene_ids retries one failed scene without touching the rest), and check_brief follows the run scene by scene.

​
Work on what you have open

When a Studio project is open, the agent knows where you are: the project, the brief and scene in the editor, and the nodes you selected. Say “rewrite this scene” or “make the logo the end frame of scene 3” and the change appears in your open tab within a few seconds, as an undoable edit that autosaves like your own typing. Ask for a whole set, such as two character sheets, a location and a creature, and the agent creates the brief itself, opens it for you and generates only after you approve the estimate. For a one-off image or clip it generates directly, with no brief. If no tab is open, the same edits are applied to the saved project and appear the next time you open it. Opening the editor, focusing nodes and generating need the project open in Memo Studio. If you and the agent change the same scene in the same instant, your tab’s version wins and the agent is told. Generation through run_brief is estimate-first: the agent shows the scenes and credits, and only starts them after you confirm. Your approval is bound to a signed receipt for exactly those scenes — if a scene finished or the brief changed in between, the agent must estimate again. The run happens in your open tab from the connected generators, so credit limits and errors show on the canvas exactly as they would if you pressed Generate yourself. The agent follows the run with check_brief, which names each scene as pending, running, completed or failed with its reason, and can retry only the failed scenes.

​
Build a presentation

An agent can make the same decks you edit in Studio → Presentations. create_presentation takes the slides as content — a layout per slide (cover, title, section, statement, title and body, bullets, two columns, picture left or right, full-bleed picture, quote, closing) with the title, body, bullets and pictures from your kit assets, generations or saved inspirations — or exact elements when it needs them, and builds the deck in your Brand Kit’s fonts and colours, measuring every text with the real fonts and shrinking or flagging what does not fit. It returns the project link, a version, and a small preview of every slide so the agent checks its own work. get_presentation reads a deck back as editable structure (every element with an id) with previews; update_presentation adds, replaces, moves or removes slides and elements and refuses a stale version, so nothing you changed in Memo is overwritten; export_presentation renders a PDF link. The presentation-builder skill is the playbook — “make me a six-slide launch deck for the red Nano” is a one-ask job.

​
Point your agent at anything

Everything you open in Memo has a link. Open it, choose Copy link, and paste the link into Claude, ChatGPT or Codex: “use this as the reference”, “animate this”, “rewrite this scene”. The agent calls open_link, which tells it what the link names, gives it the full details, and says which argument to pass it as. No searching or describing needed. In Memo’s own Studio chat, a pasted link to an inspiration or a generation counts as a reference, the same as picking it with Add a reference. A copied link carries its workspace, so it opens in the right one for anyone who belongs to it. People outside the workspace can’t open it.

​
Manage your Collections from any chat

Your inspiration library is fully agent-operable. A few things that work today:
  • “What’s in our Summer campaign collection?” — the agent opens it and, in Claude, shows the actual thumbnails inline.
  • “Save these 10 URLs into a new Moodboard collection” — one call ingests, AI-titles, tags, and files them.
  • “What’s the vibe of the Futurist Glam collection?” — the agent answers from the collection’s taste profile, and writes one if it is missing or stale.
  • “Generate three posters from the Futurist Glam collection” — the taste profile and keywords become the brief for every prompt the agent builds from it.
  • “File everything tagged ‘outdoor’ into Lifestyle” — bulk filing by tag is a single operation.
  • “Which images are still untagged? Clean them up.” — the agent looks at each image itself and writes better titles, descriptions, and tags.
Deleting a Collection never deletes images — they stay in your library. Adding images counts against your plan’s link limit, same as saving from the extension. The inline Collection preview shows thumbnails that load, including saved video posters. When none are available, the preview stays hidden and your agent can still answer from the collection list or open an individual image. Previews appear on the first page when images are requested. Your agent also knows how to keep the library tidy on its own: it sees how many images aren’t indexed or filed yet, and it follows built-in housekeeping rules — it does the describing with its own eyes (no Memo credits involved), your own tags are never touched, bulk moves are announced before they happen, and nothing can ever be deleted. In practice: “tidy up my library” is a one-line request. None of this machinery appears in your workspace — it lives entirely on the agent’s side.

​
Turn a saved video into motion

Some video models work from a video: Genjutsu, Genjutsu Object Swap and Kling 3.0 Motion Control copy its movement onto an image. Your agent passes the video by where it lives, so the file never has to travel through the conversation:
  • “Use the dance I saved in Inspirations on our mascot, with Genjutsu” — the agent finds the inspiration and passes it as reference_video_inspiration_id.
  • “Apply the motion of yesterday’s clip to this product shot” — a clip made in Memo goes as reference_video_generation_id.
  • “Here is a video file, use its movement” — in a chat where the agent has no network of its own (Claude.ai), it opens an upload card in the conversation and you drop the MP4 or MOV into it, from your computer or your phone; the clip is saved to your library and the agent gets its id. An agent that can make requests itself (Claude Code, scripts) uploads the file (create_asset_upload, MP4 or MOV, up to 50MB) and saves it with add_inspirations. A direct file address also works, as reference_video_url.
The image the motion is applied to is the start image: a brand asset, an earlier generation or an image address. With Genjutsu the clip is as long as the video, and the estimate is priced on that length before anything is spent. On Seedance the same video is a motion reference rather than the source. list_models tells the agent which models need a reference video and which can take one. A YouTube or Vimeo link, or a TikTok saved as a link, has no file behind it, so the agent is told to use the video file instead.

​
Name what you make

Long-running projects live or die on naming. Two habits keep an agent-driven library organized:
  1. Label keepers at generation time. Pass label (e.g. product-fw25-sneaker-red-v2) so the output’s title is yours, not an automatic one — labeled outputs are findable by name with search_generations next week or next month.
  2. Promote finals into the Brand Kit. When an output is approved, the agent can save it as a named brand asset (add_brand_assets with a generation_id) — including as a character — so it becomes a permanent, searchable reference the whole team can generate with.

​
Get the image itself

Every read tool returns media as links on the Memo domain, which browsers and desktop agents open directly. Agents that run in a sandbox (Claude cloud sessions, Codex) can call Memo but their network filter often blocks those downloads — they can list a Brand Kit yet never see a logo. get_asset_file closes that gap: pass a brand asset id or a completed generation id and the image comes back inline as base64 with its media type, ready to place in a slide, a document or a web page, or to save to disk. Images are downscaled to 1568 px on the longest edge by default (max_size adjusts it, never upscaling); PNG logos stay PNG, SVG is rasterized, and videos return their link instead. Hosts that read MCP resources get the same bytes from memo://asset/<id>.

​
Connection permissions

Your agent uses your Memo workspace role. Connecting Memo does not grant access to another workspace. Hosts can use the tool permission hints to distinguish reads from changes; retrying enrichment is a write because it queues background work. These hints help the host present permissions, but Memo still checks authorization on the server. If a tool answers “Internal error” with a short ref, send that reference with your support request: it points at the server-side record. Some hosts report only a generic internal error. In that case, include the host, tool name and time of the attempt so support can find the request logs.

​
When something does not work

  • “Not authenticated” or a 401 — the host could not authenticate to Memo. Reconnect once in the host’s connector settings; your workspace and everything in it are untouched. If you pasted a token by hand, it lasts about an hour: mint a fresh one on the connect page. If a fresh connection fails too, report it.
  • “OAuth token refresh failed” or “Failed to parse server response” — the failure happens while the host renews its connection, before a Memo tool runs. Reconnect once. If it repeats, stop retrying and report the host, exact error and time through Report a bug in Memo. Do not paste access tokens, refresh tokens or API keys. This needs a connection investigation; repeated image-generation retries cannot repair it.
  • Codex reconnect keeps the same refresh error — if Memo is configured as memo, use Codex’s supported codex mcp logout memo, then codex mcp login memo to clear the saved authorization and sign in again. Reload Memo’s connection in the running desktop chat afterward, and verify with whoami before generating. This renews the connection; it does not fix a provider error or prove renewal after expiry. If it still fails, retain the error and time for Support instead of repeating the reset. See Codex MCP commands.
  • The agent cannot see a new tool — hosts cache the tool list for the life of a session. Reconnect once after Memo ships a new tool.
  • The agent lists images but cannot show or place them — its sandbox cannot download Memo links. Ask it to use get_asset_file, which returns the picture itself.
  • “Not Acceptable” or “Unsupported Media Type” — the host sent Memo a request it cannot serve (wrong Accept or Content-Type headers). That is a host bug, not your account; Memo records it and we follow up with the host.
  • “You belong to multiple workspaces” — the approval page normally settles this when you connect; reconnect Memo once in the host and choose the workspace there, or tell the agent which one to use (set_context). A script can still pass workspace_id (from whoami) or connect with an X-Workspace-ID header.
  • “Rate limit exceeded” — reads are allowed 60 a minute per workspace (120 on Pro) and writes 60 an hour, shared by every agent connected to that workspace. Each brand-book page the agent reads and each price estimate counts as a read. The message names the moment to retry; a human-paced session never reaches the read limit.
  • “Internal error” with a ref — quote the ref in your support request. If a fresh connection still fails, stop reconnecting and report the host, tool name and time; a server or transport failure needs investigation.

​
Credits and safety

Ask your agent for your credit balance, monthly usage or remaining agent budget. Memo shows the credits and entitlement already available to your workspace. If a generation is blocked by insufficient credits or a spending cap, the agent explains the limit and stops. The MCP credit card does not offer top-ups, upgrades or checkout links. Generating from an agent costs the same credits as in the app — and spending is deliberately two-step:
  1. The agent calls generate_image / generate_video / run_workflow and gets back a priced estimate naming the destination project.
  2. Nothing is spent until you confirm: confirm_generation for a single image or video, run_brief with the signed estimate it just showed you for a brief, and watch_brand with its signed estimate for a watched brand. No other tool can spend credits.
A workspace admin can also set a monthly agent budget under Settings → Agents (a share of the monthly credits). It is off by default: without one, an agent may spend the workspace’s whole balance, exactly as a person can. With one, the agent is told the limit and stops.

​
Brand rules apply automatically

Your kit’s do/don’t rules ride every generation without anyone having to remember them: agent generations, Studio runs and brief scenes alike. When the references attached to a generation belong to a kit, Memo prepends that kit’s rules to the prompt on the server. Without references, pass brand_kit_id to apply a kit’s rules. To combine kits, for example a Cinema Kit with a Brand Kit, add also_kit_ids: the rules of every combined kit apply. If the references span several kits and none is named, Memo combines those kits, Brand Kits first, up to six. Rules scale by subject. A rule without subjects is kit-wide. A rule with subjects (for example ["Nano Gen 5"], or a handle such as ["char_jenny"]) rides only when one of the attached reference assets carries that name, handle or subject tag, so product-specific rules never dilute an unrelated render, however many products a kit holds. Set subjects when adding a rule, or later with update_brand_rules, which also edits and deletes rules so a kit’s list stays short. The estimate and the confirmation both carry a brandRules field (kit, applied, scoped for the subject-matched ones, and omitted when a very long rule list was trimmed to fit the model’s prompt limit), so you can see before spending which rules the model will follow. Rules are prompt guidance: they steer colours, copy, casing and composition well, but they cannot force pixel-exact geometry. For that, keep the truth as a kit asset and a kit skill, and attach the asset as a reference.

​
The right skill at the right time

list_skills ranks the workspace’s skills, the kit’s skills and Memo’s starters against the task; the agent reads a candidate with get_skill and its longer notes with get_skill_resource. Nothing is pushed: the agent chooses by the trigger hint, and using no skill is fine.

​
Where generations land

Agent generations file themselves into Studio projects. Estimates name the destination; agents can create a campaign project (create_project) or re-file strays (move_generations) instead of piling into a shared inbox. When create_project_folder or move_generations is called without a project, it uses the project open in your Studio tab, else the one the agent used last, and says which. Inside a project, get_project returns folder counts and descriptions, with one size-limited page of files, and move_generations with a folder_id files outputs into them — the same folders you see on the project’s assets page. create_project_folder adds a folder by name (or returns the existing one) and can file generations in the same call. When move_generations changes the project, an omitted folder_id puts the file in Unfiled. Within the same project it keeps the folder. Pass a destination folder explicitly to file it there, or folder_id: "none" to unfile it. The response lists the files actually moved and any IDs that were not found in your workspace. search_generations can combine a project, a folder_id inside it (or "unfiled"), a media type and review_status. Asking for approved files filters the eligible files before selecting the results, so unapproved matches cannot use up the result limit. Name and description matches come first, followed by matches ranked by meaning. A newly named file can be found before its search index catches up. With similar_to_generation_id the search becomes “more like this”: results are ranked by closeness to that file’s own index (its name, prompt and what it shows), and the file itself is left out. When the search is scoped to a project, every result names its folder. Every generation the agent reads back carries its context: a description and subjects written from the finished image rather than the prompt, the user’s reviewStatus when one was set on the canvas (prefer approved when several files fit; a missing status is not a rejection — search_generations accepts review_status to filter), the Character it depicts (characterAssetId), and what it was made from (madeFromGenerationIds, madeFromAssetIds).

​
Character reference views

When a character has a portrait and additional reference sheets, Memo labels the sent images individually. A portrait, expression sheet and pose sheet keep their own descriptions even when they belong to the same character. This helps the generation model distinguish the purpose of each picture. Choose clear descriptions when saving reference sheets.

​
Edit project files safely

Ask your connected agent to rename a file, record your review verdict, correct what an image shows, or link it to a Character. For example: “Rename this to Mira — final turnaround, and mark it approved.” A description is reference material; it never grants permission to perform an action. The agent reads get_generation, then sends update_generation with the revision of each field it changes and a stable operation_id. It can change a name while someone else changes a review status. If both change the same field, Memo reports a conflict and saves none of that file’s proposed changes. The agent must show the conflict and follow your intended choice. Retrying the same operation ID with the same request returns the original result. Replace a version instead of adding a duplicate. When you correct a file outside Memo and hand the corrected one back, the agent uploads it (create_asset_upload) and files it with add_project_file into the same project, naming the original in supersedes; a corrected file that is already in Memo is linked the same way with update_generation and patch.supersedes. The original stays, marked Replaced by the new file, and leaves the project’s file list and search_generations results unless asked for (include_superseded: true, or Show earlier versions on the page); the new file takes over its folder and name when it has none. To mark a version final, the agent sends update_generation with patch.final; the file carries a Final badge, and the final set is every file marked Final. Descriptions you or your agent author carry attribution and stay protected from later automatic descriptions. Review attribution records the authenticated user and connected client. Approval always represents an explicit verdict; a model’s guess about image quality is not approval. Editor access is required, and writes stop if Memo cannot check the workspace’s agent-access policy.

​
Find every file in a large project

get_project provides an overview of a project in one call (response contract version 3). Each folder carries its description (what the user or an agent said belongs there), its file count and approved count, images versus videos, the subjects that appear most in its pictures, its two newest files by name, and when it last changed; unfiled is described the same way, and briefs lists the Creative Briefs on the project. One globally limited page of the newest files across the project follows in filePage.files. Follow nextFolderAfter as folder_after for more folders, and pass filePage.nextCursor to list_project_files for more files. items_per_folder: 0 returns the overview without a file page. list_project_files supports folder, review status, media type, apparent role, Character, aspect ratio, text query, and missing name/description/folder/identity/provenance/embedding filters. Use folder_id: "unfiled" (or "none") for Unfiled. Pass updated_after (an ISO timestamp, for example the updatedAt a folder reported last time) to read only the files that changed since, each with its updatedAt. Results are ordered by creation time and ID, so tied timestamps do not lose files. Continue until hasMore is false. Cursors belong to one workspace and filter set; start over when changing filters. Each file in these lists is kept short so a normal project fits in one or two reads (12,000 bytes per page): a field that is none is simply absent, folder names the folder beside folderId, readiness is the word ready once a file is described and indexed (otherwise it says what is still pending or failed), and revisions lists only the counters that have moved (an absent counter is 0, which update_generation accepts). These tools limit each response’s text to 8,000 UTF-8 bytes. A page can contain fewer files than requested to stay within that limit. Labels and descriptions in a list are summaries. get_generation returns the current edit revisions; its prompt, description, and provenance sections page through the full text using nextOffset and expected_hash. Join those pages in order. Pages are not a frozen database snapshot: edits and moves can change which files qualify while you read. Read a file again before editing it.

​
Understand what a generation used

New stored generation runs capture the final provider request after model-specific settings and reference limits are applied. The run record separates the original creative request, effective settings, requested references, resolved references, images actually sent in their provider slots, and references dropped or unavailable. The provider receipt is recorded separately from the prepared request. Older files without a captured run record say unknown. Memo does not reconstruct those inputs from guesses. Inline image bytes are represented by a hash; replay needs the original bytes. Remote files and provider models can change, so even a matching request does not guarantee an identical image.

​
Stamp the logo on a finished image

stamp_logo places the kit’s real logo file on a finished image, pixel-exact, and saves it as a new generation next to the original in the same project and folder, named after the original with ”— stamped”. It is the way to get a correct logo on flat formats (social, carousel, ads), since a model only redraws a logo. The agent names the image, and optionally a logo asset, a corner, a width and margin as shares of the picture, and a backing plate; without a logo it takes the primary logo of the kit the image’s references belong to, else the workspace’s first logo, and asks you to upload one when there is none. It costs no credits. For a whole carousel the agent calls it once per card. promote_character_sheet saves a selected completed image as a permanent sheet of an existing workspace Character. It requires the Character-link revision from get_generation. The saved sheet has its own ID, permanent copy, and source record, so deleting the source generation does not remove it. Retrying resumes the same copy. A conflict returns the current link and revision; review them before choosing again. Removing a sheet from the Character is a separate explicit edit and retains the source record. reindex_generations queues up to 100 authorized file IDs for search repair. It does not run image description or generate media. Indexing and automatic descriptions have separate durable queues. Interrupted work is retried with a lease; stale results cannot replace the index for newer content. Exhausted jobs remain visible for explicit retry. Automatic generation descriptions reserve a monthly workspace allowance before each paid attempt, including retries. A failed or timed-out attempt still uses its reserved slot. If that allowance or its meter is unavailable, Memo makes no description call and uses a local prompt-based name when needed. This is separate from generation credits; names remain editable.

​
Figma presentations

import_presentation accepts a versioned source manifest prepared through your connected Figma account. The agent loads the Presentation builder skill, reads the source, supplies its exact font files and image assets, and imports editable slides into Studio → Presentations. Imports copy font bytes and use an operation ID for safe retries. Every slide still needs a preview check. Missing permissions, exhausted Figma quotas, unsupported nodes, or unavailable fonts are reported; a URL alone does not bypass them.