AI Studio & agents

AI Studio switches between Chat and Create in the top toolbar. The conversation toolbar also has Conversation / Trace and a toggle for the agent environment panel.

Chat: the agent operates your project#

The agent uses Mosael's MCP tools to see your project and propose changes: searching media, arranging the timeline, kicking off generation, even publishing.

• Confirmation cards: any action that would mutate project / external state pops a confirmation card and only lands after you approve (see the next section).
• Choice cards: at a genuine fork — two or three routes all make sense and which one is right depends on what you want (which platform to publish to, which style) — it lays the options out for you to pick, single or multi select, with an "other" box and a skip. Skipping means it continues on its own judgement rather than asking again. A choice card has no "always allow this session" — it is asking precisely because it does not know, and auto-answering would mean it made the answer up. Both kinds make it wait for you rather than carrying on after asking. If the wait runs out (ten minutes), it continues on its own judgement or wraps up; answer later and your answer still reaches the conversation.
• Skills: written methods for a kind of task that the agent reads only when needed; type / in the message box to name one. See Agent skills.
• The left column lists conversations — every conversation you have had anywhere; each is independent and can be renamed / deleted. Someone else's conversation shared into the workspace is read-only. Those that were not opened in AI Studio say where they were opened under the title ("Opened in Edit "Promo"", "Opened in the note "Weekly"") and have a Go back there button that takes you to that page to continue it there.
• You start on a new conversation: opening AI Studio (or the assistant anywhere) shows a conversation that has not started yet — it is only created, and only appears in the history, once you send the first message. While the app stays open, each place remembers which conversation you were in, so switching pages and coming back brings you back to it; after a restart every place starts on a new conversation again, and the old ones are in the history.
• Names come from what you talked about: the first message is the name at first; after the first reply, the agent uses the conversation's own model to give it a short, specific name (say, "Trim the promo script's second part"). A name you changed by hand is never overwritten; if naming fails, the first message stays.

Its tools reach across media, documents, assets, notes, boards, 3D scenes, editing, workflows and publishing: creating projects and timelines, duplicating clips, replacing media, adding a track at a given row, listing boards, checking which voice engines exist (list_speech_engines), importing media from a link, reading documents, creating assets… When it names something wrong it gets a real error back (a mistyped voice engine lists the ones that exist) instead of making something up. It edits notes passage by passage (edit_note) instead of only rewriting the whole note or appending at the end. Its browser tools reach elements inside same-origin frames (iframes), save a screenshot of the current page to the media library (browser_screenshot), and list, switch and close the pages open in a session (browser_page).

Confirmation cards follow the conversation#

A confirmation card appears under the tool call that opened it, not floating at the end of the chat. Top to bottom it shows the requester and the permission tier, the action in one sentence, the consequence, the parameters (one per line; code keeps its line breaks and syntax highlighting, the first 8 lines show with "expand all N lines"), a collapsed Raw data section, and the buttons Allow once, Always allow this session and Reject. Once decided, the card collapses into a one-line status inside that tool call ("Approved · Done", "Auto-approved · Failed", "Rejected"…) — nothing to dismiss; a failure reason is kept in full and folds when long. While a request is waiting, Jump to latest turns into A request needs your approval and takes you straight to the card.

The tier is on the card: Edit, AI cost, Render cost, Outside this app and Permanent delete. Always allow this session is remembered per tier: it only covers later cards from the same tool at the same tier or lower, and the Outside this app and Permanent delete tiers never offer it — the card says irreversible actions ask every time. If a card fails halfway, what it already did is rolled back rather than left half-done.

A card that changes a note shows original → new: one block per change — a replacement draws the difference (removed text struck through, added text highlighted, the rest unchanged), a replacement with nothing is marked as a deletion, and an insertion shows the surrounding text at the anchor plus what goes in; long ones show the first 400 characters with Show full text, and the raw JSON is still under Raw data.

Attachments, documents and background jobs#

• Attachments: 📎, dragging files from Finder onto the chat ("Drop to add to the chat") and pasting a screenshot all follow the same rules. Images, video and audio go into the media library; PDF, Word, slides, spreadsheets, EPUB, Markdown, TXT, CSV and web pages go in as documents, which the agent reads section by section — short ones whole, long ones from the table of contents, handing page images to a vision model when layout matters; other text files (scripts, subtitles, configs) are pasted into the message, up to 3,000 characters each; anything else is refused with the file and the reason. Files dragged straight out of a WeChat or Feishu chat window live in that app's sandbox and can't be read — save them to disk first.
• Images on the current message go straight to the selected model. Images and videos imported into the media library are analyzed by analyze_asset with the current session model, not a separate hidden vision model.
• Background job receipts: when a job the agent started (parsing an attachment, a generation) finishes, a one-line job notice appears in the chat (hover for "Background job receipt" and the job id) — never in your message queue; receipts that arrive while the agent is busy are saved up and handed over together when the turn ends. Jobs it already watched to the end send no receipt.
• Messages with a note excerpt: a message sent from Notes with a selection shows an excerpt line in its bubble (the note title and the start of the passage), so you can tell later which passage it was about; click it to go back to that note with the passage selected.
• Handing a web page to the agent: Start from this page → Ask the agent in a browser session's top bar starts a new conversation in AI Studio with "Take a look at this page for me:", the page title and the link in the input, waiting for you to add a line and send.
• It doesn't stop at a colon: when the model stops on a half sentence like "Let me check…:", it is prompted to continue once; likewise when the output was cut off, when it said it would call a tool but sent none, or when the provider paused the turn. If that still fails, the reason is written into the chat (for example, raise Max output tokens in the model settings).

Every place has its own conversations#

Edit, Notes, Boards, Workflows, 3D scenes and the Assistant tab of the ComfyUI workbench all have the same compact assistant panel. Each thing has its own conversations: every Edit project, note, board, workflow, 3D scene, and every workflow open in the workbench. What you talked about in Edit does not carry on when you open a note, and New chat in one place changes only that place.

• The panel's top-left heading is the current conversation's title. Click it: Here lists the conversations opened in this place (newest first), and the collapsed Elsewhere lists the rest, each saying where it was opened; search covers both. Pick one from Elsewhere to continue it here — where it was opened does not change, and a line under the title says "This conversation was opened in …".
• New chat (the + next to the title) switches to a conversation that has not started yet; it is created, as opened in this place, when you send the first message.
• When the agent takes you somewhere, the conversation comes along: if it says "let me take you to that note", the note continues the same conversation, so multi-page work is not cut off. Pages you open yourself show their own conversations. A jump the agent asked for while you were away (more than 30 seconds ago) does not pull you along.
• The hands-free voice bubble talks to the conversation of the page you are on (collapsed panel or not); on pages without a panel — media, publishing, settings — it talks to AI Studio's.
• Tools follow where you speak: in the ComfyUI workbench the agent gets the tools for ComfyUI workflows; elsewhere it gets the ones for boards, timelines, 3D scenes and workflows. So to change a ComfyUI graph, ask in the workbench's Assistant tab.
• A conversation opened in Edit includes that project's memory (the conventions the agent saved for that project, such as "the intro is always brand-intro.mp4").

Drag empty header space to move a floating panel. Long titles ellipsize, and the control stays visually flat rather than adding a framed selector.

The embedded Node.js agent runtime uses pi-agent-core / pi-ai. Requires model providers to be configured.

The composer keeps only what you look at every turn#

The composer row carries just the things you touch on every message: attachments, microphone, the model, and send. Mode switching stays in the top toolbar. Everything else lives behind the slider icon in session settings — the set-once-and-forget things:

• Thinking: off / low / medium / high. When on, the model's reasoning streams into a collapsible block you can expand, and it auto-collapses when done; the collapsed Thought row then shows how long the thinking took, formatted like a tool card's duration. "Off" only means we don't ask for it: models that reason regardless (k3, DeepSeek reasoner) still have their thinking shown.
• Video analysis mode:
  • Auto: an API-key model uses native whole-video input when its Adapter supports it; otherwise Mosael samples frames and includes any existing speech transcript. Subscription/OAuth models use sampled frames through the tool-free Gateway and need no service address.
  • Native video: forces whole-video input. The OAuth Gateway has no video block, so this fails with a clear suggestion to use Frames instead of silently changing model or mode.
  • Frames + transcript: always samples the timeline and sends existing transcript text to the current vision model alongside those frames.
• Context: a meter with "N% left", plus Compact context now.

What happens when the context fills up#

Once a conversation runs long, the app has the model summarize the earlier turns and keeps the recent ones, freeing room to continue. This is never silent — a record stays in the conversation saying how many messages moved out and roughly how many tokens were freed; expand it to read the summary itself.

• It triggers at 80% of the selected model's context window. Windows differ per model and are editable in model settings.
• You can compact on demand instead of waiting — it costs one model call, so it's an explicit button rather than something that fires on its own.
• The meter is anchored on real usage reported by the vendor (the last call's input, output and cache reads and writes); only messages newer than that are estimated.
• If fewer than 1,024 tokens would be left for the answer, the turn isn't sent; instead you're told the window size and how much is going out — enter the model's real context window in its settings, switch to a model with a bigger window, or compact the context first.

Trajectory: what it did, and where the time went#

The conversation answers "what it said". The Trace tab answers a different question: what it did, and where the time went.

Three lanes (input / model / tools) compress the whole session into blocks, with two projections: sequence gives every record equal width (needs no timestamps, so it is always drawable), and duration lays them out by real elapsed time with the idle gaps squeezed out. Below is a step-by-step ledger; open a step to see its arguments, result and timing.

The trajectory also carries the half the conversation never shows:

• The system prompt, recorded only on the turns where it changed. It is not a constant — cross-session memory and the current task plan are interpolated into it, so it differs almost every turn, and when you are asking "why did it suddenly do that", this is the first place to look.
• Context injection as its own row. What goes to the model is "what you typed + this context", so the question you see in the trajectory is the one the model actually received.
• Per-turn token detail (input / output / cache reads) on the turn header. With no usage records it is blank rather than 0 — "not recorded" and "spent nothing" are different facts.

Subagents: handing off an investigation#

The agent can hand a self-contained piece of work to a subagent — read-only tools, its own context. Only the conclusion comes back. What that saves is context, not compute: a search that would have spent forty turns rummaging through files spends them somewhere else, and your main conversation receives the answer instead of the rummaging.

• Dispatch does not block. The agent gets a receipt immediately and keeps working; whether and when to wait is its own decision. Dispatch several in one message and they run concurrently.
• Nothing is lost. Reports it never waited for are delivered at wrap-up.
• Each subagent is a session you can open, with the same interface as the main conversation — from the right-hand panel or the header. You can watch it work, step by step, while it runs.
• The main conversation's plan and recent tools show only the parent agent's level. A subagent's task cards and tool steps stay in that sub-session instead of appearing twice in parent and child.

Agents in different sessions can also @-notify each other. An idle recipient starts immediately; a busy one queues the message and picks it up when it is free. Messages that arrive this way carry a "from another agent" badge, so a conversation never looks like it talked to itself.

Create: image, video, speech, podcast, music#

Create keeps images, video, music & sound, speech and podcasts in one workspace: creation sessions on the left, the back-and-forth of the open session in the middle, the composer at the bottom and engine settings on the right. Results land in the media library.

• Show by type: a row of filters above the session list — All, Image, Video, Speech, Podcast, Music — remembered on this device; every session is tagged with its type.
• From elsewhere: generations made on a board, in a workflow, on an asset's page, by a schedule, by the agent in a chat or in the ComfyUI workbench are creation sessions too, collected at the bottom of the list under From elsewhere (collapsed, with a count). One session per place: every generation on the same board goes into "Board "Shots and ideas"", and what you approve in one chat (images, speech, podcasts) stays together. The title is that place's current name ("Deleted board" once it's gone), and Go there on the row takes you back. Open one to read it or keep generating. Long sessions show the latest 40 results first; Show earlier at the top loads more.
• The model decides the type: a new session is whatever the chosen model makes. The model list is grouped into Image, Video, Music & sound, Speech (each voice engine) and Podcast; with a type filter selected, only that type is listed.
• One family per session: image and video are one family (you can turn the last image into a video), music, speech and podcasts are one each. Once a session has results, the list offers only that family; for another type, start a new session with + at the top left.
• The placeholder while it runs, Stop, Stopped, the failure card, time taken and cost work the same for all five.
• Pick a model → write a prompt → send; the job queues and finished results land in the media library. Your default model from Settings is preselected; with no default set the picker shows "Choose a model" and you pick one before sending.
• Whether a model can run depends on its vendor's key being configured; with no usable model, the right panel links to settings.
• @ Asset under the prompt names a character, location or prop from the asset library: its description joins the prompt and its references attach, as many as the model takes (see Asset library).
• Attaching driving audio makes it a digital-human generation (talking photo, lip-sync), which needs I have the pictured person's consent ticked first — see Digital humans.
• Once submitted, it waits for the result. Video generation often takes minutes, longer when the vendor is busy. Mosael never gives up on a task you have already paid for because it took "too long" — it ends only when the vendor reports it finished (or failed), or when you cancel it in the task center. The same holds across a backend restart: the result is picked up again instead of asking you to start over (which would charge you twice). Go to on the task in the task center opens this creation session.

The controls follow the model#

Not every model takes the same parameters: Wan wants a pixel pair like 832*480, Seedance wants a tier like 720p; some let you pick a duration, some have exactly one. So the right panel shows only what this model actually supports — switch models and the controls switch with it. Manually entered models that are not in the built-in capability catalog remain usable, but Mosael does not guess their duration, resolution, or media-input rules from another model by the same vendor.

• Image models that declare resolution tiers and quality show both, starting at the model's own default (Evolink's GPT Image defaults to the cheapest: low quality, 1K). A line under quality gives the price difference: for token-priced GPT Image, low is about a ninth of medium and high about four times medium — try low first.
• Models whose sizes are only suggestions (ComfyUI workflows) let you type "width x height" into the list, such as 768x1024; a well-formed size adds a Use entry.
• The checkpoint and LoRA fields (ComfyUI workflows) show thumbnails, base model and trigger words, and Add to prompt appears after picking a LoRA; see Generating with ComfyUI. Arriving from Generate with it in the model or workflow library, the workflow is already selected and that field filled.
• Parameters the model declares a default for and you leave alone are sent with the model's default, not left to the provider's own.

First frame, last frame, reference#

Image-to-video is more than "here's a picture":

	What it means
First frame	Start moving from this image
Last frame	Give it together with the first and the model animates from one to the other
Reference	Not a starting frame — a style or subject reference

Again, only models that support these get the controls. Each takes either an image from the media library or a pasted link.

Asking the agent works the same way: "use these two images as first and last frame for a 5-second clip" and it will check what the model supports before sending — passing a parameter the model does not accept is rejected outright rather than quietly producing something else.

Music and sound effects#

The Music & sound group in the model list: pick an audio model to generate a song (with vocals), an instrumental / background track, a sound effect, or a soundtrack for a video. It runs on the same generation pipeline as images and video — same session, same parameter descriptors; results land in the media library, usage is metered, and paid asynchronous tasks are collected again after a backend restart.

• The prompt says how it should sound: genre, mood, instruments, tempo — or a sound effect such as "rain on a tin roof".
• Lyrics have their own field (Lyrics in the right panel): the words to sing, with [Verse] / [Chorus] sections. The corner shows the length and this model's limit. Lyrics alone, with no prompt, can be submitted.
• Vocals: choosing "Instrumental (no vocals)" greys out the lyrics — an instrumental has none, and sending both is rejected.
• Duration appears only when the model supports it, and it may stay empty: most music models size the track to the lyrics.
• Video-to-audio models (Kling) need a video attached. They accept public links only; a local video is first turned into a time-limited link by an object-storage plugin.
• Results are players, not thumbnails; a model that returns two tracks per request (Suno on Evolink) shows both.

What each vendor supports, and what is wired from documentation only, is in the "Music and sound" section of Providers.

Speech#

• Type the text in the composer (up to 2,000 characters; the corner shows the count) and pick a voice (the speaker button next to it plays a sample) and speed on the right. The engines are the same as on the editor's Voice tab: local voice cloning (F5-TTS / Fish Speech) or any remote engine; a new speech session starts on Edge (built in, free, nothing to set up).
• Local cloning needs a voice first — without one, a notice on the right takes you to Settings → Dubbing & voices to upload or record a reference clip; it also says when the local cloning engine isn't installed. With Alibaba Bailian (CosyVoice) you can also pick a library voice, spoken from its copy in your Bailian account; the first time, you're asked whether its reference clip may be uploaded — see Editing → Your own voice through Bailian.
• The result card is the same as for music: waveform, real duration, download, open in the media library; the title is the voice and the footnote the engine and time taken. The asset is named "voice · start of the text".
• Opening a speech session puts the right panel back on the voice and speed that session used last.

Podcast#

• Three modes above the composer: Rewrite material (paste some material and the two speakers talk it through), Discuss a topic (researched on the web, then discussed) and Read a script (you write it).
• Read a script is one line per turn: click A / B on the left to switch speaker, Enter starts the next line (read by the other speaker), Backspace on an empty line removes it; pasting several lines splits them, recognising lines that start with "A:", "B:" or a speaker's name. Up to 60 lines of 280 characters each (Volcano Podcast's limits); longer lines turn red right away.
• Pick speakers A and B (each with a sample) and the speed on the right. Connect Volcano Podcast under Settings → AI audio first; until then the right panel links to it.
• A finished podcast shows its Script (each line tagged with the speaker). Edit and read again loads it into Read a script so you can change it and read it again — this time only synthesis is billed. The asset is named "topic · Podcast", and the script is stored with that audio.

Speech and podcasts made earlier#

After the update, speech and podcasts made on the old Audio page are part of creation sessions: one "Earlier speech" and one "Earlier podcasts" session per person (named in your interface language). Only the beginning of the text was stored back then, and those records say so. Old outputs whose task records were already cleared stay in the media library, outside any session. A board's Read aloud and the agent's speech that were swept in at the time were later moved back to that board's or that chat's session.

Speech made by a board's Read aloud, a workflow's voice node, subtitle dubbing or note read-aloud doesn't go into creation sessions — it belongs to that board, timeline or note. Dubbing the subtitles on a timeline happens on the editor's Voice tab — see Editing.

Feishu (Lark) binding#

Settings → Feishu bot connects the agent to Feishu so you can chat from there.

Changes that need confirmation arrive as a card in that same Feishu chat — approve or reject without leaving Feishu.

Who may approve follows the account binding: whoever taps the button must already have their Feishu account bound to a Mosael account, and must still be a member of the workspace. Everyone in a group chat can see the card; seeing it is not permission to approve it.

A binding belongs to one bot#

Feishu's open_id is per app (the official User identity overview says: "do not use open_id in cross-application data communication"), so the same person is two different ids in two different apps. A binding therefore records which bot (which Feishu app) × which open_id, and the same person binding a second bot has to bind again.

• There is only one direction to pair: pick that bot under Settings → Feishu bots, generate a bind code (good for 10 minutes, single use) and send it to that bot. The bot will never send you a code — a code means "become that member's Feishu identity", so handing one to someone who is not bound yet would be publishing a member's credential. To get it to act for you, you generate the code.
• A bot created through the QR flow binds its creator on the spot. If the id Feishu returns for that flow turns out to belong to a different app (the docs never say which side's id it is), the first message says plainly "this bot isn't bound to your Feishu account yet" and points back to that bot's panel; it never pretends to have worked and never guesses.
• The panel groups by person: one row per member, and each binding under them says which bot it is for. The list holds only this bot's bindings — there is no third "can't be told apart" state: the rows left over from an earlier app are deleted during the upgrade, and anyone who recreated an app or deleted a bot simply binds again on the bot they still have. Deleting a bot deletes the bindings under it too.
• An old code stops working after you recreate the app: the bot says whether it expired, was already used, or was generated for a bot in another app.

Two developer-console settings are required for this (neither is settable via API, so one-click bot creation cannot do it for you): subscribe to card.action.trigger under Event Subscriptions, enable Interactive Card under App Features → Bot, then republish the app. Until then the bot falls back to a plain-text notice telling you which switches to flip.