# Pascal Editor

> Pascal Editor is a free, open-source web-based 3D building editor for architecture, interior design, and BIM. Design buildings with walls, rooms, floors, roofs, stairs, doors, windows, and furniture — all in your browser.

Pascal Editor is built for both humans and AI agents. Users can create API keys in Settings, give them to agents, and watch agents create or edit browser-visible 3D building scenes through native hosted MCP or the REST + SSE API.

## Product

- **Pascal Editor** (https://editor.pascal.app): Free browser-based 3D building editor. No download, no signup required for public viewer.
- **Agent setup and skills** (https://editor.pascal.app/docs/developers/agent-skills): Install public workflows and choose the local or hosted MCP connection for your project.
- **Pascal CLI**: Install and manage the open-source editor locally with `npx @pascal-app/cli editor`, or `npm install --global @pascal-app/cli`. Projects stay in a local SQLite database, and the published CLI includes the read-only furniture-candidate checks.
- **pascal.app**: Pascal's main website and home services platform.
- **Source code**: https://github.com/pascalorg/editor (open-source, MIT-licensed core)

## Key capabilities

- Create and edit 3D building models (walls, rooms, levels, roofs, stairs, doors, windows, slabs, fences, zones)
- Place and manage furniture and items from a built-in catalog
- 2D floorplan editor with synchronized 3D view
- Material painting and customization
- Walkthrough (first-person) mode
- Browser GLB/GLTF export where available; the MCP export_glb tool is not implemented
- Scene versioning with publish/draft model

## For AI Agents

Agents can interact with Pascal Editor programmatically:

### API keys for browser-visible co-editing

Create an API key from:

```
https://editor.pascal.app/settings
```

Use an existing key when acting on that person’s or workspace’s projects. Select the correct scope and verify recipient access to the result. A key does not grant access to arbitrary projects.

### Separate agent self-registration

Self-registration creates a separate agent-owned account with no email address and no browser login. Register only when the requested task authorizes new private hosted work, and keep the returned key in your host secret store. Reuse that identity across sessions. Private projects are not automatically accessible to a human; claiming links identities but does not transfer ownership or grant project access.

```
POST https://editor.pascal.app/api/auth/agent/register
Content-Type: application/json

{ "name": "My Agent", "agentClient": "claude-code" }
```

Returns: userId, agentId, apiKey (sk_live_* or sk_test_*), starterProjectId, mcpEndpoint, sceneApiUrl. There is no email field. Preserve agentId; a reconnect is not a new registration.

A self-registered account starts **unclaimed**. It can immediately: build private
projects, read public community projects, create an organization, invite people by
email, and redeem an agent invite link supplied by a human workspace manager. It cannot publish to the public community or
spend credits until a person claims it.

### Joining someone's organization

Ask a workspace manager for a single-use agent invite link from Settings. Send the
opaque token or the full invite URL in the request body, and never put either in a log. An existing agent includes its own
API key to join as itself; without a key, redemption creates a new agent account.

```
POST https://editor.pascal.app/api/auth/agent/invites/redeem
Authorization: Bearer <existing agent key, if already registered>
Content-Type: application/json

{ "token": "<invite token>", "name": "My Agent", "agentClient": "claude-code" }
```

The agent joins as a member. Existing agents keep their identity and API key.
Invite-link creation and management require a human workspace-manager session.
The legacy GET /api/auth/agent/invitations lists email-addressed invitations;
new agents have no email, so that list is empty. Do not invent an agent email.

### Creating your own organization

Create a workspace, list the ones you own, and invite people by email through `/api/auth/agent/organizations` and `/api/auth/agent/organizations/invite`; request and response shapes are in https://editor.pascal.app/api/openapi.json.

### Getting claimed by a person

Claiming links this agent identity to a person. It does not transfer private projects or make API-key-inaccessible features available. Public actions still require authorization; paid AI routes are not yet available to API-key clients.

```bash
pascal agent claim
pascal agent status --json
```

The commands ship in the Pascal CLI; install it with `npm install --global @pascal-app/cli`. Set `PASCAL_API_KEY` to the agent's hosted Pascal key before running either command. Use `--no-open` on a headless host. Use `--json` for structured output without opening a browser. The CLI never stores or prints the key. Claim returns a code formatted `XXXX-XXXX-XXXX` that expires after 15 minutes; requesting another code supersedes the previous one. Dashes, spaces, and letter case are ignored when the code is entered. Interactive use opens https://editor.pascal.app/settings/agents/claim with the code prefilled. Status verifies that the key remains active and returns only the agent ID, mode, claim state, and whether the key is organization-scoped.

The CLI command claims the hosted agent identity only. It is not OAuth or device login, and it does not upload or link local CLI projects. Direct HTTP integrations can use the underlying endpoints instead of the CLI:

```
POST https://editor.pascal.app/api/auth/agent/claim/start
GET  https://editor.pascal.app/api/auth/agent/status
```

### Scene API (REST)

```
GET    https://editor.pascal.app/api/scenes               — list projects/scenes owned by the key
POST   https://editor.pascal.app/api/scenes               — save a scene graph to an existing project/starterProjectId
GET    https://editor.pascal.app/api/scenes/{id}          — load scene
PUT    https://editor.pascal.app/api/scenes/{id}          — save scene
PATCH  https://editor.pascal.app/api/scenes/{id}          — rename scene
DELETE https://editor.pascal.app/api/scenes/{id}          — delete scene
GET    https://editor.pascal.app/api/scenes/{id}/events   — SSE stream (realtime scene events)
```

Auth: `Authorization: Bearer sk_live_your_key`

### MCP

```
: "${PASCAL_API_KEY:?Set PASCAL_API_KEY to the apiKey returned by Pascal}" && \
claude mcp add --scope user --transport http pascal https://editor.pascal.app/api/mcp \
  --header "Authorization: Bearer $PASCAL_API_KEY"
```

Set `PASCAL_API_KEY` in the current shell to the API key from Settings or registration before running the command. The environment check stops before changing Claude Code configuration when the variable is unset or empty. The Claude Code command uses user scope and stores the expanded static Authorization header in Claude Code’s private user configuration, making Pascal available across projects. Keep Claude Code’s user configuration private. Avoid or remove shell-history entries that assign the API key. This command connects Claude Code to hosted Pascal projects. If Pascal agent skills 0.1.7 is installed, disable its local server (plugin:pascal-agent-skills:pascal) in /mcp before adding this hosted connection.

The hosted MCP server exposes Pascal scene tools, resources, and prompts over Streamable HTTP. It is backed by the same project store as the browser editor, so saved scenes are visible online.

Read `pascal://agent-guide` first. Prefer semantic construction tools, validate and save the result, then return the `editorUrl` reported by `get_project_status` instead of constructing a URL.

Room scans uploaded by the Pascal Capture iOS app are reachable from the hosted server only:

```
list_captures             — scans in projects you can edit, newest first
get_capture               — one scan's upload, conversion and fusion status
open_capture_as_project   — bind the project owning a processed scan to this session
```

All three require edit access to the scan's own project; a public project you cannot edit is refused. `open_capture_as_project` needs `status: "processed"`, creates nothing, and returns the same project every time.

### Local editor CLI

For general local editor setup:

```bash
npx @pascal-app/cli editor
```

The CLI installs a persistent local editor at `http://pascal.localhost:<port>`, starts an authenticated loopback MCP service automatically, and keeps projects in `~/.pascal/data/pascal.db`. Its stable connector uses command `pascal` and args `["mcp", "connect"]` and discovers the dynamic port without exposing the private token. Pascal agent skills 0.1.7 already supplies one local MCP server that runs pascal mcp connect. Keep pascal on Claude Code’s PATH; local use needs no Pascal account or API key. Do not also register a manual Pascal local server. Remove an existing user-scoped entry with claude mcp remove --scope user pascal, and use /mcp to remove or disable project- or local-scoped duplicates so only plugin:pascal-agent-skills:pascal remains active. Codex and other clients still need to configure that local connector. The CLI does not create a source project or install plugins yet.

For the tested read-only furniture-candidate workflow, install the Pascal CLI with `npm install --global @pascal-app/cli` and follow https://editor.pascal.app/docs/developers/agent-skills. Installing a skill does not upgrade the runtime. Save active work and disconnect agent clients before selecting a different runtime.

### Plugins

Pascal plugins are independent packages that can contribute scene nodes, rendering, tools, floor-plan behavior, and editor panels. Hosts currently review and bundle plugin code before enabling it; the sidebar does not download arbitrary code from GitHub or npm.

## Practical workflows

For a furniture footprint-fit assessment, load the authorized measured room, confirm
item dimensions and units, and use measurement and collision tools. Return the source
project/revision, dimensions, known conflicts, and unsupported checks. Plan footprints
do not establish height clearance, door swing, delivery access, or exact mesh fit.
Missing scale or scan coverage means insufficient evidence, not a fit guarantee.

To work on a real room instead of a described one, call `list_captures`, pick a scan whose `status` is `processed`, and call `open_capture_as_project` with its `captureId`. The session is then bound to the project the scan already belongs to; inspect the scan's level with `get_level_summary` or `get_walls` before editing, and `save_scene` as usual. A scan that is not processed yet has its own next step in `get_capture`.

### Furniture fit calculator (no sign-in)

https://editor.pascal.app/tools/furniture-fit answers "does this item fit in this rectangle" without a key, an account, or a scene. It compares the item against the room as entered and rotated 90°, both axis-aligned, and reports the spare room on each axis.

Prefill it with a link so a person can check the numbers you used:

```
https://editor.pascal.app/tools/furniture-fit?roomWidth=420&roomDepth=380&itemWidth=210&itemDepth=95&clearance=60&unit=cm&shared=1
```

`roomWidth`, `roomDepth`, `itemWidth`, `itemDepth` must be positive; `clearance` may be zero; every value must be at most 1,000,000. `unit` is `cm` or `in`. `shared=1` marks the link as handed over rather than typed. `entry` is `agent_report` or `app_sidebar` and only tags analytics.

The result card copies a `pascal.furniture_fit.precheck` JSON manifest: the input, the per-orientation spare room, the verdict, and the checks this footprint math does not cover (height clearance, door swing, delivery route, collision with existing items, irregular rooms, exact mesh contact). Treat it as a precheck, not a measured-scene answer.

Installation, tested runtime, and result limits: https://editor.pascal.app/docs/developers/agent-skills

Public installable workflow skills and examples: https://github.com/pascalorg/editor/tree/main/skills

## Documentation

- Documentation index: https://editor.pascal.app/docs (also serves https://editor.pascal.app/docs/llms.txt)
- Install agent skills and choose the tested runtime: https://editor.pascal.app/docs/developers/agent-skills
- Run Pascal locally with the CLI: https://editor.pascal.app/docs/developers/local-editor
- Connect an AI agent over MCP: https://editor.pascal.app/docs/developers/mcp
- Create a plugin: https://editor.pascal.app/docs/developers/plugins
- Embed a Pascal project: https://editor.pascal.app/docs/developers/embedding
- OpenAPI spec: https://editor.pascal.app/api/openapi.json
- Machine-readable index of every interface above: https://editor.pascal.app/.well-known/api-catalog (RFC 9727 linkset)
- CLI package: https://www.npmjs.com/package/@pascal-app/cli
- Open-source MCP package: https://github.com/pascalorg/editor/tree/main/packages/mcp
- Source code: https://github.com/pascalorg/editor
- Discord: https://discord.gg/XRKsDcpqgS

## Content policy

Content-Signal: ai-train=no, search=yes, ai-input=yes

Pascal Editor content may be used in AI-powered search and answers.
It may not be used for broad model training without explicit permission.

## Limitations

- Project data is user-owned and private by default
- Hosted MCP currently uses API keys; OAuth/device login is not available yet
- MCP export_glb is unsupported; JSON export is not a GLB artifact
- Room scans are created only by the Pascal Capture iOS app: MCP can read and open a scan, but cannot start one or clone it into a new project
- An account claim does not grant a human access to the agent’s private projects
- AI features (Ask AI, scene generation) require authentication
- The hosted editor (editor.pascal.app) is the community app; the open-source packages are at github.com/pascalorg/editor