Pathrule Studio

Pathrule Studio is the native macOS app, and the flagship Pathrule surface. It is where you code with your AI engines on top of your team's context, with the local runtime bundled in.

Studio puts Claude Code, Codex, Grok, Kimi, OpenCode and Antigravity in one workspace. Start a thread with any engine, then switch models mid-conversation without losing the context you have built. But Studio is more than a chat window: around it sits a full set of surfaces, a Kanban task board your agents run, a design canvas that turns a sentence into a live interactive design, a force-directed knowledge graph, and scheduled tasks, all drawing on the same path-scoped context. Your team's memories, rules and skills are delivered natively, scoped to the path you are working in, so the assistant knows your conventions before its first move. There is no separate daemon to install: the embedded MCP server, the hook supervisor, the local cache, and the AI client config writers all live inside the app.

The surfaces

Every surface below runs on the same context layer, so the right memories, rules and skills arrive before the first tool call, whichever one you are in.

• Chat. Run Claude Code, Codex, Grok, Kimi, OpenCode and Antigravity side by side and switch the model mid-conversation. An orchestrated mode lets a conductor model plan a goal, split it into subtasks, and dispatch each to the engine that fits, running in parallel and bringing the results back in one thread. Attach a screenshot, mockup or diagram and Pathrule forwards it as real visual context to any engine that can see. Ask for a brand-new screen and the assistant can build it as a live Pathrule Artifact right in the conversation instead of a wall of code. If a run is cut short by a restart or a lost connection, Studio recovers the session and resumes it.
• Tasks board. A Kanban board you run with AI. Lay work out as a column of cards, hand any card or column to Claude Code, Codex, Grok, Kimi, OpenCode or Antigravity, and watch it move across the board as it works. Each run gets its own git branch and lands in review. Cards can carry images, pasted or dropped on, handed to the agent as visual context and encrypted end to end just like the card's prompt. Start a card on its own or run a whole column, and follow progress live across your devices.
• Isolated branches. Run a conversation or a single card in its own git checkout of the repository, on its own branch, so several agents work the same project at once and none of them touches your working copy. Your team's memories, rules and skills follow the checkout, so a parallel agent is not a context-blind one. When the work is done, Source Control merges the branch or opens a pull request for you, and a conflict leaves your working copy untouched. It is opt-in per conversation; the default stays the main checkout.
• Design canvas. Describe a screen and Studio builds a real, interactive design you can point at and refine in plain words. Connect screens into a flow and play it as a prototype, bring frames in from Figma with their tokens intact, and check the built app back against the design on web, iOS or Android. Export any design to PNG in one step, or hand it straight into chat as a snapshot to ask for the next change. Share a design as a private, zero-knowledge read-only link that anyone can open in the browser, with optional pinned comments that appear live and that you can revoke at any time. On a Team plan, your teammates' designs appear in a private, members-only team library where you can watch them update live and comment on them, all inside your organization.
• Knowledge graph. The Summary surface has a Graph tab: a fluid, force-directed map of your whole workspace, with every folder node linked to its memories, rules and skills, and memories linked to each other through the connections you write. Zoom and pan, hover a node to light up its neighbours, and let it refresh on its own as your team's knowledge grows.
• Schedules. Set a task to run on any cadence. Studio wakes up on its own, does the work with the right context in place, and leaves the result waiting for you.

What else is bundled

• Native context delivery. The hook supervisor reads the path-scoped slice from the local cache and hands the right memories, rules and skills to the engine before its first action, with no MCP wiring to maintain.
• Knowledge authoring. Write and review memories, rules and skills at the path they belong to, with team comments and threads on each item. Assistants can propose updates as small edits, an append or a targeted replace, instead of rewriting the whole body.
• Local folder attach. Bind a workspace to a directory on your machine. The runtime resolves your AI session's working directory to a workspace using that mapping.
• MCP server. The same MCP tool surface your assistant speaks to, running inside the app, available to Claude Code, Cursor, Codex, Windsurf, GitHub Copilot, and any MCP compatible client.
• Companion file sync. Writes and keeps the AI client config plus the managed companion files (CLAUDE.md, AGENTS.md) in sync as content changes, and materializes your skills to disk where each client looks for them. Pathrule marks its own files and preserves any you already had, so your hand-written setup is never clobbered.
• Dictation. Speak a prompt instead of typing it, with cloud transcription across 90+ languages and an on-device macOS engine behind it.
• The workbench. Source control, Patterns, MCP servers and extensions, usage and an integrated terminal and run, all around the chat. Chat itself splits into panes and detaches into its own windows when one thread is not enough, and a multi-device stage runs your app next to the conversation.
• Offline, dark and light. Studio works offline against the local cache and follows your system light or dark theme, on signed, notarized builds.
• Tray notifications and auto updates. Native OS notifications for suggestions, conflicts and team activity, and background updates applied on next launch.

The iOS companion

A cross-device iOS companion keeps a run in your pocket. Pathrule for iOS has the full description. Kick off a task on your Mac and follow it from your phone: the same conversations, memories and rules, with live run state synced end to end so a run keeps going while you are away. When an agent edits a file, the phone shows the actual change inline, added and removed lines, tappable to a full-screen view. You can answer a permission prompt or a question from either device, and a conversation started on the phone continues correctly from the Mac. Every connection between your iPhone and Mac is end-to-end encrypted and your source code never leaves your machine; only your team's knowledge and the live session stream sync. The iOS app is available now on the App Store; it is the companion to Pathrule Studio on macOS, so install Studio and sign in with the same account to reach your workspaces and live sessions from anywhere.

What Pathrule Studio hands off to Web

Pathrule Web is the cloud management console. A few flows live there rather than inside Studio.

• Organization profile and settings, including ownership transfer.
• Members and roles: invite teammates and manage access.
• Plans and billing.
• Workspace admin across the org (rename, archive, export) and team usage.

First run

1. Download from the macOS app page and open the app.
2. Sign in through the browser based PKCE flow that launches on first run.
3. Create or pick a workspace.
4. Attach the workspace to the local directory you want it to cover.
5. Pick the AI clients you use. Pathrule Studio writes their configs and registers the hooks.

After this, open a thread in Studio or your editor in the attached directory. The right memories, rules and skills arrive in context before the first tool call.

Coexistence with Pathrule CLI

Studio and Pathrule CLI can run on the same machine. They share the same local cache and the same workspace attachment table. The first runtime to claim a workspace owns its hook supervisor for that session.

If you cannot tell which runtime is active, run:

pathrule doctor

The doctor reports which runtime owns the workspace, where the cache is, and whether the AI client configs match.

When to use Pathrule Studio

Use Pathrule Studio when you want to code with Claude Code, Codex, Grok, Kimi, OpenCode and Antigravity on top of your team's context, plan and run work on a board, turn a conversation into a live design, and see your knowledge as a graph, with source control, MCP, schedules, usage, terminal and run in one place. It is the default recommendation for most users on macOS.

If you live entirely in the terminal, prefer Pathrule CLI. To manage your organization, members and billing from any browser, use Pathrule Web.

What to read next

• Pathrule CLI for the terminal first runtime.
• The Tasks board for running work as cards.
• Isolated branches for running several agents on one repository at once.
• Design overview for the design surface.
• Pathrule for iOS for the phone and watch companion.
• How hooks work for what the supervisor inside Studio is doing.
• Quickstart for the first end to end session.