FixAug 17
Studio keeps working when the cloud does not
A problem on Pathrule's side used to stop Studio rather than slow it down. The app could sit on its opening screen with no way past it, or drop you on the sign-in screen while your session was perfectly valid, or show the waitlist screen to an account that had been admitted for months. All three were the same mistake: treating a request that never came back as an answer. Every request to Pathrule now carries a deadline, and only a real answer from the server can sign you out or turn you away. Studio opens with the account you last used, your organizations and workspaces are listed from the copy kept on your own machine, and the account menu tells you whether your work is backed up. When it is not, Connection status names the reason, so a network you lost reads differently from a service that is down. Agents get the truth too: a coding session is no longer told your Pathrule session expired when the real answer is that Pathrule could not be reached. Writing while you are offline now works as well. Save a memory, a rule or a skill with the connection down and it is written to your own machine and queued, so your agent can read back what it just wrote instead of writing it again. The queue is a file, not a browser tab: it survives closing Studio, and it belongs to your machine rather than to any one window, so writes your agent makes while Studio is shut are delivered on the next launch. When the connection returns everything replays in an order that respects what you actually did, deletions first, so a session where you removed some notes and added others is not measured against a count you already reduced. Nothing is discarded on your behalf. The only case that needs you is a plan that has filled up: those writes stay readable on this machine and wait for your decision, with the room left on your plan stated next to them, and deleting them is the one thing only you can do.
ShipAug 13
Grok 4.6 arrives, and 4.5 stays
Grok Build now serves two models in Studio instead of one. A new Grok conversation opens on 4.6, the model the CLI itself defaults to, and 4.5 remains one pick away in the model menu for anything you would rather keep on it. Both read a 500K context window, so the usage ring and the point at which Studio folds a long conversation are correct for each of them rather than borrowing a number from another engine. Auto ranks 4.6 above 4.5 at the same cost, orchestrated runs and the council pick it as the Grok flagship, and the readiness check Studio runs before your first turn now smoke tests the model you are actually about to use.
FixAug 13
Fable 5 runs on your Claude plan
Picking Claude Fable 5 used to hold your message and ask for an Anthropic API key, even when your subscription already covered it. Anthropic includes Fable 5 on every paid plan through the sign-in you already have, so that gate was refusing turns your account could run. It is gone. Fable 5 sends like any other model, and the model menu states the plan terms in one line instead: on Max it sits inside your weekly limits, on Pro and standard Team seats it spends usage credits. Signing in to an engine works exactly as before, an API key included where you prefer one. A model your plan does not cover now says so in the engine's own words at the moment it runs, rather than being refused in advance by a rule Studio guessed.
FixAug 13
iOS apps run through your framework's own CLI
Studio used to build every iOS target with Xcode's build tool directly, which is right for a plain Xcode app and wrong for a project that ships its own CLI. Expo and React Native projects now run through that CLI, so the environment files your app config depends on are loaded, native folders are generated when they are missing, and pods are synced before the build starts. Projects using Expo's default native generation could not run at all before this and now do. A project whose entry point is its own script can use the embedded simulator too. Studio still owns the device: it boots the simulator, attaches the log stream, then hands the app to the run command. Plain Xcode and Flutter projects keep the paths that already suited them. A target that lives deeper in a monorepo is no longer refused as an unregistered workspace.
FixAug 13
Install a marketplace plugin from anywhere in the catalog
The plus button on a catalog row set everything up and then showed you nothing, so installing a plugin worked from its own page and nowhere else. There is one dialog now, and it opens wherever you press it. Vendor sign-in reaches more of the catalog too: an authorization server may publish its details at either of two legal addresses, and Studio only asked for one, so vendors that answer at the other looked broken. Both are tried now, and the vendors that use the opposite form still work.
ShipAug 12
Run several agents on one repository at once
Turn on the isolated branch chip in the composer and that conversation gets its own branch and its own checkout of the repository. The agent edits, installs and tests in there, so your working copy is never checked out, never stashed and never touched, and five agents can work the same project at the same time without overwriting each other. Arming the chip cuts the branch and starts preparing dependencies while you are still typing, so your first message waits for nothing, and the branch is named in English from that message, in the convention your repo already uses. A fresh checkout has no installed dependencies and none of your ignored files, so Studio reads your lockfile, tells you the exact command it would run and the files it would copy, and runs it only after you allow it once or for good. What makes this more than a git command: your memories, rules and skills reach an isolated checkout exactly as they reach the main one, so a parallel agent is not a context-blind one. Isolation is opt-in per conversation, the default stays the main checkout, and a single task card can be run the same way. See isolated branches.
ShipAug 12
Land an agent's branch without leaving Studio
An isolated agent is only useful if its work can come home. Source Control now switches between your checkouts, so the file list, the per-file diff, staging, commit and push all operate on the one you picked, and a landing bar takes the branch the rest of the way: merge it as a squash, a fast-forward or a merge commit, or open a pull request with the title and body the agent drafted and you edited. Studio runs git and the GitHub CLI itself, never the model, so a conflict stops and names the files it stopped on while your working copy is left exactly as it was, and a missing or unauthenticated CLI says so instead of quietly asking an agent to improvise. Nothing lands on its own. After a merge, Studio asks whether to remove the checkout and tells you how much disk it is holding, and closing a conversation leaves its branch and checkout alone until you say otherwise. See isolated branches.
UXAug 12
One set of permission rules for every engine
Permission requests used to be written by whichever engine raised them, so the same question was worded differently depending on what you were running, and the choices you made in settings only reached some of them. Every gate now travels as plain data and Studio writes the words, so a confirmation reads the same whoever asked, in your language, and one set of rules covers all of them. A request your rules already answer is settled without interrupting you, and anything they do not cover still asks. Running shell commands defaults to automatic now, because asking on every single step only taught people to click through the cards without reading them. Answering a request no longer drops a bare "Yes" into the transcript while your real replies stay where they belong. And when a coding engine's sign-in has expired, Studio signs it out and back in from inside the app instead of sending you to a terminal.
UXAug 12
Move a queued prompt to the front
Anything you type while a turn is still running waits in a queue, and now you can jump one to the head of it: the queued prompt runs immediately and the turn in flight is cut short. Stopping a turn behaves the way you would expect too. It delivers the next queued prompt rather than pushing the queue back into the composer for you to send again. The queue strip owns the space above the composer while there is something waiting, and the engine badge comes back once it drains. The suggestion for your next turn also stays on the caret's own line now, instead of drifting down an empty draft along with its Tab hint.
FixAug 12
Chat rows say what they actually did
Three rows that rendered perfectly well and told you nothing. File edits from some engines never opened, so a change you could not inspect looked like a change that never happened. Every edited file now gets its own row with its own diff preview. When one change touched two files, the two rows could show each other's diff. A finished step now settles against the file it belongs to. And web steps name their target: a search or a page fetch reads as the query or the address it ran, both while it works and after it finishes, so the research panel stops being four identical lines, with the full text available on the row itself rather than only under a mouse pointer.
UXAug 12
Drag a layer back into an auto layout
Moving a layer freely on the design canvas used to be a one-way trip: releasing it over an auto layout pinned it on top of the flow instead of joining it. Now the container under your pointer is resolved as you drag, an insertion line shows the exact slot the release would take, and the sizing that the absolute pin overwrote is restored when the layer rejoins. Holding space still bypasses adoption, as it does for frames. The Layers panel also reads an auto layout the way the canvas does, top to bottom in layout order rather than front to back, and follows reversed rows and columns.
UXAug 12
Edit a vector point from the Inspector
Point editing has moved off the floating canvas bar that kept growing wider than the artwork it was editing. Handle mirroring, bend and delete are properties of the point you have focused, so they now sit in the Inspector's vector section while the overlay keeps the artwork handles and the Done control. A vector layer that is merely selected shows its normal fill and stroke rows again. Two shapes that refused to open in vector editing, or drifted once open, behave now: a vector transferred in from elsewhere can be edited, and resizing one re-emits its path instead of stretching an authored corner radius.
FixAug 12
A paused motion frame no longer ends up in your design
Scrubbing a timeline paints the frame you are looking at onto the live document, so an edit made while the motion dock was open could store a mid-entrance frame as the layer's resting state, and a PNG export rastered a half-faded element. That paint is a loan now: it is suspended before anything is saved or exported and handed back afterwards, so what you keep is the design and not the frame you paused on. Motion coming in from an agent also stopped losing channels. Per-axis scale, 3D rotation, skew, percentage movement and perspective are accepted the way they are advertised, and one mistyped target no longer throws away the other correct animations in the same request.
UXAug 12
Fold the side panels away with one shortcut
Cmd+Shift+. hides the left rail and the Inspector on the design canvas so the artwork has the whole window, and pressing it again restores the same layout. It is a real menu item while Design is active, and it was built to fire on the key that actually produces a full stop, so it works on non-US keyboard layouts instead of only on the one it was written on.
ShipAug 11
The biggest Pathrule update so far
Every surface moves at once: Studio on the desktop, the browser app, the hosted MCP endpoint, the CLI, the VS Code extension and the iPhone app. Most of it is not new surface area. It is 118 fixes and 18 performance changes across chat, tasks, engines, multi-window behaviour and shutdown, plus a security pass that confines every file and workspace action to the folders you actually opened. On top of that, the parts of the product that were promising are now finished: tasks arrive with their context already prepared, designs become clickable prototypes you can verify against the running app, and completed work feeds back into the workspace instead of evaporating. Everything below shipped in this release.
ShipAug 11
Dictate, search and schedule from your phone
The iPhone app catches up with the desk. Dictate a prompt instead of typing it, with transcription handled for you and an on-device fallback when you are offline. Search across your conversations to reach the thread where something was decided, and use the new navigator to jump to a turn instead of scrolling for it. Scheduled tasks are now yours to review, reschedule or pause from the phone, a run in flight shows its live status and why it stopped, and a task card carries its own discussion so the context behind it travels with it.
ShipAug 11
Split Studio into as many conversations as you need
Chat in Pathrule Studio now works like a real workbench. Open conversations as tabs, drag them into side by side panes, group them, and pull one out into its own window when you want it on a second display. The layout you build is remembered, so an arrangement survives a restart instead of collapsing back to a single column. Tabs, splits and detached windows share the same native motion, and each pane keeps its own scroll position and state so switching between two long threads does not lose your place in either.
ShipAug 11
Studio tells you when work finishes
Every run, task and long operation now reports into one place. Active work appears as jobs in the activity bar, with a clear signal when something needs your answer and a notification when a background job completes while you are looking elsewhere. You no longer have to keep a conversation open to know whether a run finished, or walk through your workspaces to find the one agent that is blocked on a question.
ShipAug 11
Run several devices at once, and preview the web build in place
The device stage in Studio is no longer a single simulator. Launch your app on several devices at the same time and interact with each of them, across iOS and Android as well as your native targets, with the running app sitting next to the conversation that is changing it. Web projects get a live preview in the same rail, so a browser build and a phone build can sit side by side. The active agent shares those same sessions, so asking it to check a screen means it drives the real thing instead of guessing from your description.
ShipAug 11
Tasks arrive with their context already prepared
Pathrule now assembles a task's context before the work starts rather than while you wait. By the time a card is ready to run, the memories, rules, skills and related paths it needs have been gathered and checked, and the task opens with a receipt showing exactly what was delivered and what was missing. Preparation is bounded and deterministic, so it cannot quietly consume your allowance in the background, and the autonomous activity is visible and capped from one place.
ShipAug 11
One place for every agent that is working
Studio projects all autonomous activity into a single command center. See which agents are running, in which workspace, on which task, and what each one is currently doing, without opening every conversation to find out. Work an agent started on its own is labelled as such, so you can always tell the difference between what you asked for and what Pathrule did in the background.
ShipAug 11
Finished tasks teach your workspace
When a task completes, Pathrule closes the loop instead of dropping the result. What the work touched, what it settled, and which knowledge actually helped are folded back into the workspace, so the next task on a related path starts from what the last one learned. The loop is deterministic: it records what happened rather than inventing a summary, and anything it proposes is yours to accept or reject.
ShipAug 11
Wire your designs into a clickable prototype
The Design surface now does prototyping. Draw connections between frames with a connect tool, choose the gesture that triggers each one, and pick how the next screen arrives, including overlays, hover states, back navigation and timed transitions. Prototype mode is its own mode on its own canvas layer, so wiring a flow never disturbs the design underneath. Preview plays the whole graph inside a device shell, and the flow travels with the design when you export it, so whoever opens the file gets a working prototype rather than a pile of screens.
ShipAug 11
Your prototype doubles as a UI test
A wired prototype is a description of how your product should behave, so Pathrule can now run it as one. Point the flow at your running app and every connection becomes a step to execute and check: the gesture is performed, the expected screen is asserted, and anything that does not match is reported against the layer that defined it. A flow you drew to explain a design becomes the test that proves the implementation followed it.
ShipAug 11
Check a design against the app you are actually running
Design verification no longer stops at the browser. Compare a design against your running app on web, iOS and Android, using the app's own element tree as the reference instead of a screenshot, and get findings that name the layer and the axis that drifted. It now compares appearance and not only geometry, so a wrong colour, weight or corner radius is caught the same way a misplaced box is. Each screen also reports how much of it is built from your design system, which is where literal values tend to show up.
ShipAug 11
Design handoff points your agent at the right files
Handing a design to an agent used to mean handing over its markup. It now hands over intent: the paths in your project the screen belongs to, the platform it resolved to, and the design's structure and tokens. The agent writes SwiftUI, Compose or your own components instead of translating stored HTML into whatever it can, and a screen built this way binds your token variables rather than baking in literal values.
ShipAug 11
Two-way Figma sync you can rely on
The Figma workflow is production ready. Bring frames, libraries and components in, push changes back out, and get a receipt for every transfer that says what moved and what did not. Conflicts stay open for you to resolve instead of being silently overwritten, a failed transfer closes cleanly rather than leaving a half finished run behind, and link details survive round trips so a frame stays connected to its source. Large libraries import as a plan you can review before anything is written.
ShipAug 11
A shared design link now plays as a prototype
Designs you share from Studio open as a real prototype in the browser rather than a flat frame. Whoever has the link can walk the flow you wired, trigger the gestures, follow overlays and go back, on any device, with no account and no install. The viewer stays a static document by design: content arrives encrypted, is decrypted in the recipient's browser, and the page runs no scripts that came from the design itself.
ShipAug 11
Dictate your prompt
You can now speak to Pathrule Studio instead of typing. Dictation transcribes in the cloud for accuracy and falls back to your Mac's own on device engine when you are offline or past your allowance, so the button keeps working either way. This replaces the speech model Studio used to download on first use, so a few hundred megabytes come back on existing installs. The allowance is pooled across your organization rather than capped per person, which means a team's minutes go to whoever is actually dictating, and a transcription that fails is never counted against you.
ShipAug 11
Pathrule keeps your knowledge fresh, and shows its work
Knowledge maintenance is a proper surface now rather than a list of loose suggestions. Pathrule groups related problems in your memories and rules into cases, proposes a concrete change for each one, and applies only what you approve, with the original always recoverable. Nothing is applied silently. Each proposal explains what it noticed and which paths it affects, so you can clear a batch of small corrections in one pass instead of rereading every memory yourself.
ToolsAug 11
A plugin marketplace inside Studio
Studio has its own marketplace for the services your product depends on. Browse the available integrations, see what each one needs before you commit to it, and wire it in from inside the app instead of following a setup guide in another tab. This release adds RevenueCat to the catalog alongside the existing vendors.
ToolsAug 11
The CLI and the VS Code extension move with the app
Both ship alongside this release. The CLI stays a single binary that serves the account based edition and the no account local edition, and the extension carries the same tool surface the desktop app does, so a workspace behaves the same whether you reach it from your editor, your terminal or Studio. The design and task tools added in this release are available in all three. See install the CLI and the VS Code surface.
UXAug 11
Pathrule no longer takes over your instruction files
Opening an existing project used to mean Pathrule rewriting the agent instruction files it found. It does not any more. Your CLAUDE.md, AGENTS.md and rule files stay yours: Pathrule writes into a clearly bounded region of its own and leaves everything around it untouched, and it can restore that region if it is edited or removed by hand. It also measures what it actually delivered into a turn, so the value it claims is something you can check rather than take on faith.
UXAug 11
A calmer first run
First run was tightened up throughout. The review step stays visible while you work through it and exits cleanly when you are done, plan differences are presented as a short comparison instead of a wall of features, and skipping is an easy target rather than a hunt for a small link. First run is versioned now, so a returning user is not shown a tour they already completed, and a new one is not shown copy from an older release.
UXAug 11
Find your place in a long conversation
Long threads get a navigator alongside the transcript. Markers show where each turn, plan, tool boundary and answer sits, so you can jump back to the point where something changed instead of scrolling for it, and hovering a marker previews what is there. Search now covers your conversations as well, so finding the thread where a decision was made no longer means opening them one at a time.
UXAug 11
Answer or cancel straight from the notch
The notch companion can do more than tell you an agent is waiting. Answer the question inline as before, or cancel the prompt outright when a run has gone somewhere you did not intend, without opening the window it belongs to. Conversation titles no longer trail off mid word, so a glance is enough to tell which thread is asking.
PerfAug 11
Long conversations and big boards stay fast
A broad performance pass over the surfaces that grow with use. Transcripts render only the blocks you can see and stop re-reading the whole conversation on every incoming character, so a thread with thousands of messages types as smoothly as a fresh one. Boards project their columns in a single pass and cache large lanes, hidden surfaces stop rendering entirely while you are not looking at them, and the app no longer pays a scaling cost on every frame. Menus, conversation previews and startup checks were trimmed the same way.
FixAug 11
Several Studio windows behave like one app
Running Studio in more than one window is consistent now. Signing in, signing out and session refreshes reach every window rather than only the one you used, update prompts and download progress appear once and in the right place, and a scheduled task claims its slot so two windows can never run the same one twice. Actions you queue belong to the window you queued them in, and closing a workspace no longer leaves a stale pointer behind.
FixAug 11
A turn that goes wrong no longer leaves the chat stuck
A wide reliability pass across live conversations. A prompt sent while a turn is still running is confirmed as queued instead of assumed delivered, a stream that fails settles into a clear failed state you can retry, and cancelling a turn actually ends it rather than leaving events arriving afterwards. History across tool boundaries survives a recovery, sign-in challenges stay cancellable while they wait, and remote turns settle in order so two devices cannot disagree about what happened.
FixAug 11
Task runs land where they should
Task runs were hardened end to end. A run started by an agent keeps the placement it was given instead of drifting to another column, a run that has already finished cannot be settled a second time, and a failed optimistic move rolls back only the card it touched. Scheduler runs no longer linger without an owner when the window that started them goes away, source snapshots taken on one device stop overwriting another's, and changes stranded in a worktree are reconciled rather than lost.
FixAug 11
An engine that stalls no longer takes the conversation with it
Every coding engine Studio talks to now has a bound on how long it may take to start, answer a control request or finish a handshake, and a startup that fails is rolled back so a retry begins clean instead of on top of a half started process. A stalled local server is recovered rather than leaving the chat waiting indefinitely, an interrupted sign-in replay settles instead of repeating, and one misbehaving listener can no longer break the others. Rotated sessions are merged and stored credentials are held under a lock, so two windows refreshing at the same moment cannot sign you out.
FixAug 11
Quitting Studio really stops everything
Closing Pathrule shuts down cleanly. Runs in flight are terminated instead of being left to finish against a closing app, processes Studio started are stopped with it, and native helpers are released before exit rather than lingering. Termination is bounded, so a process that refuses to go does not hold the quit open forever, and recovery work stops once the surface that owned it is gone.
FixAug 11
Sharper recall of the knowledge that matters
A round of correctness work on the retrieval side means the context Pathrule delivers is closer to what you would have chosen yourself. Path scoped lookups return the right node when several could match, related work from earlier sessions is ranked by how much it genuinely overlaps rather than by how recent it is, and clustering no longer lets one large group pull unrelated paths toward it. Suggestions and semantic matches were corrected too, so fewer near misses reach the top of the list. See how retrieval works.
FixAug 11
Connecting from a cloud client stops re-asking for consent
Using Pathrule from a hosted client no longer reopens the authorization page every time the connection restarts. The approval you already gave is reused, so a cloud agent picks your workspace back up instead of parking on a consent screen. See MCP overview.
SecurityAug 11
Tighter boundaries around your files and credentials
A security pass ran across everything that reaches your machine. File, workspace and project actions are confined to the folders you have actually opened, and a request naming a path outside them is refused rather than trusted. Credentials for your connected servers stay inside the app's protected core and are never handed out to the interface layer. Shared designs render as static documents with any scripts in the content removed, and decrypted content is size bounded so a malformed share cannot exhaust the viewer. None of this changes what you can do. It changes what a malformed or hostile input is able to ask for.
