The Deployments tab now shows more about each build: who triggered it, whether it's a preview or live deploy, and a timeline of what happened during the build.
New cards break down the deployment detail view: a build summary, a timeline, frontend diagnostics, the interfaces exposed by that release, and a snapshot of what shipped.
Self-hosted Remy deployments now check once a day for a newer release and surface it in the operator console and in the remy CLI's platform view, so you know when it's time to upgrade. See docs/upgrading.md for details.
Apps built on Remy can now call a much wider set of AI models for image, video, audio, and text generation, including new releases from Black Forest Labs, Cohere, Google, HeyGen, Ideogram, Kling, Qwen, Wan, and others.
Highlights include a video editing mode for FLUX, new text and embedding models from Cohere and Google, avatar video generation from HeyGen, and additional image and video models from Ideogram, Kling, and Wavespeed. Pick any of these from the model catalog when wiring up a feature that needs generation or embeddings.
Remy now generates launch-ready material for your app automatically: videos, carousels, social posts, ad sets, and changelogs. This kicks off in the background once a build finishes polishing, so you get announcement-ready assets without asking for them.
If the agent is already working on something, you can now send it a note while it's running instead of waiting for it to finish. The note reaches the agent between steps, so you can redirect or add context mid-task.
Sending a new request while one is already in progress now delivers it as a note to the running task rather than kicking off a second, parallel one.
Apps that convert HTML to markdown (email content, scraped pages, Google Docs and Gmail imports, data source chunking) now use a faster converter that scales linearly with document size.
Previously, malformed HTML with heavy or unclosed nesting could stall processing for a very long time. That failure mode is gone: conversion now stays fast regardless of how messy or deeply nested the markup is.
Apps can now authenticate requests to their serve and API routes with OAuth, alongside existing auth options.
Also clarified: Remy never caches a method's HTTP response on your behalf. If your method sets a Cache-Control header via respond(...), that header is passed straight through to the client.
Color and typography blocks in your brand guide no longer need special setup. Drop them into any guide file and they render as swatches and type specimens automatically.
There's also a new asset block for logos, icons, and backgrounds. Mark it as a logo mark, icon, or background and Remy previews it in context: a mark against light and dark surfaces at each size, an icon under iOS and maskable icon shapes, and a background per device with the safe area for UI called out.
Transcription requests with word-level timestamps enabled were sometimes losing that setting, so transcripts came back without word timings. That's fixed.
Image generation requests that specify an aspect ratio or image size are now applied correctly, so output dimensions match what you asked for.
Path parameters now reliably take precedence over a query or body field with the same name.
Also, path, subdomain, host, and apex are reserved as query-param names on your app's own routes, since the platform uses them internally and they'd never reach your handler anyway.
Preview releases now load faster once their databases are set up. Remy remembers that a preview is already provisioned instead of re-checking on every request.
Mode options on image, video, and audio models now render as a dropdown everywhere instead of mixing dropdowns and toggle buttons. Configuration looks and behaves the same across every model.
Your app can now use Gemini 4 Argon. It supports adjustable thinking levels, Google Search, Maps, code execution, and URL context tools, plus a priority mode for faster responses. Introductory and standard billing tiers both apply.
When Remy's agent needs a third-party API key or credential, it can now ask for it through a masked prompt. Your answer is set directly into the app's environment and never shown to the agent, so secrets stay out of the conversation and get stored safely for later use.
Apps with an MCP server can now require sign-in through the app's own login page. OAuth-capable clients like Claude and Cursor are sent through that flow automatically instead of needing a static key.
API keys also work over Basic auth now, not just Bearer. That means commands like curl -u x:sk_... and git credential helpers work out of the box, across the API, MCP, and webhooks.
When the agent changes files by running a shell command instead of editing directly, those changes now show up in the chat as a diff, just like any other file edit. You can see exactly what changed no matter how the agent made the change.
The analyzeImage step can now use any chat model capable of reading images, not just dedicated vision models, and defaults to gemini-3.8-flash. We also refreshed the available model catalog with newer entries, so your apps have more options to pick from when analyzing images.
If your card keeps failing, auto-refill now pauses automatically instead of retrying indefinitely. You'll get an email letting you know, and your billing settings will show the paused state with a button to resume once you've updated your payment method.
When Remy is running a command that's waiting on a timer, you can now see that it's waiting and skip ahead. Tell it to move on (or just say you're in a hurry) and it ends the wait early and continues the rest of the command instead of sitting idle.
Generated API docs now show real typed shapes for many endpoint outputs that previously showed up as unknown, so you get accurate types to build against instead of guessing.
Email attachments are now checked by their actual file contents rather than the extension or declared content type, which catches mislabeled files before they're processed. File downloads from URLs also go through a stricter check to make sure they only reach public addresses.
Queries that filtered on a user-type column (an owner or assignee field, for example) could compare against the raw user ID instead of the stored format, so matching rows were sometimes missed. Filters on these columns, including IN checks, now compile correctly and return the expected rows.
Video renders from HTML compositions (mp4, webm, mov) now split into short chunks that render in parallel and get stitched back together. That raises the practical time budget for a long render to about 30 minutes, so longer or more complex videos no longer time out. GIF renders are unchanged and still render in one pass, within 15 minutes.
Clicking Share again on a report, pitch deck, or security assessment now reuses the existing link instead of creating a new one. Anyone you already shared the link with keeps seeing the latest version.
typesafeEvaluate now accepts an images parameter, so you can pass up to 4 images (4 MiB each) alongside your prompt for evaluation.
You can also now run evaluations against Clef and Clef Flash, in addition to the existing model options.
Lip sync generation now accepts a video as the source, not just a still image. Apps can sync speech to an existing video clip and the right model is picked automatically based on what you provide.
We also added a large batch of new lip sync and avatar models to choose from, including options from ByteDance, Creatify, Kling, VEED, Meituan, LTX, Pixverse, Minimax, Sync, and Wan.
Apps that generate video can now set its cover art directly. Pass an imageUrl or a timestamp (at) to pick the thumbnail, and get back a thumbnailUrl PNG you can use as a page poster.
Set asFirstFrame to burn the thumbnail into the first fraction of a second of the video itself, so it shows up even in players that ignore embedded cover art.
Fixed an issue where the agent could cut a response short if it contained repeated text, such as a list of links sharing a long common prefix. The agent no longer mistakes that kind of legitimate repetition for a stuck loop.
Long-running media actions like background removal, watermarking, importing from a URL, and video transforms now report progress as they run, so logs show how far along a job is instead of going quiet until it finishes.
Chat also renders  as inline video or audio when the file extension calls for it, not just images.
You can now buy a domain for your app without leaving Remy. Search for a name, purchase it, and Remy handles DNS and renewal automatically.
From workspace settings you can:
You'll get email notices as domains come up for renewal or expire, so nothing lapses without warning.
Date pickers and call logs could show inconsistent dates on re-render: calendar ranges would shift slightly and "today" badges on call logs could go stale. The underlying time reference is now stable across re-renders, so dates and "today" markers stay accurate and consistent.
Fixed a bug where a tool call cut off by an output limit could cause every following request in that conversation to fail. The app now only replays tool calls that actually completed, so a truncated call no longer breaks the rest of the session.
Your apps and the agent can now use Claude 5.5 Haiku. It supports adjustable thinking effort, so you can trade off speed and cost against reasoning depth, and pricing scales for long prompts over 100K tokens.
Apps that send images to AI models should see fewer failures. Several models were rejecting or hanging on image inputs; images now get encoded directly into the request instead of passed as remote links, fixing this for Mistral, DeepSeek, and Llama models and across all Bedrock models. Microsoft's Phi models keep the old behavior, since they hang on the inline format.
Separately, some models stream their reasoning text under a different field name, and that text was getting silently dropped instead of showing up in your app. That's fixed, so reasoning output now comes through consistently.
Apps can now route model calls through Microsoft Azure AI Foundry, covering catalog models like Claude, GPT, and open-weight models alongside the existing providers. Authenticate with an API key or set up keyless access via workload identity federation.
Exporting markdown with embedded images to DOCX could hang indefinitely if an image was crafted to look valid but wasn't actually PNG, JPEG, GIF, or WebP. Image data is now checked against its real file signature before conversion, and anything that doesn't match a supported format is dropped instead of causing the export to stall.
Large database transfers and uploads now report live progress instead of sitting silent until they finish. You'll see this in the editor's restart process view when a database copy or upload is running, and you can cancel a transfer midway instead of waiting it out.
Agent tool calls now cap their output at 50,000 characters by default (configurable via maxToolOutputChars), so one oversized result can't blow out a run. Truncated results are clearly flagged in the tool call history along with how much was cut.
Task agent runs now report whether they stopped because they hit the turn limit, plus a stopReason for why the run ended.
Method input types are now read directly from your handler's own parameter instead of a separate declaration, so your code is the source of truth. If a type can't be inferred, you'll see a warning in the build log.
Fixed an issue where a single file edit or tool action from the agent could show up twice in build activity. Tool calls now stream consistently from start to finish, so the activity feed accurately reflects what the agent is doing.
If a credit auto-refill charge gets blocked, Remy now waits 24 hours before trying again instead of immediately retrying against the same block.
The SQL console can now run queries against your dev release, not just live. Rejected statements show the database's actual error message instead of a generic failure, and user id columns now resolve to display names so results are easier to read.
Mappers that return documents can now yield them as a generator or async iterable instead of a single array, so mapping a data source with hundreds of thousands of rows no longer loads them all into memory at once.
Invalid documents are now quarantined individually rather than failing the whole source, and adding documents returns a count of how many were added versus invalid so you can see what happened.
Apps with a voice interface can now use GPT-Live 1 as the backend, alongside additional realtime and transcription models. Pick the model that fits your app's latency and accuracy needs when configuring voice.
Every agent task now records a trace of each turn it took, so you can see exactly what ran and when.
Apps can also surface this directly to your users: a roster of agents and their run history, with guidance built in to help you name agents clearly and show traces in your own UI.
Data sources can now tag documents and passages with named entities. Set them when you add() content, through a mapper's entities field, or in a job manifest line. Policies.entities() returns the top entities for a filter, and Policies.passages() / allPassages() page through every passage matching an entity filter, unranked.
Dictionaries add a way to keep that tagging current: push a table of named things (equipment tags, product names) with pushDictionary(), and matching passages get retagged automatically in the background as the dictionary changes. Matching is deterministic: case and separator differences are ignored, and the longest matching name wins.
The dev environment's background connections now stay alive longer, cutting down on unexpected disconnects during long idle stretches.
File uploads in your app also route through regional CDN endpoints instead of a single direct path, improving upload speed and reliability.
Shipped a round of reliability work under the hood: data storage, secret handling, and background job processing all moved to more resilient infrastructure.
This doesn't change how you build on Remy, but it improves how your app's files, secrets, and scheduled or queued work are stored and processed across regions.
Fixed a race where the agent could run a batch of shell commands out of order, causing a read to run before the write it depended on finished. Shell commands in a batch now run one after another in the order the agent wrote them, while other tool calls still run concurrently.
Your app can now call GPT-6.1 Sol. It replaces GPT-6 Sol as the latest in its line and comes with reduced cache-read pricing.
Model calls cache a resent, unchanged prompt for a few minutes by default. You can now set promptCaching: false in modelOverride to turn that off for a given call.
Claude 5.5 Sonnet is now selectable as a model for your app. It supports reasoning effort from Low to Max (defaulting to High), and runs its extended thinking continuously between tool calls rather than switching it off.
Apps can now call a new evaluation step that scores text or JSON input against a set of questions and returns calibrated probabilities and scores in one call. Questions can be boolean, multiple-choice, or scored, so an app can get structured judgments (confidence levels, classifications, ratings) without writing custom scoring logic.
Package installs inside your app's build and dev environment are now faster and more reliable, thanks to a caching layer for npm packages at the edge. This mostly shows up as quicker setup when your agent is working on new dependencies.
If a domain's mail routing already points at Remy from a previous app, claiming it now also requires publishing a verification token we give you, in addition to the usual domain checks. This closes a gap where someone could add a domain still pointed at Remy from a deleted app and start receiving mail meant for the previous owner.
The scrapeUrl step now returns its result in a content field instead of markdown. The rename reflects that scraped output isn't always markdown, so update any app code that reads markdown from a scrapeUrl step.
Apps can now use a decomposeImage step that splits an image into a base layer plus separate transparent layers, useful for editing or recomposing parts of an image independently.
The model catalog also added several new options for image, video, and 3D generation steps, including Seedream v5.0 Flash, Recraft v4.1 Flash, Minimax H3 Singularity, Wavespeed Tripo3D H3.1/P2, and Meshy 7/7.1.
Spreadsheets, Word docs, PowerPoint files, and other Office formats (docx, pptx, odt, rtf, epub) are now parsed directly instead of going through the document-extraction model. Spreadsheets come back as one table per sheet, and other formats convert to clean text with embedded images intact. Images inside these files still get a description pass, and extraction is faster since most of these files no longer need a model call.
Messages to your app's email inbox must now pass SPF or DKIM verification for the sender's domain, in addition to matching an approved address or wildcard. Messages that claim to be from an allowed address or domain but fail that check are dropped instead of delivered, closing a spoofing gap in the allowlist.
Fixed a bug where the agent could lose a conversation's compacted history if the session went idle right after compaction finished. The summary now saves immediately once compaction completes, so restarting a session no longer resumes from the full, uncompacted history.
Jewels held-out grading now scores against the actual decision your app made, not just the raw method output. Each held-out answer is projected to the proposal it implies, and any answer that can't be projected is marked so you can see where grading couldn't follow the chain.
Propose chains also report clearer results: queued results now include a queueItemId, committed proposals expose their output, replaying the same idempotencyKey returns a consistent answer for the method's attribution window, and calls outside the configured sample rate on approve/auto methods resolve as recorded.
We also clarified two data-source behaviors: a connector without --budget-per-sync set always waits for jobs approve before running, and promoting a data-source candidate permanently drops the version it replaces.
Emails sent from an app's email inbox interface could arrive with corrupted or unreadable attachments. Attachments now include explicit encoding, so files sent through that interface arrive intact.
The /familiarize command in agent chat was wired to a broken action and silently did nothing. It now correctly triggers the agent's familiarization pass.
You can now transfer an app to another organization even when it means moving data to a different storage region. Starting a transfer that crosses regions shows a dedicated progress screen while the move runs, instead of switching you to the new workspace right away.
Signing in with an email or phone number that only differed by case or formatting could create a duplicate user instead of matching the existing one. Lookups now use the same normalization everywhere, so a user gets one account regardless of how their email or phone was entered.
We also fixed a bug where a single failed sync could cause that user's retry to be dropped permanently instead of being retried.
SDK calls that failed were returning a generic transport error instead of the actual message, and err.code checks in app code never matched. Errors now carry the real message and code from the API, so catch blocks that branch on err.code work as expected.
Remy's agent now runs on Claude Opus 5.5 by default, including the visual design agent and dev sessions. The model uses adaptive thinking tuned by effort level, which should mean better results on complex app changes.
Added two new image models to the catalog: arrow-2 and arrow-2-telos, both from QuiverAI. Use them to generate SVGs from a text prompt or vectorize an existing image into one, with controls for output size and auto-crop. Neither model trains on your data.
Also added gpt-6-sol and gpt-6-luna as supported models for apps using larger context windows.
Exporting a browser-test session replay used to upload a stitched copy of your app's screen recording to a public bucket so it could be fetched back for playback. That recording now stays in your app's own private storage end to end, and playback fetches it directly from there. No change to how you use test replays, just one less place your app's UI was ever exposed.
Loading spinners and error messages in preview panes could render in the wrong spot instead of centered where they belong. These states now always position correctly, and the floating share button in overview panes is unaffected.
Apps can now call the QuickBooks Online Accounting API directly through a connected OAuth company. Describe what you need and Remy wires up the request, no custom integration code required.
Your Remy agent can now build with Grok 4.7 and Grok 4.7 Vision, including support for the highest reasoning-effort setting on this model family.
Fixed a sync bug in the spec editor that could leave the document in a broken state, including cases where the editor would stop accepting updates after a sync. Formatting on links and annotations now serializes in the correct order as well.
Previews like the app overview, pitch deck, roadmap, file previews, and data-source views now detect when their underlying link has expired and refresh it automatically, retrying once before giving up. Sharing an app's page as HTML now shows an error toast if the fetch fails, instead of failing silently.
SSO login now runs through WorkOS instead of our old SAML redemption flow. Signing in is a single Continue with SSO button, and enterprise sessions are issued and managed the same way as everywhere else on Remy.
This is a drop-in replacement, so if your organization already uses SSO, nothing changes on your end beyond the simpler login screen.
The Default Models settings page now covers the models Remy uses for its own platform-run work, like security assessments and issue triage, not just the models your app calls.
Set a default once and it applies across these built-in reports instead of falling back to a fixed choice.
Issues now support multiple labels instead of a single category, and you can filter the Issues tab by label or by which app an issue came from.
Issues and comments can also be attributed to a different app in the same workspace, so one app's tracker can hold issues filed on behalf of another. When a crash shows up in error details, you can now file it as an issue directly from that view instead of re-describing it by hand.
Long-running sessions on DeepSeek V4 models could get stuck repeating the same sentence until Remy cut the turn short. This happened when a conversation grew large enough to need compaction but hadn't yet crossed the old threshold. We lowered that threshold so compaction kicks in sooner, closing the gap.
Some apps hit an error when a conversation with the AI model ran long and needed to trim context, caused by a compatibility setting that certain model configurations reject. Remy now checks which configuration is in use before applying that setting, so long-running conversations trim context correctly instead of failing.
The Data Residency, Subprocessors, and Model Providers pages in your org settings now pull from a single, consistently maintained record of every external service Remy connects to, including where it runs and how it handles your data.
You can also turn off a connected service without losing its saved credentials. Disabling a service no longer requires deleting and re-entering its key later.
Resetting a dev database could previously queue up deletes that reached your live users table, since dev databases start as clones of live. That's now fixed: the reset path leaves your accounts table alone, and account deletions triggered from a dev environment no longer propagate to live at all. As a related safety fix, live account deletions now match on account ID only, so they can no longer catch an unrelated account that happens to share an email or phone number.
Copying an app that already had users could break sign-in on the copy: the copy's users would fail to sync and never show up. User accounts are now tracked per app, so a copy can have its own users even when they share ids with the original app.
We also added a check that enforces one account per email or phone number on each app, closing a gap that could let duplicate accounts sign in under the same contact info.
Python packages like PIL could fail to install in app code even though they appeared to load. This is fixed: package installs now complete reliably during code execution.
Apps with a realtime voice interface can now use Gemini 3.8 Live, including the extended-thinking variant, with the full set of text-to-speech voices. Token and audio pricing match Google's published rates.
When you ask Remy to add a data source, it now adds the full document instead of a trimmed excerpt, up to the platform's per-document chunk limit. It also uses the raw file directly for common formats like PDF, DOCX, and HTML rather than converting them first, since extraction is already built in. If a document doesn't show up as expected, Remy now checks its indexing status directly instead of guessing at the cause.
transcribeAudio now returns more than plain text. The result includes segments (timestamped, speaker-labeled chunks), the detected language, and the audio's durationSeconds, alongside the full text.
This works the same way across all supported transcription providers, so apps that build transcripts, captions, or speaker-aware views get the structure they need without extra parsing.
Your apps can now call DeepSeek V4.1 Flash as a model option. It's available anywhere your app calls AI models, with a large context window handled automatically so long conversations stay within limits.
Data sources now support a count() call that returns how many chunks match a filter, without paginating through results to tally them yourself. Useful for showing totals or checking if a query matches anything before running the full query.
Dedicated data source capacity now resizes faster. When your app scales up to dedicated infrastructure, Remy can rebuild only the documents added since the last sync instead of copying everything from scratch, so the switch finishes sooner and larger data sources scale with less disruption.
Connecting a large data source now plans in the background instead of blocking on a single synchronous pass, so big sources no longer stall while every record gets scanned up front. Stalled plans are automatically retried up to a limit instead of hanging indefinitely.
Apps can now generate and edit images with MiniMax H3, including text-to-image, image editing, and LoRA-based variants. Pick it from the model list like any other image model.
Apps can now generate images with GPT Image 2.5, available in two variants: gpt-image-2.5-flare and gpt-image-2.5-sunburst. Both are billed per token like the rest of the image models on Remy.
Remy can now take in a project you already built elsewhere, including a broken, overbuilt, or abandoned one, and review it before touching anything.
From that review, the agent rebuilds and rearchitects the app as a working Remy project instead of patching around whatever shape it was left in.
Your app's Dashboard now has a Data Sources tab for managing where your data lives. You can move a data source onto dedicated capacity when it needs guaranteed performance, or back onto shared capacity when it doesn't.
Dedicated resources come in small, medium, large, and xl sizes, and you can resize up or down as your needs change. Each move or resize shows up in your audit log, and you'll get an email when a resource finishes provisioning or hibernating.
Session recordings of the agent working can now be exported as video, with device framing so the output looks right whether it captured a desktop or mobile view.
The playback experience is also reworked: a cleaner recording player, a smoother cursor with press and release effects that's easier to follow, and a plain viewing mode for sharing a recording without the surrounding UI.
Fixed a bug that could block access to an app with a wrong-workspace error after switching organizations or when your session referenced an organization you'd since left. Remy now recovers automatically instead of hard-failing, and app pages also show the correct organization name.
Apps can now generate music with Lyria 3.5, Google's latest music generation model. It replaces lyria-3-pro as the default Lyria model and is billed per unit generated.
Fixed a bug where the editor could freeze up and eat memory until it needed a hard refresh. The underlying language server now gets restarted automatically when it crashes or runs out of memory, and the editor reconnects on its own, re-opening your files so you can keep working without losing your place.
Remy now tunes when a conversation gets compacted based on the model actually powering the session, instead of one fixed threshold for everyone. The suggestion to compact appears at the right point for each model, so you get the prompt at a more accurate time rather than too early or too late.
Apps built on Remy can now use GPT-6 Astra anywhere you pick a model for AI features.
Remy's agent team now includes a Research specialist that can search the web and cite its sources. Ask for something that needs current information, like competitor pricing or a library's latest API, and Remy will pull it in with citations rather than relying on what it already knows.
Remy can now build and run app logic with GLM 5.3. Pick it alongside the other available models for your app's AI-powered features.
You can now start a project by handing Remy something you already have. Drag and drop a zip file, a folder, or documents from an earlier attempt, and the agent picks up from there instead of starting from a blank prompt.
Deepseek V4 Pro is now available as a model option in Remy.
Muse Spark 1.2 and 1.3 are now available as model choices for your apps. Both support adjustable reasoning effort, so you can trade off speed against depth of reasoning depending on the task.
Apps built on Remy can now publish realtime events directly between connected clients, not just from the server. Call sub.publish(...) after events.connect(...) to broadcast ephemeral signals like cursor positions, typing indicators, or live drawing strokes to everyone else on the channel.
These client messages are batched every ~40ms and capped at 8k characters per message, and are dropped rather than retried if delivery fails, which fits fast-moving, disposable signals better than guaranteed delivery. Server-published events also get more room now: the payload limit is up to 256k.
Apps that specified Claude 3.5 Haiku were failing because the model had been removed without a working fallback. It's back as a supported model and automatically routes to Claude 4.5 Haiku, so existing apps run without any changes needed.
If you had the same app open in two sessions, an old session could occasionally overwrite newer changes in the background snapshot used for backups. Older sessions are now locked out permanently once a newer one takes over, so their backups can never clobber your latest work. The editor also now shows a warning banner if backups are failing or your session has been superseded by a newer one.
Apps that send email now track bounced recipients more accurately, so addresses that bounce are suppressed from future sends and cleared correctly if they're removed from the suppression list. This cuts down on wasted sends to addresses that keep bouncing.
We reworked the edge layer that serves your app's traffic (CDN, redirects, and API routing) for more consistent caching and CORS behavior across web, API, and file requests. Redirect caching on public file paths is also tuned for fresher responses.
Your apps can now call Gemini 3.8 Flash for AI features that use tool calling, alongside the other model options.
Clearing a session no longer resets your previously selected AI models. Your model picks now persist through a clear.
Apps that generate PDFs or page screenshots now render on a faster, more reliable backend. The new engine supports custom page sizes, retina-quality output, and waiting for a specific element to appear before capturing, so exports better match what's actually on the page.
Your app's manifest now supports redirects, rewrites, and trailingSlash for controlling how requests map to pages. Rules are validated for shape and cycles, matched with standard path patterns, and capped at 200 per app.
When you mount an app at a custom path, Remy now warns if its index.html hardcodes an absolute canonical link or if its robots.txt rules won't carry over correctly to that path.
Your app's chat agent can now call tools that run in the browser instead of on the server. Declare a tool as client-side and the agent pauses (up to 15 minutes) while your app handles the call and sends back a result. This opens the door to agent tools that need browser context, like reading page state or prompting a user for input mid-conversation.
Design reviews now verify that every wireframe Remy references actually exists before handing back results. If a review points to a wireframe that wasn't created, Remy catches it and automatically retries instead of leaving you with a broken link.
You can now archive folders in the app launcher instead of deleting them. Archived folders are hidden by default; toggle Show archived to see them dimmed and sorted to the end of the grid.
Sending email to a batch of recipients (newsletters, digests, notifications) is now tracked as a single send instead of a pile of individual messages. Each batch moves through a clear status (sending, completed, partial, failed) so you can tell at a glance whether everything went out.
Other changes:
email.send() method now supports a category of transactional or marketing, plus attachments, unsubscribe handling, and a batchId to group related messages.batchId to see everything in one batch at once.Apps that pass images to vision models now detect the real image format by reading the file itself instead of trusting a mislabeled URL or server header. This fixes cases where an image with the wrong extension or content-type caused the model to reject it.
When an image still fails, error messages now include its URL, detected type, and size, so it's easier to see why.
Uploaded zip files with non-ASCII filenames (accented characters, non-Latin scripts, etc.) used to come out corrupted after extraction. Remy's build environment now decodes filenames correctly on unzip.
We also removed a few rough edges in the environment Remy works in: commands that used to occasionally hang waiting for a credential prompt or pager now run non-interactively, so builds don't stall.
File uploads now go straight to storage instead of routing through the API as base64, so uploads up to 5 GiB work reliably. Files over 4 MiB stored with Store.put switch to this direct path automatically, no code changes needed.
The file CLI also gained new commands: files get, files sign, files stat, and files ls, alongside the existing files put, so you can inspect and pull files without leaving the terminal.
Apps that send email now get a proper activity log. You can list and inspect individual messages, group a fan-out send into a single batch and see its stats, and manage suppressions directly.
Suppression handling is also more accurate: removing a suppression now checks whether the delivery provider still blocks that address at the account level, and the dashboard warns you when a resubscribe clears your app's record but delivery is still blocked upstream.
Adding notes on a preview now works off a clean snapshot of the page instead of drawing directly inside it. The toolbar for marking up and voice-annotating a screenshot now runs in the preview panel itself, so annotations render more reliably and stay in sync with what you're pointing at.
Apps built on Remy can now call more AI models: Bria 3.2, several Qwen variants, GLM-5.3-flash, additional Grok vision models, and new embedding and image generation options.
Also fixed a bug where some Grok vision requests failed due to unsupported parameters, and corrected model selection for image editing versus text-to-image generation.
The paperclip menu in chat now offers a folder upload alongside files. Pick a folder (or drag one in) and Remy zips it up client-side and attaches it in one go, skipping node_modules and dotfiles along the way.
We also quieted a false-alarm error toast that could pop up when a file's text couldn't be extracted but the upload itself was fine.
Task agents in your apps can now use custom function tools defined right in your code, alongside the built-in actions and app methods they already support. Give a tool a name, a description, and an execute function, and the agent can call it during a task.
This works with the per-turn task flow. The older whole-task mode doesn't support function tools yet and will return an error telling you to switch over.
The Activity tab now shows a per-recipient log of every email your app sends, from the moment it's queued through delivery, bounce, or spam complaint.
You can also see and manage your app's suppression list, the addresses that are blocked from receiving further mail because of a bounce or complaint, so you can tell at a glance why a given recipient isn't getting messages.
Every branch now gets its own preview build with a shareable link, so you can hand a work-in-progress to a teammate or client before it goes live.
Open or share a preview from the deployment view: each release shows its branch, and a new Share action creates a link you can revoke or let expire on its own. Access to shared previews is logged in your audit trail alongside everything else, and preview traffic is tracked separately from production usage so it never skews your live metrics.
Three new models are available to apps you build on Remy:
Pick them anywhere your app calls a model.
Fixed a bug where pressing Stop during a conversation compaction didn't actually cancel it, letting the compaction keep running in the background. Stop now aborts it immediately, and queued messages sent while it was running are handled correctly once it's cancelled.
Requests that involved long AI thinking time could get cut off mid-stream with an "encountered an error. terminated" message. The underlying timeout was too short for extended reasoning pauses, and it's now been extended so these responses complete normally.
Remy can now update published app settings directly when you ask it to, instead of sending you to the dashboard. That covers things like the signup allowlist, authorized test accounts, and embed frame ancestors for iframes.
Your app's backend can now query its own analytics directly, so you can build admin panels and dashboards on top of real usage data instead of just viewing it in the platform dashboard.
The new analytics namespace supports query, live, sources, map, aiSources, and crawlers calls, with filters like is, is_not, and contains, breakdowns by dimension, and ranges up to 'all' time or the last '90d'. The platform dashboard itself has been rebuilt on the same engine, with new 90-day and all-time presets.
Your app's database layer now supports aggregate(), sum(), avg(), and countDistinct(), plus a sql() escape hatch for raw SQL. These compile straight to SQL aggregates instead of pulling every row into memory, so totals and averages stay fast even on large tables. Ask Remy to add these to your app whenever you need a report or dashboard number computed at the database level.
Model training runs now show live progress: a smoothed loss curve, a phase stepper, and a running log that picks back up right where it left off if you refresh the page.
When a run finishes, we grade every checkpoint and promote whichever one actually performs best, not just the last one. If an earlier checkpoint wins, the model card calls that out so you know why it wasn't the final epoch.
You'll also get an email when a training run finishes or fails, so you don't have to keep the tab open to find out.
Marketing emails sent from your app now include a one-click unsubscribe link, and each app keeps its own suppression list. Suppression is scoped per app, so an unsubscribe or bounce in one app never affects mail from another app you own.
Sign-in and verification emails are exempt from suppression, so a marketing opt-out can never block a user's login code.
Your app can now call several new models, including ByteDance Seed 1.8 and 2.0, InclusionAI Ling 3.0 Flash, Qwen3-VL-235B, StepFun Step 3.7 Flash, Thinking Machines Inkling, Xiaomi MiMo v2.5, and Zai GLM 5.3.
We also added a 3D-generation model, WaveSpeed Hi3D v3.0, for apps that need to produce 3D assets from prompts or images.
The agent's code search tool now handles file names with spaces and special characters correctly (like certain zip files) instead of failing on them.
There's a new Automation tab on the app dashboard for watching your jewels work: side-by-side comparisons of what the AI proposed versus what a person actually did, agreement-rate charts over time, a per-method roster, and a view into any custom model training runs, including downloading the underlying training dataset.
App backends can now hand a decision moment straight to a method's jewel from code: call mindstudio.jewels.propose(methodId, subject) at the point your app detects it, and let the jewel shadow it, queue it for approval, or act automatically depending on how much you trust it. Apps in approve mode can build a native review inbox with mindstudio.jewels.queue.list and .resolve.
Wireframes the agent creates while designing your app now show up as real, previewable files in the chat and spec view instead of throwaway inline images.
Apps whose methods have a jewel (a shadow AI companion learning from what people actually do) can now graduate that jewel into its own fine-tuned model. Remy trains a custom model on the recorded agreements/disagreements and serves it so the method can eventually run on its own, fully automated model instead of a human in the loop.
You can now give any app method a shadow AI companion that watches what a person actually does and learns to predict it, then climbs an autonomy ladder from silent shadowing to proposing an action for review to acting on its own. This is the foundation for methods that automate themselves over time instead of staying manual forever.
Several new AI models are now available to build with: additional 3D-generation models (Tripo3D H3.1, Hunyuan3D Rapid, Meshy v7, Rodin v2.5, Seed3D 2.0), a new video model (Wan 3.0 Prime), and a new fast chat model (Qwen3.7 Flash).
Web scraping (the Scrape URL block, plus LinkedIn, X/Twitter, and auto-enhance scraping) now runs on a more reliable provider with built-in rate limiting, so heavy usage across the platform doesn't get throttled. Scrape costs now reflect the actual work done rather than a flat rate.
Building the web interface for your app is faster. Dependency installs during that build now pull from a pre-warmed cache instead of downloading the whole package set from scratch every time.
Task agents (runTask()) can now define their output as a JSON Schema instead of an example object. Output is validated automatically on every step, with the platform repairing malformed results before handing them back, so a task either returns data matching your schema or fails clearly instead of silently returning something you had to check yourself.
Some AI models can now be served through more than one backend provider, with traffic routed automatically. This gives the platform a way to keep model calls running during a single provider's outage, and provider-status alerts now track the actual serving path instead of guessing from a display name.
Backend method execution now scales up faster when traffic arrives in bursts. A sudden spike used to leave requests queued behind pool warm-up for ~seconds; the scaling logic now reacts to burst size directly and stops blocking new capacity while it waits on pods that are still booting. That cuts worst-case wait times and reduces timeouts during traffic spikes.
Scheduled jobs now have their own Cron tab in the app dashboard: each job gets a lane showing recent runs, current status, and a countdown to its next fire. You can also trigger a job on demand instead of waiting for its schedule.
Behind the scenes, cron jobs run on a rebuilt scheduling engine with dedicated tracking for jobs and runs, so job history and status stay accurate even under heavy scheduling load.
Remy's design agent can now render pixel-precise graphics, like share cards and flat icon tiles, directly from HTML and CSS instead of relying only on AI image generation, giving exact colors, fonts, and spacing. Icon generation was also tuned so results come back as clean, full-bleed icons instead of framed mockups.
Apps start up faster after a deploy. Dependencies are now resolved once when you publish instead of being reinstalled on every new server instance, cutting cold-start time noticeably for apps with heavier dependencies.
Fixed a bug where people invited to join an organization on an enterprise plan could get stuck or land on the wrong screen while onboarding.
Fixed an issue where some Qwen-based AI models could fail or behave incorrectly when system messages were interleaved in a conversation.
Realtime voice options in the model catalog now include a short preview clip for each voice, so you can hear how a voice sounds before wiring it into your app.
Callers who verify by text message during a phone call can now be signed up automatically if they don't already have an account, instead of only being able to access an existing one. Email verification during a call still only works for existing accounts.
Voice apps now handle background noise better and can adapt to whether a call came in on the web or over the phone, including reading the caller's number when relevant. If a call gets interrupted by background noise rather than the caller actually speaking, the agent now recovers and picks back up instead of stopping mid-sentence. Outbound calls also get the same in-call verification as inbound, so an anonymous outbound call can be recognized as a known caller mid-conversation.
Agent turns should feel snappier. We restructured how the agent's internal prompt is built so the parts that change on every keystroke or screen no longer sit ahead of your conversation history, which was forcing more of the prompt to be reprocessed on each turn than necessary.
Images sent to vision-enabled AI calls are now compressed before being sent to the model, so vision requests complete faster and are less expensive.
When a model response gets stuck repeating itself, we now detect it and cut the response short instead of letting it run to the token limit. You get a clean, truncated answer instead of a wall of repeated text.
Fixed a bug where favoriting a model could fail to save correctly.
Fixed a bug that could cause Gemini models to fail when calling tools or functions from your app.
Fixed a configuration issue affecting several Grok model options in the catalog.
The generated plain-language app overview now stays up to date automatically as the agent makes changes, instead of drifting out of sync between updates.
Backend methods that run task-style agent loops now do more of their work locally instead of round-tripping to the server for every step, which should make them faster and more resilient to transient network issues. Methods can also hand off background work with a new waitUntil helper so a response can return before that work finishes.
When a long agent conversation gets compacted to make room for more context, that now shows up as a normal step in the chat instead of a vague loading banner. You can open it to see the generated summary once it's ready.
You can now promote a queued message so it gets pulled into the agent's current turn right away instead of waiting for the turn to finish. The queue panel shows which messages will run immediately versus after the current turn.
If a deploy gets interrupted mid-build (for example by a platform restart), it now automatically retries once instead of getting stuck. You should see fewer deploys that hang in a building state with no way forward.
A scheduled job in your app that keeps failing every run now pauses itself automatically instead of erroring forever in the background.
Fixed an issue where apps with recursive or deeply nested data types could fail to build with a stack overflow. Method compilation and uploads are also more efficient now, after fixing an underlying memory leak in the service that runs your app's backend code.
The deployment build progress view previously could show the wrong step as active, or blame the wrong step for a failure, since methods and interfaces build at the same time. It now correctly shows every step that's actually in progress or failed.
Billing for Gemini image models was keying off a model name that had since changed, so Flash Image ran free and Pro Image undercharged for 4K images, and some usage went unrecorded entirely. Billing now keys off a stable model identifier instead.
Token counting for newer OpenAI models no longer throws when the exact encoding isn't available locally; it falls back to a compatible encoding automatically.
Apps can now ship a real-time voice interface, so callers talk to your app over the phone or in the browser and get spoken answers back, with your app's own methods running as tools mid-conversation. This covers buying and releasing phone numbers, setting a greeting and persona, call transcripts and cost breakdowns, and limits on concurrent sessions.
Searching a data source now supports filtering by metadata, filename, page range, or exact phrase, choosing lexical vs. semantic vs. hybrid mode, limiting results per document, and getting back highlighted match positions for display. A few more file types (tsv, log) can now be added to a data source.
Two new models are available to build with: Kimi K3 and Qwen3.8 27B, both served via DeepInfra.
The Files tab now scans uploaded objects for malware and personal data and shows the results right in the browser: a health ribbon per store, status badges on individual files, and a new file viewer that withholds preview and download for anything flagged.
Uploads also go straight to storage now instead of routing through the API, so large files upload faster.
Messages sent while the agent is still finishing a previous turn are now queued and delivered together as one turn once it's ready, instead of getting lost or handled out of order. Each queued message still shows up as its own chat bubble.
Several new AI models are available for apps to use: Alibaba's Qwen image, video, and speech models, new video models (Kling 3.0 Turbo Pro, HappyHorse 1.1, PixVerse C1, Ray 3.2, Seedance 2.0), a new image model (Krea 2 Turbo, MAI Image 2.5), a lip-sync model, and a video-analysis model that can describe or answer questions about a video.
Claude and GPT models in the catalog now expose more configuration when you build with them: reasoning effort level, built-in tools like web search and code execution, and MCP server connections.
The ElevenLabs text-to-speech model gained a new configuration option when building with it.
Organizations using their own Stability AI key were being billed as if they were using the platform's key. That's fixed: your own key is now used and billed correctly.
Fixed two model configuration bugs: older saved image-to-video and video-to-video setups on the FLUX video model were silently running as text-to-video instead, and the 'Keep Original Sound' toggle on Kling motion-control models was missing in some modes.
Fixed a configuration issue with the Gemini 2.5 Flash and Pro models.
Fixed an issue where a dropped database connection in your app's backend could fail to reconnect properly.
Actions that generate files, like image, video, speech, and PDF generation, can now write their output straight into one of your app's own file stores instead of the shared public CDN. Pass { store: YourStore } as the second argument to keep generated files private, tied to a specific user, or listed alongside the rest of your app's files. It's optional, and leaving it out keeps the old behavior.
Apps can now call several new AI models, including bge-m3 and all-MiniLM-L12-v2 for embeddings, kokoro-82m for speech, and new Qwen embedding, rerank, and text-to-speech models. Voyage embedding and rerank models are also available, and the Gemini, Veo, and Lyria entries have been updated to their latest versions.
Data sources can now pull text out of scanned and image-based documents, not just plain-text PDFs, improving extraction quality for photographed pages and scans.
Video analysis can now handle much larger video files. Large uploads stream through storage instead of loading entirely into memory first, so longer or higher-resolution clips are more likely to succeed.
Querying available AI models now covers more categories, including 3D generation, music, lipsync, embeddings, reranking, and document extraction, and the model suggestions used for multi-step task agents were corrected.
Fixed two bugs in multi-turn chat: switching AI models partway through a conversation could break the session outright, and in some cases the model's internal reasoning text could leak into the visible reply instead of staying hidden. Both are fixed.
Apps can now have their own searchable knowledge base for retrieval-augmented generation. Upload documents, watch them get ingested, and search over them with hybrid (keyword + semantic) retrieval and reranking.
The dashboard has a new Data Sources tab: browse documents and their processing status, run search queries and see why each result matched, and inspect individual chunks alongside the original PDF. You can also manage a data source from the command line, and call it directly from your app's backend code.
See https://vector-databases-demo.madewithremy.com/ for more information
Typing a long answer into a chat form field no longer makes the box keep growing. It now caps at a fixed height and scrolls.
The model picker now shows models in a single, consistent row layout instead of switching between separate grid and list views. Pricing and release-date details render more reliably, and the picker now supports models that take audio input or multiple video/audio inputs.
Fixed a bug where automated browser testing could quietly stop retrying after repeated slowdowns, leaving a session without further automation. It now keeps retrying on a steady interval instead of giving up.
Screenshot capture is also more resilient: slow pages get clearer timeout errors, in-progress captures can't pile up behind an already-slow browser, and internal timeouts are tuned so the actual point of failure is reported instead of a generic error.
Remy now keeps its base knowledge focused on what it needs most often, and pulls in less common actions only when a task calls for them. This keeps Remy sharper and more efficient as it builds and iterates on your app.
Improved how the agent condenses long conversation history. It now keeps the exact wording of the most recent turns alongside the summary, so references like "yes, do that" still resolve correctly after a long conversation gets condensed, and it no longer risks losing context that arrived mid-summarization.
Fixed a bug where the agent would sometimes finish a design task without actually writing out the updated app overview and other project artifacts. Those now get saved reliably at the end of the turn.
Fixed an app startup crash for apps that declare an interface (such as a cron job or webhook) without an associated config file.
Apps can now store and serve files, not just database rows. Define a store, upload user files or generated documents, and get back stable URLs (public or private) plus signed share links that work without a session. Uploads can also go straight from the browser to storage instead of routing through a backend method, so large files don't bottleneck on your app's backend.
Task agents (runTask) can now use your own app's backend methods as tools, alongside built-in actions like search or fetch. A method invoked this way runs with the permissions of whoever started the task, so the agent can read and write your app's data on their behalf.
Fixed a bug where the publish/write plan preview could show outdated or blank content while the agent was still writing it, or stop updating once the message moved into your chat history.
You can now drag app icons in the workspace rail to reorder them, like rearranging a dock.
The API reference in your app's dashboard now links straight to your app's live OpenAPI spec instead of a saved copy, so it always matches what's deployed. Route parameters are also documented more precisely.
Usage summaries for things like web scraping and searching now break down cost by action type, not just request and error counts, for a fuller picture of what an app is spending on.
If you chose annual billing on the pricing page before signing up, that choice now carries through to checkout. Previously it silently reset to monthly.
Fixed an issue where the code editor's live connection to your app's sandbox could get stuck on a stale connecting state after a network hiccup instead of properly reconnecting.
Fixed automated browser checks occasionally failing or hanging right after a page navigation, while the preview browser was still reconnecting behind the scenes.
Fixed the "Build now" button text in the spec editor being hard to read in some themes.
When the same action repeats with the same actor, resource, and outcome, the audit log now collapses those calls into a single entry instead of listing each one separately. The entry shows a repeat count along with the first and last time it happened, so busy logs stay readable without losing any detail.
Fixed a bug in the guided question wizard used in chat setup flows: a late voice transcript could land in the wrong question's answer box and pull focus away from what you were actively typing. Answers now stay attached to the question that produced them, and off-screen questions can no longer grab focus.
Fixed an issue where browser automation could intermittently fail to connect due to incorrect proxy host resolution.
Your analytics charts now mark every deploy along the timeline, so you can line up a change in traffic, errors, or performance with the release that caused it. Hover a marker to trace it through the chart with a dotted guide line.
We also cleaned up the marker styling and fixed a label offset that was shifting the x-axis on some charts.
Web apps can now opt specific routes into prerendering for crawlers and link previews. List route patterns (e.g. /u/*, /blog/*) under prerender in your web config, and bots like Googlebot, ClaudeBot, or the Slack/iMessage unfurler get a fully-rendered snapshot instead of an empty loading shell, so page titles, descriptions, and social preview images show up correctly.
To make this work, a prerendered page needs to set its title/meta tags and then signal readiness by setting data-prerender-ready on the document. Snapshots refresh automatically on every deploy, and you can invalidate one at runtime (for example after a link target changes) by calling prerender.invalidate() from a backend method, or verify what a crawler sees with the new mindstudio-prod prerender get command.
The deployment dashboard also now shows deploy markers directly on your analytics charts, and chart date labels are more accurate for readers outside UTC. The default AI model for task agents moved to Claude 5 Sonnet.
When the agent runs automated browser tests against an app that uses Sign in with Remy for auth, it now mints a delegated test session tied to your own identity instead of needing an email or phone login to seed. Testing against these apps now works out of the box.
Fixed a bug where disabling an AI provider, or switching it to a custom API key, could silently fail to apply to every model under that provider, depending on caching. Custom key changes now test the key against the provider before saving and show you the real error inline if it's rejected, instead of failing silently.
The workspace inventory now shows a running changelog of every deploy across your apps, newest first, with who shipped it and the release message. This gives you one place to see what changed and when across all your apps.
Also fixed several keyboard-shortcut bugs in the app editor: Escape now correctly dismisses plan/tool approval prompts, and send/confirm shortcuts no longer conflict with each other while a plan is up for review.
Adding a custom domain or setting up email sending now gives you three ways to hand off the DNS records to whoever manages your domain: copy them all as a table, get a ready-to-paste prompt for an AI assistant to walk you through it, or download a zone file your DNS provider can import directly.
The Remy agent now has access to the newer GPT-5.6 model family, with reasoning effort automatically tuned to each model's capabilities. This can improve the quality of the code and plans the agent produces for your apps.
Fixed an issue where moving an organization's data to a different region could interrupt people actively working in the app editor, and where a migration that kept failing could retry indefinitely instead of surfacing the problem. Region migrations are now more reliable and less disruptive.
Some actions taken by the Remy agent, like screenshot analysis or image generation, were being incorrectly reported as "run" costs in the app, when they should have been reported as "build" costs.
When developing your app, Remy can now use the mindstudio-prod CLI's new data lift-from-live command to fill your development database with a copy of your app's production data.
Automated QA testing could stall or falsely flag pages as busy after certain network failures, and test scripts using await or returning complex results (like DOM elements or errors) could crash instead of completing.
Both are fixed: network idle detection now resets correctly after failed requests, and evaluated test scripts run and return results reliably.
Scrolling back through a long conversation with the agent now works correctly all the way to the beginning, instead of stopping at the point where the conversation was last archived or trimmed.
Automated testing of preview apps could occasionally fail to launch on certain internal ports. Test launches now automatically avoid those ports, so QA runs reliably every time.
Newly built apps now get sharper, more accurate Open Graph preview images — the card shown when a link is shared in Slack, iMessage, or elsewhere. Instead of an AI-generated illustration, the agent composes a precise card using your app's real logo and fonts and captures it directly, giving a crisper and more on-brand result.
Running low on usage credits mid-session now triggers an automatic top-up before the agent turn fails, so temporary balance gaps no longer interrupt an in-progress build.
Large images shared in agent chat are also resized behind the scenes without ever needing to be made public, so private attachments stay private.
For organizations with existing shared brand and design guidelines, the agent no longer re-asks new apps for basic visual identity. It automatically applies the organization's established look and feel.
Local development sessions now recover automatically from a rare backend hang that previously required restarting your sandbox to keep running your app's methods.
When approving a build plan, you can now pick a different model to execute it than your account default, for example a faster or cheaper option. Chat history shows which model produced each response and flags turns that ran on a build override.
Workspaces can now personalize the launcher: pick from six curated gradient wallpapers, upload your own image, or keep the default time-of-day background, and choose a heading text color that reads well against it. Hover states throughout the launcher were tuned to look good over any background.
Also fixes an occasional double-submit when pressing ⌘Enter in a dialog.
Apps meant to be embedded on a customer's own site can now allow up to 25 specific external origins to iframe them, on top of the built-in launcher access. Manage the allow-list from the app's Settings tab.
A small formatting slip in an app's configuration file, like a trailing comma, no longer crashes its development environment. The platform now repairs minor JSON mistakes automatically instead of failing to start.
Fixed an issue where a busy or momentarily slow app environment could be mistakenly declared unresponsive and restarted, interrupting an in-progress build.
Apps whose databases live outside the default region now get their working data mirrored back to durable storage on a regular hourly cadence, in addition to the checkpoint that already happens on release. This reduces the amount of recent work at risk if a region has an issue, with no action needed on your part.
Watching the agent search and edit your app's code is now much clearer. File search and code search results show up as a real, clickable list of files and matches instead of raw text, and long-running terminal output and diffs auto-scroll as they stream in. A "follow latest" control lets you jump back to what the agent is doing right now.
A push whose app manifest can't be read (for example a missing or broken config file) now shows up clearly as a failed deploy instead of appearing stuck with no build ever starting.
Every deploy of your app now runs an automated Lighthouse audit covering performance, accessibility, best practices, and SEO, plus a check for console errors and failed requests. Scores and a screenshot appear on the deployment and overview pages, and you can pull the full report with mindstudio-prod diagnostics get. You can also now right-click any file in the code or spec editor to download it directly to your machine.
The agent now keeps your app's spec in sync with the code automatically. After making meaningful changes, it hands off to a background Spec Sync agent that updates the relevant spec sections on its own, so you don't have to stop and edit the spec yourself.
The editor now shows a clear prompt when your session expires instead of failing silently, lets you inspect what a delegated sub-agent (like the design or QA specialist) is doing in more detail, and adds a usage ledger view to the app dashboard.
Apps you build can now generate video using the Flux 3 model, in addition to existing video model options, supporting text-to-video, image-to-video, and video continuation.
The app dashboard, workspace launcher, and organization settings screens are now usable on phones, with navigation, search, and list views that adapt to smaller screens instead of overflowing.
Long working sessions with the agent are now compacted more reliably: if a conversation summary can't be produced correctly, the session keeps its full history instead of silently losing context.
Fixed an issue with how file attachments were handled in agent sessions.
Improved the reliability of the per-tenant database backups every app relies on, reducing the risk of a slow instance being incorrectly treated as failed.
Fixed a billing issue that could occasionally grant duplicate credits when adding funds to an organization.
Improved how automated QA detects and tests login and credential flows in your app, catching more issues before they reach users.
A new model, DeepSeek V4 Flash, is now available to power your apps' AI features.
Three new AI models are available for your apps: MiniMax H3 for video generation, Microsoft's MAI Image 2.5 Pro for image generation and editing, and an updated Grok Imagine Video model with resolution-based pricing.
When Remy tests an app it builds for you, it can now switch between desktop and mobile rendering to check both layouts before changes go live, giving more thorough QA coverage for responsive designs.
Backend methods start faster on cold runs, since packages that are already installed and already satisfy the requested version no longer trigger a fresh install.
The Remy agent's internal code search now supports more precise matching, including case-insensitive search and surrounding context lines, so it can find and fix the right code faster while working on your app.
Vision-based AI steps in your apps can now analyze multiple images in a single request instead of being limited to one.
Your app's generated pitch deck is now updated in place rather than rebuilt from scratch each time, so prior customizations are preserved between revisions.
When starting a new app, the agent now waits for you to press Start Building to approve the initial plan instead of trying to guess approval from your chat replies, making the intake flow more predictable.
Capturing a screenshot in the local dev preview now times out instead of hanging indefinitely if a capture or upload stalls.
You can now set a single custom sending domain for your whole organization, so every app sends from your own domain by default instead of configuring it per app. The sending domain settings pages show which domain is actually being used to send email and its verification status, with copy-to-clipboard DNS records to finish setup.
Apps that receive email can now build proper reply threads. Incoming messages carry the original message ID, references, reply-to address, CC list, and date, so an app can reply in-thread instead of starting a new conversation. sendEmail now reports back who the message actually went to and which address it was sent from.
Backend runtime improvements make app sandboxes recover faster and more reliably: stale environments are cleaned up sooner, background jobs like scheduled tasks and email no longer keep unused sandboxes running, and sandbox routing stays accurate under load. This reduces the chance of slow or stuck responses for apps with backend logic.
Apps can now define a small list of test sign-in accounts with a fixed login code, useful for handing app-store reviewers working credentials without needing to receive a real one-time code. Configure them from the app's Settings tab.
Work saved in the live editor and by the agent is now captured within seconds instead of up to a minute, reducing the chance of losing recent changes if a workspace goes idle unexpectedly.
Fixed an issue where the deploy progress indicator could appear stuck even after a deploy actually finished. Progress now reliably reflects the real status.
Fixed onboarding for people invited to an existing organization: they no longer get a stray personal workspace or an unnecessary billing setup screen, and land directly in the organization they were invited to.
You can now reach support directly from your workspace settings or the account menu, send a message, and get a reply by email without leaving the app.
Email previews in the inbox also resize more reliably to fit their content.
Added two new image generation models, Krea and Seedream v5.0 Pro, for apps that generate or edit images.
Fixed a bug that could cause backend method execution to fail to load its code for apps whose data resides outside the default region.
Improved how the platform detects sandboxed preview connections, reducing false disconnects. The reconnect logic now waits for a stable connection before resetting its retry timing, avoiding rapid reconnect loops during brief network hiccups.
Automated QA testing on your apps now navigates pages more quickly, cutting wait time during test runs.
Apps can now send email from your own verified domain instead of only the shared platform address. Add a domain in the new Sending tab, verify it with the provided DNS records, and outgoing mail — including workflow email steps with a custom "from" handle — will send from it once verified.
The Domains tab now shows your scheduled jobs and webhook endpoints in dedicated panels. Cron schedules display in plain language instead of raw cron syntax, alongside next run time and run counts, and webhook endpoints list their URLs with one-click copy and recent delivery activity.
Deploy progress now updates more smoothly and closer to real time while your app builds, instead of jumping only at the start and end.
Fixed an issue where a deploy could occasionally build against newer code on the branch instead of the exact version that was submitted. Deploys now always build the precise commit that was requested.
Deploys that compile many backend methods or a complex web interface are now faster and more reliable. Builds run in isolated sandboxed workers instead of a shared build process, removing the resource contention that could previously cause large-app deploys to slow down or fail.
Fixed an issue where a workspace's autosave history could grow without bound over long sessions, which was starting to cause slowdowns and timeouts when saving changes. Autosave history now resets periodically to keep things fast.
Continued rollout of hardened, VM-isolated sandboxes for running app backend code, including added capacity, monitoring, and fixes that keep sandbox warm pools working so app executions start faster.
Fixed a backend bug that could cause file and asset links to become malformed after repeated processing, and resolved an issue where certain background operations could use stale internal dependencies during database transactions.
You can now choose where your organization's app data and files are stored, with support for US, EU, Canada, and Australia regions. Changing region kicks off a managed data migration, and you'll get email updates on progress and completion.
The workspace settings area has been reorganized with clearer navigation and dedicated pages. New sections let you pick a data residency region for your data, set default AI models per capability, and manage sign-in with Remy for the apps you build. The budgets page was also redesigned for clarity, and several settings links that pointed to the wrong page have been fixed.
Organizations can now set org-wide default AI models per feature, which apply automatically unless a person picks their own. Brand extraction (name, color, typography) no longer silently fails on larger apps, and overly large conversations now show a clear message telling you to start a new one instead of a confusing error.
The editor and AI model settings now surface a live status indicator when an upstream AI provider is degraded or down.
A small dot appears near the top bar and in the models menu; hovering or opening it shows which provider is affected, since when, and a link to its status page, so you know right away when an issue isn't on your end.
The workspace now remembers which app you had open. Refreshing the page brings you back to where you left off instead of dropping you on the home grid.
Fixed an edge case where retrying a card confirmation or a slow activation step could create a second subscription for the same workspace. Checkout now safely resumes instead of double-charging, and if activation takes a moment after payment, you'll see a clear "activating" status instead of being sent back to the subscribe form.
Fixed a bug where a brief network hiccup could crash an app's entire sandboxed backend instead of just that one connection, improving reliability of running app methods.
Fixed a bug where usage and cost accounting could lose track of which person performed a billed action in an app, recording it as unattributed instead. Per-user attribution on usage events is now accurate.
Voice messages sent to the agent now show their transcript with a mic icon instead of appearing blank in the message queue.
Backend methods in your apps, including database queries, now execute faster. Repeated calls reuse a warm connection instead of opening a new one each time, and the platform avoids resending code that a running instance already has, cutting round trips on every invocation.
Fixed a bug where session recordings captured during local app development could get mixed together and fail to play back correctly.
Fixed an issue where running a backend method that logged a lot of output during local development could cause the dev session to hang.
Fixed several backend reliability issues: app icon and diff generation failures are now properly tracked instead of failing silently, run-completed email notifications are more reliable, and a bug in organization service settings capability checks was corrected.
The preview address bar now updates automatically as you navigate inside your running app, instead of only reflecting the page it started on. It also no longer overwrites what you're typing while an in-app navigation update arrives.
Also in this update: the editor's queued-message list wraps long messages cleanly instead of cutting them off, and the preview toolbar was simplified down to a single Publish action.
Cancelling the agent mid-task used to also clear any messages you had queued up behind it. Now cancelling only stops the current task; anything you queued still runs afterward.
App backend methods now run over a persistent connection instead of a new request each time, cutting overhead and improving reliability under load. No changes required on your end.
Person profiles in the team People directory now show an activity history, with clear indicators for whether each action succeeded, was denied, or failed. Role badges on a profile are now clickable for faster role changes. The People list also remembers your filter and sort choices between visits.
Separately, refreshing the live preview while building an app now keeps you on the page you were viewing instead of jumping back to the home screen.
Public share links for API/MCP references and assessment reports can now be embedded on other websites. Their layout also stays readable on more screen sizes instead of collapsing the side navigation too early.
Organization admins can now see everyone across their apps in one place, workspace members and app end-users together, with each person's roles per app, spend and usage over time, and last-active date. A new People/Team page replaces the old member list with a searchable, sortable directory.
Fixed an issue where logging out could leave you signed in after a refresh. Also fixed a bug where opening the editor could sometimes hang indefinitely waiting for your app's environment to start; it now recovers automatically.
Fixed a bug where browsing certain app lists or an app's email inbox could crash the page if you didn't have permission to view one of the items on it.
The audit log pipeline now partitions data by organization and buffers longer before writing, improving reliability and consistency for exported logs. We also completed routine infrastructure upgrades to keep the platform's hosting layer current and efficient, with no action needed on your part.
This release bundles several improvements:
Apps can now use Moonshot AI's Kimi K3 model as an additional AI model option.
Generated security and governance assessments now include an access model section that classifies whether an app's meaningful functionality is public, gated behind login, or a mix of both, with a list of any public entry points. This makes it easier to spot unintended public access when reviewing an app's security posture.
Some apps could hit unexpected storage errors under heavier database and git activity due to an undersized disk allocation. Capacity has been increased to prevent this.
You can now browse every app in your workspace from one screen, each with a generated, plain-language overview you can open directly.
A companion Security view lists each app's latest security and governance assessment, including its risk posture and finding counts, so you can review compliance status across your whole portfolio without opening each app individually.
The Costs tab now has a dedicated Build view with a detailed usage ledger (a breakdown of every step, model call, and its cost) for a selected time range, and the Run view can break spend down by backend method. You can now set a default workspace, and starred workspaces reliably sort to the top of your workspace list. The Analytics tab's sub-tabs are now labeled Users and Agents.
A new Portfolio view lists every app in your workspace, including drafts, with spend and traffic trends shown as a small trend chart on each row. This gives builders and admins one place to see how every app is performing and being used. The live activity feed also now consistently shows which app each event belongs to.
Every app now gets an auto-generated security and compliance attestation (a CSA CAIQ v4.1 questionnaire) grounded in the app's own security assessment. It's viewable and regeneratable from the app's Assessment tab, and can be downloaded or shared.
Admins can also now permanently delete a managed user from an app's Users tab, removing them from both the dashboard and the app's own database.
Fixed an issue where the agent's last activity label from a previous conversation could briefly appear to carry over into a new one.
The audit log is now a full governance feature: every action across your organization is captured, viewable with filters by action and actor, and exportable in OCSF format for ingestion into your SIEM. A new live activity feed on your organization overview shows what's happening across your apps in near real time, including who did what and from where. As part of this work, static assets in the app viewer now load from the edge cache instead of round-tripping to origin on every request, making pages load faster.
Builders can now choose additional AI models for their apps, including Meta's Muse Spark, GLM-5.2, and Kimi K2, alongside improved support for tool use (function calling) on more of the available models.
Workspaces can now turn on an experimental launcher-first home screen, so members land in the app launcher instead of the builder view when they open the workspace. Launched apps now open in place instead of a new tab.
Separately, launching an app via Sign in with Remy from the catalog is now reliable end to end, fixing cases where the launch link would fail to sign the user in.
Long-running conversations with the Remy agent are now automatically kept to a manageable size behind the scenes, preventing the slowdowns and instability that could occur once a session's history grew very large. Full history is preserved; only the working file is trimmed.
Deploys roll out with better gating so a stuck rollout is caught before it affects your app, and apps recover faster when the underlying infrastructure needs to fail over. Builds also compile faster, since app methods now compile in parallel batches instead of one at a time.
You can now create an issue directly from an error or crash shown in your app's dashboard, and the platform automatically triages it: an agent reviews the deploying commit and leaves a receipt showing what it checked, the model used, and the outcome. The error-detail view also now shows which methods are throwing a given error and how often, with a trend chart. Sign-in and checkout redirects were also made more reliable when moving between different parts of the platform.
When Remy edits an app's spec, it now uses the same precise find-and-replace matching as file edits, making spec updates more consistent and reliable.
Organizations can now set a design system reference that the agent consults so new apps stay visually consistent with what they've already built.
App settings gained new controls: automatic triage of incoming issues, telemetry capture of response bodies, and the ability to exclude specific query parameters from analytics.
The app dashboard's deployment detail view was also rebuilt with clearer build timelines and commit diffs, alongside a reorganized navigation layout.
Apps can now be forked into a new, independent app that starts from an existing app's codebase and history.
You now receive an email notification when your app finishes deploying.
Improved reliability of code intelligence (autocomplete, type checking) in the browser development environment, fixing cases where a language-server hiccup could prevent the environment from starting.
The agent now has access to a newer model, Grok 4.5, and its default coding subagents were upgraded to a newer Claude model for better output quality.
Data flow diagrams in the security and governance assessment can now be zoomed, panned, and opened full-screen for easier reading.
Every app now gets an Issues tab for logging bugs and ideas, commenting, and tracking status — including a reportIssue hook you can wire into your own app so your users can report problems directly, with Remy able to pick issues up and fix them. Apps also get an automatically generated assessment report: a plain-language overview of what the app does, its data flows, dependency risks, and security posture, refreshed on every deploy and viewable in the dashboard.
The mindstudio CLI now also accepts mindstudio upload-file <path> (alongside upload) to get a hosted URL for a local file, with clearer built-in guidance on when to use it versus uploading from your app's own code.
Fixed an issue where queued messages you sent to the agent could briefly appear to vanish while the agent was still working or right after a restart. The queue now stays accurate and visible throughout.
QA testing for apps with one-time passcode login flows now handles both single-field and segmented, per-digit code inputs, with retry logic to catch codes that arrive late. This makes automated testing more reliable for apps that use OTP-based authentication.
Apps in My Workspace can now be organized into folders, and published apps that support "Sign in with Remy" can be launched straight from the catalog already signed in.
Also included: password reset now reliably shows an error when a reset link is invalid or expired instead of a false success, and the live-visitor activity chart now displays an evenly spaced timeline instead of a few oversized bars.
Fixed a bug where a person's effective permissions on an app could be computed incorrectly when they had access through more than one path (for example, direct sharing plus an organization role). Permission levels are now resolved consistently.
Fixed an issue where some files in a deployed app (particularly HTML files without a .html extension) could be served with the wrong content type, which could cause them to render incorrectly in the browser.
Apps can now offer "Sign in with Remy" as an authentication option, letting an organization's members sign into an app without a verification code. Add remy to an app's auth methods and offer a "Continue with {Organization}" button; the platform resolves who the user is and the app just reads the result. Organizations can also require delegated sign-in only, blocking email/SMS codes for their apps. This works both in production and inside the live preview used while building an app.
Fixed an issue where closing certain dialogs could leave the page unresponsive to clicks or scrolling.
Apps with an MCP interface now generate a downloadable SKILL.md file describing their tools and how to use them, so other AI agents can quickly learn to work with your app. You can download it or copy a direct link from the MCP reference page.
You can now transfer an app to a different workspace you belong to, right from the app's dashboard menu. A confirmation step prevents accidental transfers, and the move is recorded in your audit log.
The specialist agents that build and refine your app (roadmap, QA, architecture review, copy editing, and more) now run on a newer Claude model by default, improving the quality of their output.
When Remy proposes text changes in your app, it now explains why before showing the change, then applies a full rewrite or a targeted edit depending on what fits best.
Error messages for credit or budget limits are now detected more reliably and shown with clearer guidance instead of a generic error. Sharing an app preview (via link or QR code) now correctly points to the exact page you were viewing instead of the app's root.
Remy now has a dedicated Copy Agent that reviews and sharpens the text your app shows to users — button labels, empty states, your Build Overview, pitch deck copy, and launch posts — making it read clearly and naturally without changing any facts. You can watch it work in the build activity panel, and the Build Overview page now updates instantly whenever its content is rewritten.
The Email tab on an app's Domains page has a cleaner layout: the inbox now scrolls within its own panel instead of the whole page, message rows show sender avatars and names, and hovering domain or inbox rows uses a lighter, more subtle highlight.
If your app's backend method deliberately throws an error with a specific HTTP status (like a 404 or 400), the API now returns that exact status and error code instead of always falling back to a generic server error. Unexpected failures still return a plain 500 as before.
Fixed an issue where an app could get stuck on a hidden preview after its workspace restarted, requiring a manual step to continue. Onboarding now finishes automatically in that case.
The dashboard now includes an email inbox for apps that receive mail, showing sender, subject, and a preview snippet for each message, with full detail one click away.
API and MCP reference pages can now be shared publicly via a link, separate from the dashboard, so teammates or partners can browse an app's endpoints without dashboard access. Inline code in chat and docs also reads more cleanly, and code blocks on light backgrounds display their copy button with better contrast.
Apps now get a built-in, interactive API reference in the dashboard: browse every endpoint with its parameters, request body, and responses, and copy ready-to-run request snippets.
Fixed an issue where fetching a Google Doc stored in a shared drive would fail. Google Docs integrations now work regardless of which drive the document lives in.
You can now send another message to the agent while it is still working on your current request instead of waiting or having it rejected. Messages queue up and run in order, and you can cancel a queued message before it starts. The roadmap view inside the app editor also got a visual refresh with clearer lanes for planned work.
When Remy finishes building your app for the first time, you now get an email letting you know it's ready, with a link straight into the app.
You can now change your display name from account settings. The change email and change password forms also got clearer field labels and a cleaner layout.
The app dashboard now has a dedicated Build Overview tab alongside Pitch Deck and Roadmap. All three now reflect exactly what's currently live, since they're generated and locked in at deploy time instead of being read live off your latest code, and each one can be shared as a public link with one click.
Restoring a paused development environment is now faster. It no longer pulls unnecessary history, and the first save after a restore only uploads what actually changed instead of the whole project.
You can now switch the AI model used for an app's chat mid-conversation, with the change taking effect on your next message instead of starting a new chat and losing your history.
The usage and cost dashboard now opens grouped by model by default instead of by app.
Fixed an issue where a requested image format could be silently overridden during image processing steps like face swap, background removal, and upscaling.
Fixed an issue where selecting text in a voice message transcript would accidentally collapse it.
The agent's deployment plan now renders as a formatted document you can review directly in the builder, instead of a plain status line, and it's easier to tell which specialist agent (design, pitch deck, roadmap, etc.) is working at a glance thanks to distinct icons and colors. Team invite permissions also now correctly reflect any special account adjustments made for your organization.
Session replays from automated browser testing are now smoother and more reliable. Instead of separate, sometimes-missing clips for each action, the QA agent's test run is captured as one continuous recording that you can scrub through, with no flashing or gaps between steps when reviewing what the agent did.
Image-analysis steps in your apps now work with more image formats, including SVG and other formats models can't read directly. Remy automatically converts them before analysis so these steps no longer fail on unsupported image types.
Hardened backend infrastructure access controls, reducing the paths through which internal systems could reach node credentials or shared images. No action needed; this is an internal security improvement with no visible change to how you build or run apps.
You can now generate a shareable public link for a pitch deck, screenshot, or recording instead of sending a file. Analytics tables (top pages, sources, UTM sources, map view, custom events) can load additional pages of results instead of stopping at a fixed limit. When adding a plan or topping up your balance, you can reuse a saved card instead of entering your card details again.
Fixed image generation so Flux-based models correctly support image-to-image edits and image prompts, in addition to text-to-image.
Organizations can now subscribe to a plan and manage their payment method directly in-app, without being redirected to an external checkout page.
We also fixed an issue where coupon codes could apply to the wrong plan during checkout.
Alibaba Cloud is now available as an AI model provider, including its Wan family of image and video generation models, giving builders more model options to power their apps.
You can now drop notes directly on the live preview to flag issues or leave feedback for the agent, and typing in a note no longer accidentally triggers the app's own keyboard shortcuts.
Improved how the agent keeps track of long conversations. When history gets compacted, the agent now retains the decisions and work that matter and drops mechanical noise, so it stays on track over long-running projects without losing context.
Fixed a bug where local model connection status could show stale or incorrect information after switching between organizations.
Fixed a timing issue where the agent's automated testing could capture a screenshot before the page finished scrolling into position. Scrolling and capturing now happen together, so QA screenshots reliably show the intended part of the page.
A new AI model, Claude Fable 5, is now available for apps to use, including as a recommended option for background task execution. It supports adaptive reasoning with adjustable effort levels.
When Remy checks its own visual work while building an app, it can now capture just the visible portion of the screen instead of always rendering the full page. This speeds up routine visual verification during iteration.
Apps built on the platform can now select Grok Build 0.1 as an AI model option, alongside the existing Anthropic, Google, and OpenAI models.
Webhook endpoints in your app now run synchronously and return the method's output directly to the caller, and the method receives the exact raw request body so you can verify signatures from providers like Stripe, GitHub, Shopify, or Slack. Webhook URLs are now shown in the app dashboard in the cleaner https://your-app-host/_/webhook/{secret} form, and secrets stay stable across deploys so a URL you register once keeps working.
Fixed Google Calendar integrations that were failing to read calendar data due to missing permission scopes. Calendar-related actions in your app should now authorize correctly.
Builders can now inspect frontend crashes and traffic analytics for their production app directly through the same production management tooling the agent uses — grouped browser error reports with drill-down into individual occurrences, plus traffic breakdowns by page, referrer, country, device, and browser. Previously only server-side request logs were available this way.
App analytics now show when AI crawlers (like GPTBot or PerplexityBot) visit your app, broken down by vendor and page, plus which AI assistants are sending you human referral traffic. Live-visitor presence tracking was also made more reliable under load.
Apps can now generate images with LumaLabs' Uni 1.1 model, including support for reference and edit images.
When previewing an app during development, sign-in with a test account now autofills and submits automatically, so you can get straight to testing without typing credentials each time.
Apps can now receive inbound email at a custom domain instead of only the platform's default subdomain. Add your domain in the dashboard's email settings, point a single MX record at it, and any address on that domain routes to your app's email handler.
You can also restrict who is allowed to send to it with an approvedSenders list, and inbound messages are capped at 25 MB.
Improved the accuracy of visitor location data (country, city, coordinates) shown in app analytics, particularly for apps served on a custom domain.
Fixed an issue where apps on a custom domain with a www alias could send API requests to the wrong host after a redirect, which could break app functionality on the www version of the domain. Both the primary domain and its www alias now route correctly.
Stopping the agent mid-task is now handled more reliably: when you cancel an action, the agent waits for your next instruction instead of sometimes retrying the cancelled step on its own.
Apps built on the platform are now hosted under the madewithremy.com domain by default, including preview URLs and webhook endpoints. Documentation and CLI help text have been updated to match.
Separately, the design guidance the agent follows when building your app's interface has been tightened: backgrounds no longer imitate physical materials like paper or texture, and sans-serif typefaces are the default choice, with serif fonts reserved for cases that genuinely call for them.
The frontend SDK now supports streaming structured progress updates from your backend methods, not just text output. Pass onStreamData alongside stream: true to receive status, progress, or intermediate results as they happen, in addition to the existing token-by-token text streaming.
Fixed a bug in usage analytics where filtering by anonymous or public users could return incorrect or missing results. Anonymous usage now filters correctly across both the summary and detailed breakdown views.
You can now add, verify, and manage a fully custom domain for your app, not just a platform subdomain. Webhooks and other endpoints work correctly on whichever domain you choose.
Gemini 3.5 Flash is now available as a model option for your app.
Fixed an issue where certain AI models could fail with an error when your app wasn't using reasoning mode.
Apps can now be served on a custom domain that you own, in addition to the default subdomain. Point a CNAME at Remy and certificate provisioning and routing are handled automatically.
You can now choose which AI model powers different parts of your app's build agent (the main assistant vs. specialist helpers like the design or QA agent), and that choice now persists across sessions. The interface shows which model actually handled a given response, and you'll get a clear error if you pick a model that isn't supported.
The background removal step now supports an advanced quality tier for higher-fidelity results on images, in addition to the existing standard option. Usage of the advanced tier is metered like other AI-powered steps.
Apps can now generate 3D models directly from a text prompt or an image, in addition to text, image, and video generation. Generated 3D assets show up alongside other generated files with previews and titles.
Every app now gets automatic error reporting and visitor analytics built in, no setup required.
analytics.track('event_name', { ...props }).This is designed to be cookie-banner-free: no fingerprinting, no third-party scripts, and geo data is limited to country level.
The browser IDE now supports searching across your whole app's codebase and applying find-and-replace edits across multiple files at once, with results streaming in as they're found. File edits are now safely serialized so simultaneous changes to the same file can no longer clobber each other.
You can now download a raw database snapshot for any app release directly from the dashboard. Also fixed an issue where a release's databases sometimes failed to appear while a build was still promoting, and corrected unique-user counts on the usage analytics dashboard, which had been inflated when users were active across multiple time periods.
You can now push much larger changes to your app's git repository without hitting a size limit.
Improved reliability of database access during platform deploys and maintenance. Requests that previously could fail while a database's connection moved between servers now recover automatically, reducing transient errors for apps under active use.
Signups now reject known disposable and throwaway email domains at the verification step, cutting down on burner accounts and abuse.
Separately, app builds that get stuck are now automatically detected and marked as failed within minutes instead of hanging indefinitely.
Fixed a bug where certain AI responses using extended reasoning could cause a conversation to error out and stop responding. Conversations that trigger this reasoning mode now continue reliably.
Every app now tracks its own AI usage: model, tokens, and cost for each call, alongside your other billing events.
This feeds directly into the per-method usage-and-cost accounting you already see for your app, so you can see exactly what each app's AI activity costs, not just totals across your organization.
Apps that receive email can restrict who's allowed to send to them using email.approvedSenders, with exact addresses or a *@domain.com wildcard; anything else is rejected before it reaches your app. Incoming messages are handed to your app with to, from, subject, message, and html fields, with any attachments delivered as ready-to-use file URLs rather than raw uploads.
Added support for the Grok 4.3 model, including for image/vision requests. Usage-based billing now correctly distinguishes standard and high-context token pricing for this model.
Fixed an issue where image size settings were not being applied correctly for Gemini 3.1 Flash image generation, which could cause incorrect billing and output.
Fixed a bug where pasting certain text (for example from Apple Notes) into agent chat could corrupt the conversation history, and fixed cases where scrolling back through a long conversation could show incomplete or missing messages, especially in larger projects.
Fixed a bug where terminal and process logs could stop showing up in your dev environment after restoring a previous version of your app.
When the agent runs an automated browser test, the final screenshot it captured now appears directly in the chat response instead of being buried in raw data.
Fixed a bug where some automated agent messages could be hidden from the conversation when they should have been visible.
The agent can now share clickable links in chat that jump your live preview straight to a specific page, instead of only describing where to go.
Long conversations with the agent now compact themselves automatically as they approach the model's context limit, so very long build sessions keep working instead of failing once the conversation gets too big.
Canceling a build in progress no longer leaves the editor stuck showing "Building…" — canceling now returns you to the editor immediately.
Fixed an issue where some uploaded images would fail to load or render as a broken error image when their file extension didn't match their actual format. These now fall back to serving the original file so the image still displays.
Reconnecting or refreshing an existing third-party service connection no longer resets its access permissions back to the default. Custom access settings you've configured are now preserved.
Remy now steers even further away from generic AI-generated looks, avoiding both the overused purple gradient style and the cream-and-terracotta editorial look, so generated apps look more distinct out of the box.
Automated browser testing and screenshots are now clearer about only checking settled screen states rather than mid-animation frames, and generated project plans no longer end with unnecessary sign-off lines.
Navigating within an app's live preview could drop it out of preview mode, causing queued actions to stall and time out. Preview mode now persists across page navigations, so testing multi-page apps in the browser works reliably.
Fixed a bug where uploaded file references could leak into displayed chat history after restoring a session. Also fixed rare cases where pasted text containing special line-break characters could corrupt in-progress agent commands, which could make the editor appear stuck; the agent can now also recover automatically when this happens.
The agent now always builds custom-styled dialogs, confirmations, and notifications for your app instead of falling back to plain browser popups. It also won't guess at how long or how much a task will cost to build within the platform, though it can still help you understand the scope of a request in traditional engineering terms.
When an AI response gets blocked by content moderation, you now get a clear explanation instead of a raw error, along with a tip that rephrasing your request usually fixes it.
Fixed an issue where some backend methods could intermittently fail to run due to missing dependencies after a deploy. Methods now reliably have access to everything the app declares.
The builder now automatically picks up your app's brand — name, tagline, logo, colors, and fonts — from its spec and applies it to the plan and status documents you see while building, so they read like your app instead of a generic template. This updates automatically as you edit your spec.
Fixed a bug where the agent could fail mid-conversation with an error when its internal reasoning was interleaved between two separate replies.