Reactor Studio

Reactor Studio is a desktop application (Tauri + React) that becomes the developer’s home for any project built on Reactor. It combines a Cursor-like chat interface, a Rust agent harness with full filesystem and shell access, a six-phase task workflow, and first-class Reactor Cloud integration.

One window = one project

Opening a folder scaffolds .reactor/ and binds one Tauri window to that project. No project switcher — the OS handles window management.

Why Studio exists

Building on Reactor today means jumping between an editor, a browser tab for reactor.cloud, terminals for reactor-cli, and ad-hoc AI chats with no project memory. Studio unifies this into a single environment where an AI agent can read your schema, write migrations, run tests, and deploy — all with persistent context.

---

Architecture

┌──────────────────────────────────────────────────────────────────┐
│  React Renderer (WebView)                                        │
│  Chat, tabs, file tree, task pipeline, cloud dashboard           │
└────────────────────────────┬─────────────────────────────────────┘
                             │ Tauri IPC (commands + events)
                             ▼
┌──────────────────────────────────────────────────────────────────┐
│  Tauri Main Process (Rust)                                       │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │ studio-agent│  │ studio-task │  │ studio-cloud            │  │
│  │ agent loop  │  │ 6-phase FSM │  │ reactor.cloud client    │  │
│  └──────┬──────┘  └─────────────┘  └─────────────────────────┘  │
│         ▼                                                        │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │ studio-tools: fs, shell, browser, lsp, mcp, reactor_cli     ││
│  └─────────────────────────────────────────────────────────────┘│
│         ▼                                                        │
│  ┌─────────────────────────────────────────────────────────────┐│
│  │ studio-storage → <project>/.reactor/                        ││
│  └─────────────────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────────────────┘
                             │
                             ▼ (optional, size 1)
                    reactor-server embedded library

Studio can run in two modes:

Linked (cloud)

Project bound to a reactor.cloud project via .reactor/config.toml. Agent deploys with reactor_cli, monitors logs, manages env vars.

Local (embedded)

Size 1 (local) — embeds reactor-server as a library. Postgres runs locally (Docker or native). Full offline development.

---

Four-pane layout

┌──────────────────────────────────────────────────────────────────┐
│  Reactor Studio — my-app                            [−] [□] [×]  │
├──────┬────────────────┬───────────────────────────────┬──────────┤
│  🦋  │  Conversations │  [Tab 1] [Tab 2] [+]          │  Files   │
│  🤖  │                │                               │  ▼ src/  │
│  📐  │  ● Pipeline    │       Main Tab Content        │  ▼ ...   │
│  💻  │  ○ Setup chat  │  (Code / Browser / Cloud /    │          │
│  ✅  │                │   Diff / Markdown / Terminal) │  Plugins │
│  🚀  │  Tasks (3)     │                               │          │
│  📚  │  ● Add auth ⏳ │                               │          │
│  +   │  [Chat input]  │                               │          │
└──────┴────────────────┴───────────────────────────────┴──────────┘
 AgentBar   ChatPanel          MainPane                FileBrowser

Pane	Width	Purpose
AgentBar	~56px	Agent avatars + Tasks entry
ChatPanel	~380px	Conversations, task pipeline, chat input
MainPane	flex	Tabbed views (code, browser, cloud, diff)
FileBrowser	~250px	Project tree + plugins/skills panel

---

Task workflow

Every feature request flows through six phases with locked/unlocked progression:

stateDiagram-v2
    [*] --> Alignment
    Alignment --> Planning: readiness
    Planning --> Development: plan approved
    Development --> Testing: changes committed
    Testing --> UAT: tests passed
    UAT --> Deployment: user approved
    Deployment --> Done: deploy receipt

Phase	Default agent	Gate to advance
Alignment	Planner	Agent readiness (task_advance)
Planning	Planner	plan.md exists + user approval
Development	Coder	Changes committed or confirmed
Testing	Tester	Test reports generated
UAT	User	Manual approval
Deployment	Deployer	Deploy receipt from cloud

Each phase has its own conversation (tasks/<id>/phases/<n>-<name>/conversation.jsonl). Completed phases are readonly but inspectable.

---

Default agents

Agent	Role	Key tools
planner	Orchestrator, task pipeline	all + task_advance, delegate
coder	Writes code, runs tests	fs, search, shell, lsp, mcp
reviewer	Reviews diffs	fs, search, lsp, diff view
tester	Runs tests, reports	shell, fs
deployer	Deploys, monitors	reactor_cli, reactor_cloud_*
researcher	Web research, docs	webfetch, websearch, browser

Agents are plain agent.yaml + prompt.md files in .reactor/agents/ — fully editable.

---

Reactor-specific tools

The agent harness includes tools that wrap the CLI and cloud API:

Tool	Purpose
reactor_cli	Full reactor CLI access (deploy, db, logs, storage)
reactor_cloud_status	Structured project status
reactor_cloud_deploy	Trigger deploy with checked-in Reactor.toml
reactor_cloud_logs	Tail deployment logs
task_advance	Mark current phase ready to advance
task_artifact_write	Write to phase artifact directory

Anything you can do with the CLI, the agent can do.

---

.reactor/ project state

Opening a folder scaffolds (idempotently):

<project-root>/
├── .reactor/
│   ├── config.toml              # Studio + cloud link settings
│   ├── agents/                  # Agent definitions
│   ├── tasks/                   # Task pipeline state
│   ├── conversations/           # Ad-hoc chats
│   ├── memory/                  # Agent memory graph
│   ├── skills/                  # User-installed skills
│   ├── credentials/             # Encrypted vault (OS keychain-backed)
│   └── cache/
└── (your project files)

Recommended .gitignore: ignore credentials/, cache/, index/; keep tasks/ and agents/.

Cloud link config

.reactor/config.toml

[project]
name = "my-app"

[cloud]
project_id = "rc_abc123"
endpoint = "https://api.reactor.cloud"

[tasks]
phases = ["alignment", "planning", "development", "testing", "uat", "deployment"]

---

Reactor Cloud tab

Native React view (not embedded webview) showing:

• Production and preview deployment health
• Recent deployment history with log links
• Status cards for Jobs, Storage, Functions, Database
• Lightweight controls: promote, rollback, env-var quick view

The agent is the primary control surface — the tab is for at-a-glance status. “Open in web” links to the full reactor.cloud dashboard.

---

View types

View	Purpose
code-editor	Monaco editor + diff mode
markdown	Render and edit markdown
browser	Tauri WebView for web testing
diff	Side-by-side hunk accept/reject
reactor-cloud	Cloud dashboard
terminal	xterm.js + shell
conversation	Pop-out chat tab
settings	Providers, agents, cloud link, keys

Agents open views via the view_open tool.

---

Self-modifying harness (selfdev)

Lifted from jcode — the agent can rebuild and reload its own tool harness:

• selfdev_status — build state, last reload
• selfdev_build — schedule rebuild of studio-* crates
• selfdev_launch — launch new harness instance
• selfdev_reload — hot-swap providers/tools

Gated behind a confirmation modal by default.

---

IPC surface

Renderer communicates with Rust via Tauri commands and events:

Commands: agent.send, task.create, task.advance, cloud.deploy, file.read, view.open

Events: agent:chunk, task:phase-changed, task:advance-ready, cloud:log-line, file:changed

Types are generated from Rust to TypeScript via specta for end-to-end type safety.

---

Getting started

1. Download Reactor Studio for your platform
2. File → Open Folder — select your project directory
3. Studio scaffolds .reactor/ if needed
4. Start a conversation with the Planner agent or create a Task
5. Link to Reactor Cloud from Settings or the Cloud tab

For local-only development, Studio can embed reactor-server (size 1) with a local Postgres instance.

---

Related

• Architecture overview — size 1 (Tauri) embedding
• Deployment topologies — size 1 (local)
• Self-hosting — running the backend locally