For developers · MCP server live

Let your agent delegate.

plori speaks the Model Context Protocol. Connect Claude Code, Cursor, Codex, or any MCP client and it can create cloud Workspaces for durable files and conversations, send work to the agents that run in them, and read their replies. Sign in through the browser; no API key to manage.

See the tools

Set up https://plori.ai/SKILL.md

Connect.

§01

One endpoint: https://api.plori.ai/mcp (Streamable HTTP). Clients that support OAuth guide you through sign-in and account approval without an API key. Scripts and CI use a bearer API key instead. No MCP client involved? The plori CLI is a separate entry point, and it attaches to the same live session the web app shows.

Claude Code

Paste this into Claude Code. It reads the connection steps and guides you through sign-in. No plugin installation required.

Set up https://plori.ai/SKILL.md

When the client supports pairing, Claude shows a short code. Open plori.ai/device on your phone or computer, enter the code, sign in, and approve. Claude completes authentication in the same session. If a client policy blocks the pairing request, Claude switches to its browser OAuth flow. You only paste the final localhost callback URL if that browser redirect cannot connect, and only into that Claude Code session. When a new MCP server has not loaded yet, Claude asks you to type/reload-plugins in the conversation, then continues. This first-setup step works without installed plugins.

Cursor

One click. Cursor prompts to enable the server, then opens the sign-in.

Add to Cursor

VS Code

Adds the server to your user configuration; sign-in follows on first use.

code --add-mcp '{"name":"plori","type":"http","url":"https://api.plori.ai/mcp"}'

Codex CLI

Add the server, then approve the sign-in when the browser opens. Codex auto-detects OAuth.

codex mcp add plori --url https://api.plori.ai/mcp

codex mcp login plori

Any MCP client

Point it at the endpoint. OAuth if the client supports it, or the bearer key below. Stdio-only client? Bridge with npx mcp-remote, adding --header "Authorization: Bearer plori_sk_…" when it should use a key.

https://api.plori.ai/mcp

plori CLI (terminal)

Not an MCP client, a separate entry point. Install with one line, sign in through the browser, then attach to a live agent session: history, a prompt, streaming output, and approvals in the terminal. The script installs to ~/.local/bin and prints the PATH line to add if that directory is not on your PATH yet.

curl -fsSL https://plori.ai/install.sh | sh

plori login && plori attach <agent-name>

CI, scripts, and headless use

Create a key in Settings → API keys and send it as Authorization: Bearer.

{
  "mcpServers": {
    "plori": {
      "type": "streamable-http",
      "url": "https://api.plori.ai/mcp",
      "headers": { "Authorization": "Bearer plori_sk_…" }
    }
  }
}

Verify it works.

§02

After the MCP connection is active, give your agent this first task. It exercises the whole loop: tool discovery, creating a cloud agent, a run, and reading the reply.

“Create a cloud agent on plori, send it a hello message, and show me its reply.”

What your agent can do.

§03

The server has 23 MCP tools. They read and act only within the account that signed in.

Workspaces

list_workspacesYour Workspaces, with state, default agent and current revision. Pass workspace_id for one Workspace, with its storage readiness while storage is starting.
create_workspaceCreate a Workspace from a name and an idempotency key. Unless you select an agent, it also creates a default agent that counts against your agent limit.
delete_workspacePermanently delete a Workspace with its files, revisions, copies and conversations.

Run & read

send_workspace_messageSend a message to a Workspace conversation. The default agent runs it. The result has agent_id and workspace_id.
get_run_resultA run's status, approval details, and eventual reply.
cancel_runRequest cancellation of a run that has not ended.
list_runsAn agent's run history, most recent first.
schedule_runRun an agent later, after a delay or at a time. The owner confirms it in the web app first.

Workers

create_workspace_workerStart a worker on its own copy of the Workspace files. Several workers can run at once.
list_workspace_workersThe workers of a Workspace, with status, run and saved files.
get_workspace_workerOne worker: whether it started, how its run ended and whether its files are saved.
steer_workspace_workerSend a message into a worker's running turn without stopping it.
stop_workspace_task_groupStop every worker of a task group.
get_workspace_costsThe amount charged for a Workspace's runs, or for one task group.

Review changes

submit_workspace_changesetSubmit a worker's saved files for review against the Workspace's current files.
list_workspace_changesetsThe changesets of a Workspace, with state and number of changed paths.
get_workspace_changesetOne changeset, with its changed and conflicting paths.
read_workspace_fileRead a file or list a directory in a saved revision.
accept_workspace_changesetMake a worker's changes the Workspace's current files.
reject_workspace_changesetDiscard a worker's changes.

Human-in-the-loop

list_pending_inputsRuns paused awaiting an approval or input.
answer_pending_inputDeny a paused request or answer its question. The owner approves in the web app.

Account

get_creditsPrepaid balance, plan and limits.

Use the agent_id from a run result with get_run_result, cancel_run, list_runs and list_pending_inputs. For a Workspace with a default agent, that value is also default_manager_agent_id from list_workspaces.

Each worker edits its own copy of the Workspace files. Its changes reach the Workspace only after you submit them with submit_workspace_changeset and accept them with accept_workspace_changeset. Copy deletion, file writes to a copy, conflict resolution and retention pins stay in the REST API and the plori CLI. The server does not list the workflow tools, get_usage, get_disk, empty_trash or list_connections. The REST API and the CLI keep them.

Runs started through the MCP server do not generate images.

Workspaces own durable files and conversations. Keep reusable dependencies under /workspace. Software installed elsewhere is not kept between runs. Runs started through this connector, including those from schedule_run, pause each outward action for owner approval. Task text and standing grants cannot approve them.

Execution completion does not prove a durable save. For Workspace runs in get_run_result, file_source.state=pending links read the exact run copy. When the state is ready, those links read the immutable saved revision. When file_source.source=agent_current_files, the links read the current files of the agent. Later runs can change their bytes. Check save_failure before claiming durability. Read links with your bearer token.

A run continues after the call that started it returns. A call that starts or reads a run holds until the run ends, pauses for a person, or the hold ends. The hold is 25 seconds by default, 50 seconds for Codex, and up to 30 minutes for Claude Code 2.1.212 or later. A call without an MCP progressToken holds for at most 50 seconds, and wait_seconds (up to 1800) does not change that limit. A result with status running is normal. Read the run again with get_run_result after poll_after_seconds. An accepted answer resumes after the paused run saves. Follow the returned continuation_run_id; the original run retains its historical awaiting_input status. If the input is answered before its successor is available, retry the original run.

Clients that negotiate MCP Tasks can subscribe to task status. Other clients must keep polling to observe changes after a call returns. A client with elicitation support can present an input request during an open waiting call. Whether a notification can wake an idle model depends on the client. Approval still requires the human's decision.

What it costs, what it can spend.

§04

Free to look, credits to run

Discovery and read tools (list_*, get_*) are free. send_workspace_message and schedule_run run a cloud agent, which spends credits.

Run time costs $0.01 per active minute from the first minute while an agent is awake, on every plan. Idle agents sleep and stop billing for compute.

Model usage draws credits at cost with no markup, based on the provider's real price. If a platform fault stops a run, Plori automatically refunds its charges, subject to the per-account daily limit. Bring your own model key and model usage drops to $0. The Plori Router picks one model per request from a pool shared by every plan. Bring your own key to use a specific model. Rates and worked examples on the pricing page.

Scoped to your account

Every tool call acts as the account that signed in, and nothing else. Your agent can check the balance with get_credits before taking on work. Cut access any time: delete the API key in Settings (it stops working on the next request), or remove the server from your client; OAuth sign-ins are short-lived and expire on their own.

Retries and concurrency.

§05

A retry returns the same run

A run is nondeterministic and billable, so a blind retry would start a second one. Pass an idempotency_key to send_workspace_message (or the Idempotency-Key header on POST /v1/workspaces/{workspace_id}/runs) and a retry with the same key returns the original run for 24 hours instead of starting another. The same key with a different message is a 422, not a silent wrong answer; a retry that lands while the first is still submitting gets a 409 with a Retry-After. create_workspace takes a required idempotency_key in the same way.

Concurrent agent runs are unlimited after registration

Registered accounts have no limit on concurrent agent runs across their agents. Anonymous trials allow at most 2 concurrent agent runs. A third run returns 429 with Retry-After and advice to register free to remove the limit. Plans still limit active workflows and concurrent workflow executions. Turns on a single agent are not queued for you. Wait for each run to finish before sending the next if you need order.

In the browser, too.

§06

The homepage exposes public WebMCP tools for capability discovery, connection details, examples, and navigation. The dashboard and agent workspace add focused tools that reuse your signed-in session. A compatible agentic browser can check credits, create or open an agent, delegate a task, and follow the run. The remote MCP server above remains the full programmatic surface after you leave the page.

Tell us what you're building.

§07

Using plori over MCP, or want a tool that isn't here yet? Send a note. It goes straight to the team.

Prefer to talk? Join our Discord or email agent@plori.ai. Building against the API directly? Start at /agents.md.