Studio runs Claude Code, Codex, Grok, Kimi, Antigravity and OpenCode on one workspace, gives each task its own branch and checkout, keeps design in the same place as the code, and turns runtime events into work. Every turn starts from the memories, rules and skills attached to the path you are working in.
Run the agents you already use in one place. Every turn starts with the memories, rules and skills relevant to the path you're working in, and can run in an isolated checkout of its own.
Several agents at once
A tab per engine, all on one workspace, all running.
Pathrule Auto
Pick it once and stop choosing models turn by turn.
Plugins
Connect once, and every engine on your machine gets it.
Isolated branches
A session can run in its own checkout, never in yours.
Dictation
Hold to talk. Nothing listens in the background.
A card carries the context its run needs, gets its own branch and checkout, and brings what it learns back into the workspace.
The board
Cards that carry the context their run needs.
Parallel runs
Cards that touch different files run at once, in their own worktrees.
Auto plan
Every new card gets a plan in the background, before you ask.
Control AI activity
Decide how much ambiguity an agent can resolve on its own.
Workspace maximum
Set the maximum AI activity level available across the workspace.
What an agent may touch
The limits a run works inside, and what stops it.
Rules as guardrails
A strict rule stops a matching change before it lands.
Design screens, connect them into flows, verify them against the running app, and hand them off with the paths and tokens behind them.
The canvas
A design surface in the same workspace as the code.
From Figma
Bring a screen in and keep it linked to its source.
UI kits and components
Variants, variables and modes. The variables are your tokens.
Motion
A real timeline, per property, that compiles to pure CSS.
Flows and prototypes
Wire screens together and walk the journey.
Prototypes as UI tests
The flow you drew, run against the app. It cannot drift.
Verify against the app
Check a drawing against what the running app does.
Design to code
Your tokens, your components, your paths. Not a picture.
Artifacts
Publish a design as one live link, encrypted on your machine.
A runtime event is grouped into one incident, mapped to the code and rules that touch it, and handed to a task with a brief. It is context, not analytics.
Signals
liveFix checkout.submit crash on payment retry
Runtime context, not analytics
No users, no sessions, no funnels. Events tied to code.
Event to incident to task
Grouped, mapped to the code that touches it, handed over.
Watching production
After it ships: verified fixed, quiet, or issue returned.
Opt in, point by point
A read-only scan proposes; you approve each instrumentation.
Quotas and retention
So the volume never surprises you.
The shared capabilities behind every surface: what Pathrule remembers, how your team works together, and where the workspace can run.
Knowledge
Memories
Capture a decision at the path it belongs to, once.
Rules
Turn a hard constraint into a guardrail agents work inside.
Skills
Package a repeatable procedure as one set of instructions.
Patterns
Import a ready set of memories, rules and skills at a path.
Work episodes
How your team solved something like this the last time.
Delivered before the turn
Context arrives before the agent's first tool call.
Only what the work needs
How the knowledge for a turn is chosen, and why it is small.
Knowledge that corrects itself
What has drifted comes back as a proposed edit.
Workspace
Team
Pathrule is free for solo developers. Start with the work you already have.
